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
   4    Free Software Foundation, Inc.
   5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.
  23
  24 Java and all Java-based marks are trademarks or registered trademarks
  25 of Sun Microsystems, Inc. in the United States and other countries.
  26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  27
  28 /* This file parses java source code and issues a tree node image
  29 suitable for code generation (byte code and targeted CPU assembly
  30 language).
  31
  32 The grammar conforms to the Java grammar described in "The Java(TM)
  33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  34 1996, ISBN 0-201-63451-1"
  35
  36 The following modifications were brought to the original grammar:
  37
  38 method_body: added the rule '| block SC_TK'
  39 static_initializer: added the rule 'static block SC_TK'.
  40
  41 Note: All the extra rules described above should go away when the
  42       empty_statement rule will work.
  43
  44 statement_nsi: 'nsi' should be read no_short_if.
  45
  46 Some rules have been modified to support JDK1.1 inner classes
  47 definitions and other extensions.  */
  48
  49 %{
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include <dirent.h>
  55 #include "tree.h"
  56 #include "rtl.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "flags.h"
  61 #include "java-tree.h"
  62 #include "jcf.h"
  63 #include "lex.h"
  64 #include "parse.h"
  65 #include "zipfile.h"
  66 #include "convert.h"
  67 #include "buffer.h"
  68 #include "xref.h"
  69 #include "function.h"
  70 #include "except.h"
  71 #include "ggc.h"
  72 #include "debug.h"
  73 #include "tree-inline.h"
  74 #include "cgraph.h"
  75
  76 /* Local function prototypes */
  77 static char *java_accstring_lookup (int);
  78 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  79 static void  variable_redefinition_error (tree, tree, tree, int);
  80 static tree  create_class (int, tree, tree, tree);
  81 static tree  create_interface (int, tree, tree);
  82 static void  end_class_declaration (int);
  83 static tree  find_field (tree, tree);
  84 static tree lookup_field_wrapper (tree, tree);
  85 static int   duplicate_declaration_error_p (tree, tree, tree);
  86 static void  register_fields (int, tree, tree);
  87 static tree parser_qualified_classname (tree);
  88 static int  parser_check_super (tree, tree, tree);
  89 static int  parser_check_super_interface (tree, tree, tree);
  90 static void check_modifiers_consistency (int);
  91 static tree lookup_cl (tree);
  92 static tree lookup_java_method2 (tree, tree, int);
  93 static tree method_header (int, tree, tree, tree);
  94 static void fix_method_argument_names (tree ,tree);
  95 static tree method_declarator (tree, tree);
  96 static void parse_warning_context (tree cl, const char *msg, ...)
  97   ATTRIBUTE_PRINTF_2;
  98 static void issue_warning_error_from_context (tree, const char *msg, va_list)
  99   ATTRIBUTE_PRINTF (2, 0);
 100 static void parse_ctor_invocation_error (void);
 101 static tree parse_jdk1_1_error (const char *);
 102 static void complete_class_report_errors (jdep *);
 103 static int process_imports (void);
 104 static void read_import_dir (tree);
 105 static int find_in_imports_on_demand (tree, tree);
 106 static void find_in_imports (tree, tree);
 107 static void check_inner_class_access (tree, tree, tree);
 108 static int check_pkg_class_access (tree, tree, bool);
 109 static void register_package (tree);
 110 static tree resolve_package (tree, tree *, tree *);
 111 static tree resolve_class (tree, tree, tree, tree);
 112 static void declare_local_variables (int, tree, tree);
 113 static void dump_java_tree (enum tree_dump_index, tree);
 114 static void source_start_java_method (tree);
 115 static void source_end_java_method (void);
 116 static tree find_name_in_single_imports (tree);
 117 static void check_abstract_method_header (tree);
 118 static tree lookup_java_interface_method2 (tree, tree);
 119 static tree resolve_expression_name (tree, tree *);
 120 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 121 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 122 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 123 static int breakdown_qualified (tree *, tree *, tree);
 124 static int in_same_package (tree, tree);
 125 static tree resolve_and_layout (tree, tree);
 126 static tree qualify_and_find (tree, tree, tree);
 127 static tree resolve_no_layout (tree, tree);
 128 static int invocation_mode (tree, int);
 129 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 130 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 131 static tree find_most_specific_methods_list (tree);
 132 static int argument_types_convertible (tree, tree);
 133 static tree patch_invoke (tree, tree, tree);
 134 static int maybe_use_access_method (int, tree *, tree *);
 135 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 136 static tree register_incomplete_type (int, tree, tree, tree);
 137 static tree check_inner_circular_reference (tree, tree);
 138 static tree check_circular_reference (tree);
 139 static tree obtain_incomplete_type (tree);
 140 static tree java_complete_lhs (tree);
 141 static tree java_complete_tree (tree);
 142 static tree maybe_generate_pre_expand_clinit (tree);
 143 static int analyze_clinit_body (tree, tree);
 144 static int maybe_yank_clinit (tree);
 145 static void java_complete_expand_method (tree);
 146 static void java_expand_method_bodies (tree);
 147 static int  unresolved_type_p (tree, tree *);
 148 static void create_jdep_list (struct parser_ctxt *);
 149 static tree build_expr_block (tree, tree);
 150 static tree enter_block (void);
 151 static tree exit_block (void);
 152 static tree lookup_name_in_blocks (tree);
 153 static void maybe_absorb_scoping_blocks (void);
 154 static tree build_method_invocation (tree, tree);
 155 static tree build_new_invocation (tree, tree);
 156 static tree build_assignment (int, int, tree, tree);
 157 static tree build_binop (enum tree_code, int, tree, tree);
 158 static tree patch_assignment (tree, tree);
 159 static tree patch_binop (tree, tree, tree);
 160 static tree build_unaryop (int, int, tree);
 161 static tree build_incdec (int, int, tree, int);
 162 static tree patch_unaryop (tree, tree);
 163 static tree build_cast (int, tree, tree);
 164 static tree build_null_of_type (tree);
 165 static tree patch_cast (tree, tree);
 166 static int valid_ref_assignconv_cast_p (tree, tree, int);
 167 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 168 static int valid_cast_to_p (tree, tree);
 169 static int valid_method_invocation_conversion_p (tree, tree);
 170 static tree try_builtin_assignconv (tree, tree, tree);
 171 static tree try_reference_assignconv (tree, tree);
 172 static tree build_unresolved_array_type (tree);
 173 static int build_type_name_from_array_name (tree, tree *);
 174 static tree build_array_from_name (tree, tree, tree, tree *);
 175 static tree build_array_ref (int, tree, tree);
 176 static tree patch_array_ref (tree);
 177 static tree make_qualified_name (tree, tree, int);
 178 static tree merge_qualified_name (tree, tree);
 179 static tree make_qualified_primary (tree, tree, int);
 180 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 181 static void qualify_ambiguous_name (tree);
 182 static tree resolve_field_access (tree, tree *, tree *);
 183 static tree build_newarray_node (tree, tree, int);
 184 static tree patch_newarray (tree);
 185 static tree resolve_type_during_patch (tree);
 186 static tree build_this (int);
 187 static tree build_wfl_wrap (tree, int);
 188 static tree build_return (int, tree);
 189 static tree patch_return (tree);
 190 static tree maybe_access_field (tree, tree, tree);
 191 static int complete_function_arguments (tree);
 192 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 193 static int not_accessible_p (tree, tree, tree, int);
 194 static void check_deprecation (tree, tree);
 195 static int class_in_current_package (tree);
 196 static tree build_if_else_statement (int, tree, tree, tree);
 197 static tree patch_if_else_statement (tree);
 198 static tree add_stmt_to_compound (tree, tree, tree);
 199 static tree add_stmt_to_block (tree, tree, tree);
 200 static tree patch_exit_expr (tree);
 201 static tree build_labeled_block (int, tree);
 202 static tree finish_labeled_statement (tree, tree);
 203 static tree build_bc_statement (int, int, tree);
 204 static tree patch_bc_statement (tree);
 205 static tree patch_loop_statement (tree);
 206 static tree build_new_loop (tree);
 207 static tree build_loop_body (int, tree, int);
 208 static tree finish_loop_body (int, tree, tree, int);
 209 static tree build_debugable_stmt (int, tree);
 210 static tree finish_for_loop (int, tree, tree, tree);
 211 static tree patch_switch_statement (tree);
 212 static tree string_constant_concatenation (tree, tree);
 213 static tree build_string_concatenation (tree, tree);
 214 static tree patch_string_cst (tree);
 215 static tree patch_string (tree);
 216 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 217 static tree build_assertion (int, tree, tree);
 218 static tree build_try_statement (int, tree, tree);
 219 static tree build_try_finally_statement (int, tree, tree);
 220 static tree patch_try_statement (tree);
 221 static tree patch_synchronized_statement (tree, tree);
 222 static tree patch_throw_statement (tree, tree);
 223 static void check_thrown_exceptions (int, tree, tree);
 224 static int check_thrown_exceptions_do (tree);
 225 static void purge_unchecked_exceptions (tree);
 226 static bool ctors_unchecked_throws_clause_p (tree);
 227 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 228 static void check_throws_clauses (tree, tree, tree);
 229 static void finish_method_declaration (tree);
 230 static tree build_super_invocation (tree);
 231 static int verify_constructor_circularity (tree, tree);
 232 static char *constructor_circularity_msg (tree, tree);
 233 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 234 static const char *get_printable_method_name (tree);
 235 static tree patch_conditional_expr (tree, tree, tree);
 236 static tree generate_finit (tree);
 237 static tree generate_instinit (tree);
 238 static tree build_instinit_invocation (tree);
 239 static void fix_constructors (tree);
 240 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 241 static tree craft_constructor (tree, tree);
 242 static int verify_constructor_super (tree);
 243 static tree create_artificial_method (tree, int, tree, tree, tree);
 244 static void start_artificial_method_body (tree);
 245 static void end_artificial_method_body (tree);
 246 static int check_method_redefinition (tree, tree);
 247 static int check_method_types_complete (tree);
 248 static bool hack_is_accessible_p (tree, tree);
 249 static void java_check_regular_methods (tree);
 250 static void check_interface_throws_clauses (tree, tree);
 251 static void java_check_abstract_methods (tree);
 252 static void unreachable_stmt_error (tree);
 253 static int not_accessible_field_error (tree, tree);
 254 static tree find_expr_with_wfl (tree);
 255 static void missing_return_error (tree);
 256 static tree build_new_array_init (int, tree);
 257 static tree patch_new_array_init (tree, tree);
 258 static tree maybe_build_array_element_wfl (tree);
 259 static int array_constructor_check_entry (tree, tree);
 260 static const char *purify_type_name (const char *);
 261 static tree fold_constant_for_init (tree, tree);
 262 static tree strip_out_static_field_access_decl (tree);
 263 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 264 static void static_ref_err (tree, tree, tree);
 265 static void parser_add_interface (tree, tree, tree);
 266 static void add_superinterfaces (tree, tree);
 267 static tree jdep_resolve_class (jdep *);
 268 static int note_possible_classname (const char *, int);
 269 static void java_complete_expand_classes (void);
 270 static void java_complete_expand_class (tree);
 271 static void java_complete_expand_methods (tree);
 272 static tree cut_identifier_in_qualified (tree);
 273 static tree java_stabilize_reference (tree);
 274 static tree do_unary_numeric_promotion (tree);
 275 static char * operator_string (tree);
 276 static tree do_merge_string_cste (tree, const char *, int, int);
 277 static tree merge_string_cste (tree, tree, int);
 278 static tree java_refold (tree);
 279 static int java_decl_equiv (tree, tree);
 280 static int binop_compound_p (enum tree_code);
 281 static tree search_loop (tree);
 282 static int labeled_block_contains_loop_p (tree, tree);
 283 static int check_abstract_method_definitions (int, tree, tree);
 284 static void java_check_abstract_method_definitions (tree);
 285 static void java_debug_context_do (int);
 286 static void java_parser_context_push_initialized_field (void);
 287 static void java_parser_context_pop_initialized_field (void);
 288 static tree reorder_static_initialized (tree);
 289 static void java_parser_context_suspend (void);
 290 static void java_parser_context_resume (void);
 291 static int pop_current_osb (struct parser_ctxt *);
 292
 293 /* JDK 1.1 work. FIXME */
 294
 295 static tree maybe_make_nested_class_name (tree);
 296 static int make_nested_class_name (tree);
 297 static void set_nested_class_simple_name_value (tree, int);
 298 static void link_nested_class_to_enclosing (void);
 299 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 300 static tree find_as_inner_class (tree, tree, tree);
 301 static tree find_as_inner_class_do (tree, tree);
 302 static int check_inner_class_redefinition (tree, tree);
 303
 304 static tree build_thisn_assign (void);
 305 static tree build_current_thisn (tree);
 306 static tree build_access_to_thisn (tree, tree, int);
 307 static tree maybe_build_thisn_access_method (tree);
 308
 309 static tree build_outer_field_access (tree, tree);
 310 static tree build_outer_field_access_methods (tree);
 311 static tree build_outer_field_access_expr (int, tree, tree,
 312                                                   tree, tree);
 313 static tree build_outer_method_access_method (tree);
 314 static tree build_new_access_id (void);
 315 static tree build_outer_field_access_method (tree, tree, tree,
 316                                                     tree, tree);
 317
 318 static int outer_field_access_p (tree, tree);
 319 static int outer_field_expanded_access_p (tree, tree *,
 320                                                  tree *, tree *);
 321 static tree outer_field_access_fix (tree, tree, tree);
 322 static tree build_incomplete_class_ref (int, tree);
 323 static tree patch_incomplete_class_ref (tree);
 324 static tree create_anonymous_class (int, tree);
 325 static void patch_anonymous_class (tree, tree, tree);
 326 static void add_inner_class_fields (tree, tree);
 327
 328 static tree build_dot_class_method (tree);
 329 static tree build_dot_class_method_invocation (tree);
 330 static void create_new_parser_context (int);
 331 static tree maybe_build_class_init_for_field (tree, tree);
 332
 333 static int attach_init_test_initialization_flags (void **, void *);
 334 static int emit_test_initialization (void **, void *);
 335
 336 static char *string_convert_int_cst (tree);
 337
 338 /* Number of error found so far. */
 339 int java_error_count;
 340 /* Number of warning found so far. */
 341 int java_warning_count;
 342 /* Tell when not to fold, when doing xrefs */
 343 int do_not_fold;
 344 /* Cyclic inheritance report, as it can be set by layout_class */
 345 const char *cyclic_inheritance_report;
 346
 347 /* The current parser context */
 348 struct parser_ctxt *ctxp;
 349
 350 /* List of things that were analyzed for which code will be generated */
 351 struct parser_ctxt *ctxp_for_generation = NULL;
 352
 353 /* binop_lookup maps token to tree_code. It is used where binary
 354    operations are involved and required by the parser. RDIV_EXPR
 355    covers both integral/floating point division. The code is changed
 356    once the type of both operator is worked out.  */
 357
 358 static const enum tree_code binop_lookup[19] =
 359   {
 360     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 361     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 362     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 363     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 364     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 365    };
 366 #define BINOP_LOOKUP(VALUE)                                             \
 367   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 368
 369 /* This is the end index for binary operators that can also be used
 370    in compound assignements. */
 371 #define BINOP_COMPOUND_CANDIDATES 11
 372
 373 /* The "$L" identifier we use to create labels.  */
 374 static GTY(()) tree label_id;
 375
 376 /* The "StringBuffer" identifier used for the String `+' operator. */
 377 static GTY(()) tree wfl_string_buffer;
 378
 379 /* The "append" identifier used for String `+' operator.  */
 380 static GTY(()) tree wfl_append;
 381
 382 /* The "toString" identifier used for String `+' operator. */
 383 static GTY(()) tree wfl_to_string;
 384
 385 /* The "java.lang" import qualified name.  */
 386 static GTY(()) tree java_lang_id;
 387
 388 /* The generated `inst$' identifier used for generated enclosing
 389    instance/field access functions.  */
 390 static GTY(()) tree inst_id;
 391
 392 /* Context and flag for static blocks */
 393 static GTY(()) tree current_static_block;
 394
 395 /* The generated `write_parm_value$' identifier.  */
 396 static GTY(()) tree wpv_id;
 397
 398 /* The list of all packages we've seen so far */
 399 static GTY(()) tree package_list;
 400
 401 /* Hold THIS for the scope of the current method decl.  */
 402 static GTY(()) tree current_this;
 403
 404 /* Hold a list of catch clauses list. The first element of this list is
 405    the list of the catch clauses of the currently analysed try block. */
 406 static GTY(()) tree currently_caught_type_list;
 407
 408 /* This holds a linked list of all the case labels for the current
 409    switch statement.  It is only used when checking to see if there
 410    are duplicate labels.  FIXME: probably this should just be attached
 411    to the switch itself; then it could be referenced via
 412    `ctxp->current_loop'.  */
 413 static GTY(()) tree case_label_list;
 414
 415 /* Anonymous class counter. Will be reset to 1 every time a non
 416    anonymous class gets created. */
 417 static int anonymous_class_counter = 1;
 418
 419 static GTY(()) tree src_parse_roots[1];
 420
 421 /* All classes seen from source code */
 422 #define gclass_list src_parse_roots[0]
 423
 424 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 425    line and point it out.  */
 426 /* Should point out the one that don't fit. ASCII/unicode, going
 427    backward. FIXME */
 428
 429 #define check_modifiers(__message, __value, __mask) do {        \
 430   if ((__value) & ~(__mask))                                    \
 431     {                                                           \
 432       size_t i, remainder = (__value) & ~(__mask);              \
 433       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 434         if ((1 << i) & remainder)                               \
 435           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 436                                java_accstring_lookup (1 << i)); \
 437     }                                                           \
 438 } while (0)
 439
 440 %}
 441
 442 %union {
 443   tree node;
 444   int sub_token;
 445   struct {
 446     int token;
 447     int location;
 448   } operator;
 449   int value;
 450 }
 451
 452 %{
 453 #include "lex.c"
 454 %}
 455
 456 %pure_parser
 457
 458 /* Things defined here have to match the order of what's in the
 459    binop_lookup table.  */
 460
 461 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 462 %token   LS_TK           SRS_TK          ZRS_TK
 463 %token   AND_TK          XOR_TK          OR_TK
 464 %token   BOOL_AND_TK BOOL_OR_TK
 465 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 466
 467 /* This maps to the same binop_lookup entry than the token above */
 468
 469 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 470 %token   REM_ASSIGN_TK
 471 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 472 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 473
 474
 475 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 476
 477 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 478 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 479 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 480 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 481 %token   MODIFIER_TK
 482
 483 /* Keep those two in order, too */
 484 %token   DECR_TK INCR_TK
 485
 486 /* From now one, things can be in any order */
 487
 488 %token   DEFAULT_TK      IF_TK              THROW_TK
 489 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 490 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 491 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 492 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 493 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 494 %token   SUPER_TK        WHILE_TK           CLASS_TK
 495 %token   SWITCH_TK       CONST_TK           TRY_TK
 496 %token   FOR_TK          NEW_TK             CONTINUE_TK
 497 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 498 %token   ASSERT_TK
 499
 500 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 501 %token   CHAR_TK         INTEGRAL_TK
 502
 503 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 504
 505 %token   ID_TK
 506
 507 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 508
 509 %token   ASSIGN_ANY_TK   ASSIGN_TK
 510 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 511
 512 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 513 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 514
 515 %type    <value>        modifiers MODIFIER_TK final synchronized
 516
 517 %type    <node>         super ID_TK identifier
 518 %type    <node>         name simple_name qualified_name
 519 %type    <node>         type_declaration compilation_unit
 520                         field_declaration method_declaration extends_interfaces
 521                         interfaces interface_type_list
 522                         import_declarations package_declaration
 523                         type_declarations interface_body
 524                         interface_member_declaration constant_declaration
 525                         interface_member_declarations interface_type
 526                         abstract_method_declaration
 527 %type    <node>         class_body_declaration class_member_declaration
 528                         static_initializer constructor_declaration block
 529 %type    <node>         class_body_declarations constructor_header
 530 %type    <node>         class_or_interface_type class_type class_type_list
 531                         constructor_declarator explicit_constructor_invocation
 532 %type    <node>         dim_expr dim_exprs this_or_super throws
 533
 534 %type    <node>         variable_declarator_id variable_declarator
 535                         variable_declarators variable_initializer
 536                         variable_initializers constructor_body
 537                         array_initializer
 538
 539 %type    <node>         class_body block_end constructor_block_end
 540 %type    <node>         statement statement_without_trailing_substatement
 541                         labeled_statement if_then_statement label_decl
 542                         if_then_else_statement while_statement for_statement
 543                         statement_nsi labeled_statement_nsi do_statement
 544                         if_then_else_statement_nsi while_statement_nsi
 545                         for_statement_nsi statement_expression_list for_init
 546                         for_update statement_expression expression_statement
 547                         primary_no_new_array expression primary
 548                         array_creation_expression array_type
 549                         class_instance_creation_expression field_access
 550                         method_invocation array_access something_dot_new
 551                         argument_list postfix_expression while_expression
 552                         post_increment_expression post_decrement_expression
 553                         unary_expression_not_plus_minus unary_expression
 554                         pre_increment_expression pre_decrement_expression
 555                         cast_expression
 556                         multiplicative_expression additive_expression
 557                         shift_expression relational_expression
 558                         equality_expression and_expression
 559                         exclusive_or_expression inclusive_or_expression
 560                         conditional_and_expression conditional_or_expression
 561                         conditional_expression assignment_expression
 562                         left_hand_side assignment for_header for_begin
 563                         constant_expression do_statement_begin empty_statement
 564                         switch_statement synchronized_statement throw_statement
 565                         try_statement assert_statement
 566                         switch_expression switch_block
 567                         catches catch_clause catch_clause_parameter finally
 568                         anonymous_class_creation trap_overflow_corner_case
 569 %type    <node>         return_statement break_statement continue_statement
 570
 571 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 572 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 573 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 574 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 575 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 576 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 577 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 578 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 579 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 580 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 581 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 582 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 583 %type    <operator>     NEW_TK ASSERT_TK
 584
 585 %type    <node>         method_body
 586
 587 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 588                         STRING_LIT_TK NULL_TK VOID_TK
 589
 590 %type    <node>         IF_TK WHILE_TK FOR_TK
 591
 592 %type    <node>         formal_parameter_list formal_parameter
 593                         method_declarator method_header
 594
 595 %type    <node>         primitive_type reference_type type
 596                         BOOLEAN_TK INTEGRAL_TK FP_TK
 597
 598 /* Added or modified JDK 1.1 rule types  */
 599 %type    <node>         type_literals
 600
 601 %%
 602 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 603 goal:  compilation_unit
 604                 {}
 605 ;
 606
 607 /* 19.3 Productions from 3: Lexical structure  */
 608 literal:
 609         INT_LIT_TK
 610 |       FP_LIT_TK
 611 |       BOOL_LIT_TK
 612 |       CHAR_LIT_TK
 613 |       STRING_LIT_TK
 614 |       NULL_TK
 615 ;
 616
 617 /* 19.4 Productions from 4: Types, Values and Variables  */
 618 type:
 619         primitive_type
 620 |       reference_type
 621 ;
 622
 623 primitive_type:
 624         INTEGRAL_TK
 625 |       FP_TK
 626 |       BOOLEAN_TK
 627 ;
 628
 629 reference_type:
 630         class_or_interface_type
 631 |       array_type
 632 ;
 633
 634 class_or_interface_type:
 635         name
 636 ;
 637
 638 class_type:
 639         class_or_interface_type /* Default rule */
 640 ;
 641
 642 interface_type:
 643          class_or_interface_type
 644 ;
 645
 646 array_type:
 647         primitive_type dims
 648                 {
 649                   int osb = pop_current_osb (ctxp);
 650                   tree t = build_java_array_type (($1), -1);
 651                   while (--osb)
 652                     t = build_unresolved_array_type (t);
 653                   $$ = t;
 654                 }
 655 |       name dims
 656                 {
 657                   int osb = pop_current_osb (ctxp);
 658                   tree t = $1;
 659                   while (osb--)
 660                     t = build_unresolved_array_type (t);
 661                   $$ = t;
 662                 }
 663 ;
 664
 665 /* 19.5 Productions from 6: Names  */
 666 name:
 667         simple_name             /* Default rule */
 668 |       qualified_name          /* Default rule */
 669 ;
 670
 671 simple_name:
 672         identifier              /* Default rule */
 673 ;
 674
 675 qualified_name:
 676         name DOT_TK identifier
 677                 { $$ = make_qualified_name ($1, $3, $2.location); }
 678 ;
 679
 680 identifier:
 681         ID_TK
 682 ;
 683
 684 /* 19.6: Production from 7: Packages  */
 685 compilation_unit:
 686                 {$$ = NULL;}
 687 |       package_declaration
 688 |       import_declarations
 689 |       type_declarations
 690 |       package_declaration import_declarations
 691 |       package_declaration type_declarations
 692 |       import_declarations type_declarations
 693 |       package_declaration import_declarations type_declarations
 694 ;
 695
 696 import_declarations:
 697         import_declaration
 698                 {
 699                   $$ = NULL;
 700                 }
 701 |       import_declarations import_declaration
 702                 {
 703                   $$ = NULL;
 704                 }
 705 ;
 706
 707 type_declarations:
 708         type_declaration
 709 |       type_declarations type_declaration
 710 ;
 711
 712 package_declaration:
 713         PACKAGE_TK name SC_TK
 714                 {
 715                   ctxp->package = EXPR_WFL_NODE ($2);
 716                   register_package (ctxp->package);
 717                 }
 718 |       PACKAGE_TK error
 719                 {yyerror ("Missing name"); RECOVER;}
 720 |       PACKAGE_TK name error
 721                 {yyerror ("';' expected"); RECOVER;}
 722 ;
 723
 724 import_declaration:
 725         single_type_import_declaration
 726 |       type_import_on_demand_declaration
 727 ;
 728
 729 single_type_import_declaration:
 730         IMPORT_TK name SC_TK
 731                 {
 732                   tree name = EXPR_WFL_NODE ($2), last_name;
 733                   int   i = IDENTIFIER_LENGTH (name)-1;
 734                   const char *last = &IDENTIFIER_POINTER (name)[i];
 735                   while (last != IDENTIFIER_POINTER (name))
 736                     {
 737                       if (last [0] == '.')
 738                         break;
 739                       last--;
 740                     }
 741                   last_name = get_identifier (++last);
 742                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 743                     {
 744                       tree err = find_name_in_single_imports (last_name);
 745                       if (err && err != name)
 746                         parse_error_context
 747                           ($2, "Ambiguous class: `%s' and `%s'",
 748                            IDENTIFIER_POINTER (name),
 749                            IDENTIFIER_POINTER (err));
 750                       else
 751                         REGISTER_IMPORT ($2, last_name);
 752                     }
 753                   else
 754                     REGISTER_IMPORT ($2, last_name);
 755                 }
 756 |       IMPORT_TK error
 757                 {yyerror ("Missing name"); RECOVER;}
 758 |       IMPORT_TK name error
 759                 {yyerror ("';' expected"); RECOVER;}
 760 ;
 761
 762 type_import_on_demand_declaration:
 763         IMPORT_TK name DOT_TK MULT_TK SC_TK
 764                 {
 765                   tree name = EXPR_WFL_NODE ($2);
 766                   tree it;
 767                   /* Search for duplicates. */
 768                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 769                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 770                       break;
 771                   /* Don't import the same thing more than once, just ignore
 772                      duplicates (7.5.2) */
 773                   if (! it)
 774                     {
 775                       read_import_dir ($2);
 776                       ctxp->import_demand_list =
 777                         chainon (ctxp->import_demand_list,
 778                                  build_tree_list ($2, NULL_TREE));
 779                     }
 780                 }
 781 |       IMPORT_TK name DOT_TK error
 782                 {yyerror ("'*' expected"); RECOVER;}
 783 |       IMPORT_TK name DOT_TK MULT_TK error
 784                 {yyerror ("';' expected"); RECOVER;}
 785 ;
 786
 787 type_declaration:
 788         class_declaration
 789                 { end_class_declaration (0); }
 790 |       interface_declaration
 791                 { end_class_declaration (0); }
 792 |       empty_statement
 793 |       error
 794                 {
 795                   YYERROR_NOW;
 796                   yyerror ("Class or interface declaration expected");
 797                 }
 798 ;
 799
 800 /* 19.7 Shortened from the original:
 801    modifiers: modifier | modifiers modifier
 802    modifier: any of public...  */
 803 modifiers:
 804         MODIFIER_TK
 805                 {
 806                   $$ = (1 << $1);
 807                 }
 808 |       modifiers MODIFIER_TK
 809                 {
 810                   int acc = (1 << $2);
 811                   if ($$ & acc)
 812                     parse_error_context
 813                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 814                        java_accstring_lookup (acc));
 815                   else
 816                     {
 817                       $$ |= acc;
 818                     }
 819                 }
 820 ;
 821
 822 /* 19.8.1 Production from $8.1: Class Declaration */
 823 class_declaration:
 824         modifiers CLASS_TK identifier super interfaces
 825                 { create_class ($1, $3, $4, $5); }
 826         class_body
 827                 {;}
 828 |       CLASS_TK identifier super interfaces
 829                 { create_class (0, $2, $3, $4); }
 830         class_body
 831                 {;}
 832 |       modifiers CLASS_TK error
 833                 { yyerror ("Missing class name"); RECOVER; }
 834 |       CLASS_TK error
 835                 { yyerror ("Missing class name"); RECOVER; }
 836 |       CLASS_TK identifier error
 837                 {
 838                   if (!ctxp->class_err) yyerror ("'{' expected");
 839                   DRECOVER(class1);
 840                 }
 841 |       modifiers CLASS_TK identifier error
 842                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 843 ;
 844
 845 super:
 846                 { $$ = NULL; }
 847 |       EXTENDS_TK class_type
 848                 { $$ = $2; }
 849 |       EXTENDS_TK class_type error
 850                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 851 |       EXTENDS_TK error
 852                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 853 ;
 854
 855 interfaces:
 856                 { $$ = NULL_TREE; }
 857 |       IMPLEMENTS_TK interface_type_list
 858                 { $$ = $2; }
 859 |       IMPLEMENTS_TK error
 860                 {
 861                   ctxp->class_err=1;
 862                   yyerror ("Missing interface name");
 863                 }
 864 ;
 865
 866 interface_type_list:
 867         interface_type
 868                 {
 869                   ctxp->interface_number = 1;
 870                   $$ = build_tree_list ($1, NULL_TREE);
 871                 }
 872 |       interface_type_list C_TK interface_type
 873                 {
 874                   ctxp->interface_number++;
 875                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 876                 }
 877 |       interface_type_list C_TK error
 878                 {yyerror ("Missing interface name"); RECOVER;}
 879 ;
 880
 881 class_body:
 882         OCB_TK CCB_TK
 883                 {
 884                   /* Store the location of the `}' when doing xrefs */
 885                   if (flag_emit_xref)
 886                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 887                       EXPR_WFL_ADD_COL ($2.location, 1);
 888                   $$ = GET_CPC ();
 889                 }
 890 |       OCB_TK class_body_declarations CCB_TK
 891                 {
 892                   /* Store the location of the `}' when doing xrefs */
 893                   if (flag_emit_xref)
 894                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 895                       EXPR_WFL_ADD_COL ($3.location, 1);
 896                   $$ = GET_CPC ();
 897                 }
 898 ;
 899
 900 class_body_declarations:
 901         class_body_declaration
 902 |       class_body_declarations class_body_declaration
 903 ;
 904
 905 class_body_declaration:
 906         class_member_declaration
 907 |       static_initializer
 908 |       constructor_declaration
 909 |       block                   /* Added, JDK1.1, instance initializer */
 910                 {
 911                   if ($1 != empty_stmt_node)
 912                     {
 913                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 914                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 915                     }
 916                 }
 917 ;
 918
 919 class_member_declaration:
 920         field_declaration
 921 |       method_declaration
 922 |       class_declaration       /* Added, JDK1.1 inner classes */
 923                 { end_class_declaration (1); }
 924 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 925                 { end_class_declaration (1); }
 926 |       empty_statement
 927 ;
 928
 929 /* 19.8.2 Productions from 8.3: Field Declarations  */
 930 field_declaration:
 931         type variable_declarators SC_TK
 932                 { register_fields (0, $1, $2); }
 933 |       modifiers type variable_declarators SC_TK
 934                 {
 935                   check_modifiers
 936                     ("Illegal modifier `%s' for field declaration",
 937                      $1, FIELD_MODIFIERS);
 938                   check_modifiers_consistency ($1);
 939                   register_fields ($1, $2, $3);
 940                 }
 941 ;
 942
 943 variable_declarators:
 944         /* Should we use build_decl_list () instead ? FIXME */
 945         variable_declarator     /* Default rule */
 946 |       variable_declarators C_TK variable_declarator
 947                 { $$ = chainon ($1, $3); }
 948 |       variable_declarators C_TK error
 949                 {yyerror ("Missing term"); RECOVER;}
 950 ;
 951
 952 variable_declarator:
 953         variable_declarator_id
 954                 { $$ = build_tree_list ($1, NULL_TREE); }
 955 |       variable_declarator_id ASSIGN_TK variable_initializer
 956                 {
 957                   if (java_error_count)
 958                     $3 = NULL_TREE;
 959                   $$ = build_tree_list
 960                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 961                 }
 962 |       variable_declarator_id ASSIGN_TK error
 963                 {
 964                   yyerror ("Missing variable initializer");
 965                   $$ = build_tree_list ($1, NULL_TREE);
 966                   RECOVER;
 967                 }
 968 |       variable_declarator_id ASSIGN_TK variable_initializer error
 969                 {
 970                   yyerror ("';' expected");
 971                   $$ = build_tree_list ($1, NULL_TREE);
 972                   RECOVER;
 973                 }
 974 ;
 975
 976 variable_declarator_id:
 977         identifier
 978 |       variable_declarator_id OSB_TK CSB_TK
 979                 { $$ = build_unresolved_array_type ($1); }
 980 |       identifier error
 981                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 982 |       variable_declarator_id OSB_TK error
 983                 {
 984                   yyerror ("']' expected");
 985                   DRECOVER(vdi);
 986                 }
 987 |       variable_declarator_id CSB_TK error
 988                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 989 ;
 990
 991 variable_initializer:
 992         expression
 993 |       array_initializer
 994 ;
 995
 996 /* 19.8.3 Productions from 8.4: Method Declarations  */
 997 method_declaration:
 998         method_header
 999                 {
1000                   current_function_decl = $1;
1001                   if (current_function_decl
1002                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1003                     source_start_java_method (current_function_decl);
1004                   else
1005                     current_function_decl = NULL_TREE;
1006                 }
1007         method_body
1008                 { finish_method_declaration ($3); }
1009 |       method_header error
1010                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1011 ;
1012
1013 method_header:
1014         type method_declarator throws
1015                 { $$ = method_header (0, $1, $2, $3); }
1016 |       VOID_TK method_declarator throws
1017                 { $$ = method_header (0, void_type_node, $2, $3); }
1018 |       modifiers type method_declarator throws
1019                 { $$ = method_header ($1, $2, $3, $4); }
1020 |       modifiers VOID_TK method_declarator throws
1021                 { $$ = method_header ($1, void_type_node, $3, $4); }
1022 |       type error
1023                 {
1024                   yyerror ("Invalid method declaration, method name required");
1025                   RECOVER;
1026                 }
1027 |       modifiers type error
1028                 {
1029                   yyerror ("Identifier expected");
1030                   RECOVER;
1031                 }
1032 |       VOID_TK error
1033                 {
1034                   yyerror ("Identifier expected");
1035                   RECOVER;
1036                 }
1037 |       modifiers VOID_TK error
1038                 {
1039                   yyerror ("Identifier expected");
1040                   RECOVER;
1041                 }
1042 |       modifiers error
1043                 {
1044                   yyerror ("Invalid method declaration, return type required");
1045                   RECOVER;
1046                 }
1047 ;
1048
1049 method_declarator:
1050         identifier OP_TK CP_TK
1051                 {
1052                   ctxp->formal_parameter_number = 0;
1053                   $$ = method_declarator ($1, NULL_TREE);
1054                 }
1055 |       identifier OP_TK formal_parameter_list CP_TK
1056                 { $$ = method_declarator ($1, $3); }
1057 |       method_declarator OSB_TK CSB_TK
1058                 {
1059                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1060                   TREE_PURPOSE ($1) =
1061                     build_unresolved_array_type (TREE_PURPOSE ($1));
1062                   parse_warning_context
1063                     (wfl_operator,
1064                      "Discouraged form of returned type specification");
1065                 }
1066 |       identifier OP_TK error
1067                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1068 |       method_declarator OSB_TK error
1069                 {yyerror ("']' expected"); RECOVER;}
1070 ;
1071
1072 formal_parameter_list:
1073         formal_parameter
1074                 {
1075                   ctxp->formal_parameter_number = 1;
1076                 }
1077 |       formal_parameter_list C_TK formal_parameter
1078                 {
1079                   ctxp->formal_parameter_number += 1;
1080                   $$ = chainon ($1, $3);
1081                 }
1082 |       formal_parameter_list C_TK error
1083                 { yyerror ("Missing formal parameter term"); RECOVER; }
1084 ;
1085
1086 formal_parameter:
1087         type variable_declarator_id
1088                 {
1089                   $$ = build_tree_list ($2, $1);
1090                 }
1091 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1092                 {
1093                   $$ = build_tree_list ($3, $2);
1094                   ARG_FINAL_P ($$) = 1;
1095                 }
1096 |       type error
1097                 {
1098                   yyerror ("Missing identifier"); RECOVER;
1099                   $$ = NULL_TREE;
1100                 }
1101 |       final type error
1102                 {
1103                   yyerror ("Missing identifier"); RECOVER;
1104                   $$ = NULL_TREE;
1105                 }
1106 ;
1107
1108 final:
1109         modifiers
1110                 {
1111                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1112                                    $1, ACC_FINAL);
1113                   if ($1 != ACC_FINAL)
1114                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1115                 }
1116 ;
1117
1118 throws:
1119                 { $$ = NULL_TREE; }
1120 |       THROWS_TK class_type_list
1121                 { $$ = $2; }
1122 |       THROWS_TK error
1123                 {yyerror ("Missing class type term"); RECOVER;}
1124 ;
1125
1126 class_type_list:
1127         class_type
1128                 { $$ = build_tree_list ($1, $1); }
1129 |       class_type_list C_TK class_type
1130                 { $$ = tree_cons ($3, $3, $1); }
1131 |       class_type_list C_TK error
1132                 {yyerror ("Missing class type term"); RECOVER;}
1133 ;
1134
1135 method_body:
1136         block
1137 |       SC_TK { $$ = NULL_TREE; }
1138 ;
1139
1140 /* 19.8.4 Productions from 8.5: Static Initializers  */
1141 static_initializer:
1142         static block
1143                 {
1144                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1145                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1146                   current_static_block = NULL_TREE;
1147                 }
1148 ;
1149
1150 static:                         /* Test lval.sub_token here */
1151         modifiers
1152                 {
1153                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1154                   /* Can't have a static initializer in an innerclass */
1155                   if ($1 | ACC_STATIC &&
1156                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1157                     parse_error_context
1158                       (MODIFIER_WFL (STATIC_TK),
1159                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1160                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1161                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1162                 }
1163 ;
1164
1165 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1166 constructor_declaration:
1167         constructor_header
1168                 {
1169                   current_function_decl = $1;
1170                   source_start_java_method (current_function_decl);
1171                 }
1172         constructor_body
1173                 { finish_method_declaration ($3); }
1174 ;
1175
1176 constructor_header:
1177         constructor_declarator throws
1178                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1179 |       modifiers constructor_declarator throws
1180                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1181 ;
1182
1183 constructor_declarator:
1184         simple_name OP_TK CP_TK
1185                 {
1186                   ctxp->formal_parameter_number = 0;
1187                   $$ = method_declarator ($1, NULL_TREE);
1188                 }
1189 |       simple_name OP_TK formal_parameter_list CP_TK
1190                 { $$ = method_declarator ($1, $3); }
1191 ;
1192
1193 constructor_body:
1194         /* Unlike regular method, we always need a complete (empty)
1195            body so we can safely perform all the required code
1196            addition (super invocation and field initialization) */
1197         block_begin constructor_block_end
1198                 {
1199                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1200                   $$ = $2;
1201                 }
1202 |       block_begin explicit_constructor_invocation constructor_block_end
1203                 { $$ = $3; }
1204 |       block_begin block_statements constructor_block_end
1205                 { $$ = $3; }
1206 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1207                 { $$ = $4; }
1208 ;
1209
1210 constructor_block_end:
1211         block_end
1212 ;
1213
1214 /* Error recovery for that rule moved down expression_statement: rule.  */
1215 explicit_constructor_invocation:
1216         this_or_super OP_TK CP_TK SC_TK
1217                 {
1218                   $$ = build_method_invocation ($1, NULL_TREE);
1219                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1220                   $$ = java_method_add_stmt (current_function_decl, $$);
1221                 }
1222 |       this_or_super OP_TK argument_list CP_TK SC_TK
1223                 {
1224                   $$ = build_method_invocation ($1, $3);
1225                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1226                   $$ = java_method_add_stmt (current_function_decl, $$);
1227                 }
1228         /* Added, JDK1.1 inner classes. Modified because the rule
1229            'primary' couldn't work.  */
1230 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1231                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1232 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1233                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1234 ;
1235
1236 this_or_super:                  /* Added, simplifies error diagnostics */
1237         THIS_TK
1238                 {
1239                   tree wfl = build_wfl_node (this_identifier_node);
1240                   EXPR_WFL_LINECOL (wfl) = $1.location;
1241                   $$ = wfl;
1242                 }
1243 |       SUPER_TK
1244                 {
1245                   tree wfl = build_wfl_node (super_identifier_node);
1246                   EXPR_WFL_LINECOL (wfl) = $1.location;
1247                   $$ = wfl;
1248                 }
1249 ;
1250
1251 /* 19.9 Productions from 9: Interfaces  */
1252 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1253 interface_declaration:
1254         INTERFACE_TK identifier
1255                 { create_interface (0, $2, NULL_TREE); }
1256         interface_body
1257                 { ; }
1258 |       modifiers INTERFACE_TK identifier
1259                 { create_interface ($1, $3, NULL_TREE); }
1260         interface_body
1261                 { ; }
1262 |       INTERFACE_TK identifier extends_interfaces
1263                 { create_interface (0, $2, $3); }
1264         interface_body
1265                 { ; }
1266 |       modifiers INTERFACE_TK identifier extends_interfaces
1267                 { create_interface ($1, $3, $4); }
1268         interface_body
1269                 { ; }
1270 |       INTERFACE_TK identifier error
1271                 { yyerror ("'{' expected"); RECOVER; }
1272 |       modifiers INTERFACE_TK identifier error
1273                 { yyerror ("'{' expected"); RECOVER; }
1274 ;
1275
1276 extends_interfaces:
1277         EXTENDS_TK interface_type
1278                 {
1279                   ctxp->interface_number = 1;
1280                   $$ = build_tree_list ($2, NULL_TREE);
1281                 }
1282 |       extends_interfaces C_TK interface_type
1283                 {
1284                   ctxp->interface_number++;
1285                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1286                 }
1287 |       EXTENDS_TK error
1288                 {yyerror ("Invalid interface type"); RECOVER;}
1289 |       extends_interfaces C_TK error
1290                 {yyerror ("Missing term"); RECOVER;}
1291 ;
1292
1293 interface_body:
1294         OCB_TK CCB_TK
1295                 { $$ = NULL_TREE; }
1296 |       OCB_TK interface_member_declarations CCB_TK
1297                 { $$ = NULL_TREE; }
1298 ;
1299
1300 interface_member_declarations:
1301         interface_member_declaration
1302 |       interface_member_declarations interface_member_declaration
1303 ;
1304
1305 interface_member_declaration:
1306         constant_declaration
1307 |       abstract_method_declaration
1308 |       class_declaration       /* Added, JDK1.1 inner classes */
1309                 { end_class_declaration (1); }
1310 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1311                 { end_class_declaration (1); }
1312 ;
1313
1314 constant_declaration:
1315         field_declaration
1316 ;
1317
1318 abstract_method_declaration:
1319         method_header SC_TK
1320                 {
1321                   check_abstract_method_header ($1);
1322                   current_function_decl = NULL_TREE; /* FIXME ? */
1323                 }
1324 |       method_header error
1325                 {yyerror ("';' expected"); RECOVER;}
1326 ;
1327
1328 /* 19.10 Productions from 10: Arrays  */
1329 array_initializer:
1330         OCB_TK CCB_TK
1331                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1332 |       OCB_TK C_TK CCB_TK
1333                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1334 |       OCB_TK variable_initializers CCB_TK
1335                 { $$ = build_new_array_init ($1.location, $2); }
1336 |       OCB_TK variable_initializers C_TK CCB_TK
1337                 { $$ = build_new_array_init ($1.location, $2); }
1338 ;
1339
1340 variable_initializers:
1341         variable_initializer
1342                 {
1343                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1344                                   $1, NULL_TREE);
1345                 }
1346 |       variable_initializers C_TK variable_initializer
1347                 {
1348                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1349                 }
1350 |       variable_initializers C_TK error
1351                 {yyerror ("Missing term"); RECOVER;}
1352 ;
1353
1354 /* 19.11 Production from 14: Blocks and Statements  */
1355 block:
1356         block_begin block_end
1357                 { $$ = $2; }
1358 |       block_begin block_statements block_end
1359                 { $$ = $3; }
1360 ;
1361
1362 block_begin:
1363         OCB_TK
1364                 { enter_block (); }
1365 ;
1366
1367 block_end:
1368         CCB_TK
1369                 {
1370                   maybe_absorb_scoping_blocks ();
1371                   /* Store the location of the `}' when doing xrefs */
1372                   if (current_function_decl && flag_emit_xref)
1373                     DECL_END_SOURCE_LINE (current_function_decl) =
1374                       EXPR_WFL_ADD_COL ($1.location, 1);
1375                   $$ = exit_block ();
1376                   if (!BLOCK_SUBBLOCKS ($$))
1377                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1378                 }
1379 ;
1380
1381 block_statements:
1382         block_statement
1383 |       block_statements block_statement
1384 ;
1385
1386 block_statement:
1387         local_variable_declaration_statement
1388 |       statement
1389                 { java_method_add_stmt (current_function_decl, $1); }
1390 |       class_declaration       /* Added, JDK1.1 local classes */
1391                 {
1392                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1393                   end_class_declaration (1);
1394                 }
1395 ;
1396
1397 local_variable_declaration_statement:
1398         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1399 ;
1400
1401 local_variable_declaration:
1402         type variable_declarators
1403                 { declare_local_variables (0, $1, $2); }
1404 |       final type variable_declarators /* Added, JDK1.1 final locals */
1405                 { declare_local_variables ($1, $2, $3); }
1406 ;
1407
1408 statement:
1409         statement_without_trailing_substatement
1410 |       labeled_statement
1411 |       if_then_statement
1412 |       if_then_else_statement
1413 |       while_statement
1414 |       for_statement
1415                 { $$ = exit_block (); }
1416 ;
1417
1418 statement_nsi:
1419         statement_without_trailing_substatement
1420 |       labeled_statement_nsi
1421 |       if_then_else_statement_nsi
1422 |       while_statement_nsi
1423 |       for_statement_nsi
1424                 { $$ = exit_block (); }
1425 ;
1426
1427 statement_without_trailing_substatement:
1428         block
1429 |       empty_statement
1430 |       expression_statement
1431 |       switch_statement
1432 |       do_statement
1433 |       break_statement
1434 |       continue_statement
1435 |       return_statement
1436 |       synchronized_statement
1437 |       throw_statement
1438 |       try_statement
1439 |       assert_statement
1440 ;
1441
1442 empty_statement:
1443         SC_TK
1444                 {
1445                   if (flag_extraneous_semicolon
1446                       && ! current_static_block
1447                       && (! current_function_decl ||
1448                           /* Verify we're not in a inner class declaration */
1449                           (GET_CPC () != TYPE_NAME
1450                            (DECL_CONTEXT (current_function_decl)))))
1451
1452                     {
1453                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1454                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1455                     }
1456                   $$ = empty_stmt_node;
1457                 }
1458 ;
1459
1460 label_decl:
1461         identifier REL_CL_TK
1462                 {
1463                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1464                                             EXPR_WFL_NODE ($1));
1465                   pushlevel (2);
1466                   push_labeled_block ($$);
1467                   PUSH_LABELED_BLOCK ($$);
1468                 }
1469 ;
1470
1471 labeled_statement:
1472         label_decl statement
1473                 { $$ = finish_labeled_statement ($1, $2); }
1474 |       identifier error
1475                 {yyerror ("':' expected"); RECOVER;}
1476 ;
1477
1478 labeled_statement_nsi:
1479         label_decl statement_nsi
1480                 { $$ = finish_labeled_statement ($1, $2); }
1481 ;
1482
1483 /* We concentrate here a bunch of error handling rules that we couldn't write
1484    earlier, because expression_statement catches a missing ';'.  */
1485 expression_statement:
1486         statement_expression SC_TK
1487                 {
1488                   /* We have a statement. Generate a WFL around it so
1489                      we can debug it */
1490                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1491                   /* We know we have a statement, so set the debug
1492                      info to be eventually generate here. */
1493                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1494                 }
1495 |       error SC_TK
1496                 {
1497                   YYNOT_TWICE yyerror ("Invalid expression statement");
1498                   DRECOVER (expr_stmt);
1499                 }
1500 |       error OCB_TK
1501                 {
1502                   YYNOT_TWICE yyerror ("Invalid expression statement");
1503                   DRECOVER (expr_stmt);
1504                 }
1505 |       error CCB_TK
1506                 {
1507                   YYNOT_TWICE yyerror ("Invalid expression statement");
1508                   DRECOVER (expr_stmt);
1509                 }
1510 |       this_or_super OP_TK error
1511                 {yyerror ("')' expected"); RECOVER;}
1512 |       this_or_super OP_TK CP_TK error
1513                 {
1514                   parse_ctor_invocation_error ();
1515                   RECOVER;
1516                 }
1517 |       this_or_super OP_TK argument_list error
1518                 {yyerror ("')' expected"); RECOVER;}
1519 |       this_or_super OP_TK argument_list CP_TK error
1520                 {
1521                   parse_ctor_invocation_error ();
1522                   RECOVER;
1523                 }
1524 |       name DOT_TK SUPER_TK error
1525                 {yyerror ("'(' expected"); RECOVER;}
1526 |       name DOT_TK SUPER_TK OP_TK error
1527                 {yyerror ("')' expected"); RECOVER;}
1528 |       name DOT_TK SUPER_TK OP_TK argument_list error
1529                 {yyerror ("')' expected"); RECOVER;}
1530 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1531                 {yyerror ("';' expected"); RECOVER;}
1532 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1533                 {yyerror ("';' expected"); RECOVER;}
1534 ;
1535
1536 statement_expression:
1537         assignment
1538 |       pre_increment_expression
1539 |       pre_decrement_expression
1540 |       post_increment_expression
1541 |       post_decrement_expression
1542 |       method_invocation
1543 |       class_instance_creation_expression
1544 ;
1545
1546 if_then_statement:
1547         IF_TK OP_TK expression CP_TK statement
1548                 {
1549                   $$ = build_if_else_statement ($2.location, $3,
1550                                                 $5, NULL_TREE);
1551                 }
1552 |       IF_TK error
1553                 {yyerror ("'(' expected"); RECOVER;}
1554 |       IF_TK OP_TK error
1555                 {yyerror ("Missing term"); RECOVER;}
1556 |       IF_TK OP_TK expression error
1557                 {yyerror ("')' expected"); RECOVER;}
1558 ;
1559
1560 if_then_else_statement:
1561         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1562                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1563 ;
1564
1565 if_then_else_statement_nsi:
1566         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1567                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1568 ;
1569
1570 switch_statement:
1571         switch_expression
1572                 {
1573                   enter_block ();
1574                 }
1575         switch_block
1576                 {
1577                   /* Make into "proper list" of COMPOUND_EXPRs.
1578                      I.e. make the last statement also have its own
1579                      COMPOUND_EXPR. */
1580                   maybe_absorb_scoping_blocks ();
1581                   TREE_OPERAND ($1, 1) = exit_block ();
1582                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1583                 }
1584 ;
1585
1586 switch_expression:
1587         SWITCH_TK OP_TK expression CP_TK
1588                 {
1589                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1590                   EXPR_WFL_LINECOL ($$) = $2.location;
1591                 }
1592 |       SWITCH_TK error
1593                 {yyerror ("'(' expected"); RECOVER;}
1594 |       SWITCH_TK OP_TK error
1595                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1596 |       SWITCH_TK OP_TK expression CP_TK error
1597                 {yyerror ("'{' expected"); RECOVER;}
1598 ;
1599
1600 /* Default assignment is there to avoid type node on switch_block
1601    node. */
1602
1603 switch_block:
1604         OCB_TK CCB_TK
1605                 { $$ = NULL_TREE; }
1606 |       OCB_TK switch_labels CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_block_statement_groups CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1611                 { $$ = NULL_TREE; }
1612 ;
1613
1614 switch_block_statement_groups:
1615         switch_block_statement_group
1616 |       switch_block_statement_groups switch_block_statement_group
1617 ;
1618
1619 switch_block_statement_group:
1620         switch_labels block_statements
1621 ;
1622
1623 switch_labels:
1624         switch_label
1625 |       switch_labels switch_label
1626 ;
1627
1628 switch_label:
1629         CASE_TK constant_expression REL_CL_TK
1630                 {
1631                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1632                   EXPR_WFL_LINECOL (lab) = $1.location;
1633                   java_method_add_stmt (current_function_decl, lab);
1634                 }
1635 |       DEFAULT_TK REL_CL_TK
1636                 {
1637                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1638                   EXPR_WFL_LINECOL (lab) = $1.location;
1639                   java_method_add_stmt (current_function_decl, lab);
1640                 }
1641 |       CASE_TK error
1642                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1643 |       CASE_TK constant_expression error
1644                 {yyerror ("':' expected"); RECOVER;}
1645 |       DEFAULT_TK error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 ;
1648
1649 while_expression:
1650         WHILE_TK OP_TK expression CP_TK
1651                 {
1652                   tree body = build_loop_body ($2.location, $3, 0);
1653                   $$ = build_new_loop (body);
1654                 }
1655 ;
1656
1657 while_statement:
1658         while_expression statement
1659                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1660 |       WHILE_TK error
1661                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1662 |       WHILE_TK OP_TK error
1663                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK expression error
1665                 {yyerror ("')' expected"); RECOVER;}
1666 ;
1667
1668 while_statement_nsi:
1669         while_expression statement_nsi
1670                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1671 ;
1672
1673 do_statement_begin:
1674         DO_TK
1675                 {
1676                   tree body = build_loop_body (0, NULL_TREE, 1);
1677                   $$ = build_new_loop (body);
1678                 }
1679         /* Need error handing here. FIXME */
1680 ;
1681
1682 do_statement:
1683         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1684                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1685 ;
1686
1687 for_statement:
1688         for_begin SC_TK expression SC_TK for_update CP_TK statement
1689                 {
1690                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1691                     $3 = build_wfl_node ($3);
1692                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1693                 }
1694 |       for_begin SC_TK SC_TK for_update CP_TK statement
1695                 {
1696                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1697                   /* We have not condition, so we get rid of the EXIT_EXPR */
1698                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1699                     empty_stmt_node;
1700                 }
1701 |       for_begin SC_TK error
1702                 {yyerror ("Invalid control expression"); RECOVER;}
1703 |       for_begin SC_TK expression SC_TK error
1704                 {yyerror ("Invalid update expression"); RECOVER;}
1705 |       for_begin SC_TK SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 ;
1708
1709 for_statement_nsi:
1710         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1711                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1712 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1713                 {
1714                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1715                   /* We have not condition, so we get rid of the EXIT_EXPR */
1716                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1717                     empty_stmt_node;
1718                 }
1719 ;
1720
1721 for_header:
1722         FOR_TK OP_TK
1723                 {
1724                   /* This scope defined for local variable that may be
1725                      defined within the scope of the for loop */
1726                   enter_block ();
1727                 }
1728 |       FOR_TK error
1729                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1730 |       FOR_TK OP_TK error
1731                 {yyerror ("Invalid init statement"); RECOVER;}
1732 ;
1733
1734 for_begin:
1735         for_header for_init
1736                 {
1737                   /* We now declare the loop body. The loop is
1738                      declared as a for loop. */
1739                   tree body = build_loop_body (0, NULL_TREE, 0);
1740                   $$ =  build_new_loop (body);
1741                   FOR_LOOP_P ($$) = 1;
1742                   /* The loop is added to the current block the for
1743                      statement is defined within */
1744                   java_method_add_stmt (current_function_decl, $$);
1745                 }
1746 ;
1747 for_init:                       /* Can be empty */
1748                 { $$ = empty_stmt_node; }
1749 |       statement_expression_list
1750                 {
1751                   /* Init statement recorded within the previously
1752                      defined block scope */
1753                   $$ = java_method_add_stmt (current_function_decl, $1);
1754                 }
1755 |       local_variable_declaration
1756                 {
1757                   /* Local variable are recorded within the previously
1758                      defined block scope */
1759                   $$ = NULL_TREE;
1760                 }
1761 |       statement_expression_list error
1762                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1763 ;
1764
1765 for_update:                     /* Can be empty */
1766                 {$$ = empty_stmt_node;}
1767 |       statement_expression_list
1768                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1769 ;
1770
1771 statement_expression_list:
1772         statement_expression
1773                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1774 |       statement_expression_list C_TK statement_expression
1775                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1776 |       statement_expression_list C_TK error
1777                 {yyerror ("Missing term"); RECOVER;}
1778 ;
1779
1780 break_statement:
1781         BREAK_TK SC_TK
1782                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1783 |       BREAK_TK identifier SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, $2); }
1785 |       BREAK_TK error
1786                 {yyerror ("Missing term"); RECOVER;}
1787 |       BREAK_TK identifier error
1788                 {yyerror ("';' expected"); RECOVER;}
1789 ;
1790
1791 continue_statement:
1792         CONTINUE_TK SC_TK
1793                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1794 |       CONTINUE_TK identifier SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, $2); }
1796 |       CONTINUE_TK error
1797                 {yyerror ("Missing term"); RECOVER;}
1798 |       CONTINUE_TK identifier error
1799                 {yyerror ("';' expected"); RECOVER;}
1800 ;
1801
1802 return_statement:
1803         RETURN_TK SC_TK
1804                 { $$ = build_return ($1.location, NULL_TREE); }
1805 |       RETURN_TK expression SC_TK
1806                 { $$ = build_return ($1.location, $2); }
1807 |       RETURN_TK error
1808                 {yyerror ("Missing term"); RECOVER;}
1809 |       RETURN_TK expression error
1810                 {yyerror ("';' expected"); RECOVER;}
1811 ;
1812
1813 throw_statement:
1814         THROW_TK expression SC_TK
1815                 {
1816                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1817                   EXPR_WFL_LINECOL ($$) = $1.location;
1818                 }
1819 |       THROW_TK error
1820                 {yyerror ("Missing term"); RECOVER;}
1821 |       THROW_TK expression error
1822                 {yyerror ("';' expected"); RECOVER;}
1823 ;
1824
1825 assert_statement:
1826         ASSERT_TK expression REL_CL_TK expression SC_TK
1827                 {
1828                   $$ = build_assertion ($1.location, $2, $4);
1829                 }
1830 |       ASSERT_TK expression SC_TK
1831                 {
1832                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1833                 }
1834 |       ASSERT_TK error
1835                 {yyerror ("Missing term"); RECOVER;}
1836 |       ASSERT_TK expression error
1837                 {yyerror ("';' expected"); RECOVER;}
1838 ;
1839
1840 synchronized_statement:
1841         synchronized OP_TK expression CP_TK block
1842                 {
1843                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1844                   EXPR_WFL_LINECOL ($$) =
1845                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1846                 }
1847 |       synchronized OP_TK expression CP_TK error
1848                 {yyerror ("'{' expected"); RECOVER;}
1849 |       synchronized error
1850                 {yyerror ("'(' expected"); RECOVER;}
1851 |       synchronized OP_TK error CP_TK
1852                 {yyerror ("Missing term"); RECOVER;}
1853 |       synchronized OP_TK error
1854                 {yyerror ("Missing term"); RECOVER;}
1855 ;
1856
1857 synchronized:
1858         modifiers
1859                 {
1860                   check_modifiers (
1861              "Illegal modifier `%s'. Only `synchronized' was expected here",
1862                                    $1, ACC_SYNCHRONIZED);
1863                   if ($1 != ACC_SYNCHRONIZED)
1864                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1865                       build_wfl_node (NULL_TREE);
1866                 }
1867 ;
1868
1869 try_statement:
1870         TRY_TK block catches
1871                 { $$ = build_try_statement ($1.location, $2, $3); }
1872 |       TRY_TK block finally
1873                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1874 |       TRY_TK block catches finally
1875                 { $$ = build_try_finally_statement
1876                     ($1.location, build_try_statement ($1.location,
1877                                                        $2, $3), $4);
1878                 }
1879 |       TRY_TK error
1880                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1881 ;
1882
1883 catches:
1884         catch_clause
1885 |       catches catch_clause
1886                 {
1887                   TREE_CHAIN ($2) = $1;
1888                   $$ = $2;
1889                 }
1890 ;
1891
1892 catch_clause:
1893         catch_clause_parameter block
1894                 {
1895                   java_method_add_stmt (current_function_decl, $2);
1896                   exit_block ();
1897                   $$ = $1;
1898                 }
1899 ;
1900
1901 catch_clause_parameter:
1902         CATCH_TK OP_TK formal_parameter CP_TK
1903                 {
1904                   /* We add a block to define a scope for
1905                      formal_parameter (CCBP). The formal parameter is
1906                      declared initialized by the appropriate function
1907                      call */
1908                   tree ccpb = enter_block ();
1909                   tree init = build_assignment
1910                     (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1911                      build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1912                   declare_local_variables (0, TREE_VALUE ($3),
1913                                            build_tree_list (TREE_PURPOSE ($3),
1914                                                             init));
1915                   $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1916                   EXPR_WFL_LINECOL ($$) = $1.location;
1917                 }
1918 |       CATCH_TK error
1919                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1920 |       CATCH_TK OP_TK error
1921                 {
1922                   yyerror ("Missing term or ')' expected");
1923                   RECOVER; $$ = NULL_TREE;
1924                 }
1925 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1926                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1927 ;
1928
1929 finally:
1930         FINALLY_TK block
1931                 { $$ = $2; }
1932 |       FINALLY_TK error
1933                 {yyerror ("'{' expected"); RECOVER; }
1934 ;
1935
1936 /* 19.12 Production from 15: Expressions  */
1937 primary:
1938         primary_no_new_array
1939 |       array_creation_expression
1940 ;
1941
1942 primary_no_new_array:
1943         literal
1944 |       THIS_TK
1945                 { $$ = build_this ($1.location); }
1946 |       OP_TK expression CP_TK
1947                 {$$ = $2;}
1948 |       class_instance_creation_expression
1949 |       field_access
1950 |       method_invocation
1951 |       array_access
1952 |       type_literals
1953         /* Added, JDK1.1 inner classes. Documentation is wrong
1954            refering to a 'ClassName' (class_name) rule that doesn't
1955            exist. Used name: instead.  */
1956 |       name DOT_TK THIS_TK
1957                 {
1958                   tree wfl = build_wfl_node (this_identifier_node);
1959                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1960                 }
1961 |       OP_TK expression error
1962                 {yyerror ("')' expected"); RECOVER;}
1963 |       name DOT_TK error
1964                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1965 |       primitive_type DOT_TK error
1966                 {yyerror ("'class' expected" ); RECOVER;}
1967 |       VOID_TK DOT_TK error
1968                 {yyerror ("'class' expected" ); RECOVER;}
1969 ;
1970
1971 type_literals:
1972         name DOT_TK CLASS_TK
1973                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1974 |       array_type DOT_TK CLASS_TK
1975                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1976 |       primitive_type DOT_TK CLASS_TK
1977                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1978 |       VOID_TK DOT_TK CLASS_TK
1979                 {
1980                    $$ = build_incomplete_class_ref ($2.location,
1981                                                    void_type_node);
1982                 }
1983 ;
1984
1985 class_instance_creation_expression:
1986         NEW_TK class_type OP_TK argument_list CP_TK
1987                 { $$ = build_new_invocation ($2, $4); }
1988 |       NEW_TK class_type OP_TK CP_TK
1989                 { $$ = build_new_invocation ($2, NULL_TREE); }
1990 |       anonymous_class_creation
1991         /* Added, JDK1.1 inner classes, modified to use name or
1992            primary instead of primary solely which couldn't work in
1993            all situations.  */
1994 |       something_dot_new identifier OP_TK CP_TK
1995                 {
1996                   tree ctor = build_new_invocation ($2, NULL_TREE);
1997                   $$ = make_qualified_primary ($1, ctor,
1998                                                EXPR_WFL_LINECOL ($1));
1999                 }
2000 |       something_dot_new identifier OP_TK CP_TK class_body
2001 |       something_dot_new identifier OP_TK argument_list CP_TK
2002                 {
2003                   tree ctor = build_new_invocation ($2, $4);
2004                   $$ = make_qualified_primary ($1, ctor,
2005                                                EXPR_WFL_LINECOL ($1));
2006                 }
2007 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2008 |       NEW_TK error SC_TK
2009                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2010 |       NEW_TK class_type error
2011                 {yyerror ("'(' expected"); RECOVER;}
2012 |       NEW_TK class_type OP_TK error
2013                 {yyerror ("')' or term expected"); RECOVER;}
2014 |       NEW_TK class_type OP_TK argument_list error
2015                 {yyerror ("')' expected"); RECOVER;}
2016 |       something_dot_new error
2017                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2018 |       something_dot_new identifier error
2019                 {yyerror ("'(' expected"); RECOVER;}
2020 ;
2021
2022 /* Created after JDK1.1 rules originally added to
2023    class_instance_creation_expression, but modified to use
2024    'class_type' instead of 'TypeName' (type_name) which is mentionned
2025    in the documentation but doesn't exist. */
2026
2027 anonymous_class_creation:
2028         NEW_TK class_type OP_TK argument_list CP_TK
2029                 { create_anonymous_class ($1.location, $2); }
2030         class_body
2031                 {
2032                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2033                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2034
2035                   end_class_declaration (1);
2036
2037                   /* Now we can craft the new expression */
2038                   $$ = build_new_invocation (id, $4);
2039
2040                   /* Note that we can't possibly be here if
2041                      `class_type' is an interface (in which case the
2042                      anonymous class extends Object and implements
2043                      `class_type', hence its constructor can't have
2044                      arguments.) */
2045
2046                   /* Otherwise, the innerclass must feature a
2047                      constructor matching `argument_list'. Anonymous
2048                      classes are a bit special: it's impossible to
2049                      define constructor for them, hence constructors
2050                      must be generated following the hints provided by
2051                      the `new' expression. Whether a super constructor
2052                      of that nature exists or not is to be verified
2053                      later on in verify_constructor_super.
2054
2055                      It's during the expansion of a `new' statement
2056                      refering to an anonymous class that a ctor will
2057                      be generated for the anonymous class, with the
2058                      right arguments. */
2059
2060                 }
2061 |       NEW_TK class_type OP_TK CP_TK
2062                 { create_anonymous_class ($1.location, $2); }
2063         class_body
2064                 {
2065                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2066                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2067
2068                   end_class_declaration (1);
2069
2070                   /* Now we can craft the new expression. The
2071                      statement doesn't need to be remember so that a
2072                      constructor can be generated, since its signature
2073                      is already known. */
2074                   $$ = build_new_invocation (id, NULL_TREE);
2075                 }
2076 ;
2077
2078 something_dot_new:              /* Added, not part of the specs. */
2079         name DOT_TK NEW_TK
2080                 { $$ = $1; }
2081 |       primary DOT_TK NEW_TK
2082                 { $$ = $1; }
2083 ;
2084
2085 argument_list:
2086         expression
2087                 {
2088                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2089                   ctxp->formal_parameter_number = 1;
2090                 }
2091 |       argument_list C_TK expression
2092                 {
2093                   ctxp->formal_parameter_number += 1;
2094                   $$ = tree_cons (NULL_TREE, $3, $1);
2095                 }
2096 |       argument_list C_TK error
2097                 {yyerror ("Missing term"); RECOVER;}
2098 ;
2099
2100 array_creation_expression:
2101         NEW_TK primitive_type dim_exprs
2102                 { $$ = build_newarray_node ($2, $3, 0); }
2103 |       NEW_TK class_or_interface_type dim_exprs
2104                 { $$ = build_newarray_node ($2, $3, 0); }
2105 |       NEW_TK primitive_type dim_exprs dims
2106                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2107 |       NEW_TK class_or_interface_type dim_exprs dims
2108                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2109         /* Added, JDK1.1 anonymous array. Initial documentation rule
2110            modified */
2111 |       NEW_TK class_or_interface_type dims array_initializer
2112                 {
2113                   char *sig;
2114                   int osb = pop_current_osb (ctxp);
2115                   while (osb--)
2116                     obstack_grow (&temporary_obstack, "[]", 2);
2117                   obstack_1grow (&temporary_obstack, '\0');
2118                   sig = obstack_finish (&temporary_obstack);
2119                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2120                               $2, get_identifier (sig), $4);
2121                 }
2122 |       NEW_TK primitive_type dims array_initializer
2123                 {
2124                   int osb = pop_current_osb (ctxp);
2125                   tree type = $2;
2126                   while (osb--)
2127                     type = build_java_array_type (type, -1);
2128                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2129                               build_pointer_type (type), NULL_TREE, $4);
2130                 }
2131 |       NEW_TK error CSB_TK
2132                 {yyerror ("'[' expected"); DRECOVER ("]");}
2133 |       NEW_TK error OSB_TK
2134                 {yyerror ("']' expected"); RECOVER;}
2135 ;
2136
2137 dim_exprs:
2138         dim_expr
2139                 { $$ = build_tree_list (NULL_TREE, $1); }
2140 |       dim_exprs dim_expr
2141                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2142 ;
2143
2144 dim_expr:
2145         OSB_TK expression CSB_TK
2146                 {
2147                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2148                     {
2149                       $2 = build_wfl_node ($2);
2150                       TREE_TYPE ($2) = NULL_TREE;
2151                     }
2152                   EXPR_WFL_LINECOL ($2) = $1.location;
2153                   $$ = $2;
2154                 }
2155 |       OSB_TK expression error
2156                 {yyerror ("']' expected"); RECOVER;}
2157 |       OSB_TK error
2158                 {
2159                   yyerror ("Missing term");
2160                   yyerror ("']' expected");
2161                   RECOVER;
2162                 }
2163 ;
2164
2165 dims:
2166         OSB_TK CSB_TK
2167                 {
2168                   int allocate = 0;
2169                   /* If not initialized, allocate memory for the osb
2170                      numbers stack */
2171                   if (!ctxp->osb_limit)
2172                     {
2173                       allocate = ctxp->osb_limit = 32;
2174                       ctxp->osb_depth = -1;
2175                     }
2176                   /* If capacity overflown, reallocate a bigger chunk */
2177                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2178                     allocate = ctxp->osb_limit << 1;
2179
2180                   if (allocate)
2181                     {
2182                       allocate *= sizeof (int);
2183                       if (ctxp->osb_number)
2184                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2185                                                      allocate);
2186                       else
2187                         ctxp->osb_number = xmalloc (allocate);
2188                     }
2189                   ctxp->osb_depth++;
2190                   CURRENT_OSB (ctxp) = 1;
2191                 }
2192 |       dims OSB_TK CSB_TK
2193                 { CURRENT_OSB (ctxp)++; }
2194 |       dims OSB_TK error
2195                 { yyerror ("']' expected"); RECOVER;}
2196 ;
2197
2198 field_access:
2199         primary DOT_TK identifier
2200                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2201                 /*  FIXME - REWRITE TO:
2202                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2203 |       SUPER_TK DOT_TK identifier
2204                 {
2205                   tree super_wfl = build_wfl_node (super_identifier_node);
2206                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2207                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2208                 }
2209 |       SUPER_TK error
2210                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2211 ;
2212
2213 method_invocation:
2214         name OP_TK CP_TK
2215                 { $$ = build_method_invocation ($1, NULL_TREE); }
2216 |       name OP_TK argument_list CP_TK
2217                 { $$ = build_method_invocation ($1, $3); }
2218 |       primary DOT_TK identifier OP_TK CP_TK
2219                 {
2220                   if (TREE_CODE ($1) == THIS_EXPR)
2221                     $$ = build_this_super_qualified_invocation
2222                       (1, $3, NULL_TREE, 0, $2.location);
2223                   else
2224                     {
2225                       tree invok = build_method_invocation ($3, NULL_TREE);
2226                       $$ = make_qualified_primary ($1, invok, $2.location);
2227                     }
2228                 }
2229 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2230                 {
2231                   if (TREE_CODE ($1) == THIS_EXPR)
2232                     $$ = build_this_super_qualified_invocation
2233                       (1, $3, $5, 0, $2.location);
2234                   else
2235                     {
2236                       tree invok = build_method_invocation ($3, $5);
2237                       $$ = make_qualified_primary ($1, invok, $2.location);
2238                     }
2239                 }
2240 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2241                 {
2242                   $$ = build_this_super_qualified_invocation
2243                     (0, $3, NULL_TREE, $1.location, $2.location);
2244                 }
2245 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2246                 {
2247                   $$ = build_this_super_qualified_invocation
2248                     (0, $3, $5, $1.location, $2.location);
2249                 }
2250         /* Screws up thing. I let it here until I'm convinced it can
2251            be removed. FIXME
2252 |       primary DOT_TK error
2253                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2254 |       SUPER_TK DOT_TK error CP_TK
2255                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2256 |       SUPER_TK DOT_TK error DOT_TK
2257                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2258 ;
2259
2260 array_access:
2261         name OSB_TK expression CSB_TK
2262                 { $$ = build_array_ref ($2.location, $1, $3); }
2263 |       primary_no_new_array OSB_TK expression CSB_TK
2264                 { $$ = build_array_ref ($2.location, $1, $3); }
2265 |       name OSB_TK error
2266                 {
2267                   yyerror ("Missing term and ']' expected");
2268                   DRECOVER(array_access);
2269                 }
2270 |       name OSB_TK expression error
2271                 {
2272                   yyerror ("']' expected");
2273                   DRECOVER(array_access);
2274                 }
2275 |       primary_no_new_array OSB_TK error
2276                 {
2277                   yyerror ("Missing term and ']' expected");
2278                   DRECOVER(array_access);
2279                 }
2280 |       primary_no_new_array OSB_TK expression error
2281                 {
2282                   yyerror ("']' expected");
2283                   DRECOVER(array_access);
2284                 }
2285 ;
2286
2287 postfix_expression:
2288         primary
2289 |       name
2290 |       post_increment_expression
2291 |       post_decrement_expression
2292 ;
2293
2294 post_increment_expression:
2295         postfix_expression INCR_TK
2296                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2297 ;
2298
2299 post_decrement_expression:
2300         postfix_expression DECR_TK
2301                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2302 ;
2303
2304 trap_overflow_corner_case:
2305         pre_increment_expression
2306 |       pre_decrement_expression
2307 |       PLUS_TK unary_expression
2308                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2309 |       unary_expression_not_plus_minus
2310 |       PLUS_TK error
2311                 {yyerror ("Missing term"); RECOVER}
2312 ;
2313
2314 unary_expression:
2315         trap_overflow_corner_case
2316                 {
2317                   error_if_numeric_overflow ($1);
2318                   $$ = $1;
2319                 }
2320 |       MINUS_TK trap_overflow_corner_case
2321                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2322 |       MINUS_TK error
2323                 {yyerror ("Missing term"); RECOVER}
2324 ;
2325
2326 pre_increment_expression:
2327         INCR_TK unary_expression
2328                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2329 |       INCR_TK error
2330                 {yyerror ("Missing term"); RECOVER}
2331 ;
2332
2333 pre_decrement_expression:
2334         DECR_TK unary_expression
2335                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2336 |       DECR_TK error
2337                 {yyerror ("Missing term"); RECOVER}
2338 ;
2339
2340 unary_expression_not_plus_minus:
2341         postfix_expression
2342 |       NOT_TK unary_expression
2343                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2344 |       NEG_TK unary_expression
2345                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2346 |       cast_expression
2347 |       NOT_TK error
2348                 {yyerror ("Missing term"); RECOVER}
2349 |       NEG_TK error
2350                 {yyerror ("Missing term"); RECOVER}
2351 ;
2352
2353 cast_expression:                /* Error handling here is potentially weak */
2354         OP_TK primitive_type dims CP_TK unary_expression
2355                 {
2356                   tree type = $2;
2357                   int osb = pop_current_osb (ctxp);
2358                   while (osb--)
2359                     type = build_java_array_type (type, -1);
2360                   $$ = build_cast ($1.location, type, $5);
2361                 }
2362 |       OP_TK primitive_type CP_TK unary_expression
2363                 { $$ = build_cast ($1.location, $2, $4); }
2364 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2365                 { $$ = build_cast ($1.location, $2, $4); }
2366 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2367                 {
2368                   const char *ptr;
2369                   int osb = pop_current_osb (ctxp);
2370                   obstack_grow (&temporary_obstack,
2371                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2372                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2373                   while (osb--)
2374                     obstack_grow (&temporary_obstack, "[]", 2);
2375                   obstack_1grow (&temporary_obstack, '\0');
2376                   ptr = obstack_finish (&temporary_obstack);
2377                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2378                   $$ = build_cast ($1.location, $2, $5);
2379                 }
2380 |       OP_TK primitive_type OSB_TK error
2381                 {yyerror ("']' expected, invalid type expression");}
2382 |       OP_TK error
2383                 {
2384                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2385                   RECOVER;
2386                 }
2387 |       OP_TK primitive_type dims CP_TK error
2388                 {yyerror ("Missing term"); RECOVER;}
2389 |       OP_TK primitive_type CP_TK error
2390                 {yyerror ("Missing term"); RECOVER;}
2391 |       OP_TK name dims CP_TK error
2392                 {yyerror ("Missing term"); RECOVER;}
2393 ;
2394
2395 multiplicative_expression:
2396         unary_expression
2397 |       multiplicative_expression MULT_TK unary_expression
2398                 {
2399                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2400                                     $2.location, $1, $3);
2401                 }
2402 |       multiplicative_expression DIV_TK unary_expression
2403                 {
2404                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2405                                     $1, $3);
2406                 }
2407 |       multiplicative_expression REM_TK unary_expression
2408                 {
2409                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2410                                     $1, $3);
2411                 }
2412 |       multiplicative_expression MULT_TK error
2413                 {yyerror ("Missing term"); RECOVER;}
2414 |       multiplicative_expression DIV_TK error
2415                 {yyerror ("Missing term"); RECOVER;}
2416 |       multiplicative_expression REM_TK error
2417                 {yyerror ("Missing term"); RECOVER;}
2418 ;
2419
2420 additive_expression:
2421         multiplicative_expression
2422 |       additive_expression PLUS_TK multiplicative_expression
2423                 {
2424                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2425                                     $1, $3);
2426                 }
2427 |       additive_expression MINUS_TK multiplicative_expression
2428                 {
2429                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2430                                     $1, $3);
2431                 }
2432 |       additive_expression PLUS_TK error
2433                 {yyerror ("Missing term"); RECOVER;}
2434 |       additive_expression MINUS_TK error
2435                 {yyerror ("Missing term"); RECOVER;}
2436 ;
2437
2438 shift_expression:
2439         additive_expression
2440 |       shift_expression LS_TK additive_expression
2441                 {
2442                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2443                                     $1, $3);
2444                 }
2445 |       shift_expression SRS_TK additive_expression
2446                 {
2447                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2448                                     $1, $3);
2449                 }
2450 |       shift_expression ZRS_TK additive_expression
2451                 {
2452                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2453                                     $1, $3);
2454                 }
2455 |       shift_expression LS_TK error
2456                 {yyerror ("Missing term"); RECOVER;}
2457 |       shift_expression SRS_TK error
2458                 {yyerror ("Missing term"); RECOVER;}
2459 |       shift_expression ZRS_TK error
2460                 {yyerror ("Missing term"); RECOVER;}
2461 ;
2462
2463 relational_expression:
2464         shift_expression
2465 |       relational_expression LT_TK shift_expression
2466                 {
2467                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2468                                     $1, $3);
2469                 }
2470 |       relational_expression GT_TK shift_expression
2471                 {
2472                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2473                                     $1, $3);
2474                 }
2475 |       relational_expression LTE_TK shift_expression
2476                 {
2477                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2478                                     $1, $3);
2479                 }
2480 |       relational_expression GTE_TK shift_expression
2481                 {
2482                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2483                                     $1, $3);
2484                 }
2485 |       relational_expression INSTANCEOF_TK reference_type
2486                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2487 |       relational_expression LT_TK error
2488                 {yyerror ("Missing term"); RECOVER;}
2489 |       relational_expression GT_TK error
2490                 {yyerror ("Missing term"); RECOVER;}
2491 |       relational_expression LTE_TK error
2492                 {yyerror ("Missing term"); RECOVER;}
2493 |       relational_expression GTE_TK error
2494                 {yyerror ("Missing term"); RECOVER;}
2495 |       relational_expression INSTANCEOF_TK error
2496                 {yyerror ("Invalid reference type"); RECOVER;}
2497 ;
2498
2499 equality_expression:
2500         relational_expression
2501 |       equality_expression EQ_TK relational_expression
2502                 {
2503                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2504                                     $1, $3);
2505                 }
2506 |       equality_expression NEQ_TK relational_expression
2507                 {
2508                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2509                                     $1, $3);
2510                 }
2511 |       equality_expression EQ_TK error
2512                 {yyerror ("Missing term"); RECOVER;}
2513 |       equality_expression NEQ_TK error
2514                 {yyerror ("Missing term"); RECOVER;}
2515 ;
2516
2517 and_expression:
2518         equality_expression
2519 |       and_expression AND_TK equality_expression
2520                 {
2521                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2522                                     $1, $3);
2523                 }
2524 |       and_expression AND_TK error
2525                 {yyerror ("Missing term"); RECOVER;}
2526 ;
2527
2528 exclusive_or_expression:
2529         and_expression
2530 |       exclusive_or_expression XOR_TK and_expression
2531                 {
2532                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2533                                     $1, $3);
2534                 }
2535 |       exclusive_or_expression XOR_TK error
2536                 {yyerror ("Missing term"); RECOVER;}
2537 ;
2538
2539 inclusive_or_expression:
2540         exclusive_or_expression
2541 |       inclusive_or_expression OR_TK exclusive_or_expression
2542                 {
2543                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2544                                     $1, $3);
2545                 }
2546 |       inclusive_or_expression OR_TK error
2547                 {yyerror ("Missing term"); RECOVER;}
2548 ;
2549
2550 conditional_and_expression:
2551         inclusive_or_expression
2552 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2553                 {
2554                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2555                                     $1, $3);
2556                 }
2557 |       conditional_and_expression BOOL_AND_TK error
2558                 {yyerror ("Missing term"); RECOVER;}
2559 ;
2560
2561 conditional_or_expression:
2562         conditional_and_expression
2563 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2564                 {
2565                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2566                                     $1, $3);
2567                 }
2568 |       conditional_or_expression BOOL_OR_TK error
2569                 {yyerror ("Missing term"); RECOVER;}
2570 ;
2571
2572 conditional_expression:         /* Error handling here is weak */
2573         conditional_or_expression
2574 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2575                 {
2576                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2577                   EXPR_WFL_LINECOL ($$) = $2.location;
2578                 }
2579 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2580                 {
2581                   YYERROR_NOW;
2582                   yyerror ("Missing term");
2583                   DRECOVER (1);
2584                 }
2585 |       conditional_or_expression REL_QM_TK error
2586                 {yyerror ("Missing term"); DRECOVER (2);}
2587 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2588                 {yyerror ("Missing term"); DRECOVER (3);}
2589 ;
2590
2591 assignment_expression:
2592         conditional_expression
2593 |       assignment
2594 ;
2595
2596 assignment:
2597         left_hand_side assignment_operator assignment_expression
2598                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2599 |       left_hand_side assignment_operator error
2600                 {
2601                   YYNOT_TWICE yyerror ("Missing term");
2602                   DRECOVER (assign);
2603                 }
2604 ;
2605
2606 left_hand_side:
2607         name
2608 |       field_access
2609 |       array_access
2610 ;
2611
2612 assignment_operator:
2613         ASSIGN_ANY_TK
2614 |       ASSIGN_TK
2615 ;
2616
2617 expression:
2618         assignment_expression
2619 ;
2620
2621 constant_expression:
2622         expression
2623 ;
2624
2625 %%
2626
2627 /* Helper function to retrieve an OSB count. Should be used when the
2628    `dims:' rule is being used.  */
2629
2630 static int
2631 pop_current_osb (struct parser_ctxt *ctxp)
2632 {
2633   int to_return;
2634
2635   if (ctxp->osb_depth < 0)
2636     abort ();
2637
2638   to_return = CURRENT_OSB (ctxp);
2639   ctxp->osb_depth--;
2640
2641   return to_return;
2642 }
2643
2644 \f
2645
2646 /* This section of the code deal with save/restoring parser contexts.
2647    Add mode documentation here. FIXME */
2648
2649 /* Helper function. Create a new parser context. With
2650    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2651    context is copied, otherwise, the new context is zeroed. The newly
2652    created context becomes the current one.  */
2653
2654 static void
2655 create_new_parser_context (int copy_from_previous)
2656 {
2657   struct parser_ctxt *new;
2658
2659   new = ggc_alloc (sizeof (struct parser_ctxt));
2660   if (copy_from_previous)
2661     {
2662       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2663       new->saved_data_ctx = 1;
2664     }
2665   else
2666     memset (new, 0, sizeof (struct parser_ctxt));
2667
2668   new->next = ctxp;
2669   ctxp = new;
2670 }
2671
2672 /* Create a new parser context and make it the current one. */
2673
2674 void
2675 java_push_parser_context (void)
2676 {
2677   create_new_parser_context (0);
2678 }
2679
2680 void
2681 java_pop_parser_context (int generate)
2682 {
2683   tree current;
2684   struct parser_ctxt *toFree, *next;
2685
2686   if (!ctxp)
2687     return;
2688
2689   toFree = ctxp;
2690   next = ctxp->next;
2691   if (next)
2692     {
2693       input_line = ctxp->lineno;
2694       current_class = ctxp->class_type;
2695     }
2696
2697   /* If the old and new lexers differ, then free the old one.  */
2698   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2699     java_destroy_lexer (ctxp->lexer);
2700
2701   /* Set the single import class file flag to 0 for the current list
2702      of imported things */
2703   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2704     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2705
2706   /* And restore those of the previous context */
2707   if ((ctxp = next))            /* Assignment is really meant here */
2708     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2709       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2710
2711   /* If we pushed a context to parse a class intended to be generated,
2712      we keep it so we can remember the class. What we could actually
2713      do is to just update a list of class names.  */
2714   if (generate)
2715     {
2716       toFree->next = ctxp_for_generation;
2717       ctxp_for_generation = toFree;
2718     }
2719 }
2720
2721 /* Create a parser context for the use of saving some global
2722    variables.  */
2723
2724 void
2725 java_parser_context_save_global (void)
2726 {
2727   if (!ctxp)
2728     {
2729       java_push_parser_context ();
2730       ctxp->saved_data_ctx = 1;
2731     }
2732
2733   /* If this context already stores data, create a new one suitable
2734      for data storage. */
2735   else if (ctxp->saved_data)
2736     create_new_parser_context (1);
2737
2738   ctxp->lineno = input_line;
2739   ctxp->class_type = current_class;
2740   ctxp->filename = input_filename;
2741   ctxp->function_decl = current_function_decl;
2742   ctxp->saved_data = 1;
2743 }
2744
2745 /* Restore some global variables from the previous context. Make the
2746    previous context the current one.  */
2747
2748 void
2749 java_parser_context_restore_global (void)
2750 {
2751   input_line = ctxp->lineno;
2752   current_class = ctxp->class_type;
2753   input_filename = ctxp->filename;
2754   if (wfl_operator)
2755     {
2756       tree s;
2757       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2758       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2759     }
2760   current_function_decl = ctxp->function_decl;
2761   ctxp->saved_data = 0;
2762   if (ctxp->saved_data_ctx)
2763     java_pop_parser_context (0);
2764 }
2765
2766 /* Suspend vital data for the current class/function being parsed so
2767    that an other class can be parsed. Used to let local/anonymous
2768    classes be parsed.  */
2769
2770 static void
2771 java_parser_context_suspend (void)
2772 {
2773   /* This makes debugging through java_debug_context easier */
2774   static const char *const name = "<inner buffer context>";
2775
2776   /* Duplicate the previous context, use it to save the globals we're
2777      interested in */
2778   create_new_parser_context (1);
2779   ctxp->function_decl = current_function_decl;
2780   ctxp->class_type = current_class;
2781
2782   /* Then create a new context which inherits all data from the
2783      previous one. This will be the new current context  */
2784   create_new_parser_context (1);
2785
2786   /* Help debugging */
2787   ctxp->next->filename = name;
2788 }
2789
2790 /* Resume vital data for the current class/function being parsed so
2791    that an other class can be parsed. Used to let local/anonymous
2792    classes be parsed.  The trick is the data storing file position
2793    informations must be restored to their current value, so parsing
2794    can resume as if no context was ever saved. */
2795
2796 static void
2797 java_parser_context_resume (void)
2798 {
2799   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2800   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2801   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2802
2803   /* We need to inherit the list of classes to complete/generate */
2804   restored->classd_list = old->classd_list;
2805   restored->class_list = old->class_list;
2806
2807   /* Restore the current class and function from the saver */
2808   current_class = saver->class_type;
2809   current_function_decl = saver->function_decl;
2810
2811   /* Retrive the restored context */
2812   ctxp = restored;
2813
2814   /* Re-installed the data for the parsing to carry on */
2815   memcpy (&ctxp->marker_begining, &old->marker_begining,
2816           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2817 }
2818
2819 /* Add a new anchor node to which all statement(s) initializing static
2820    and non static initialized upon declaration field(s) will be
2821    linked.  */
2822
2823 static void
2824 java_parser_context_push_initialized_field (void)
2825 {
2826   tree node;
2827
2828   node = build_tree_list (NULL_TREE, NULL_TREE);
2829   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2830   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2831
2832   node = build_tree_list (NULL_TREE, NULL_TREE);
2833   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2834   CPC_INITIALIZER_LIST (ctxp) = node;
2835
2836   node = build_tree_list (NULL_TREE, NULL_TREE);
2837   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2838   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2839 }
2840
2841 /* Pop the lists of initialized field. If this lists aren't empty,
2842    remember them so we can use it to create and populate the finit$
2843    or <clinit> functions. */
2844
2845 static void
2846 java_parser_context_pop_initialized_field (void)
2847 {
2848   tree stmts;
2849   tree class_type = TREE_TYPE (GET_CPC ());
2850
2851   if (CPC_INITIALIZER_LIST (ctxp))
2852     {
2853       stmts = CPC_INITIALIZER_STMT (ctxp);
2854       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2855       if (stmts && !java_error_count)
2856         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2857     }
2858
2859   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2860     {
2861       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2862       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2863         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2864       /* Keep initialization in order to enforce 8.5 */
2865       if (stmts && !java_error_count)
2866         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2867     }
2868
2869   /* JDK 1.1 instance initializers */
2870   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2871     {
2872       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2873       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2874         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2875       if (stmts && !java_error_count)
2876         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2877     }
2878 }
2879
2880 static tree
2881 reorder_static_initialized (tree list)
2882 {
2883   /* We have to keep things in order. The alias initializer have to
2884      come first, then the initialized regular field, in reverse to
2885      keep them in lexical order. */
2886   tree marker, previous = NULL_TREE;
2887   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2888     if (TREE_CODE (marker) == TREE_LIST
2889         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2890       break;
2891
2892   /* No static initialized, the list is fine as is */
2893   if (!previous)
2894     list = TREE_CHAIN (marker);
2895
2896   /* No marker? reverse the whole list */
2897   else if (!marker)
2898     list = nreverse (list);
2899
2900   /* Otherwise, reverse what's after the marker and the new reordered
2901      sublist will replace the marker. */
2902   else
2903     {
2904       TREE_CHAIN (previous) = NULL_TREE;
2905       list = nreverse (list);
2906       list = chainon (TREE_CHAIN (marker), list);
2907     }
2908   return list;
2909 }
2910
2911 /* Helper functions to dump the parser context stack.  */
2912
2913 #define TAB_CONTEXT(C) \
2914   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2915
2916 static void
2917 java_debug_context_do (int tab)
2918 {
2919   struct parser_ctxt *copy = ctxp;
2920   while (copy)
2921     {
2922       TAB_CONTEXT (tab);
2923       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2924       TAB_CONTEXT (tab);
2925       fprintf (stderr, "filename: %s\n", copy->filename);
2926       TAB_CONTEXT (tab);
2927       fprintf (stderr, "lineno: %d\n", copy->lineno);
2928       TAB_CONTEXT (tab);
2929       fprintf (stderr, "package: %s\n",
2930                (copy->package ?
2931                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2932       TAB_CONTEXT (tab);
2933       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2934       TAB_CONTEXT (tab);
2935       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2936       copy = copy->next;
2937       tab += 2;
2938     }
2939 }
2940
2941 /* Dump the stacked up parser contexts. Intended to be called from a
2942    debugger.  */
2943
2944 void
2945 java_debug_context (void)
2946 {
2947   java_debug_context_do (0);
2948 }
2949
2950 \f
2951
2952 /* Flag for the error report routine to issue the error the first time
2953    it's called (overriding the default behavior which is to drop the
2954    first invocation and honor the second one, taking advantage of a
2955    richer context.  */
2956 static int force_error = 0;
2957
2958 /* Reporting an constructor invocation error.  */
2959 static void
2960 parse_ctor_invocation_error (void)
2961 {
2962   if (DECL_CONSTRUCTOR_P (current_function_decl))
2963     yyerror ("Constructor invocation must be first thing in a constructor");
2964   else
2965     yyerror ("Only constructors can invoke constructors");
2966 }
2967
2968 /* Reporting JDK1.1 features not implemented.  */
2969
2970 static tree
2971 parse_jdk1_1_error (const char *msg)
2972 {
2973   sorry (": `%s' JDK1.1(TM) feature", msg);
2974   java_error_count++;
2975   return empty_stmt_node;
2976 }
2977
2978 static int do_warning = 0;
2979
2980 void
2981 yyerror (const char *msg)
2982 {
2983   static java_lc elc;
2984   static int  prev_lineno;
2985   static const char *prev_msg;
2986
2987   int save_lineno;
2988   char *remainder, *code_from_source;
2989
2990   if (!force_error && prev_lineno == input_line)
2991     return;
2992
2993   /* Save current error location but report latter, when the context is
2994      richer.  */
2995   if (ctxp->java_error_flag == 0)
2996     {
2997       ctxp->java_error_flag = 1;
2998       elc = ctxp->elc;
2999       /* Do something to use the previous line if we're reaching the
3000          end of the file... */
3001 #ifdef VERBOSE_SKELETON
3002       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3003 #endif
3004       return;
3005     }
3006
3007   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3008   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3009     return;
3010
3011   ctxp->java_error_flag = 0;
3012   if (do_warning)
3013     java_warning_count++;
3014   else
3015     java_error_count++;
3016
3017   if (elc.col == 0 && msg && msg[1] == ';')
3018     {
3019       elc.col  = ctxp->p_line->char_col-1;
3020       elc.line = ctxp->p_line->lineno;
3021     }
3022
3023   save_lineno = input_line;
3024   prev_lineno = input_line = elc.line;
3025   prev_msg = msg;
3026
3027   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3028   obstack_grow0 (&temporary_obstack,
3029                  code_from_source, strlen (code_from_source));
3030   remainder = obstack_finish (&temporary_obstack);
3031   if (do_warning)
3032     warning ("%s.\n%s", msg, remainder);
3033   else
3034     error ("%s.\n%s", msg, remainder);
3035
3036   /* This allow us to cheaply avoid an extra 'Invalid expression
3037      statement' error report when errors have been already reported on
3038      the same line. This occurs when we report an error but don't have
3039      a synchronization point other than ';', which
3040      expression_statement is the only one to take care of.  */
3041   ctxp->prevent_ese = input_line = save_lineno;
3042 }
3043
3044 static void
3045 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3046 {
3047   const char *saved, *saved_input_filename;
3048   char buffer [4096];
3049   vsprintf (buffer, msg, ap);
3050   force_error = 1;
3051
3052   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3053   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3054                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3055
3056   /* We have a CL, that's a good reason for using it if it contains data */
3057   saved = ctxp->filename;
3058   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3059     ctxp->filename = EXPR_WFL_FILENAME (cl);
3060   saved_input_filename = input_filename;
3061   input_filename = ctxp->filename;
3062   java_error (NULL);
3063   java_error (buffer);
3064   ctxp->filename = saved;
3065   input_filename = saved_input_filename;
3066   force_error = 0;
3067 }
3068
3069 /* Issue an error message at a current source line CL */
3070
3071 void
3072 parse_error_context (tree cl, const char *msg, ...)
3073 {
3074   va_list ap;
3075   va_start (ap, msg);
3076   issue_warning_error_from_context (cl, msg, ap);
3077   va_end (ap);
3078 }
3079
3080 /* Issue a warning at a current source line CL */
3081
3082 static void
3083 parse_warning_context (tree cl, const char *msg, ...)
3084 {
3085   va_list ap;
3086   va_start (ap, msg);
3087
3088   force_error = do_warning = 1;
3089   issue_warning_error_from_context (cl, msg, ap);
3090   do_warning = force_error = 0;
3091   va_end (ap);
3092 }
3093
3094 static tree
3095 find_expr_with_wfl (tree node)
3096 {
3097   while (node)
3098     {
3099       char code;
3100       tree to_return;
3101
3102       switch (TREE_CODE (node))
3103         {
3104         case BLOCK:
3105           node = BLOCK_EXPR_BODY (node);
3106           continue;
3107
3108         case COMPOUND_EXPR:
3109           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3110           if (to_return)
3111             return to_return;
3112           node = TREE_OPERAND (node, 1);
3113           continue;
3114
3115         case LOOP_EXPR:
3116           node = TREE_OPERAND (node, 0);
3117           continue;
3118
3119         case LABELED_BLOCK_EXPR:
3120           node = TREE_OPERAND (node, 1);
3121           continue;
3122
3123         default:
3124           code = TREE_CODE_CLASS (TREE_CODE (node));
3125           if (((code == '1') || (code == '2') || (code == 'e'))
3126               && EXPR_WFL_LINECOL (node))
3127             return node;
3128           return NULL_TREE;
3129         }
3130     }
3131   return NULL_TREE;
3132 }
3133
3134 /* Issue a missing return statement error. Uses METHOD to figure the
3135    last line of the method the error occurs in.  */
3136
3137 static void
3138 missing_return_error (tree method)
3139 {
3140   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3141   parse_error_context (wfl_operator, "Missing return statement");
3142 }
3143
3144 /* Issue an unreachable statement error. From NODE, find the next
3145    statement to report appropriately.  */
3146 static void
3147 unreachable_stmt_error (tree node)
3148 {
3149   /* Browse node to find the next expression node that has a WFL. Use
3150      the location to report the error */
3151   if (TREE_CODE (node) == COMPOUND_EXPR)
3152     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3153   else
3154     node = find_expr_with_wfl (node);
3155
3156   if (node)
3157     {
3158       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3159       parse_error_context (wfl_operator, "Unreachable statement");
3160     }
3161   else
3162     abort ();
3163 }
3164
3165 static int
3166 not_accessible_field_error (tree wfl, tree decl)
3167 {
3168   parse_error_context
3169     (wfl, "Can't access %s field `%s.%s' from `%s'",
3170      java_accstring_lookup (get_access_flags_from_decl (decl)),
3171      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3172      IDENTIFIER_POINTER (DECL_NAME (decl)),
3173      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3174   return 1;
3175 }
3176
3177 int
3178 java_report_errors (void)
3179 {
3180   if (java_error_count)
3181     fprintf (stderr, "%d error%s",
3182              java_error_count, (java_error_count == 1 ? "" : "s"));
3183   if (java_warning_count)
3184     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3185              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3186   if (java_error_count || java_warning_count)
3187     putc ('\n', stderr);
3188   return java_error_count;
3189 }
3190
3191 static char *
3192 java_accstring_lookup (int flags)
3193 {
3194   static char buffer [80];
3195 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3196
3197   /* Access modifier looked-up first for easier report on forbidden
3198      access. */
3199   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3200   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3201   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3202   if (flags & ACC_STATIC) COPY_RETURN ("static");
3203   if (flags & ACC_FINAL) COPY_RETURN ("final");
3204   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3205   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3206   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3207   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3208   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3209   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3210
3211   buffer [0] = '\0';
3212   return buffer;
3213 #undef COPY_RETURN
3214 }
3215
3216 /* Issuing error messages upon redefinition of classes, interfaces or
3217    variables. */
3218
3219 static void
3220 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3221 {
3222   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3223                        context, IDENTIFIER_POINTER (id),
3224                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3225   /* Here we should point out where its redefined. It's a unicode. FIXME */
3226 }
3227
3228 static void
3229 variable_redefinition_error (tree context, tree name, tree type, int line)
3230 {
3231   const char *type_name;
3232
3233   /* Figure a proper name for type. We might haven't resolved it */
3234   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3235     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3236   else
3237     type_name = lang_printable_name (type, 0);
3238
3239   parse_error_context (context,
3240                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3241                        IDENTIFIER_POINTER (name),
3242                        type_name, IDENTIFIER_POINTER (name), line);
3243 }
3244
3245 /* If ANAME is terminated with `[]', it indicates an array. This
3246    function returns the number of `[]' found and if this number is
3247    greater than zero, it extracts the array type name and places it in
3248    the node pointed to by TRIMMED unless TRIMMED is null.  */
3249
3250 static int
3251 build_type_name_from_array_name (tree aname, tree *trimmed)
3252 {
3253   const char *name = IDENTIFIER_POINTER (aname);
3254   int len = IDENTIFIER_LENGTH (aname);
3255   int array_dims;
3256
3257   STRING_STRIP_BRACKETS (name, len, array_dims);
3258
3259   if (array_dims && trimmed)
3260     *trimmed = get_identifier_with_length (name, len);
3261
3262   return array_dims;
3263 }
3264
3265 static tree
3266 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3267 {
3268   int more_dims = 0;
3269
3270   /* Eventually get more dims */
3271   more_dims = build_type_name_from_array_name (name, &name);
3272
3273   /* If we have, then craft a new type for this variable */
3274   if (more_dims)
3275     {
3276       tree save = type;
3277
3278       /* If we have a pointer, use its type */
3279       if (TREE_CODE (type) == POINTER_TYPE)
3280         type = TREE_TYPE (type);
3281
3282       /* Building the first dimension of a primitive type uses this
3283          function */
3284       if (JPRIMITIVE_TYPE_P (type))
3285         {
3286           type = build_java_array_type (type, -1);
3287           more_dims--;
3288         }
3289       /* Otherwise, if we have a WFL for this type, use it (the type
3290          is already an array on an unresolved type, and we just keep
3291          on adding dimensions) */
3292       else if (type_wfl)
3293         {
3294           type = type_wfl;
3295           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3296                                                         NULL);
3297         }
3298
3299       /* Add all the dimensions */
3300       while (more_dims--)
3301         type = build_unresolved_array_type (type);
3302
3303       /* The type may have been incomplete in the first place */
3304       if (type_wfl)
3305         type = obtain_incomplete_type (type);
3306     }
3307
3308   if (ret_name)
3309     *ret_name = name;
3310   return type;
3311 }
3312
3313 /* Build something that the type identifier resolver will identify as
3314    being an array to an unresolved type. TYPE_WFL is a WFL on a
3315    identifier. */
3316
3317 static tree
3318 build_unresolved_array_type (tree type_or_wfl)
3319 {
3320   const char *ptr;
3321   tree wfl;
3322
3323   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3324      just create a array type */
3325   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3326     return build_java_array_type (type_or_wfl, -1);
3327
3328   obstack_grow (&temporary_obstack,
3329                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3330                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3331   obstack_grow0 (&temporary_obstack, "[]", 2);
3332   ptr = obstack_finish (&temporary_obstack);
3333   wfl = build_expr_wfl (get_identifier (ptr),
3334                         EXPR_WFL_FILENAME (type_or_wfl),
3335                         EXPR_WFL_LINENO (type_or_wfl),
3336                         EXPR_WFL_COLNO (type_or_wfl));
3337   /* Re-install the existing qualifications so that the type can be
3338      resolved properly. */
3339   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3340   return wfl;
3341 }
3342
3343 static void
3344 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3345 {
3346   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3347     parse_error_context (wfl, "Interface `%s' repeated",
3348                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3349 }
3350
3351 /* Bulk of common class/interface checks. Return 1 if an error was
3352    encountered. TAG is 0 for a class, 1 for an interface.  */
3353
3354 static int
3355 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3356                                 tree qualified_name, tree decl, tree cl)
3357 {
3358   tree node;
3359   int sca = 0;                  /* Static class allowed */
3360   int icaf = 0;                 /* Inner class allowed flags */
3361   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3362
3363   if (!quiet_flag)
3364     fprintf (stderr, " %s%s %s",
3365              (CPC_INNER_P () ? "inner" : ""),
3366              (is_interface ? "interface" : "class"),
3367              IDENTIFIER_POINTER (qualified_name));
3368
3369   /* Scope of an interface/class type name:
3370        - Can't be imported by a single type import
3371        - Can't already exists in the package */
3372   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3373       && (node = find_name_in_single_imports (raw_name))
3374       && !CPC_INNER_P ())
3375     {
3376       parse_error_context
3377         (cl, "%s name `%s' clashes with imported type `%s'",
3378          (is_interface ? "Interface" : "Class"),
3379          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3380       return 1;
3381     }
3382   if (decl && CLASS_COMPLETE_P (decl))
3383     {
3384       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3385                                    qualified_name, decl, cl);
3386       return 1;
3387     }
3388
3389   if (check_inner_class_redefinition (raw_name, cl))
3390     return 1;
3391
3392   /* If public, file name should match class/interface name, except
3393      when dealing with an inner class */
3394   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3395     {
3396       const char *f;
3397
3398       for (f = &input_filename [strlen (input_filename)];
3399            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3400            f--)
3401         ;
3402       if (IS_DIR_SEPARATOR (f[0]))
3403         f++;
3404       if (strncmp (IDENTIFIER_POINTER (raw_name),
3405                    f , IDENTIFIER_LENGTH (raw_name)) ||
3406           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3407         parse_error_context
3408           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3409                              (is_interface ? "interface" : "class"),
3410                              IDENTIFIER_POINTER (qualified_name),
3411                              IDENTIFIER_POINTER (raw_name));
3412     }
3413
3414   /* Static classes can be declared only in top level classes. Note:
3415      once static, a inner class is a top level class. */
3416   if (flags & ACC_STATIC)
3417     {
3418       /* Catch the specific error of declaring an class inner class
3419          with no toplevel enclosing class. Prevent check_modifiers from
3420          complaining a second time */
3421       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3422         {
3423           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3424                                IDENTIFIER_POINTER (qualified_name));
3425           sca = ACC_STATIC;
3426         }
3427       /* Else, in the context of a top-level class declaration, let
3428          `check_modifiers' do its job, otherwise, give it a go */
3429       else
3430         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3431     }
3432
3433   /* Inner classes can be declared private or protected
3434      within their enclosing classes. */
3435   if (CPC_INNER_P ())
3436     {
3437       /* A class which is local to a block can't be public, private,
3438          protected or static. But it is created final, so allow this
3439          one. */
3440       if (current_function_decl)
3441         icaf = sca = uaaf = ACC_FINAL;
3442       else
3443         {
3444           check_modifiers_consistency (flags);
3445           icaf = ACC_PROTECTED;
3446           if (! CLASS_INTERFACE (GET_CPC ()))
3447             icaf |= ACC_PRIVATE;
3448         }
3449     }
3450
3451   if (is_interface)
3452     {
3453       if (CPC_INNER_P ())
3454         uaaf = INTERFACE_INNER_MODIFIERS;
3455       else
3456         uaaf = INTERFACE_MODIFIERS;
3457
3458       check_modifiers ("Illegal modifier `%s' for interface declaration",
3459                        flags, uaaf);
3460     }
3461   else
3462     check_modifiers ((current_function_decl ?
3463                       "Illegal modifier `%s' for local class declaration" :
3464                       "Illegal modifier `%s' for class declaration"),
3465                      flags, uaaf|sca|icaf);
3466   return 0;
3467 }
3468
3469 /* Construct a nested class name.  If the final component starts with
3470    a digit, return true.  Otherwise return false.  */
3471 static int
3472 make_nested_class_name (tree cpc_list)
3473 {
3474   tree name;
3475
3476   if (!cpc_list)
3477     return 0;
3478
3479   make_nested_class_name (TREE_CHAIN (cpc_list));
3480
3481   /* Pick the qualified name when dealing with the first upmost
3482      enclosing class */
3483   name = (TREE_CHAIN (cpc_list)
3484           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3485   obstack_grow (&temporary_obstack,
3486                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3487   obstack_1grow (&temporary_obstack, '$');
3488
3489   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3490 }
3491
3492 /* Can't redefine a class already defined in an earlier scope. */
3493
3494 static int
3495 check_inner_class_redefinition (tree raw_name, tree cl)
3496 {
3497   tree scope_list;
3498
3499   for (scope_list = GET_CPC_LIST (); scope_list;
3500        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3501     if (raw_name == GET_CPC_UN_NODE (scope_list))
3502       {
3503         parse_error_context
3504           (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3505            IDENTIFIER_POINTER (raw_name));
3506         return 1;
3507       }
3508   return 0;
3509 }
3510
3511 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3512    we remember ENCLOSING and SUPER.  */
3513
3514 static tree
3515 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3516                      tree *super, tree class_type)
3517 {
3518   tree local_enclosing = *enclosing;
3519   tree local_super = NULL_TREE;
3520
3521   while (local_enclosing)
3522     {
3523       tree intermediate, decl;
3524
3525       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3526         local_enclosing;
3527
3528       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3529         return decl;
3530
3531       intermediate = local_enclosing;
3532       /* Explore enclosing contexts. */
3533       while (INNER_CLASS_DECL_P (intermediate))
3534         {
3535           intermediate = DECL_CONTEXT (intermediate);
3536           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3537             return decl;
3538         }
3539
3540       /* Now go to the upper classes, bail out if necessary.  We will
3541          analyze the returned SUPER and act accordingly (see
3542          do_resolve_class).  */
3543       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3544           || TREE_TYPE (local_enclosing) == void_type_node)
3545         {
3546           parse_error_context (cl, "Qualifier must be a reference");
3547           local_enclosing = NULL_TREE;
3548           break;
3549         }
3550       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3551       if (!local_super || local_super == object_type_node)
3552         break;
3553
3554       if (TREE_CODE (local_super) == POINTER_TYPE)
3555         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3556       else
3557         local_super = TYPE_NAME (local_super);
3558
3559       /* We may not have checked for circular inheritance yet, so do so
3560          here to prevent an infinite loop. */
3561       if (htab_find (circularity_hash, local_super) != NULL)
3562         {
3563           if (!cl)
3564             cl = lookup_cl (local_enclosing);
3565
3566           parse_error_context
3567             (cl, "Cyclic inheritance involving %s",
3568              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3569           local_enclosing = NULL_TREE;
3570         }
3571       else
3572         local_enclosing = local_super;
3573     }
3574
3575   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3576   *super = local_super;
3577   *enclosing = local_enclosing;
3578
3579   return NULL_TREE;
3580 }
3581
3582 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3583    qualified. */
3584
3585 static tree
3586 find_as_inner_class (tree enclosing, tree name, tree cl)
3587 {
3588   tree qual, to_return;
3589   if (!enclosing)
3590     return NULL_TREE;
3591
3592   name = TYPE_NAME (name);
3593
3594   /* First search: within the scope of `enclosing', search for name */
3595   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3596     qual = EXPR_WFL_QUALIFICATION (cl);
3597   else if (cl)
3598     qual = build_tree_list (cl, NULL_TREE);
3599   else
3600     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3601
3602   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3603     return to_return;
3604
3605   /* We're dealing with a qualified name. Try to resolve thing until
3606      we get something that is an enclosing class. */
3607   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3608     {
3609       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3610
3611       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3612            qual = TREE_CHAIN (qual))
3613         {
3614           acc = merge_qualified_name (acc,
3615                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3616           BUILD_PTR_FROM_NAME (ptr, acc);
3617           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3618         }
3619
3620       /* A NULL qual and a decl means that the search ended
3621          successfully?!? We have to do something then. FIXME */
3622
3623       if (decl)
3624         enclosing = decl;
3625       else
3626         qual = EXPR_WFL_QUALIFICATION (cl);
3627     }
3628   /* Otherwise, create a qual for the other part of the resolution. */
3629   else
3630     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3631
3632   return find_as_inner_class_do (qual, enclosing);
3633 }
3634
3635 /* We go inside the list of sub classes and try to find a way
3636    through. */
3637
3638 static tree
3639 find_as_inner_class_do (tree qual, tree enclosing)
3640 {
3641   if (!qual)
3642     return NULL_TREE;
3643
3644   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3645     {
3646       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3647       tree next_enclosing = NULL_TREE;
3648       tree inner_list;
3649
3650       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3651            inner_list; inner_list = TREE_CHAIN (inner_list))
3652         {
3653           if (TREE_VALUE (inner_list) == name_to_match)
3654             {
3655               next_enclosing = TREE_PURPOSE (inner_list);
3656               break;
3657             }
3658         }
3659       enclosing = next_enclosing;
3660     }
3661
3662   return (!qual && enclosing ? enclosing : NULL_TREE);
3663 }
3664
3665 /* Reach all inner classes and tie their unqualified name to a
3666    DECL. */
3667
3668 static void
3669 set_nested_class_simple_name_value (tree outer, int set)
3670 {
3671   tree l;
3672
3673   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3674     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3675                                                 TREE_PURPOSE (l) : NULL_TREE);
3676 }
3677
3678 static void
3679 link_nested_class_to_enclosing (void)
3680 {
3681   if (GET_ENCLOSING_CPC ())
3682     {
3683       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3684       DECL_INNER_CLASS_LIST (enclosing) =
3685         tree_cons (GET_CPC (), GET_CPC_UN (),
3686                    DECL_INNER_CLASS_LIST (enclosing));
3687     }
3688 }
3689
3690 static tree
3691 maybe_make_nested_class_name (tree name)
3692 {
3693   tree id = NULL_TREE;
3694
3695   if (CPC_INNER_P ())
3696     {
3697       /* If we're in a function, we must append a number to create the
3698          nested class name.  However, we don't do this if the class we
3699          are constructing is anonymous, because in that case we'll
3700          already have a number as the class name.  */
3701       if (! make_nested_class_name (GET_CPC_LIST ())
3702           && current_function_decl != NULL_TREE
3703           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3704         {
3705           char buf[10];
3706           sprintf (buf, "%d", anonymous_class_counter);
3707           ++anonymous_class_counter;
3708           obstack_grow (&temporary_obstack, buf, strlen (buf));
3709           obstack_1grow (&temporary_obstack, '$');
3710         }
3711       obstack_grow0 (&temporary_obstack,
3712                      IDENTIFIER_POINTER (name),
3713                      IDENTIFIER_LENGTH (name));
3714       id = get_identifier (obstack_finish (&temporary_obstack));
3715       if (ctxp->package)
3716         QUALIFIED_P (id) = 1;
3717     }
3718   return id;
3719 }
3720
3721 /* If DECL is NULL, create and push a new DECL, record the current
3722    line CL and do other maintenance things.  */
3723
3724 static tree
3725 maybe_create_class_interface_decl (tree decl, tree raw_name,
3726                                    tree qualified_name, tree cl)
3727 {
3728   if (!decl)
3729     decl = push_class (make_class (), qualified_name);
3730
3731   /* Take care of the file and line business */
3732   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3733   /* If we're emiting xrefs, store the line/col number information */
3734   if (flag_emit_xref)
3735     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3736   else
3737     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3738   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3739   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3740   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3741     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3742
3743   PUSH_CPC (decl, raw_name);
3744   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3745
3746   /* Link the declaration to the already seen ones */
3747   TREE_CHAIN (decl) = ctxp->class_list;
3748   ctxp->class_list = decl;
3749
3750   /* Create a new nodes in the global lists */
3751   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3752   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3753
3754   /* Install a new dependency list element */
3755   create_jdep_list (ctxp);
3756
3757   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3758                           IDENTIFIER_POINTER (qualified_name)));
3759   return decl;
3760 }
3761
3762 static void
3763 add_superinterfaces (tree decl, tree interface_list)
3764 {
3765   tree node;
3766   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3767      takes care of ensuring that:
3768        - This is an accessible interface type,
3769        - Circularity detection.
3770    parser_add_interface is then called. If present but not defined,
3771    the check operation is delayed until the super interface gets
3772    defined.  */
3773   for (node = interface_list; node; node = TREE_CHAIN (node))
3774     {
3775       tree current = TREE_PURPOSE (node);
3776       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3777       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3778         {
3779           if (!parser_check_super_interface (idecl, decl, current))
3780             parser_add_interface (decl, idecl, current);
3781         }
3782       else
3783         register_incomplete_type (JDEP_INTERFACE,
3784                                   current, decl, NULL_TREE);
3785     }
3786 }
3787
3788 /* Create an interface in pass1 and return its decl. Return the
3789    interface's decl in pass 2.  */
3790
3791 static tree
3792 create_interface (int flags, tree id, tree super)
3793 {
3794   tree raw_name = EXPR_WFL_NODE (id);
3795   tree q_name = parser_qualified_classname (raw_name);
3796   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3797
3798   /* Certain syntax errors are making SUPER be like ID. Avoid this
3799      case. */
3800   if (ctxp->class_err && id == super)
3801     super = NULL;
3802
3803   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3804
3805   /* Basic checks: scope, redefinition, modifiers */
3806   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3807     {
3808       PUSH_ERROR ();
3809       return NULL_TREE;
3810     }
3811
3812   /* Suspend the current parsing context if we're parsing an inner
3813      interface */
3814   if (CPC_INNER_P ())
3815     {
3816       java_parser_context_suspend ();
3817       /* Interface members are public. */
3818       if (CLASS_INTERFACE (GET_CPC ()))
3819         flags |= ACC_PUBLIC;
3820     }
3821
3822   /* Push a new context for (static) initialized upon declaration fields */
3823   java_parser_context_push_initialized_field ();
3824
3825   /* Interface modifiers check
3826        - public/abstract allowed (already done at that point)
3827        - abstract is obsolete (comes first, it's a warning, or should be)
3828        - Can't use twice the same (checked in the modifier rule) */
3829   if ((flags & ACC_ABSTRACT) && flag_redundant)
3830     parse_warning_context
3831       (MODIFIER_WFL (ABSTRACT_TK),
3832        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3833
3834   /* Create a new decl if DECL is NULL, otherwise fix it */
3835   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3836
3837   /* Set super info and mark the class a complete */
3838   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3839                   object_type_node, ctxp->interface_number);
3840   ctxp->interface_number = 0;
3841   CLASS_COMPLETE_P (decl) = 1;
3842   add_superinterfaces (decl, super);
3843
3844   /* Eventually sets the @deprecated tag flag */
3845   CHECK_DEPRECATED (decl);
3846
3847   return decl;
3848 }
3849
3850 /* Patch anonymous class CLASS, by either extending or implementing
3851    DEP.  */
3852
3853 static void
3854 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3855 {
3856   tree class = TREE_TYPE (class_decl);
3857   tree type =  TREE_TYPE (type_decl);
3858   tree binfo = TYPE_BINFO (class);
3859
3860   /* If it's an interface, implement it */
3861   if (CLASS_INTERFACE (type_decl))
3862     {
3863       tree s_binfo;
3864       int length;
3865
3866       if (parser_check_super_interface (type_decl, class_decl, wfl))
3867         return;
3868
3869       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3870       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3871       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3872       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3873       /* And add the interface */
3874       parser_add_interface (class_decl, type_decl, wfl);
3875     }
3876   /* Otherwise, it's a type we want to extend */
3877   else
3878     {
3879       if (parser_check_super (type_decl, class_decl, wfl))
3880         return;
3881       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3882     }
3883 }
3884
3885 static tree
3886 create_anonymous_class (int location, tree type_name)
3887 {
3888   char buffer [80];
3889   tree super = NULL_TREE, itf = NULL_TREE;
3890   tree id, type_decl, class;
3891
3892   /* The unqualified name of the anonymous class. It's just a number. */
3893   sprintf (buffer, "%d", anonymous_class_counter++);
3894   id = build_wfl_node (get_identifier (buffer));
3895   EXPR_WFL_LINECOL (id) = location;
3896
3897   /* We know about the type to extend/implement. We go ahead */
3898   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3899     {
3900       /* Create a class which either implements on extends the designated
3901          class. The class bears an innacessible name. */
3902       if (CLASS_INTERFACE (type_decl))
3903         {
3904           /* It's OK to modify it here. It's been already used and
3905              shouldn't be reused */
3906           ctxp->interface_number = 1;
3907           /* Interfaces should presented as a list of WFLs */
3908           itf = build_tree_list (type_name, NULL_TREE);
3909         }
3910       else
3911         super = type_name;
3912     }
3913
3914   class = create_class (ACC_FINAL, id, super, itf);
3915
3916   /* We didn't know anything about the stuff. We register a dependence. */
3917   if (!type_decl)
3918     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3919
3920   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3921   return class;
3922 }
3923
3924 /* Create a class in pass1 and return its decl. Return class
3925    interface's decl in pass 2.  */
3926
3927 static tree
3928 create_class (int flags, tree id, tree super, tree interfaces)
3929 {
3930   tree raw_name = EXPR_WFL_NODE (id);
3931   tree class_id, decl;
3932   tree super_decl_type;
3933
3934   /* Certain syntax errors are making SUPER be like ID. Avoid this
3935      case. */
3936   if (ctxp->class_err && id == super)
3937     super = NULL;
3938
3939   class_id = parser_qualified_classname (raw_name);
3940   decl = IDENTIFIER_CLASS_VALUE (class_id);
3941   EXPR_WFL_NODE (id) = class_id;
3942
3943   /* Basic check: scope, redefinition, modifiers */
3944   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3945     {
3946       PUSH_ERROR ();
3947       return NULL_TREE;
3948     }
3949
3950   /* Suspend the current parsing context if we're parsing an inner
3951      class or an anonymous class. */
3952   if (CPC_INNER_P ())
3953     {
3954       java_parser_context_suspend ();
3955       /* Interface members are public. */
3956       if (CLASS_INTERFACE (GET_CPC ()))
3957         flags |= ACC_PUBLIC;
3958     }
3959
3960   /* Push a new context for (static) initialized upon declaration fields */
3961   java_parser_context_push_initialized_field ();
3962
3963   /* Class modifier check:
3964        - Allowed modifier (already done at that point)
3965        - abstract AND final forbidden
3966        - Public classes defined in the correct file */
3967   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3968     parse_error_context
3969       (id, "Class `%s' can't be declared both abstract and final",
3970        IDENTIFIER_POINTER (raw_name));
3971
3972   /* Create a new decl if DECL is NULL, otherwise fix it */
3973   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3974
3975   /* If SUPER exists, use it, otherwise use Object */
3976   if (super)
3977     {
3978       /* Can't extend java.lang.Object */
3979       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3980         {
3981           parse_error_context (id, "Can't extend `java.lang.Object'");
3982           return NULL_TREE;
3983         }
3984
3985       super_decl_type =
3986         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
3987     }
3988   else if (TREE_TYPE (decl) != object_type_node)
3989     super_decl_type = object_type_node;
3990   /* We're defining java.lang.Object */
3991   else
3992     super_decl_type = NULL_TREE;
3993
3994   /* A class nested in an interface is implicitly static. */
3995   if (INNER_CLASS_DECL_P (decl)
3996       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
3997     {
3998       flags |= ACC_STATIC;
3999     }
4000
4001   /* Set super info and mark the class as complete. */
4002   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4003                   ctxp->interface_number);
4004   ctxp->interface_number = 0;
4005   CLASS_COMPLETE_P (decl) = 1;
4006   add_superinterfaces (decl, interfaces);
4007
4008   /* Add the private this$<n> field, Replicate final locals still in
4009      scope as private final fields mangled like val$<local_name>.
4010      This doesn't not occur for top level (static) inner classes. */
4011   if (PURE_INNER_CLASS_DECL_P (decl))
4012     add_inner_class_fields (decl, current_function_decl);
4013
4014   /* If doing xref, store the location at which the inherited class
4015      (if any) was seen. */
4016   if (flag_emit_xref && super)
4017     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4018
4019   /* Eventually sets the @deprecated tag flag */
4020   CHECK_DEPRECATED (decl);
4021
4022   /* Reset the anonymous class counter when declaring non inner classes */
4023   if (!INNER_CLASS_DECL_P (decl))
4024     anonymous_class_counter = 1;
4025
4026   return decl;
4027 }
4028
4029 /* End a class declaration: register the statements used to create
4030    finit$ and <clinit>, pop the current class and resume the prior
4031    parser context if necessary.  */
4032
4033 static void
4034 end_class_declaration (int resume)
4035 {
4036   /* If an error occurred, context weren't pushed and won't need to be
4037      popped by a resume. */
4038   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4039
4040   if (GET_CPC () != error_mark_node)
4041     dump_java_tree (TDI_class, GET_CPC ());
4042
4043   java_parser_context_pop_initialized_field ();
4044   POP_CPC ();
4045   if (resume && no_error_occurred)
4046     java_parser_context_resume ();
4047
4048   /* We're ending a class declaration, this is a good time to reset
4049      the interface cout. Note that might have been already done in
4050      create_interface, but if at that time an inner class was being
4051      dealt with, the interface count was reset in a context created
4052      for the sake of handling inner classes declaration. */
4053   ctxp->interface_number = 0;
4054 }
4055
4056 static void
4057 add_inner_class_fields (tree class_decl, tree fct_decl)
4058 {
4059   tree block, marker, f;
4060
4061   f = add_field (TREE_TYPE (class_decl),
4062                  build_current_thisn (TREE_TYPE (class_decl)),
4063                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4064                  ACC_PRIVATE);
4065   FIELD_THISN (f) = 1;
4066
4067   if (!fct_decl)
4068     return;
4069
4070   for (block = GET_CURRENT_BLOCK (fct_decl);
4071        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4072     {
4073       tree decl;
4074       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4075         {
4076           tree name, pname;
4077           tree wfl, init, list;
4078
4079           /* Avoid non final arguments. */
4080           if (!LOCAL_FINAL_P (decl))
4081             continue;
4082
4083           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4084           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4085           wfl = build_wfl_node (name);
4086           init = build_wfl_node (pname);
4087           /* Build an initialization for the field: it will be
4088              initialized by a parameter added to finit$, bearing a
4089              mangled name of the field itself (param$<n>.) The
4090              parameter is provided to finit$ by the constructor
4091              invoking it (hence the constructor will also feature a
4092              hidden parameter, set to the value of the outer context
4093              local at the time the inner class is created.)
4094
4095              Note: we take into account all possible locals that can
4096              be accessed by the inner class. It's actually not trivial
4097              to minimize these aliases down to the ones really
4098              used. One way to do that would be to expand all regular
4099              methods first, then finit$ to get a picture of what's
4100              used.  It works with the exception that we would have to
4101              go back on all constructor invoked in regular methods to
4102              have their invokation reworked (to include the right amount
4103              of alias initializer parameters.)
4104
4105              The only real way around, I think, is a first pass to
4106              identify locals really used in the inner class. We leave
4107              the flag FIELD_LOCAL_ALIAS_USED around for that future
4108              use.
4109
4110              On the other hand, it only affect local inner classes,
4111              whose constructors (and finit$ call) will be featuring
4112              unecessary arguments. It's easy for a developper to keep
4113              this number of parameter down by using the `final'
4114              keyword only when necessary. For the time being, we can
4115              issue a warning on unecessary finals. FIXME */
4116           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4117                                    wfl, init);
4118
4119           /* Register the field. The TREE_LIST holding the part
4120              initialized/initializer will be marked ARG_FINAL_P so
4121              that the created field can be marked
4122              FIELD_LOCAL_ALIAS. */
4123           list = build_tree_list (wfl, init);
4124           ARG_FINAL_P (list) = 1;
4125           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4126         }
4127     }
4128
4129   if (!CPC_INITIALIZER_STMT (ctxp))
4130     return;
4131
4132   /* If we ever registered an alias field, insert and marker to
4133      remeber where the list ends. The second part of the list (the one
4134      featuring initialized fields) so it can be later reversed to
4135      enforce 8.5. The marker will be removed during that operation. */
4136   marker = build_tree_list (NULL_TREE, NULL_TREE);
4137   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4138   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4139 }
4140
4141 /* Can't use lookup_field () since we don't want to load the class and
4142    can't set the CLASS_LOADED_P flag */
4143
4144 static tree
4145 find_field (tree class, tree name)
4146 {
4147   tree decl;
4148   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4149     {
4150       if (DECL_NAME (decl) == name)
4151         return decl;
4152     }
4153   return NULL_TREE;
4154 }
4155
4156 /* Wrap around lookup_field that doesn't potentially upset the value
4157    of CLASS */
4158
4159 static tree
4160 lookup_field_wrapper (tree class, tree name)
4161 {
4162   tree type = class;
4163   tree decl = NULL_TREE;
4164   java_parser_context_save_global ();
4165
4166   /* Last chance: if we're within the context of an inner class, we
4167      might be trying to access a local variable defined in an outer
4168      context. We try to look for it now. */
4169   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4170     {
4171       tree new_name;
4172       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4173       decl = lookup_field (&type, new_name);
4174       if (decl && decl != error_mark_node)
4175         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4176     }
4177   if (!decl || decl == error_mark_node)
4178     {
4179       type = class;
4180       decl = lookup_field (&type, name);
4181     }
4182
4183   /* If the field still hasn't been found, try the next enclosing context. */
4184   if (!decl && INNER_CLASS_TYPE_P (class))
4185     {
4186       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4187       decl = lookup_field_wrapper (outer_type, name);
4188     }
4189
4190   java_parser_context_restore_global ();
4191   return decl == error_mark_node ? NULL : decl;
4192 }
4193
4194 /* Find duplicate field within the same class declarations and report
4195    the error. Returns 1 if a duplicated field was found, 0
4196    otherwise.  */
4197
4198 static int
4199 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4200 {
4201   /* This might be modified to work with method decl as well */
4202   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4203   if (decl)
4204     {
4205       char *t1 = xstrdup (purify_type_name
4206                          ((TREE_CODE (new_type) == POINTER_TYPE
4207                            && TREE_TYPE (new_type) == NULL_TREE) ?
4208                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4209                           lang_printable_name (new_type, 1)));
4210       /* The type may not have been completed by the time we report
4211          the error */
4212       char *t2 = xstrdup (purify_type_name
4213                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4214                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4215                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4216                           lang_printable_name (TREE_TYPE (decl), 1)));
4217       parse_error_context
4218         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4219          t1, IDENTIFIER_POINTER (new_field_name),
4220          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4221          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4222       free (t1);
4223       free (t2);
4224       return 1;
4225     }
4226   return 0;
4227 }
4228
4229 /* Field registration routine. If TYPE doesn't exist, field
4230    declarations are linked to the undefined TYPE dependency list, to
4231    be later resolved in java_complete_class () */
4232
4233 static void
4234 register_fields (int flags, tree type, tree variable_list)
4235 {
4236   tree current, saved_type;
4237   tree class_type = NULL_TREE;
4238   int saved_lineno = input_line;
4239   int must_chain = 0;
4240   tree wfl = NULL_TREE;
4241
4242   if (GET_CPC ())
4243     class_type = TREE_TYPE (GET_CPC ());
4244
4245   if (!class_type || class_type == error_mark_node)
4246     return;
4247
4248   /* If we're adding fields to interfaces, those fields are public,
4249      static, final */
4250   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4251     {
4252       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4253                                  flags, ACC_PUBLIC, "interface field(s)");
4254       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4255                                  flags, ACC_STATIC, "interface field(s)");
4256       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4257                                  flags, ACC_FINAL, "interface field(s)");
4258       check_modifiers ("Illegal interface member modifier `%s'", flags,
4259                        INTERFACE_FIELD_MODIFIERS);
4260       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4261     }
4262
4263   /* Obtain a suitable type for resolution, if necessary */
4264   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4265
4266   /* If TYPE is fully resolved and we don't have a reference, make one */
4267   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4268
4269   for (current = variable_list, saved_type = type; current;
4270        current = TREE_CHAIN (current), type = saved_type)
4271     {
4272       tree real_type;
4273       tree field_decl;
4274       tree cl = TREE_PURPOSE (current);
4275       tree init = TREE_VALUE (current);
4276       tree current_name = EXPR_WFL_NODE (cl);
4277
4278       /* Can't declare non-final static fields in inner classes */
4279       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4280           && !(flags & ACC_FINAL))
4281         parse_error_context
4282           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4283            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4284            lang_printable_name (class_type, 0));
4285
4286       /* Process NAME, as it may specify extra dimension(s) for it */
4287       type = build_array_from_name (type, wfl, current_name, &current_name);
4288
4289       /* Type adjustment. We may have just readjusted TYPE because
4290          the variable specified more dimensions. Make sure we have
4291          a reference if we can and don't have one already. Also
4292          change the name if we have an init. */
4293       if (type != saved_type)
4294         {
4295           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4296           if (init)
4297             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4298         }
4299
4300       real_type = GET_REAL_TYPE (type);
4301       /* Check for redeclarations */
4302       if (duplicate_declaration_error_p (current_name, real_type, cl))
4303         continue;
4304
4305       /* Set lineno to the line the field was found and create a
4306          declaration for it. Eventually sets the @deprecated tag flag. */
4307       if (flag_emit_xref)
4308         input_line = EXPR_WFL_LINECOL (cl);
4309       else
4310         input_line = EXPR_WFL_LINENO (cl);
4311       field_decl = add_field (class_type, current_name, real_type, flags);
4312       CHECK_DEPRECATED_NO_RESET (field_decl);
4313
4314       /* If the field denotes a final instance variable, then we
4315          allocate a LANG_DECL_SPECIFIC part to keep track of its
4316          initialization. We also mark whether the field was
4317          initialized upon its declaration. We don't do that if the
4318          created field is an alias to a final local. */
4319       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4320         {
4321           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4322           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4323         }
4324
4325       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4326          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4327          hide parameters to this inner class finit$ and
4328          constructors. It also means that the field isn't final per
4329          say. */
4330       if (ARG_FINAL_P (current))
4331         {
4332           FIELD_LOCAL_ALIAS (field_decl) = 1;
4333           FIELD_FINAL (field_decl) = 0;
4334         }
4335
4336       /* Check if we must chain. */
4337       if (must_chain)
4338         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4339
4340       /* If we have an initialization value tied to the field */
4341       if (init)
4342         {
4343           /* The field is declared static */
4344           if (flags & ACC_STATIC)
4345             {
4346               /* We include the field and its initialization part into
4347                  a list used to generate <clinit>. After <clinit> is
4348                  walked, field initializations will be processed and
4349                  fields initialized with known constants will be taken
4350                  out of <clinit> and have their DECL_INITIAL set
4351                  appropriately. */
4352               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4353               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4354               if (TREE_OPERAND (init, 1)
4355                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4356                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4357             }
4358           /* A non-static field declared with an immediate initialization is
4359              to be initialized in <init>, if any.  This field is remembered
4360              to be processed at the time of the generation of <init>. */
4361           else
4362             {
4363               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4364               SET_CPC_INITIALIZER_STMT (ctxp, init);
4365             }
4366           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4367           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4368         }
4369     }
4370
4371   CLEAR_DEPRECATED;
4372   input_line = saved_lineno;
4373 }
4374
4375 /* Generate finit$, using the list of initialized fields to populate
4376    its body. finit$'s parameter(s) list is adjusted to include the
4377    one(s) used to initialized the field(s) caching outer context
4378    local(s).  */
4379
4380 static tree
4381 generate_finit (tree class_type)
4382 {
4383   int count = 0;
4384   tree list = TYPE_FINIT_STMT_LIST (class_type);
4385   tree mdecl, current, parms;
4386
4387   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4388                                                   class_type, NULL_TREE,
4389                                                   &count);
4390   CRAFTED_PARAM_LIST_FIXUP (parms);
4391   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4392                                     finit_identifier_node, parms);
4393   fix_method_argument_names (parms, mdecl);
4394   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4395                        mdecl, NULL_TREE);
4396   DECL_FUNCTION_NAP (mdecl) = count;
4397   start_artificial_method_body (mdecl);
4398
4399   for (current = list; current; current = TREE_CHAIN (current))
4400     java_method_add_stmt (mdecl,
4401                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4402                                                 current));
4403   end_artificial_method_body (mdecl);
4404   return mdecl;
4405 }
4406
4407 /* Generate a function to run the instance initialization code. The
4408    private method is called `instinit$'. Unless we're dealing with an
4409    anonymous class, we determine whether all ctors of CLASS_TYPE
4410    declare a checked exception in their `throws' clause in order to
4411    see whether it's necessary to encapsulate the instance initializer
4412    statements in a try/catch/rethrow sequence.  */
4413
4414 static tree
4415 generate_instinit (tree class_type)
4416 {
4417   tree current;
4418   tree compound = NULL_TREE;
4419   tree parms = tree_cons (this_identifier_node,
4420                           build_pointer_type (class_type), end_params_node);
4421   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4422                                          void_type_node,
4423                                          instinit_identifier_node, parms);
4424
4425   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4426                        mdecl, NULL_TREE);
4427
4428   /* Gather all the statements in a compound */
4429   for (current = TYPE_II_STMT_LIST (class_type);
4430        current; current = TREE_CHAIN (current))
4431     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4432
4433   /* We need to encapsulate COMPOUND by a try/catch statement to
4434      rethrow exceptions that might occur in the instance initializer.
4435      We do that only if all ctors of CLASS_TYPE are set to catch a
4436      checked exception. This doesn't apply to anonymous classes (since
4437      they don't have declared ctors.) */
4438   if (!ANONYMOUS_CLASS_P (class_type) &&
4439       ctors_unchecked_throws_clause_p (class_type))
4440     {
4441       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4442                                              build1 (THROW_EXPR, NULL_TREE,
4443                                                      build_wfl_node (wpv_id)));
4444       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4445                                                       exception_type_node);
4446     }
4447
4448   start_artificial_method_body (mdecl);
4449   java_method_add_stmt (mdecl, compound);
4450   end_artificial_method_body (mdecl);
4451
4452   return mdecl;
4453 }
4454
4455 /* FIXME */
4456 static tree
4457 build_instinit_invocation (tree class_type)
4458 {
4459   tree to_return = NULL_TREE;
4460
4461   if (TYPE_II_STMT_LIST (class_type))
4462     {
4463       tree parm = build_tree_list (NULL_TREE,
4464                                    build_wfl_node (this_identifier_node));
4465       to_return =
4466         build_method_invocation (build_wfl_node (instinit_identifier_node),
4467                                  parm);
4468     }
4469   return to_return;
4470 }
4471
4472 /* Shared accros method_declarator and method_header to remember the
4473    patch stage that was reached during the declaration of the method.
4474    A method DECL is built differently is there is no patch
4475    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4476    pending on the currently defined method.  */
4477
4478 static int patch_stage;
4479
4480 /* Check the method declaration and add the method to its current
4481    class.  If the argument list is known to contain incomplete types,
4482    the method is partially added and the registration will be resume
4483    once the method arguments resolved. If TYPE is NULL, we're dealing
4484    with a constructor.  */
4485
4486 static tree
4487 method_header (int flags, tree type, tree mdecl, tree throws)
4488 {
4489   tree type_wfl = NULL_TREE;
4490   tree meth_name = NULL_TREE;
4491   tree current, orig_arg, this_class = NULL;
4492   tree id, meth;
4493   int saved_lineno;
4494   int constructor_ok = 0, must_chain;
4495   int count;
4496
4497   if (mdecl == error_mark_node)
4498     return error_mark_node;
4499   meth = TREE_VALUE (mdecl);
4500   id = TREE_PURPOSE (mdecl);
4501
4502   check_modifiers_consistency (flags);
4503
4504   if (GET_CPC ())
4505     this_class = TREE_TYPE (GET_CPC ());
4506
4507   if (!this_class || this_class == error_mark_node)
4508     return NULL_TREE;
4509
4510   /* There are some forbidden modifiers for an abstract method and its
4511      class must be abstract as well.  */
4512   if (type && (flags & ACC_ABSTRACT))
4513     {
4514       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4515       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4516       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4517       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4518       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4519       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4520       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4521           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4522         parse_error_context
4523           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4524            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4525            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4526     }
4527
4528   /* A native method can't be strictfp.  */
4529   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4530     parse_error_context (id, "native method `%s' can't be strictfp",
4531                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4532   /* No such thing as a transient or volatile method.  */
4533   if ((flags & ACC_TRANSIENT))
4534     parse_error_context (id, "method `%s' can't be transient",
4535                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4536   if ((flags & ACC_VOLATILE))
4537     parse_error_context (id, "method `%s' can't be volatile",
4538                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4539
4540   /* Things to be checked when declaring a constructor */
4541   if (!type)
4542     {
4543       int ec = java_error_count;
4544       /* 8.6: Constructor declarations: we might be trying to define a
4545          method without specifying a return type. */
4546       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4547         parse_error_context
4548           (id, "Invalid method declaration, return type required");
4549       /* 8.6.3: Constructor modifiers */
4550       else
4551         {
4552           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4553           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4554           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4555           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4556           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4557           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4558         }
4559       /* If we found error here, we don't consider it's OK to tread
4560          the method definition as a constructor, for the rest of this
4561          function */
4562       if (ec == java_error_count)
4563         constructor_ok = 1;
4564     }
4565
4566   /* Method declared within the scope of an interface are implicitly
4567      abstract and public. Conflicts with other erroneously provided
4568      modifiers are checked right after. */
4569
4570   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4571     {
4572       /* If FLAGS isn't set because of a modifier, turn the
4573          corresponding modifier WFL to NULL so we issue a warning on
4574          the obsolete use of the modifier */
4575       if (!(flags & ACC_PUBLIC))
4576         MODIFIER_WFL (PUBLIC_TK) = NULL;
4577       if (!(flags & ACC_ABSTRACT))
4578         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4579       flags |= ACC_PUBLIC;
4580       flags |= ACC_ABSTRACT;
4581     }
4582
4583   /* Inner class can't declare static methods */
4584   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4585     {
4586       parse_error_context
4587         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4588          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4589          lang_printable_name (this_class, 0));
4590     }
4591
4592   /* Modifiers context reset moved up, so abstract method declaration
4593      modifiers can be later checked.  */
4594
4595   /* Set constructor returned type to void and method name to <init>,
4596      unless we found an error identifier the constructor (in which
4597      case we retain the original name) */
4598   if (!type)
4599     {
4600       type = void_type_node;
4601       if (constructor_ok)
4602         meth_name = init_identifier_node;
4603     }
4604   else
4605     meth_name = EXPR_WFL_NODE (id);
4606
4607   /* Do the returned type resolution and registration if necessary */
4608   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4609
4610   if (meth_name)
4611     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4612   EXPR_WFL_NODE (id) = meth_name;
4613   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4614
4615   if (must_chain)
4616     {
4617       patch_stage = JDEP_METHOD_RETURN;
4618       register_incomplete_type (patch_stage, type_wfl, id, type);
4619       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4620     }
4621   else
4622     TREE_TYPE (meth) = type;
4623
4624   saved_lineno = input_line;
4625   /* When defining an abstract or interface method, the curly
4626      bracket at level 1 doesn't exist because there is no function
4627      body */
4628   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4629             EXPR_WFL_LINENO (id));
4630
4631   /* Remember the original argument list */
4632   orig_arg = TYPE_ARG_TYPES (meth);
4633
4634   if (patch_stage)              /* includes ret type and/or all args */
4635     {
4636       jdep *jdep;
4637       meth = add_method_1 (this_class, flags, meth_name, meth);
4638       /* Patch for the return type */
4639       if (patch_stage == JDEP_METHOD_RETURN)
4640         {
4641           jdep = CLASSD_LAST (ctxp->classd_list);
4642           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4643         }
4644       /* This is the stop JDEP. METH allows the function's signature
4645          to be computed. */
4646       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4647     }
4648   else
4649     meth = add_method (this_class, flags, meth_name,
4650                        build_java_signature (meth));
4651
4652   /* Remember final parameters */
4653   MARK_FINAL_PARMS (meth, orig_arg);
4654
4655   /* Fix the method argument list so we have the argument name
4656      information */
4657   fix_method_argument_names (orig_arg, meth);
4658
4659   /* Register the parameter number and re-install the current line
4660      number */
4661   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4662   input_line = saved_lineno;
4663
4664   /* Register exception specified by the `throws' keyword for
4665      resolution and set the method decl appropriate field to the list.
4666      Note: the grammar ensures that what we get here are class
4667      types. */
4668   if (throws)
4669     {
4670       throws = nreverse (throws);
4671       for (current = throws; current; current = TREE_CHAIN (current))
4672         {
4673           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4674                                     NULL_TREE, NULL_TREE);
4675           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4676             &TREE_VALUE (current);
4677         }
4678       DECL_FUNCTION_THROWS (meth) = throws;
4679     }
4680
4681   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4682     DECL_FUNCTION_WFL (meth) = id;
4683
4684   /* Set the flag if we correctly processed a constructor */
4685   if (constructor_ok)
4686     {
4687       DECL_CONSTRUCTOR_P (meth) = 1;
4688       /* Compute and store the number of artificial parameters declared
4689          for this constructor */
4690       for (count = 0, current = TYPE_FIELDS (this_class); current;
4691            current = TREE_CHAIN (current))
4692         if (FIELD_LOCAL_ALIAS (current))
4693           count++;
4694       DECL_FUNCTION_NAP (meth) = count;
4695     }
4696
4697   /* Eventually set the @deprecated tag flag */
4698   CHECK_DEPRECATED (meth);
4699
4700   /* If doing xref, store column and line number information instead
4701      of the line number only. */
4702   if (flag_emit_xref)
4703     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4704
4705   return meth;
4706 }
4707
4708 static void
4709 fix_method_argument_names (tree orig_arg, tree meth)
4710 {
4711   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4712   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4713     {
4714       TREE_PURPOSE (arg) = this_identifier_node;
4715       arg = TREE_CHAIN (arg);
4716     }
4717   while (orig_arg != end_params_node)
4718     {
4719       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4720       orig_arg = TREE_CHAIN (orig_arg);
4721       arg = TREE_CHAIN (arg);
4722     }
4723 }
4724
4725 /* Complete the method declaration with METHOD_BODY.  */
4726
4727 static void
4728 finish_method_declaration (tree method_body)
4729 {
4730   int flags;
4731
4732   if (!current_function_decl)
4733     return;
4734
4735   flags = get_access_flags_from_decl (current_function_decl);
4736
4737   /* 8.4.5 Method Body */
4738   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4739     {
4740       tree name = DECL_NAME (current_function_decl);
4741       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4742                            "%s method `%s' can't have a body defined",
4743                            (METHOD_NATIVE (current_function_decl) ?
4744                             "Native" : "Abstract"),
4745                            IDENTIFIER_POINTER (name));
4746       method_body = NULL_TREE;
4747     }
4748   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4749     {
4750       tree name = DECL_NAME (current_function_decl);
4751       parse_error_context
4752         (DECL_FUNCTION_WFL (current_function_decl),
4753          "Non native and non abstract method `%s' must have a body defined",
4754          IDENTIFIER_POINTER (name));
4755       method_body = NULL_TREE;
4756     }
4757
4758   if (flag_emit_class_files && method_body
4759       && TREE_CODE (method_body) == NOP_EXPR
4760       && TREE_TYPE (current_function_decl)
4761       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4762     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4763
4764   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4765   maybe_absorb_scoping_blocks ();
4766   /* Exit function's body */
4767   exit_block ();
4768   /* Merge last line of the function with first line, directly in the
4769      function decl. It will be used to emit correct debug info. */
4770   if (!flag_emit_xref)
4771     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4772
4773   /* Since function's argument's list are shared, reset the
4774      ARG_FINAL_P parameter that might have been set on some of this
4775      function parameters. */
4776   UNMARK_FINAL_PARMS (current_function_decl);
4777
4778   /* So we don't have an irrelevant function declaration context for
4779      the next static block we'll see. */
4780   current_function_decl = NULL_TREE;
4781 }
4782
4783 /* Build a an error message for constructor circularity errors.  */
4784
4785 static char *
4786 constructor_circularity_msg (tree from, tree to)
4787 {
4788   static char string [4096];
4789   char *t = xstrdup (lang_printable_name (from, 0));
4790   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4791   free (t);
4792   return string;
4793 }
4794
4795 /* Verify a circular call to METH. Return 1 if an error is found, 0
4796    otherwise.  */
4797
4798 static GTY(()) tree vcc_list;
4799 static int
4800 verify_constructor_circularity (tree meth, tree current)
4801 {
4802   tree c;
4803
4804   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4805     {
4806       if (TREE_VALUE (c) == meth)
4807         {
4808           char *t;
4809           if (vcc_list)
4810             {
4811               tree liste;
4812               vcc_list = nreverse (vcc_list);
4813               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4814                 {
4815                   parse_error_context
4816                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4817                      constructor_circularity_msg
4818                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4819                   java_error_count--;
4820                 }
4821             }
4822           t = xstrdup (lang_printable_name (meth, 0));
4823           parse_error_context (TREE_PURPOSE (c),
4824                                "%s: recursive invocation of constructor `%s'",
4825                                constructor_circularity_msg (current, meth), t);
4826           free (t);
4827           vcc_list = NULL_TREE;
4828           return 1;
4829         }
4830     }
4831   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4832     {
4833       vcc_list = tree_cons (c, current, vcc_list);
4834       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4835         return 1;
4836       vcc_list = TREE_CHAIN (vcc_list);
4837     }
4838   return 0;
4839 }
4840
4841 /* Check modifiers that can be declared but exclusively */
4842
4843 static void
4844 check_modifiers_consistency (int flags)
4845 {
4846   int acc_count = 0;
4847   tree cl = NULL_TREE;
4848
4849   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4850   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4851   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4852   if (acc_count > 1)
4853     parse_error_context
4854       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4855
4856   acc_count = 0;
4857   cl = NULL_TREE;
4858   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4859   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4860   if (acc_count > 1)
4861     parse_error_context (cl,
4862                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4863 }
4864
4865 /* Check the methode header METH for abstract specifics features */
4866
4867 static void
4868 check_abstract_method_header (tree meth)
4869 {
4870   int flags = get_access_flags_from_decl (meth);
4871
4872   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4873                               ACC_ABSTRACT, "abstract method",
4874                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4875   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4876                               ACC_PUBLIC, "abstract method",
4877                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4878
4879   check_modifiers ("Illegal modifier `%s' for interface method",
4880                   flags, INTERFACE_METHOD_MODIFIERS);
4881 }
4882
4883 /* Create a FUNCTION_TYPE node and start augmenting it with the
4884    declared function arguments. Arguments type that can't be resolved
4885    are left as they are, but the returned node is marked as containing
4886    incomplete types.  */
4887
4888 static tree
4889 method_declarator (tree id, tree list)
4890 {
4891   tree arg_types = NULL_TREE, current, node;
4892   tree meth = make_node (FUNCTION_TYPE);
4893   jdep *jdep;
4894
4895   patch_stage = JDEP_NO_PATCH;
4896
4897   if (GET_CPC () == error_mark_node)
4898     return error_mark_node;
4899
4900   /* If we're dealing with an inner class constructor, we hide the
4901      this$<n> decl in the name field of its parameter declaration.  We
4902      also might have to hide the outer context local alias
4903      initializers. Not done when the class is a toplevel class. */
4904   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4905       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4906     {
4907       tree aliases_list, type, thisn;
4908       /* First the aliases, linked to the regular parameters */
4909       aliases_list =
4910         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4911                                                 TREE_TYPE (GET_CPC ()),
4912                                                 NULL_TREE, NULL);
4913       list = chainon (nreverse (aliases_list), list);
4914
4915       /* Then this$<n> */
4916       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4917       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4918       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4919                         list);
4920     }
4921
4922   for (current = list; current; current = TREE_CHAIN (current))
4923     {
4924       int must_chain = 0;
4925       tree wfl_name = TREE_PURPOSE (current);
4926       tree type = TREE_VALUE (current);
4927       tree name = EXPR_WFL_NODE (wfl_name);
4928       tree already, arg_node;
4929       tree type_wfl = NULL_TREE;
4930       tree real_type;
4931
4932       /* Obtain a suitable type for resolution, if necessary */
4933       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4934
4935       /* Process NAME, as it may specify extra dimension(s) for it */
4936       type = build_array_from_name (type, type_wfl, name, &name);
4937       EXPR_WFL_NODE (wfl_name) = name;
4938
4939       real_type = GET_REAL_TYPE (type);
4940       if (TREE_CODE (real_type) == RECORD_TYPE)
4941         {
4942           real_type = promote_type (real_type);
4943           if (TREE_CODE (type) == TREE_LIST)
4944             TREE_PURPOSE (type) = real_type;
4945         }
4946
4947       /* Check redefinition */
4948       for (already = arg_types; already; already = TREE_CHAIN (already))
4949         if (TREE_PURPOSE (already) == name)
4950           {
4951             parse_error_context
4952               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4953                IDENTIFIER_POINTER (name),
4954                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4955             break;
4956           }
4957
4958       /* If we've an incomplete argument type, we know there is a location
4959          to patch when the type get resolved, later.  */
4960       jdep = NULL;
4961       if (must_chain)
4962         {
4963           patch_stage = JDEP_METHOD;
4964           type = register_incomplete_type (patch_stage,
4965                                            type_wfl, wfl_name, type);
4966           jdep = CLASSD_LAST (ctxp->classd_list);
4967           JDEP_MISC (jdep) = id;
4968         }
4969
4970       /* The argument node: a name and a (possibly) incomplete type.  */
4971       arg_node = build_tree_list (name, real_type);
4972       /* Remeber arguments declared final. */
4973       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4974
4975       if (jdep)
4976         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4977       TREE_CHAIN (arg_node) = arg_types;
4978       arg_types = arg_node;
4979     }
4980   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4981   node = build_tree_list (id, meth);
4982   return node;
4983 }
4984
4985 static int
4986 unresolved_type_p (tree wfl, tree *returned)
4987
4988 {
4989   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
4990     {
4991       if (returned)
4992         {
4993           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
4994           if (decl && current_class && (decl == TYPE_NAME (current_class)))
4995             *returned = TREE_TYPE (decl);
4996           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
4997             *returned = TREE_TYPE (GET_CPC ());
4998           else
4999             *returned = NULL_TREE;
5000         }
5001       return 1;
5002     }
5003   if (returned)
5004     *returned = wfl;
5005   return 0;
5006 }
5007
5008 /* From NAME, build a qualified identifier node using the
5009    qualification from the current package definition. */
5010
5011 static tree
5012 parser_qualified_classname (tree name)
5013 {
5014   tree nested_class_name;
5015
5016   if ((nested_class_name = maybe_make_nested_class_name (name)))
5017     return nested_class_name;
5018
5019   if (ctxp->package)
5020     return merge_qualified_name (ctxp->package, name);
5021   else
5022     return name;
5023 }
5024
5025 /* Called once the type a interface extends is resolved. Returns 0 if
5026    everything is OK.  */
5027
5028 static int
5029 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5030 {
5031   tree super_type = TREE_TYPE (super_decl);
5032
5033   /* Has to be an interface */
5034   if (!CLASS_INTERFACE (super_decl))
5035     {
5036       parse_error_context
5037         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5038          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5039           "Interface" : "Class"),
5040          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5041          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5042          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5043       return 1;
5044     }
5045
5046   /* Check top-level interface access. Inner classes are subject to member
5047      access rules (6.6.1). */
5048   if (! INNER_CLASS_P (super_type)
5049       && check_pkg_class_access (DECL_NAME (super_decl),
5050                                  lookup_cl (this_decl), true))
5051     return 1;
5052
5053   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5054                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5055                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5056   return 0;
5057 }
5058
5059 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5060    0 if everthing is OK.  */
5061
5062 static int
5063 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5064 {
5065   tree super_type = TREE_TYPE (super_decl);
5066
5067   /* SUPER should be a CLASS (neither an array nor an interface) */
5068   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5069     {
5070       parse_error_context
5071         (wfl, "Class `%s' can't subclass %s `%s'",
5072          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5073          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5074          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5075       return 1;
5076     }
5077
5078   if (CLASS_FINAL (TYPE_NAME (super_type)))
5079     {
5080       parse_error_context (wfl, "Can't subclass final classes: %s",
5081                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5082       return 1;
5083     }
5084
5085   /* Check top-level class scope. Inner classes are subject to member access
5086      rules (6.6.1). */
5087   if (! INNER_CLASS_P (super_type)
5088       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5089     return 1;
5090
5091   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5092                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5093                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5094   return 0;
5095 }
5096
5097 /* Create a new dependency list and link it (in a LIFO manner) to the
5098    CTXP list of type dependency list.  */
5099
5100 static void
5101 create_jdep_list (struct parser_ctxt *ctxp)
5102 {
5103   jdeplist *new = xmalloc (sizeof (jdeplist));
5104   new->first = new->last = NULL;
5105   new->next = ctxp->classd_list;
5106   ctxp->classd_list = new;
5107 }
5108
5109 static jdeplist *
5110 reverse_jdep_list (struct parser_ctxt *ctxp)
5111 {
5112   register jdeplist *prev = NULL, *current, *next;
5113   for (current = ctxp->classd_list; current; current = next)
5114     {
5115       next = current->next;
5116       current->next = prev;
5117       prev = current;
5118     }
5119   return prev;
5120 }
5121
5122 /* Create a fake pointer based on the ID stored in
5123    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5124    registered again. */
5125
5126 static tree
5127 obtain_incomplete_type (tree type_name)
5128 {
5129   tree ptr = NULL_TREE, name;
5130
5131   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5132     name = EXPR_WFL_NODE (type_name);
5133   else if (INCOMPLETE_TYPE_P (type_name))
5134     name = TYPE_NAME (type_name);
5135   else
5136     abort ();
5137
5138   /* Workaround from build_pointer_type for incomplete types.  */
5139   BUILD_PTR_FROM_NAME (ptr, name);
5140   TYPE_MODE (ptr) = ptr_mode;
5141   layout_type (ptr);
5142
5143   return ptr;
5144 }
5145
5146 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5147    non NULL instead of computing a new fake type based on WFL. The new
5148    dependency is inserted in the current type dependency list, in FIFO
5149    manner.  */
5150
5151 static tree
5152 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5153 {
5154   jdep *new = xmalloc (sizeof (jdep));
5155
5156   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5157     ptr = obtain_incomplete_type (wfl);
5158
5159   JDEP_KIND (new) = kind;
5160   JDEP_DECL (new) = decl;
5161   JDEP_TO_RESOLVE (new) = ptr;
5162   JDEP_WFL (new) = wfl;
5163   JDEP_CHAIN (new) = NULL;
5164   JDEP_MISC (new) = NULL_TREE;
5165   /* For some dependencies, set the enclosing class of the current
5166      class to be the enclosing context */
5167   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5168       && GET_ENCLOSING_CPC ())
5169     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5170   else if (kind == JDEP_SUPER)
5171     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5172                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5173   else
5174     JDEP_ENCLOSING (new) = GET_CPC ();
5175   JDEP_GET_PATCH (new) = (tree *)NULL;
5176
5177   JDEP_INSERT (ctxp->classd_list, new);
5178
5179   return ptr;
5180 }
5181
5182 /* This checks for circular references with innerclasses. We start
5183    from SOURCE and should never reach TARGET. Extended/implemented
5184    types in SOURCE have their enclosing context checked not to reach
5185    TARGET. When the last enclosing context of SOURCE is reached, its
5186    extended/implemented types are also checked not to reach TARGET.
5187    In case of error, WFL of the offending type is returned; NULL_TREE
5188    otherwise.  */
5189
5190 static tree
5191 check_inner_circular_reference (tree source, tree target)
5192 {
5193   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5194   tree ctx, cl;
5195   int i;
5196
5197   if (!basetype_vec)
5198     return NULL_TREE;
5199
5200   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5201     {
5202       tree su;
5203
5204       /* We can end up with a NULL_TREE or an incomplete type here if
5205          we encountered previous type resolution errors. It's safe to
5206          simply ignore these cases.  */
5207       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5208         continue;
5209       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5210       if (INCOMPLETE_TYPE_P (su))
5211         continue;
5212
5213       if (inherits_from_p (su, target))
5214         return lookup_cl (TYPE_NAME (su));
5215
5216       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5217         {
5218           /* An enclosing context shouldn't be TARGET */
5219           if (ctx == TYPE_NAME (target))
5220             return lookup_cl (TYPE_NAME (su));
5221
5222           /* When we reach the enclosing last context, start a check
5223              on it, with the same target */
5224           if (! DECL_CONTEXT (ctx) &&
5225               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5226             return cl;
5227         }
5228     }
5229   return NULL_TREE;
5230 }
5231
5232 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5233    offending type if a circularity is detected. NULL_TREE is returned
5234    otherwise. TYPE can be an interface or a class.   */
5235
5236 static tree
5237 check_circular_reference (tree type)
5238 {
5239   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5240   int i;
5241
5242   if (!basetype_vec)
5243     return NULL_TREE;
5244
5245   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5246     {
5247       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5248         return lookup_cl (TYPE_NAME (type));
5249       return NULL_TREE;
5250     }
5251
5252   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5253     {
5254       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5255       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5256           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5257         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5258     }
5259   return NULL_TREE;
5260 }
5261
5262 void
5263 java_check_circular_reference (void)
5264 {
5265   tree current;
5266   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5267     {
5268       tree type = TREE_TYPE (current);
5269       tree cl;
5270
5271       cl = check_circular_reference (type);
5272       if (! cl)
5273         cl = check_inner_circular_reference (type, type);
5274       if (cl)
5275         parse_error_context (cl, "Cyclic class inheritance%s",
5276                              (cyclic_inheritance_report ?
5277                               cyclic_inheritance_report : ""));
5278     }
5279 }
5280
5281 /* Augment the parameter list PARM with parameters crafted to
5282    initialize outer context locals aliases. Through ARTIFICIAL, a
5283    count is kept of the number of crafted parameters. MODE governs
5284    what eventually gets created: something suitable for a function
5285    creation or a function invocation, either the constructor or
5286    finit$.  */
5287
5288 static tree
5289 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5290                                         int *artificial)
5291 {
5292   tree field;
5293   tree additional_parms = NULL_TREE;
5294
5295   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5296     if (FIELD_LOCAL_ALIAS (field))
5297       {
5298         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5299         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5300         tree mangled_id;
5301
5302         switch (mode)
5303           {
5304           case AIPL_FUNCTION_DECLARATION:
5305             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5306                                                          &buffer [4]);
5307             purpose = build_wfl_node (mangled_id);
5308             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5309               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5310             else
5311               value = TREE_TYPE (field);
5312             break;
5313
5314           case AIPL_FUNCTION_CREATION:
5315             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5316                                                          &buffer [4]);
5317             value = TREE_TYPE (field);
5318             break;
5319
5320           case AIPL_FUNCTION_FINIT_INVOCATION:
5321             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5322                                                          &buffer [4]);
5323             /* Now, this is wrong. purpose should always be the NAME
5324                of something and value its matching value (decl, type,
5325                etc...) FIXME -- but there is a lot to fix. */
5326
5327             /* When invoked for this kind of operation, we already
5328                know whether a field is used or not. */
5329             purpose = TREE_TYPE (field);
5330             value = build_wfl_node (mangled_id);
5331             break;
5332
5333           case AIPL_FUNCTION_CTOR_INVOCATION:
5334             /* There are two case: the constructor invokation happends
5335                outside the local inner, in which case, locales from the outer
5336                context are directly used.
5337
5338                Otherwise, we fold to using the alias directly. */
5339             if (class_type == current_class)
5340               value = field;
5341             else
5342               {
5343                 name = get_identifier (&buffer[4]);
5344                 value = IDENTIFIER_LOCAL_VALUE (name);
5345               }
5346             break;
5347           }
5348         additional_parms = tree_cons (purpose, value, additional_parms);
5349         if (artificial)
5350           *artificial +=1;
5351       }
5352   if (additional_parms)
5353     {
5354       if (ANONYMOUS_CLASS_P (class_type)
5355           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5356         additional_parms = nreverse (additional_parms);
5357       parm = chainon (additional_parms, parm);
5358     }
5359
5360    return parm;
5361 }
5362
5363 /* Craft a constructor for CLASS_DECL -- what we should do when none
5364    where found. ARGS is non NULL when a special signature must be
5365    enforced. This is the case for anonymous classes.  */
5366
5367 static tree
5368 craft_constructor (tree class_decl, tree args)
5369 {
5370   tree class_type = TREE_TYPE (class_decl);
5371   tree parm = NULL_TREE;
5372   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5373                ACC_PUBLIC : 0);
5374   int i = 0, artificial = 0;
5375   tree decl, ctor_name;
5376   char buffer [80];
5377
5378   /* The constructor name is <init> unless we're dealing with an
5379      anonymous class, in which case the name will be fixed after having
5380      be expanded. */
5381   if (ANONYMOUS_CLASS_P (class_type))
5382     ctor_name = DECL_NAME (class_decl);
5383   else
5384     ctor_name = init_identifier_node;
5385
5386   /* If we're dealing with an inner class constructor, we hide the
5387      this$<n> decl in the name field of its parameter declaration. */
5388   if (PURE_INNER_CLASS_TYPE_P (class_type))
5389     {
5390       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5391       parm = tree_cons (build_current_thisn (class_type),
5392                         build_pointer_type (type), parm);
5393
5394       /* Some more arguments to be hidden here. The values of the local
5395          variables of the outer context that the inner class needs to see. */
5396       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5397                                                      class_type, parm,
5398                                                      &artificial);
5399     }
5400
5401   /* Then if there are any args to be enforced, enforce them now */
5402   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5403     {
5404       sprintf (buffer, "parm%d", i++);
5405       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5406     }
5407
5408   CRAFTED_PARAM_LIST_FIXUP (parm);
5409   decl = create_artificial_method (class_type, flags, void_type_node,
5410                                    ctor_name, parm);
5411   fix_method_argument_names (parm, decl);
5412   /* Now, mark the artificial parameters. */
5413   DECL_FUNCTION_NAP (decl) = artificial;
5414   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5415   DECL_INLINE (decl) = 1;
5416   return decl;
5417 }
5418
5419
5420 /* Fix the constructors. This will be called right after circular
5421    references have been checked. It is necessary to fix constructors
5422    early even if no code generation will take place for that class:
5423    some generated constructor might be required by the class whose
5424    compilation triggered this one to be simply loaded.  */
5425
5426 void
5427 java_fix_constructors (void)
5428 {
5429   tree current;
5430
5431   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5432     {
5433       tree class_type = TREE_TYPE (current);
5434       int saw_ctor = 0;
5435       tree decl;
5436
5437       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5438         continue;
5439
5440       current_class = class_type;
5441       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5442         {
5443           if (DECL_CONSTRUCTOR_P (decl))
5444             {
5445               fix_constructors (decl);
5446               saw_ctor = 1;
5447             }
5448         }
5449
5450       /* Anonymous class constructor can't be generated that early. */
5451       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5452         craft_constructor (current, NULL_TREE);
5453     }
5454 }
5455
5456 /* safe_layout_class just makes sure that we can load a class without
5457    disrupting the current_class, input_file, lineno, etc, information
5458    about the class processed currently.  */
5459
5460 void
5461 safe_layout_class (tree class)
5462 {
5463   tree save_current_class = current_class;
5464   const char *save_input_filename = input_filename;
5465   int save_lineno = input_line;
5466
5467   layout_class (class);
5468
5469   current_class = save_current_class;
5470   input_filename = save_input_filename;
5471   input_line = save_lineno;
5472 }
5473
5474 static tree
5475 jdep_resolve_class (jdep *dep)
5476 {
5477   tree decl;
5478
5479   if (JDEP_RESOLVED_P (dep))
5480     decl = JDEP_RESOLVED_DECL (dep);
5481   else
5482     {
5483       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5484                             JDEP_DECL (dep), JDEP_WFL (dep));
5485       JDEP_RESOLVED (dep, decl);
5486       /* If there is no WFL, that's ok.  We generate this warning
5487          elsewhere.  */
5488       if (decl && JDEP_WFL (dep) != NULL_TREE)
5489         check_deprecation (JDEP_WFL (dep), decl);
5490     }
5491
5492   if (!decl)
5493     complete_class_report_errors (dep);
5494   else if (PURE_INNER_CLASS_DECL_P (decl))
5495     {
5496       tree inner = TREE_TYPE (decl);
5497       if (! CLASS_LOADED_P (inner))
5498         {
5499           safe_layout_class (inner);
5500           if (TYPE_SIZE (inner) == error_mark_node)
5501             TYPE_SIZE (inner) = NULL_TREE;
5502         }
5503       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5504     }
5505   return decl;
5506 }
5507
5508 /* Complete unsatisfied class declaration and their dependencies */
5509
5510 void
5511 java_complete_class (void)
5512 {
5513   tree cclass;
5514   jdeplist *cclassd;
5515   int error_found;
5516   tree type;
5517
5518   /* Process imports */
5519   process_imports ();
5520
5521   /* Reverse things so we have the right order */
5522   ctxp->class_list = nreverse (ctxp->class_list);
5523   ctxp->classd_list = reverse_jdep_list (ctxp);
5524
5525   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5526        cclass && cclassd;
5527        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5528     {
5529       jdep *dep;
5530
5531       /* We keep the compilation unit imports in the class so that
5532          they can be used later to resolve type dependencies that
5533          aren't necessary to solve now. */
5534       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5535       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5536
5537       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5538         {
5539           tree decl;
5540           if (!(decl = jdep_resolve_class (dep)))
5541             continue;
5542
5543           /* Now it's time to patch */
5544           switch (JDEP_KIND (dep))
5545             {
5546             case JDEP_SUPER:
5547               /* Simply patch super */
5548               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5549                 continue;
5550               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5551                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5552               break;
5553
5554             case JDEP_FIELD:
5555               {
5556                 /* We do part of the job done in add_field */
5557                 tree field_decl = JDEP_DECL (dep);
5558                 tree field_type = TREE_TYPE (decl);
5559                 if (TREE_CODE (field_type) == RECORD_TYPE)
5560                   field_type = promote_type (field_type);
5561                 TREE_TYPE (field_decl) = field_type;
5562                 DECL_ALIGN (field_decl) = 0;
5563                 DECL_USER_ALIGN (field_decl) = 0;
5564                 layout_decl (field_decl, 0);
5565                 SOURCE_FRONTEND_DEBUG
5566                   (("Completed field/var decl `%s' with `%s'",
5567                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5568                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5569                 break;
5570               }
5571             case JDEP_METHOD:   /* We start patching a method */
5572             case JDEP_METHOD_RETURN:
5573               error_found = 0;
5574               while (1)
5575                 {
5576                   if (decl)
5577                     {
5578                       type = TREE_TYPE(decl);
5579                       if (TREE_CODE (type) == RECORD_TYPE)
5580                         type = promote_type (type);
5581                       JDEP_APPLY_PATCH (dep, type);
5582                       SOURCE_FRONTEND_DEBUG
5583                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5584                            "Completing fct `%s' with ret type `%s'":
5585                            "Completing arg `%s' with type `%s'"),
5586                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5587                                               (JDEP_DECL_WFL (dep))),
5588                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5589                     }
5590                   else
5591                     error_found = 1;
5592                   dep = JDEP_CHAIN (dep);
5593                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5594                     break;
5595                   else
5596                     decl = jdep_resolve_class (dep);
5597                 }
5598               if (!error_found)
5599                 {
5600                   tree mdecl = JDEP_DECL (dep), signature;
5601                   /* Recompute and reset the signature, check first that
5602                      all types are now defined. If they're not,
5603                      don't build the signature. */
5604                   if (check_method_types_complete (mdecl))
5605                     {
5606                       signature = build_java_signature (TREE_TYPE (mdecl));
5607                       set_java_signature (TREE_TYPE (mdecl), signature);
5608                     }
5609                 }
5610               else
5611                 continue;
5612               break;
5613
5614             case JDEP_INTERFACE:
5615               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5616                                                 JDEP_WFL (dep)))
5617                 continue;
5618               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5619               break;
5620
5621             case JDEP_PARM:
5622             case JDEP_VARIABLE:
5623               type = TREE_TYPE(decl);
5624               if (TREE_CODE (type) == RECORD_TYPE)
5625                 type = promote_type (type);
5626               JDEP_APPLY_PATCH (dep, type);
5627               break;
5628
5629             case JDEP_TYPE:
5630               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5631               SOURCE_FRONTEND_DEBUG
5632                 (("Completing a random type dependency on a '%s' node",
5633                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5634               break;
5635
5636             case JDEP_EXCEPTION:
5637               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5638               SOURCE_FRONTEND_DEBUG
5639                 (("Completing `%s' `throws' argument node",
5640                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5641               break;
5642
5643             case JDEP_ANONYMOUS:
5644               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5645               break;
5646
5647             default:
5648               abort ();
5649             }
5650         }
5651     }
5652   return;
5653 }
5654
5655 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5656    array.  */
5657
5658 static tree
5659 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5660 {
5661   tree tname = TYPE_NAME (class_type);
5662   tree resolved_type = TREE_TYPE (class_type);
5663   int array_dims = 0;
5664   tree resolved_type_decl;
5665
5666   if (resolved_type != NULL_TREE)
5667     {
5668       tree resolved_type_decl = TYPE_NAME (resolved_type);
5669       if (resolved_type_decl == NULL_TREE
5670           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5671         {
5672           resolved_type_decl = build_decl (TYPE_DECL,
5673                                            TYPE_NAME (class_type),
5674                                            resolved_type);
5675         }
5676       return resolved_type_decl;
5677     }
5678
5679   /* 1- Check to see if we have an array. If true, find what we really
5680      want to resolve  */
5681   if ((array_dims = build_type_name_from_array_name (tname,
5682                                                      &TYPE_NAME (class_type))))
5683     WFL_STRIP_BRACKET (cl, cl);
5684
5685   /* 2- Resolve the bare type */
5686   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5687                                                decl, cl)))
5688     return NULL_TREE;
5689   resolved_type = TREE_TYPE (resolved_type_decl);
5690
5691   /* 3- If we have an array, reconstruct the array down to its nesting */
5692   if (array_dims)
5693     {
5694       for (; array_dims; array_dims--)
5695         resolved_type = build_java_array_type (resolved_type, -1);
5696       resolved_type_decl = TYPE_NAME (resolved_type);
5697     }
5698   TREE_TYPE (class_type) = resolved_type;
5699   return resolved_type_decl;
5700 }
5701
5702 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5703    are used to report error messages; CL must either be NULL_TREE or a
5704    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5705    by a variable, since it is changed by find_in_imports{_on_demand}
5706    and (but it doesn't really matter) qualify_and_find.  */
5707
5708 tree
5709 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5710 {
5711   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5712   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5713   tree decl_result;
5714   htab_t circularity_hash;
5715
5716   if (QUALIFIED_P (TYPE_NAME (class_type)))
5717     {
5718       /* If the type name is of the form `Q . Id', then Q is either a
5719          package name or a class name.  First we try to find Q as a
5720          class and then treat Id as a member type.  If we can't find Q
5721          as a class then we fall through.  */
5722       tree q, left, left_type, right;
5723       breakdown_qualified (&left, &right, TYPE_NAME (class_type));
5724       BUILD_PTR_FROM_NAME (left_type, left);
5725       q = do_resolve_class (enclosing, left_type, decl, cl);
5726       if (q)
5727         {
5728           enclosing = q;
5729           saved_enclosing_type = TREE_TYPE (q);
5730           BUILD_PTR_FROM_NAME (class_type, right);
5731         }
5732     }
5733
5734   if (enclosing)
5735     {
5736       /* This hash table is used to register the classes we're going
5737          through when searching the current class as an inner class, in
5738          order to detect circular references. Remember to free it before
5739          returning the section 0- of this function. */
5740       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5741                                       NULL);
5742
5743       /* 0- Search in the current class as an inner class.
5744          Maybe some code here should be added to load the class or
5745          something, at least if the class isn't an inner class and ended
5746          being loaded from class file. FIXME. */
5747       while (enclosing)
5748         {
5749           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5750                                                 &super, class_type);
5751           if (new_class_decl)
5752             break;
5753
5754           /* If we haven't found anything because SUPER reached Object and
5755              ENCLOSING happens to be an innerclass, try the enclosing context. */
5756           if ((!super || super == object_type_node) &&
5757               enclosing && INNER_CLASS_DECL_P (enclosing))
5758             enclosing = DECL_CONTEXT (enclosing);
5759           else
5760             enclosing = NULL_TREE;
5761         }
5762
5763       htab_delete (circularity_hash);
5764
5765       if (new_class_decl)
5766         return new_class_decl;
5767     }
5768
5769   /* 1- Check for the type in single imports. This will change
5770      TYPE_NAME() if something relevant is found */
5771   find_in_imports (saved_enclosing_type, class_type);
5772
5773   /* 2- And check for the type in the current compilation unit */
5774   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5775     {
5776       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5777           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5778         load_class (TYPE_NAME (class_type), 0);
5779       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5780     }
5781
5782   /* 3- Search according to the current package definition */
5783   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5784     {
5785       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5786                                              TYPE_NAME (class_type))))
5787         return new_class_decl;
5788     }
5789
5790   /* 4- Check the import on demands. Don't allow bar.baz to be
5791      imported from foo.* */
5792   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5793     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5794       return NULL_TREE;
5795
5796   /* If found in find_in_imports_on_demand, the type has already been
5797      loaded. */
5798   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5799     return new_class_decl;
5800
5801   /* 5- Try with a name qualified with the package name we've seen so far */
5802   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5803     {
5804       tree package;
5805
5806       /* If there is a current package (ctxp->package), it's the first
5807          element of package_list and we can skip it. */
5808       for (package = (ctxp->package ?
5809                       TREE_CHAIN (package_list) : package_list);
5810            package; package = TREE_CHAIN (package))
5811         if ((new_class_decl = qualify_and_find (class_type,
5812                                                TREE_PURPOSE (package),
5813                                                TYPE_NAME (class_type))))
5814           return new_class_decl;
5815     }
5816
5817   /* 5- Check another compilation unit that bears the name of type */
5818   load_class (TYPE_NAME (class_type), 0);
5819
5820   if (!cl)
5821     cl = lookup_cl (decl);
5822
5823   /* If we don't have a value for CL, then we're being called recursively.
5824      We can't check package access just yet, but it will be taken care of
5825      by the caller. */
5826   if (cl)
5827     {
5828       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5829         return NULL_TREE;
5830     }
5831
5832   /* 6- Last call for a resolution */
5833   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5834
5835   /* The final lookup might have registered a.b.c into a.b$c If we
5836      failed at the first lookup, progressively change the name if
5837      applicable and use the matching DECL instead. */
5838   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5839     {
5840       char *separator;
5841       tree name = TYPE_NAME (class_type);
5842       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5843
5844       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5845
5846       do {
5847
5848        /* Reach the last '.', and if applicable, replace it by a `$' and
5849           see if this exists as a type. */
5850        if ((separator = strrchr (namebuffer, '.')))
5851          {
5852            *separator = '$';
5853            name = get_identifier (namebuffer);
5854            decl_result = IDENTIFIER_CLASS_VALUE (name);
5855          }
5856       } while (!decl_result && separator);
5857     }
5858   return decl_result;
5859 }
5860
5861 static tree
5862 qualify_and_find (tree class_type, tree package, tree name)
5863 {
5864   tree new_qualified = merge_qualified_name (package, name);
5865   tree new_class_decl;
5866
5867   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5868     load_class (new_qualified, 0);
5869   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5870     {
5871       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5872           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5873         load_class (new_qualified, 0);
5874       TYPE_NAME (class_type) = new_qualified;
5875       return IDENTIFIER_CLASS_VALUE (new_qualified);
5876     }
5877   return NULL_TREE;
5878 }
5879
5880 /* Resolve NAME and lay it out (if not done and if not the current
5881    parsed class). Return a decl node. This function is meant to be
5882    called when type resolution is necessary during the walk pass.  */
5883
5884 static tree
5885 resolve_and_layout (tree something, tree cl)
5886 {
5887   tree decl, decl_type;
5888
5889   /* Don't do that on the current class */
5890   if (something == current_class)
5891     return TYPE_NAME (current_class);
5892
5893   /* Don't do anything for void and other primitive types */
5894   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5895     return NULL_TREE;
5896
5897   /* Pointer types can be reall pointer types or fake pointers. When
5898      finding a real pointer, recheck for primitive types */
5899   if (TREE_CODE (something) == POINTER_TYPE)
5900     {
5901       if (TREE_TYPE (something))
5902         {
5903           something = TREE_TYPE (something);
5904           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5905             return NULL_TREE;
5906         }
5907       else
5908         something = TYPE_NAME (something);
5909     }
5910
5911   /* Don't do anything for arrays of primitive types */
5912   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5913       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5914     return NULL_TREE;
5915
5916   /* Something might be a WFL */
5917   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5918     something = EXPR_WFL_NODE (something);
5919
5920   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5921      TYPE_DECL or a real TYPE */
5922   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5923     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5924             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5925
5926   if (!(decl = resolve_no_layout (something, cl)))
5927     return NULL_TREE;
5928
5929   /* Resolve and layout if necessary */
5930   decl_type = TREE_TYPE (decl);
5931   layout_class_methods (decl_type);
5932   /* Check methods */
5933   if (CLASS_FROM_SOURCE_P (decl_type))
5934     java_check_methods (decl);
5935   /* Layout the type if necessary */
5936   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5937     safe_layout_class (decl_type);
5938
5939   return decl;
5940 }
5941
5942 /* Resolve a class, returns its decl but doesn't perform any
5943    layout. The current parsing context is saved and restored */
5944
5945 static tree
5946 resolve_no_layout (tree name, tree cl)
5947 {
5948   tree ptr, decl;
5949   BUILD_PTR_FROM_NAME (ptr, name);
5950   java_parser_context_save_global ();
5951   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5952   java_parser_context_restore_global ();
5953
5954   return decl;
5955 }
5956
5957 /* Called when reporting errors. Skip the '[]'s in a complex array
5958    type description that failed to be resolved. purify_type_name can't
5959    use an identifier tree.  */
5960
5961 static const char *
5962 purify_type_name (const char *name)
5963 {
5964   int len = strlen (name);
5965   int bracket_found;
5966
5967   STRING_STRIP_BRACKETS (name, len, bracket_found);
5968   if (bracket_found)
5969     {
5970       char *stripped_name = xmemdup (name, len, len+1);
5971       stripped_name [len] = '\0';
5972       return stripped_name;
5973     }
5974   return name;
5975 }
5976
5977 /* The type CURRENT refers to can't be found. We print error messages.  */
5978
5979 static void
5980 complete_class_report_errors (jdep *dep)
5981 {
5982   const char *name;
5983
5984   if (!JDEP_WFL (dep))
5985     return;
5986
5987   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
5988   switch (JDEP_KIND (dep))
5989     {
5990     case JDEP_SUPER:
5991       parse_error_context
5992         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
5993          purify_type_name (name),
5994          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5995       break;
5996     case JDEP_FIELD:
5997       parse_error_context
5998         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
5999          purify_type_name (name),
6000          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6001       break;
6002     case JDEP_METHOD:           /* Covers arguments */
6003       parse_error_context
6004         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6005          purify_type_name (name),
6006          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6007          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6008       break;
6009     case JDEP_METHOD_RETURN:    /* Covers return type */
6010       parse_error_context
6011         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6012          purify_type_name (name),
6013          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6014       break;
6015     case JDEP_INTERFACE:
6016       parse_error_context
6017         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6018          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6019          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6020          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6021       break;
6022     case JDEP_VARIABLE:
6023       parse_error_context
6024         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6025          purify_type_name (IDENTIFIER_POINTER
6026                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6027          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6028       break;
6029     case JDEP_EXCEPTION:        /* As specified by `throws' */
6030       parse_error_context
6031           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6032          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6033       break;
6034     default:
6035       /* Fix for -Wall. Just break doing nothing. The error will be
6036          caught later */
6037       break;
6038     }
6039 }
6040
6041 /* Return a static string containing the DECL prototype string. If
6042    DECL is a constructor, use the class name instead of the form
6043    <init> */
6044
6045 static const char *
6046 get_printable_method_name (tree decl)
6047 {
6048   const char *to_return;
6049   tree name = NULL_TREE;
6050
6051   if (DECL_CONSTRUCTOR_P (decl))
6052     {
6053       name = DECL_NAME (decl);
6054       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6055     }
6056
6057   to_return = lang_printable_name (decl, 0);
6058   if (DECL_CONSTRUCTOR_P (decl))
6059     DECL_NAME (decl) = name;
6060
6061   return to_return;
6062 }
6063
6064 /* Track method being redefined inside the same class. As a side
6065    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6066    function it's a FWL, so we can track errors more accurately.)  */
6067
6068 static int
6069 check_method_redefinition (tree class, tree method)
6070 {
6071   tree redef, sig;
6072
6073   /* There's no need to verify <clinit> and finit$ and instinit$ */
6074   if (DECL_CLINIT_P (method)
6075       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6076     return 0;
6077
6078   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6079   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6080     {
6081       if (redef == method)
6082         break;
6083       if (DECL_NAME (redef) == DECL_NAME (method)
6084           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6085           && !DECL_ARTIFICIAL (method))
6086         {
6087           parse_error_context
6088             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6089              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6090              get_printable_method_name (redef));
6091           return 1;
6092         }
6093     }
6094   return 0;
6095 }
6096
6097 /* Return 1 if check went ok, 0 otherwise.  */
6098 static int
6099 check_abstract_method_definitions (int do_interface, tree class_decl,
6100                                    tree type)
6101 {
6102   tree class = TREE_TYPE (class_decl);
6103   tree method, end_type;
6104   int ok = 1;
6105
6106   end_type = (do_interface ? object_type_node : type);
6107   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6108     {
6109       tree other_super, other_method, method_sig, method_name;
6110       int found = 0;
6111       int end_type_reached = 0;
6112
6113       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6114         continue;
6115
6116       /* Now verify that somewhere in between TYPE and CLASS,
6117          abstract method METHOD gets a non abstract definition
6118          that is inherited by CLASS.  */
6119
6120       method_sig = build_java_signature (TREE_TYPE (method));
6121       method_name = DECL_NAME (method);
6122       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6123         method_name = EXPR_WFL_NODE (method_name);
6124
6125       other_super = class;
6126       do {
6127         if (other_super == end_type)
6128           end_type_reached = 1;
6129
6130         /* Method search */
6131         for (other_method = TYPE_METHODS (other_super); other_method;
6132             other_method = TREE_CHAIN (other_method))
6133           {
6134             tree s = build_java_signature (TREE_TYPE (other_method));
6135             tree other_name = DECL_NAME (other_method);
6136
6137             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6138               other_name = EXPR_WFL_NODE (other_name);
6139             if (!DECL_CLINIT_P (other_method)
6140                 && !DECL_CONSTRUCTOR_P (other_method)
6141                 && method_name == other_name
6142                 && method_sig == s
6143                 && !METHOD_ABSTRACT (other_method))
6144              {
6145                found = 1;
6146                break;
6147              }
6148           }
6149         other_super = CLASSTYPE_SUPER (other_super);
6150       } while (!end_type_reached);
6151
6152       /* Report that abstract METHOD didn't find an implementation
6153          that CLASS can use. */
6154       if (!found)
6155         {
6156           char *t = xstrdup (lang_printable_name
6157                             (TREE_TYPE (TREE_TYPE (method)), 0));
6158           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6159
6160           parse_error_context
6161             (lookup_cl (class_decl),
6162              "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
6163              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6164              t, lang_printable_name (method, 0),
6165              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6166               "interface" : "class"),
6167              IDENTIFIER_POINTER (ccn),
6168              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6169              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6170           ok = 0;
6171           free (t);
6172         }
6173     }
6174
6175   if (ok && do_interface)
6176     {
6177       /* Check for implemented interfaces. */
6178       int i;
6179       tree vector = TYPE_BINFO_BASETYPES (type);
6180       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6181         {
6182           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6183           ok = check_abstract_method_definitions (1, class_decl, super);
6184         }
6185     }
6186
6187   return ok;
6188 }
6189
6190 /* Check that CLASS_DECL somehow implements all inherited abstract
6191    methods.  */
6192
6193 static void
6194 java_check_abstract_method_definitions (tree class_decl)
6195 {
6196   tree class = TREE_TYPE (class_decl);
6197   tree super, vector;
6198   int i;
6199
6200   if (CLASS_ABSTRACT (class_decl))
6201     return;
6202
6203   /* Check for inherited types */
6204   super = class;
6205   do {
6206     super = CLASSTYPE_SUPER (super);
6207     check_abstract_method_definitions (0, class_decl, super);
6208   } while (super != object_type_node);
6209
6210   /* Check for implemented interfaces. */
6211   vector = TYPE_BINFO_BASETYPES (class);
6212   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6213     {
6214       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6215       check_abstract_method_definitions (1, class_decl, super);
6216     }
6217 }
6218
6219 /* Check all the types method DECL uses and return 1 if all of them
6220    are now complete, 0 otherwise. This is used to check whether its
6221    safe to build a method signature or not.  */
6222
6223 static int
6224 check_method_types_complete (tree decl)
6225 {
6226   tree type = TREE_TYPE (decl);
6227   tree args;
6228
6229   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6230     return 0;
6231
6232   args = TYPE_ARG_TYPES (type);
6233   if (TREE_CODE (type) == METHOD_TYPE)
6234     args = TREE_CHAIN (args);
6235   for (; args != end_params_node; args = TREE_CHAIN (args))
6236     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6237       return 0;
6238
6239   return 1;
6240 }
6241
6242 /* Visible interface to check methods contained in CLASS_DECL */
6243
6244 void
6245 java_check_methods (tree class_decl)
6246 {
6247   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6248     return;
6249
6250   if (CLASS_INTERFACE (class_decl))
6251     java_check_abstract_methods (class_decl);
6252   else
6253     java_check_regular_methods (class_decl);
6254
6255   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6256 }
6257
6258 /* Like not_accessible_p, but doesn't refer to the current class at
6259    all.  */
6260 static bool
6261 hack_is_accessible_p (tree member, tree from_where)
6262 {
6263   int flags = get_access_flags_from_decl (member);
6264
6265   if (from_where == DECL_CONTEXT (member)
6266       || (flags & ACC_PUBLIC))
6267     return true;
6268
6269   if ((flags & ACC_PROTECTED))
6270     {
6271       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6272         return true;
6273     }
6274
6275   if ((flags & ACC_PRIVATE))
6276     return false;
6277
6278   /* Package private, or protected.  */
6279   return in_same_package (TYPE_NAME (from_where),
6280                           TYPE_NAME (DECL_CONTEXT (member)));
6281 }
6282
6283 /* Check all the methods of CLASS_DECL. Methods are first completed
6284    then checked according to regular method existence rules.  If no
6285    constructor for CLASS_DECL were encountered, then build its
6286    declaration.  */
6287 static void
6288 java_check_regular_methods (tree class_decl)
6289 {
6290   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6291   tree method;
6292   tree class = TREE_TYPE (class_decl);
6293   tree found = NULL_TREE;
6294   tree mthrows;
6295
6296   /* It is not necessary to check methods defined in java.lang.Object */
6297   if (class == object_type_node)
6298     return;
6299
6300   if (!TYPE_NVIRTUALS (class))
6301     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6302
6303   /* Should take interfaces into account. FIXME */
6304   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6305     {
6306       tree sig;
6307       tree method_wfl = DECL_FUNCTION_WFL (method);
6308       int aflags;
6309
6310       /* Check for redefinitions */
6311       if (check_method_redefinition (class, method))
6312         continue;
6313
6314       /* We verify things thrown by the method.  They must inherit from
6315          java.lang.Throwable.  */
6316       for (mthrows = DECL_FUNCTION_THROWS (method);
6317            mthrows; mthrows = TREE_CHAIN (mthrows))
6318         {
6319           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6320             parse_error_context
6321               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6322                IDENTIFIER_POINTER
6323                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6324         }
6325
6326       /* If we see one constructor a mark so we don't generate the
6327          default one.  Also skip other verifications: constructors
6328          can't be inherited hence hidden or overridden.  */
6329       if (DECL_CONSTRUCTOR_P (method))
6330         {
6331           saw_constructor = 1;
6332           continue;
6333         }
6334
6335       sig = build_java_argument_signature (TREE_TYPE (method));
6336       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6337                                               SEARCH_SUPER | SEARCH_INTERFACE);
6338
6339       /* Inner class can't declare static methods */
6340       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6341         {
6342           char *t = xstrdup (lang_printable_name (class, 0));
6343           parse_error_context
6344             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6345              lang_printable_name (method, 0), t);
6346           free (t);
6347         }
6348
6349       /* Nothing overrides or it's a private method. */
6350       if (!found)
6351         continue;
6352       if (METHOD_PRIVATE (found))
6353         {
6354           found = NULL_TREE;
6355           continue;
6356         }
6357
6358       /* If `found' is declared in an interface, make sure the
6359          modifier matches. */
6360       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6361           && clinit_identifier_node != DECL_NAME (found)
6362           && !METHOD_PUBLIC (method))
6363         {
6364           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6365           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6366                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6367                                lang_printable_name (method, 0),
6368                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6369         }
6370
6371       /* Can't override a method with the same name and different return
6372          types. */
6373       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6374         {
6375           char *t = xstrdup
6376             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6377           parse_error_context
6378             (method_wfl,
6379              "Method `%s' was defined with return type `%s' in class `%s'",
6380              lang_printable_name (found, 0), t,
6381              IDENTIFIER_POINTER
6382                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6383           free (t);
6384         }
6385
6386       aflags = get_access_flags_from_decl (found);
6387
6388       /* Can't override final. Can't override static. */
6389       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6390         {
6391           /* Static *can* override static */
6392           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6393             continue;
6394           parse_error_context
6395             (method_wfl,
6396              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6397              (METHOD_FINAL (found) ? "Final" : "Static"),
6398              lang_printable_name (found, 0),
6399              (METHOD_FINAL (found) ? "final" : "static"),
6400              IDENTIFIER_POINTER
6401                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6402           continue;
6403         }
6404
6405       /* Static method can't override instance method. */
6406       if (METHOD_STATIC (method))
6407         {
6408           parse_error_context
6409             (method_wfl,
6410              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6411              lang_printable_name (found, 0),
6412              IDENTIFIER_POINTER
6413                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6414           continue;
6415         }
6416
6417       /* - Overriding/hiding public must be public
6418          - Overriding/hiding protected must be protected or public
6419          - If the overridden or hidden method has default (package)
6420            access, then the overriding or hiding method must not be
6421            private; otherwise, a compile-time error occurs.  If
6422            `found' belongs to an interface, things have been already
6423            taken care of.  */
6424       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6425           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6426               || (METHOD_PROTECTED (found)
6427                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6428               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6429                   && METHOD_PRIVATE (method))))
6430         {
6431           parse_error_context
6432             (method_wfl,
6433              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6434              (METHOD_PUBLIC (method) ? "public" :
6435               (METHOD_PRIVATE (method) ? "private" : "protected")),
6436              IDENTIFIER_POINTER (DECL_NAME
6437                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6438           continue;
6439         }
6440
6441       /* Check this method against all the other implementations it
6442          overrides.  Here we only check the class hierarchy; the rest
6443          of the checking is done later.  If this method is just a
6444          Miranda method, we can skip the check.  */
6445       if (! METHOD_INVISIBLE (method))
6446         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6447     }
6448
6449   /* The above throws clause check only looked at superclasses.  Now
6450      we must also make sure that all methods declared in interfaces
6451      have compatible throws clauses.  FIXME: there are more efficient
6452      ways to organize this checking; we should implement one.  */
6453   check_interface_throws_clauses (class, class);
6454
6455   if (!TYPE_NVIRTUALS (class))
6456     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6457
6458   /* Search for inherited abstract method not yet implemented in this
6459      class.  */
6460   java_check_abstract_method_definitions (class_decl);
6461
6462   if (!saw_constructor)
6463     abort ();
6464 }
6465
6466 /* Check to make sure that all the methods in all the interfaces
6467    implemented by CLASS_DECL are compatible with the concrete
6468    implementations available in CHECK_CLASS_DECL.  */
6469 static void
6470 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6471 {
6472   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6473     {
6474       tree bases = TYPE_BINFO_BASETYPES (class_decl);
6475       int iface_len = TREE_VEC_LENGTH (bases) - 1;
6476       int i;
6477
6478       for (i = iface_len; i > 0; --i)
6479         {
6480           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6481           tree iface_method;
6482
6483           for (iface_method = TYPE_METHODS (interface);
6484                iface_method != NULL_TREE;
6485                iface_method = TREE_CHAIN (iface_method))
6486             {
6487               tree sig, method;
6488
6489               /* First look for a concrete method implemented or
6490                  inherited by this class.  No need to search
6491                  interfaces here, since we're already looking through
6492                  all of them.  */
6493               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6494               method
6495                 = lookup_argument_method_generic (check_class_decl,
6496                                                   DECL_NAME (iface_method),
6497                                                   sig, SEARCH_VISIBLE);
6498               /* If we don't find an implementation, that is ok.  Any
6499                  potential errors from that are diagnosed elsewhere.
6500                  Also, multiple inheritance with conflicting throws
6501                  clauses is fine in the absence of a concrete
6502                  implementation.  */
6503               if (method != NULL_TREE && !METHOD_ABSTRACT (method))
6504                 {
6505                   tree method_wfl = DECL_FUNCTION_WFL (method);
6506                   check_throws_clauses (method, method_wfl, iface_method);
6507                 }
6508             }
6509
6510           /* Now check superinterfaces.  */
6511           check_interface_throws_clauses (check_class_decl, interface);
6512         }
6513     }
6514 }
6515
6516 /* Check throws clauses of a method against the clauses of all the
6517    methods it overrides.  We do this by searching up the class
6518    hierarchy, examining all matching accessible methods.  */
6519 static void
6520 check_concrete_throws_clauses (tree class, tree self_method,
6521                                tree name, tree signature)
6522 {
6523   tree method = lookup_argument_method_generic (class, name, signature,
6524                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6525   while (method != NULL_TREE)
6526     {
6527       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6528         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6529                               method);
6530
6531       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6532                                                name, signature,
6533                                                SEARCH_SUPER | SEARCH_VISIBLE);
6534     }
6535 }
6536
6537 /* Generate an error if the `throws' clause of METHOD (if any) is
6538    incompatible with the `throws' clause of FOUND (if any).  */
6539 static void
6540 check_throws_clauses (tree method, tree method_wfl, tree found)
6541 {
6542   tree mthrows;
6543
6544   /* Can't check these things with class loaded from bytecode. FIXME */
6545   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6546     return;
6547
6548   for (mthrows = DECL_FUNCTION_THROWS (method);
6549        mthrows; mthrows = TREE_CHAIN (mthrows))
6550     {
6551       tree fthrows;
6552
6553       /* We don't verify unchecked expressions */
6554       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6555         continue;
6556       /* Checked expression must be compatible */
6557       for (fthrows = DECL_FUNCTION_THROWS (found);
6558            fthrows; fthrows = TREE_CHAIN (fthrows))
6559         {
6560           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6561             break;
6562         }
6563       if (!fthrows)
6564         {
6565           parse_error_context
6566             (method_wfl, "Invalid checked exception class `%s' in `throws' clause.  The exception must be a subclass of an exception thrown by `%s' from class `%s'",
6567              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6568              lang_printable_name (found, 0),
6569              IDENTIFIER_POINTER
6570              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6571         }
6572     }
6573 }
6574
6575 /* Check abstract method of interface INTERFACE */
6576 static void
6577 java_check_abstract_methods (tree interface_decl)
6578 {
6579   int i, n;
6580   tree method, basetype_vec, found;
6581   tree interface = TREE_TYPE (interface_decl);
6582
6583   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6584     {
6585       /* 2- Check for double definition inside the defining interface */
6586       if (check_method_redefinition (interface, method))
6587         continue;
6588
6589       /* 3- Overriding is OK as far as we preserve the return type.  */
6590       found = lookup_java_interface_method2 (interface, method);
6591       if (found)
6592         {
6593           char *t;
6594           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6595           parse_error_context
6596             (DECL_FUNCTION_WFL (found),
6597              "Method `%s' was defined with return type `%s' in class `%s'",
6598              lang_printable_name (found, 0), t,
6599              IDENTIFIER_POINTER
6600                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6601           free (t);
6602           continue;
6603         }
6604     }
6605
6606   /* 4- Inherited methods can't differ by their returned types */
6607   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6608     return;
6609   n = TREE_VEC_LENGTH (basetype_vec);
6610   for (i = 0; i < n; i++)
6611     {
6612       tree sub_interface_method, sub_interface;
6613       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6614       if (!vec_elt)
6615         continue;
6616       sub_interface = BINFO_TYPE (vec_elt);
6617       for (sub_interface_method = TYPE_METHODS (sub_interface);
6618            sub_interface_method;
6619            sub_interface_method = TREE_CHAIN (sub_interface_method))
6620         {
6621           found = lookup_java_interface_method2 (interface,
6622                                                  sub_interface_method);
6623           if (found && (found != sub_interface_method))
6624             {
6625               parse_error_context
6626                 (lookup_cl (sub_interface_method),
6627                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6628                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6629                  lang_printable_name (found, 0),
6630                  IDENTIFIER_POINTER
6631                    (DECL_NAME (TYPE_NAME
6632                                (DECL_CONTEXT (sub_interface_method)))),
6633                  IDENTIFIER_POINTER
6634                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6635             }
6636         }
6637     }
6638 }
6639
6640 /* Lookup methods in interfaces using their name and partial
6641    signature. Return a matching method only if their types differ.  */
6642
6643 static tree
6644 lookup_java_interface_method2 (tree class, tree method_decl)
6645 {
6646   int i, n;
6647   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6648
6649   if (!basetype_vec)
6650     return NULL_TREE;
6651
6652   n = TREE_VEC_LENGTH (basetype_vec);
6653   for (i = 0; i < n; i++)
6654     {
6655       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6656       if ((BINFO_TYPE (vec_elt) != object_type_node)
6657           && (to_return =
6658               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6659         return to_return;
6660     }
6661   for (i = 0; i < n; i++)
6662     {
6663       to_return = lookup_java_interface_method2
6664         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6665       if (to_return)
6666         return to_return;
6667     }
6668
6669   return NULL_TREE;
6670 }
6671
6672 /* Lookup method using their name and partial signature. Return a
6673    matching method only if their types differ.  */
6674
6675 static tree
6676 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6677 {
6678   tree method, method_signature, method_name, method_type, name;
6679
6680   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6681   name = DECL_NAME (method_decl);
6682   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6683                  EXPR_WFL_NODE (name) : name);
6684   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6685
6686   while (clas != NULL_TREE)
6687     {
6688       for (method = TYPE_METHODS (clas);
6689            method != NULL_TREE;  method = TREE_CHAIN (method))
6690         {
6691           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6692           tree name = DECL_NAME (method);
6693           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6694                EXPR_WFL_NODE (name) : name) == method_name
6695               && method_sig == method_signature
6696               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6697             return method;
6698         }
6699       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6700     }
6701   return NULL_TREE;
6702 }
6703
6704 /* Return the line that matches DECL line number, and try its best to
6705    position the column number. Used during error reports.  */
6706
6707 static GTY(()) tree cl_v;
6708 static tree
6709 lookup_cl (tree decl)
6710 {
6711   char *line, *found;
6712
6713   if (!decl)
6714     return NULL_TREE;
6715
6716   if (cl_v == NULL_TREE)
6717     {
6718       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6719     }
6720
6721   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6722   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6723
6724   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6725                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6726
6727   found = strstr ((const char *)line,
6728                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6729   if (found)
6730     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6731
6732   return cl_v;
6733 }
6734
6735 /* Look for a simple name in the single-type import list */
6736
6737 static tree
6738 find_name_in_single_imports (tree name)
6739 {
6740   tree node;
6741
6742   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6743     if (TREE_VALUE (node) == name)
6744       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6745
6746   return NULL_TREE;
6747 }
6748
6749 /* Process all single-type import. */
6750
6751 static int
6752 process_imports (void)
6753 {
6754   tree import;
6755   int error_found;
6756
6757   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6758     {
6759       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6760       char *original_name;
6761
6762       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6763                                IDENTIFIER_LENGTH (to_be_found),
6764                                IDENTIFIER_LENGTH (to_be_found) + 1);
6765
6766       /* Don't load twice something already defined. */
6767       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6768         continue;
6769
6770       while (1)
6771         {
6772           tree left;
6773
6774           QUALIFIED_P (to_be_found) = 1;
6775           load_class (to_be_found, 0);
6776           error_found =
6777             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6778
6779           /* We found it, we can bail out */
6780           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6781             {
6782               check_deprecation (TREE_PURPOSE (import),
6783                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6784               break;
6785             }
6786
6787           /* We haven't found it. Maybe we're trying to access an
6788              inner class.  The only way for us to know is to try again
6789              after having dropped a qualifier. If we can't break it further,
6790              we have an error. */
6791           if (breakdown_qualified (&left, NULL, to_be_found))
6792             break;
6793
6794           to_be_found = left;
6795         }
6796       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6797         {
6798           parse_error_context (TREE_PURPOSE (import),
6799                                "Class or interface `%s' not found in import",
6800                                original_name);
6801           error_found = 1;
6802         }
6803
6804       free (original_name);
6805       if (error_found)
6806         return 1;
6807     }
6808   return 0;
6809 }
6810
6811 /* Possibly find and mark a class imported by a single-type import
6812    statement.  */
6813
6814 static void
6815 find_in_imports (tree enclosing_type, tree class_type)
6816 {
6817   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6818                  ctxp->import_list);
6819   while (import)
6820     {
6821       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6822         {
6823           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6824           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6825           return;
6826         }
6827       import = TREE_CHAIN (import);
6828     }
6829 }
6830
6831 static int
6832 note_possible_classname (const char *name, int len)
6833 {
6834   tree node;
6835   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6836     len = len - 5;
6837   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6838     len = len - 6;
6839   else
6840     return 0;
6841   node = ident_subst (name, len, "", '/', '.', "");
6842   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6843   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6844   return 1;
6845 }
6846
6847 /* Read a import directory, gathering potential match for further type
6848    references. Indifferently reads a filesystem or a ZIP archive
6849    directory.  */
6850
6851 static void
6852 read_import_dir (tree wfl)
6853 {
6854   tree package_id = EXPR_WFL_NODE (wfl);
6855   const char *package_name = IDENTIFIER_POINTER (package_id);
6856   int package_length = IDENTIFIER_LENGTH (package_id);
6857   DIR *dirp = NULL;
6858   JCF *saved_jcf = current_jcf;
6859
6860   int found = 0;
6861   int k;
6862   void *entry;
6863   struct buffer filename[1];
6864
6865   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6866     return;
6867   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6868
6869   BUFFER_INIT (filename);
6870   buffer_grow (filename, package_length + 100);
6871
6872   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6873     {
6874       const char *entry_name = jcf_path_name (entry);
6875       int entry_length = strlen (entry_name);
6876       if (jcf_path_is_zipfile (entry))
6877         {
6878           ZipFile *zipf;
6879           buffer_grow (filename, entry_length);
6880           memcpy (filename->data, entry_name, entry_length - 1);
6881           filename->data[entry_length-1] = '\0';
6882           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6883           if (zipf == NULL)
6884             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6885           else
6886             {
6887               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6888               BUFFER_RESET (filename);
6889               for (k = 0; k < package_length; k++)
6890                 {
6891                   char ch = package_name[k];
6892                   *filename->ptr++ = ch == '.' ? '/' : ch;
6893                 }
6894               *filename->ptr++ = '/';
6895
6896               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6897                 {
6898                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6899                   int current_entry_len = zipd->filename_length;
6900
6901                   if (current_entry_len >= BUFFER_LENGTH (filename)
6902                       && strncmp (filename->data, current_entry,
6903                                   BUFFER_LENGTH (filename)) != 0)
6904                     continue;
6905                   found |= note_possible_classname (current_entry,
6906                                                     current_entry_len);
6907                 }
6908             }
6909         }
6910       else
6911         {
6912           BUFFER_RESET (filename);
6913           buffer_grow (filename, entry_length + package_length + 4);
6914           strcpy (filename->data, entry_name);
6915           filename->ptr = filename->data + entry_length;
6916           for (k = 0; k < package_length; k++)
6917             {
6918               char ch = package_name[k];
6919               *filename->ptr++ = ch == '.' ? '/' : ch;
6920             }
6921           *filename->ptr = '\0';
6922
6923           dirp = opendir (filename->data);
6924           if (dirp == NULL)
6925             continue;
6926           *filename->ptr++ = '/';
6927           for (;;)
6928             {
6929               int len;
6930               const char *d_name;
6931               struct dirent *direntp = readdir (dirp);
6932               if (!direntp)
6933                 break;
6934               d_name = direntp->d_name;
6935               len = strlen (direntp->d_name);
6936               buffer_grow (filename, len+1);
6937               strcpy (filename->ptr, d_name);
6938               found |= note_possible_classname (filename->data + entry_length,
6939                                                 package_length+len+1);
6940             }
6941           if (dirp)
6942             closedir (dirp);
6943         }
6944     }
6945
6946   free (filename->data);
6947
6948   /* Here we should have a unified way of retrieving an entry, to be
6949      indexed. */
6950   if (!found)
6951     {
6952       static int first = 1;
6953       if (first)
6954         {
6955           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6956           java_error_count++;
6957           first = 0;
6958         }
6959       else
6960         parse_error_context (wfl, "Package `%s' not found in import",
6961                              package_name);
6962       current_jcf = saved_jcf;
6963       return;
6964     }
6965   current_jcf = saved_jcf;
6966 }
6967
6968 /* Possibly find a type in the import on demands specified
6969    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6970    entire list, to detected potential double definitions.  */
6971
6972 static int
6973 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6974 {
6975   tree class_type_name = TYPE_NAME (class_type);
6976   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
6977                   ctxp->import_demand_list);
6978   tree cl = NULL_TREE;
6979   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
6980   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
6981   tree node;
6982
6983   for (; import; import = TREE_CHAIN (import))
6984     {
6985       int saved_lineno = input_line;
6986       int access_check;
6987       const char *id_name;
6988       tree decl, type_name_copy;
6989
6990       obstack_grow (&temporary_obstack,
6991                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6992                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6993       obstack_1grow (&temporary_obstack, '.');
6994       obstack_grow0 (&temporary_obstack,
6995                      IDENTIFIER_POINTER (class_type_name),
6996                      IDENTIFIER_LENGTH (class_type_name));
6997       id_name = obstack_finish (&temporary_obstack);
6998
6999       if (! (node = maybe_get_identifier (id_name)))
7000         continue;
7001
7002       /* Setup lineno so that it refers to the line of the import (in
7003          case we parse a class file and encounter errors */
7004       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7005
7006       type_name_copy = TYPE_NAME (class_type);
7007       TYPE_NAME (class_type) = node;
7008       QUALIFIED_P (node) = 1;
7009       decl = IDENTIFIER_CLASS_VALUE (node);
7010       access_check = -1;
7011       /* If there is no DECL set for the class or if the class isn't
7012          loaded and not seen in source yet, then load */
7013       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7014                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7015         {
7016           load_class (node, 0);
7017           decl = IDENTIFIER_CLASS_VALUE (node);
7018         }
7019       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7020         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7021                                                false);
7022       else
7023         /* 6.6.1: Inner classes are subject to member access rules. */
7024         access_check = 0;
7025
7026       input_line = saved_lineno;
7027
7028       /* If the loaded class is not accessible or couldn't be loaded,
7029          we restore the original TYPE_NAME and process the next
7030          import. */
7031       if (access_check || !decl)
7032         {
7033           TYPE_NAME (class_type) = type_name_copy;
7034           continue;
7035         }
7036
7037       /* If the loaded class is accessible, we keep a tab on it to
7038          detect and report multiple inclusions. */
7039       if (IS_A_CLASSFILE_NAME (node))
7040         {
7041           if (seen_once < 0)
7042             {
7043               cl = TREE_PURPOSE (import);
7044               seen_once = 1;
7045             }
7046           else if (seen_once >= 0)
7047             {
7048               tree location = (cl ? cl : TREE_PURPOSE (import));
7049               tree package = (cl ? EXPR_WFL_NODE (cl) :
7050                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7051               seen_once++;
7052               parse_error_context
7053                 (location,
7054                  "Type `%s' also potentially defined in package `%s'",
7055                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7056                  IDENTIFIER_POINTER (package));
7057             }
7058         }
7059       to_return = access_check;
7060     }
7061
7062   if (seen_once == 1)
7063     return to_return;
7064   else
7065     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7066 }
7067
7068 /* Add package NAME to the list of packages encountered so far. To
7069    speed up class lookup in do_resolve_class, we make sure a
7070    particular package is added only once.  */
7071
7072 static void
7073 register_package (tree name)
7074 {
7075   static htab_t pht;
7076   void **e;
7077
7078   if (pht == NULL)
7079     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7080
7081   e = htab_find_slot (pht, name, INSERT);
7082   if (*e == NULL)
7083     {
7084       package_list = chainon (package_list, build_tree_list (name, NULL));
7085       *e = name;
7086     }
7087 }
7088
7089 static tree
7090 resolve_package (tree pkg, tree *next, tree *type_name)
7091 {
7092   tree current;
7093   tree decl = NULL_TREE;
7094   *type_name = NULL_TREE;
7095
7096   /* The trick is to determine when the package name stops and were
7097      the name of something contained in the package starts. Then we
7098      return a fully qualified name of what we want to get. */
7099
7100   *next = EXPR_WFL_QUALIFICATION (pkg);
7101
7102   /* Try to progressively construct a type name */
7103   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7104     for (current = EXPR_WFL_QUALIFICATION (pkg);
7105          current; current = TREE_CHAIN (current))
7106       {
7107         /* If we don't have what we're expecting, exit now. TYPE_NAME
7108            will be null and the error caught later. */
7109         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7110           break;
7111         *type_name =
7112           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7113         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7114           {
7115             /* resolve_package should be used in a loop, hence we
7116                point at this one to naturally process the next one at
7117                the next iteration. */
7118             *next = current;
7119             break;
7120           }
7121       }
7122   return decl;
7123 }
7124
7125
7126 /* Check accessibility of inner classes according to member access rules.
7127    DECL is the inner class, ENCLOSING_DECL is the class from which the
7128    access is being attempted. */
7129
7130 static void
7131 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7132 {
7133   const char *access;
7134   tree enclosing_decl_type;
7135
7136   /* We don't issue an error message when CL is null. CL can be null
7137      as a result of processing a JDEP crafted by source_start_java_method
7138      for the purpose of patching its parm decl. But the error would
7139      have been already trapped when fixing the method's signature.
7140      DECL can also be NULL in case of earlier errors. */
7141   if (!decl || !cl)
7142     return;
7143
7144   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7145
7146   if (CLASS_PRIVATE (decl))
7147     {
7148       /* Access is permitted only within the body of the top-level
7149          class in which DECL is declared. */
7150       tree top_level = decl;
7151       while (DECL_CONTEXT (top_level))
7152         top_level = DECL_CONTEXT (top_level);
7153       while (DECL_CONTEXT (enclosing_decl))
7154         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7155       if (top_level == enclosing_decl)
7156         return;
7157       access = "private";
7158     }
7159   else if (CLASS_PROTECTED (decl))
7160     {
7161       tree decl_context;
7162       /* Access is permitted from within the same package... */
7163       if (in_same_package (decl, enclosing_decl))
7164         return;
7165
7166       /* ... or from within the body of a subtype of the context in which
7167          DECL is declared. */
7168       decl_context = DECL_CONTEXT (decl);
7169       while (enclosing_decl)
7170         {
7171           if (CLASS_INTERFACE (decl))
7172             {
7173               if (interface_of_p (TREE_TYPE (decl_context),
7174                                   enclosing_decl_type))
7175                 return;
7176             }
7177           else
7178             {
7179               /* Eww. The order of the arguments is different!! */
7180               if (inherits_from_p (enclosing_decl_type,
7181                                    TREE_TYPE (decl_context)))
7182                 return;
7183             }
7184           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7185         }
7186       access = "protected";
7187     }
7188   else if (! CLASS_PUBLIC (decl))
7189     {
7190       /* Access is permitted only from within the same package as DECL. */
7191       if (in_same_package (decl, enclosing_decl))
7192         return;
7193       access = "non-public";
7194     }
7195   else
7196     /* Class is public. */
7197     return;
7198
7199   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7200                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7201                        lang_printable_name (decl, 0), access);
7202 }
7203
7204 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7205    foreign package, it must be PUBLIC. Return 0 if no access
7206    violations were found, 1 otherwise. If VERBOSE is true and an error
7207    was found, it is reported and accounted for.  */
7208
7209 static int
7210 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7211 {
7212   tree type;
7213
7214   if (!IDENTIFIER_CLASS_VALUE (class_name))
7215     return 0;
7216
7217   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7218     return 0;
7219
7220   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7221     {
7222       /* Access to a private class within the same package is
7223          allowed. */
7224       tree l, r;
7225       breakdown_qualified (&l, &r, class_name);
7226       if (!QUALIFIED_P (class_name) && !ctxp->package)
7227         /* Both in the empty package. */
7228         return 0;
7229       if (l == ctxp->package)
7230         /* Both in the same package. */
7231         return 0;
7232
7233       if (verbose)
7234         parse_error_context
7235           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7236            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7237            IDENTIFIER_POINTER (class_name));
7238       return 1;
7239     }
7240   return 0;
7241 }
7242
7243 /* Local variable declaration. */
7244
7245 static void
7246 declare_local_variables (int modifier, tree type, tree vlist)
7247 {
7248   tree decl, current, saved_type;
7249   tree type_wfl = NULL_TREE;
7250   int must_chain = 0;
7251   int final_p = 0;
7252
7253   /* Push a new block if statements were seen between the last time we
7254      pushed a block and now. Keep a count of blocks to close */
7255   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7256     {
7257       tree b = enter_block ();
7258       BLOCK_IS_IMPLICIT (b) = 1;
7259     }
7260
7261   if (modifier)
7262     {
7263       size_t i;
7264       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7265         if (1 << i & modifier)
7266           break;
7267       if (modifier == ACC_FINAL)
7268         final_p = 1;
7269       else
7270         {
7271           parse_error_context
7272             (ctxp->modifier_ctx [i],
7273              "Only `final' is allowed as a local variables modifier");
7274           return;
7275         }
7276     }
7277
7278   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7279      hold the TYPE value if a new incomplete has to be created (as
7280      opposed to being found already existing and reused). */
7281   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7282
7283   /* If TYPE is fully resolved and we don't have a reference, make one */
7284   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7285
7286   /* Go through all the declared variables */
7287   for (current = vlist, saved_type = type; current;
7288        current = TREE_CHAIN (current), type = saved_type)
7289     {
7290       tree other, real_type;
7291       tree wfl  = TREE_PURPOSE (current);
7292       tree name = EXPR_WFL_NODE (wfl);
7293       tree init = TREE_VALUE (current);
7294
7295       /* Process NAME, as it may specify extra dimension(s) for it */
7296       type = build_array_from_name (type, type_wfl, name, &name);
7297
7298       /* Variable redefinition check */
7299       if ((other = lookup_name_in_blocks (name)))
7300         {
7301           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7302                                        DECL_SOURCE_LINE (other));
7303           continue;
7304         }
7305
7306       /* Type adjustment. We may have just readjusted TYPE because
7307          the variable specified more dimensions. Make sure we have
7308          a reference if we can and don't have one already. */
7309       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7310
7311       real_type = GET_REAL_TYPE (type);
7312       /* Never layout this decl. This will be done when its scope
7313          will be entered */
7314       decl = build_decl (VAR_DECL, name, real_type);
7315       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7316       DECL_FINAL (decl) = final_p;
7317       BLOCK_CHAIN_DECL (decl);
7318
7319       /* If doing xreferencing, replace the line number with the WFL
7320          compound value */
7321       if (flag_emit_xref)
7322         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7323
7324       /* Don't try to use an INIT statement when an error was found */
7325       if (init && java_error_count)
7326         init = NULL_TREE;
7327
7328       /* Add the initialization function to the current function's code */
7329       if (init)
7330         {
7331           /* Name might have been readjusted */
7332           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7333           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7334           java_method_add_stmt (current_function_decl,
7335                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7336                                                       init));
7337         }
7338
7339       /* Setup dependency the type of the decl */
7340       if (must_chain)
7341         {
7342           jdep *dep;
7343           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7344           dep = CLASSD_LAST (ctxp->classd_list);
7345           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7346         }
7347     }
7348   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7349 }
7350
7351 /* Called during parsing. Build decls from argument list.  */
7352
7353 static void
7354 source_start_java_method (tree fndecl)
7355 {
7356   tree tem;
7357   tree parm_decl;
7358   int i;
7359
7360   if (!fndecl)
7361     return;
7362
7363   current_function_decl = fndecl;
7364
7365   /* New scope for the function */
7366   enter_block ();
7367   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7368        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7369     {
7370       tree type = TREE_VALUE (tem);
7371       tree name = TREE_PURPOSE (tem);
7372
7373       /* If type is incomplete. Create an incomplete decl and ask for
7374          the decl to be patched later */
7375       if (INCOMPLETE_TYPE_P (type))
7376         {
7377           jdep *jdep;
7378           tree real_type = GET_REAL_TYPE (type);
7379           parm_decl = build_decl (PARM_DECL, name, real_type);
7380           type = obtain_incomplete_type (type);
7381           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7382           jdep = CLASSD_LAST (ctxp->classd_list);
7383           JDEP_MISC (jdep) = name;
7384           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7385         }
7386       else
7387         parm_decl = build_decl (PARM_DECL, name, type);
7388
7389       /* Remember if a local variable was declared final (via its
7390          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7391       if (ARG_FINAL_P (tem))
7392         {
7393           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7394           DECL_FINAL (parm_decl) = 1;
7395         }
7396
7397       BLOCK_CHAIN_DECL (parm_decl);
7398     }
7399   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7400   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7401     nreverse (tem);
7402   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7403   DECL_MAX_LOCALS (current_function_decl) = i;
7404 }
7405
7406 /* Called during parsing. Creates an artificial method declaration.  */
7407
7408 static tree
7409 create_artificial_method (tree class, int flags, tree type,
7410                           tree name, tree args)
7411 {
7412   tree mdecl;
7413
7414   java_parser_context_save_global ();
7415   input_line = 0;
7416   mdecl = make_node (FUNCTION_TYPE);
7417   TREE_TYPE (mdecl) = type;
7418   TYPE_ARG_TYPES (mdecl) = args;
7419   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7420   java_parser_context_restore_global ();
7421   DECL_ARTIFICIAL (mdecl) = 1;
7422   return mdecl;
7423 }
7424
7425 /* Starts the body if an artificial method.  */
7426
7427 static void
7428 start_artificial_method_body (tree mdecl)
7429 {
7430   DECL_SOURCE_LINE (mdecl) = 1;
7431   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7432   source_start_java_method (mdecl);
7433   enter_block ();
7434 }
7435
7436 static void
7437 end_artificial_method_body (tree mdecl)
7438 {
7439   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7440      It has to be evaluated first. (if mdecl is current_function_decl,
7441      we have an undefined behavior if no temporary variable is used.) */
7442   tree b = exit_block ();
7443   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7444   exit_block ();
7445 }
7446
7447 /* Dump a tree of some kind.  This is a convenience wrapper for the
7448    dump_* functions in tree-dump.c.  */
7449 static void
7450 dump_java_tree (enum tree_dump_index phase, tree t)
7451 {
7452   FILE *stream;
7453   int flags;
7454
7455   stream = dump_begin (phase, &flags);
7456   flags |= TDF_SLIM;
7457   if (stream)
7458     {
7459       dump_node (t, flags, stream);
7460       dump_end (phase, stream);
7461     }
7462 }
7463
7464 /* Terminate a function and expand its body.  */
7465
7466 static void
7467 source_end_java_method (void)
7468 {
7469   tree fndecl = current_function_decl;
7470
7471   if (!fndecl)
7472     return;
7473
7474   java_parser_context_save_global ();
7475   input_line = ctxp->last_ccb_indent1;
7476
7477   /* Turn function bodies with only a NOP expr null, so they don't get
7478      generated at all and we won't get warnings when using the -W
7479      -Wall flags. */
7480   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7481     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7482
7483   /* We've generated all the trees for this function, and it has been
7484      patched.  Dump it to a file if the user requested it.  */
7485   dump_java_tree (TDI_original, fndecl);
7486
7487   /* In unit-at-a-time mode, don't expand the method yet.  */
7488   if (DECL_SAVED_TREE (fndecl) && flag_unit_at_a_time)
7489     {
7490       cgraph_finalize_function (fndecl, false);
7491       current_function_decl = NULL_TREE;
7492       java_parser_context_restore_global ();
7493       return;
7494     }
7495
7496   java_optimize_inline (fndecl);
7497
7498   /* Expand the function's body.  */
7499   java_expand_body (fndecl);
7500
7501   java_parser_context_restore_global ();
7502 }
7503
7504 /* Record EXPR in the current function block. Complements compound
7505    expression second operand if necessary.  */
7506
7507 tree
7508 java_method_add_stmt (tree fndecl, tree expr)
7509 {
7510   if (!GET_CURRENT_BLOCK (fndecl))
7511     return NULL_TREE;
7512   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7513 }
7514
7515 static tree
7516 add_stmt_to_block (tree b, tree type, tree stmt)
7517 {
7518   tree body = BLOCK_EXPR_BODY (b), c;
7519
7520   if (java_error_count)
7521     return body;
7522
7523   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7524     return body;
7525
7526   BLOCK_EXPR_BODY (b) = c;
7527   TREE_SIDE_EFFECTS (c) = 1;
7528   return c;
7529 }
7530
7531 /* Add STMT to EXISTING if possible, otherwise create a new
7532    COMPOUND_EXPR and add STMT to it. */
7533
7534 static tree
7535 add_stmt_to_compound (tree existing, tree type, tree stmt)
7536 {
7537   if (existing)
7538     return build (COMPOUND_EXPR, type, existing, stmt);
7539   else
7540     return stmt;
7541 }
7542
7543 void java_layout_seen_class_methods (void)
7544 {
7545   tree previous_list = all_class_list;
7546   tree end = NULL_TREE;
7547   tree current;
7548
7549   while (1)
7550     {
7551       for (current = previous_list;
7552            current != end; current = TREE_CHAIN (current))
7553         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7554
7555       if (previous_list != all_class_list)
7556         {
7557           end = previous_list;
7558           previous_list = all_class_list;
7559         }
7560       else
7561         break;
7562     }
7563 }
7564
7565 static GTY(()) tree stop_reordering;
7566 void
7567 java_reorder_fields (void)
7568 {
7569   tree current;
7570
7571   for (current = gclass_list; current; current = TREE_CHAIN (current))
7572     {
7573       current_class = TREE_TYPE (TREE_VALUE (current));
7574
7575       if (current_class == stop_reordering)
7576         break;
7577
7578       /* Reverse the fields, but leave the dummy field in front.
7579          Fields are already ordered for Object and Class */
7580       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7581           && current_class != class_type_node)
7582       {
7583         /* If the dummy field is there, reverse the right fields and
7584            just layout the type for proper fields offset */
7585         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7586           {
7587             tree fields = TYPE_FIELDS (current_class);
7588             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7589             TYPE_SIZE (current_class) = NULL_TREE;
7590           }
7591         /* We don't have a dummy field, we need to layout the class,
7592            after having reversed the fields */
7593         else
7594           {
7595             TYPE_FIELDS (current_class) =
7596               nreverse (TYPE_FIELDS (current_class));
7597             TYPE_SIZE (current_class) = NULL_TREE;
7598           }
7599       }
7600     }
7601   /* There are cases were gclass_list will be empty. */
7602   if (gclass_list)
7603     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7604 }
7605
7606 /* Layout the methods of all classes loaded in one way or another.
7607    Check methods of source parsed classes. Then reorder the
7608    fields and layout the classes or the type of all source parsed
7609    classes */
7610
7611 void
7612 java_layout_classes (void)
7613 {
7614   tree current;
7615   int save_error_count = java_error_count;
7616
7617   /* Layout the methods of all classes seen so far */
7618   java_layout_seen_class_methods ();
7619   java_parse_abort_on_error ();
7620   all_class_list = NULL_TREE;
7621
7622   /* Then check the methods of all parsed classes */
7623   for (current = gclass_list; current; current = TREE_CHAIN (current))
7624     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7625       java_check_methods (TREE_VALUE (current));
7626   java_parse_abort_on_error ();
7627
7628   for (current = gclass_list; current; current = TREE_CHAIN (current))
7629     {
7630       current_class = TREE_TYPE (TREE_VALUE (current));
7631       layout_class (current_class);
7632
7633       /* Error reported by the caller */
7634       if (java_error_count)
7635         return;
7636     }
7637
7638   /* We might have reloaded classes durign the process of laying out
7639      classes for code generation. We must layout the methods of those
7640      late additions, as constructor checks might use them */
7641   java_layout_seen_class_methods ();
7642   java_parse_abort_on_error ();
7643 }
7644
7645 /* Expand methods in the current set of classes rememebered for
7646    generation.  */
7647
7648 static void
7649 java_complete_expand_classes (void)
7650 {
7651   tree current;
7652
7653   do_not_fold = flag_emit_xref;
7654
7655   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7656     if (!INNER_CLASS_DECL_P (current))
7657       java_complete_expand_class (current);
7658 }
7659
7660 /* Expand the methods found in OUTER, starting first by OUTER's inner
7661    classes, if any.  */
7662
7663 static void
7664 java_complete_expand_class (tree outer)
7665 {
7666   tree inner_list;
7667
7668   set_nested_class_simple_name_value (outer, 1); /* Set */
7669
7670   /* We need to go after all inner classes and start expanding them,
7671      starting with most nested ones. We have to do that because nested
7672      classes might add functions to outer classes */
7673
7674   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7675        inner_list; inner_list = TREE_CHAIN (inner_list))
7676     java_complete_expand_class (TREE_PURPOSE (inner_list));
7677
7678   java_complete_expand_methods (outer);
7679   set_nested_class_simple_name_value (outer, 0); /* Reset */
7680 }
7681
7682 /* Expand methods registered in CLASS_DECL. The general idea is that
7683    we expand regular methods first. This allows us get an estimate on
7684    how outer context local alias fields are really used so we can add
7685    to the constructor just enough code to initialize them properly (it
7686    also lets us generate finit$ correctly.) Then we expand the
7687    constructors and then <clinit>.  */
7688
7689 static void
7690 java_complete_expand_methods (tree class_decl)
7691 {
7692   tree clinit, decl, first_decl;
7693
7694   current_class = TREE_TYPE (class_decl);
7695
7696   /* Initialize a new constant pool */
7697   init_outgoing_cpool ();
7698
7699   /* Pre-expand <clinit> to figure whether we really need it or
7700      not. If we do need it, we pre-expand the static fields so they're
7701      ready to be used somewhere else. <clinit> will be fully expanded
7702      after we processed the constructors. */
7703   first_decl = TYPE_METHODS (current_class);
7704   clinit = maybe_generate_pre_expand_clinit (current_class);
7705
7706   /* Then generate finit$ (if we need to) because constructors will
7707    try to use it.*/
7708   if (TYPE_FINIT_STMT_LIST (current_class))
7709     java_complete_expand_method (generate_finit (current_class));
7710
7711   /* Then generate instinit$ (if we need to) because constructors will
7712      try to use it. */
7713   if (TYPE_II_STMT_LIST (current_class))
7714     java_complete_expand_method (generate_instinit (current_class));
7715
7716   /* Now do the constructors */
7717   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7718     {
7719       int no_body;
7720
7721       if (!DECL_CONSTRUCTOR_P (decl))
7722         continue;
7723
7724       no_body = !DECL_FUNCTION_BODY (decl);
7725       /* Don't generate debug info on line zero when expanding a
7726          generated constructor. */
7727       if (no_body)
7728         restore_line_number_status (1);
7729
7730       java_complete_expand_method (decl);
7731
7732       if (no_body)
7733         restore_line_number_status (0);
7734     }
7735
7736   /* First, do the ordinary methods. */
7737   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7738     {
7739       /* Ctors aren't part of this batch. */
7740       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7741         continue;
7742
7743       /* Skip abstract or native methods -- but do handle native
7744          methods when generating JNI stubs.  */
7745       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7746         {
7747           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7748           continue;
7749         }
7750
7751       if (METHOD_NATIVE (decl))
7752         {
7753           tree body;
7754           current_function_decl = decl;
7755           body = build_jni_stub (decl);
7756           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7757         }
7758
7759       java_complete_expand_method (decl);
7760     }
7761
7762   /* If there is indeed a <clinit>, fully expand it now */
7763   if (clinit)
7764     {
7765       /* Prevent the use of `this' inside <clinit> */
7766       ctxp->explicit_constructor_p = 1;
7767       java_complete_expand_method (clinit);
7768       ctxp->explicit_constructor_p = 0;
7769     }
7770
7771   /* We might have generated a class$ that we now want to expand */
7772   if (TYPE_DOT_CLASS (current_class))
7773     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7774
7775   /* Now verify constructor circularity (stop after the first one we
7776      prove wrong.) */
7777   if (!CLASS_INTERFACE (class_decl))
7778     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7779       if (DECL_CONSTRUCTOR_P (decl)
7780           && verify_constructor_circularity (decl, decl))
7781         break;
7782
7783   /* Save the constant pool. We'll need to restore it later. */
7784   TYPE_CPOOL (current_class) = outgoing_cpool;
7785 }
7786
7787 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7788    safely used in some other methods/constructors.  */
7789
7790 static tree
7791 maybe_generate_pre_expand_clinit (tree class_type)
7792 {
7793   tree current, mdecl;
7794
7795   if (!TYPE_CLINIT_STMT_LIST (class_type))
7796     return NULL_TREE;
7797
7798   /* Go through all static fields and pre expand them */
7799   for (current = TYPE_FIELDS (class_type); current;
7800        current = TREE_CHAIN (current))
7801     if (FIELD_STATIC (current))
7802       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7803
7804   /* Then build the <clinit> method */
7805   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7806                                     clinit_identifier_node, end_params_node);
7807   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7808                        mdecl, NULL_TREE);
7809   start_artificial_method_body (mdecl);
7810
7811   /* We process the list of assignment we produced as the result of
7812      the declaration of initialized static field and add them as
7813      statement to the <clinit> method. */
7814   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7815        current = TREE_CHAIN (current))
7816     {
7817       tree stmt = current;
7818       /* We build the assignment expression that will initialize the
7819          field to its value. There are strict rules on static
7820          initializers (8.5). FIXME */
7821       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7822         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7823       java_method_add_stmt (mdecl, stmt);
7824     }
7825
7826   end_artificial_method_body (mdecl);
7827
7828   /* Now we want to place <clinit> as the last method (because we need
7829      it at least for interface so that it doesn't interfere with the
7830      dispatch table based lookup. */
7831   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7832     {
7833       current = TREE_CHAIN (TYPE_METHODS (class_type));
7834       TYPE_METHODS (class_type) = current;
7835
7836       while (TREE_CHAIN (current))
7837         current = TREE_CHAIN (current);
7838
7839       TREE_CHAIN (current) = mdecl;
7840       TREE_CHAIN (mdecl) = NULL_TREE;
7841     }
7842
7843   return mdecl;
7844 }
7845
7846 /* Analyzes a method body and look for something that isn't a
7847    MODIFY_EXPR with a constant value.  */
7848
7849 static int
7850 analyze_clinit_body (tree this_class, tree bbody)
7851 {
7852   while (bbody)
7853     switch (TREE_CODE (bbody))
7854       {
7855       case BLOCK:
7856         bbody = BLOCK_EXPR_BODY (bbody);
7857         break;
7858
7859       case EXPR_WITH_FILE_LOCATION:
7860         bbody = EXPR_WFL_NODE (bbody);
7861         break;
7862
7863       case COMPOUND_EXPR:
7864         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7865           return 1;
7866         bbody = TREE_OPERAND (bbody, 1);
7867         break;
7868
7869       case MODIFY_EXPR:
7870         /* If we're generating to class file and we're dealing with an
7871            array initialization, we return 1 to keep <clinit> */
7872         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7873             && flag_emit_class_files)
7874           return 1;
7875
7876         /* There are a few cases where we're required to keep
7877            <clinit>:
7878            - If this is an assignment whose operand is not constant,
7879            - If this is an assignment to a non-initialized field,
7880            - If this field is not a member of the current class.
7881         */
7882         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7883                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7884                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7885
7886       default:
7887         return 1;
7888       }
7889   return 0;
7890 }
7891
7892
7893 /* See whether we could get rid of <clinit>. Criteria are: all static
7894    final fields have constant initial values and the body of <clinit>
7895    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7896
7897 static int
7898 maybe_yank_clinit (tree mdecl)
7899 {
7900   tree type, current;
7901   tree fbody, bbody;
7902
7903   if (!DECL_CLINIT_P (mdecl))
7904     return 0;
7905
7906   /* If the body isn't empty, then we keep <clinit>. Note that if
7907      we're emitting classfiles, this isn't enough not to rule it
7908      out. */
7909   fbody = DECL_FUNCTION_BODY (mdecl);
7910   bbody = BLOCK_EXPR_BODY (fbody);
7911   if (bbody && bbody != error_mark_node)
7912     bbody = BLOCK_EXPR_BODY (bbody);
7913   else
7914     return 0;
7915   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7916     return 0;
7917
7918   type = DECL_CONTEXT (mdecl);
7919   current = TYPE_FIELDS (type);
7920
7921   for (current = (current ? TREE_CHAIN (current) : current);
7922        current; current = TREE_CHAIN (current))
7923     {
7924       tree f_init;
7925
7926       /* We're not interested in non-static fields.  */
7927       if (!FIELD_STATIC (current))
7928         continue;
7929
7930       /* Nor in fields without initializers. */
7931       f_init = DECL_INITIAL (current);
7932       if (f_init == NULL_TREE)
7933         continue;
7934
7935       /* Anything that isn't String or a basic type is ruled out -- or
7936          if we know how to deal with it (when doing things natively) we
7937          should generated an empty <clinit> so that SUID are computed
7938          correctly. */
7939       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7940           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7941         return 0;
7942
7943       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7944         return 0;
7945     }
7946
7947   /* Now we analyze the method body and look for something that
7948      isn't a MODIFY_EXPR */
7949   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7950     return 0;
7951
7952   /* Get rid of <clinit> in the class' list of methods */
7953   if (TYPE_METHODS (type) == mdecl)
7954     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7955   else
7956     for (current = TYPE_METHODS (type); current;
7957          current = TREE_CHAIN (current))
7958       if (TREE_CHAIN (current) == mdecl)
7959         {
7960           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7961           break;
7962         }
7963
7964   return 1;
7965 }
7966
7967 /* Install the argument from MDECL. Suitable to completion and
7968    expansion of mdecl's body.  */
7969
7970 void
7971 start_complete_expand_method (tree mdecl)
7972 {
7973   tree tem;
7974
7975   pushlevel (1);                /* Prepare for a parameter push */
7976   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7977   DECL_ARGUMENTS (mdecl) = tem;
7978
7979   for (; tem; tem = TREE_CHAIN (tem))
7980     {
7981       /* TREE_CHAIN (tem) will change after pushdecl. */
7982       tree next = TREE_CHAIN (tem);
7983       tree type = TREE_TYPE (tem);
7984       if (PROMOTE_PROTOTYPES
7985           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7986           && INTEGRAL_TYPE_P (type))
7987         type = integer_type_node;
7988       DECL_ARG_TYPE (tem) = type;
7989       layout_decl (tem, 0);
7990       pushdecl (tem);
7991       /* Re-install the next so that the list is kept and the loop
7992          advances. */
7993       TREE_CHAIN (tem) = next;
7994     }
7995   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7996   input_line = DECL_SOURCE_LINE (mdecl);
7997   build_result_decl (mdecl);
7998 }
7999
8000
8001 /* Complete and expand a method.  */
8002
8003 static void
8004 java_complete_expand_method (tree mdecl)
8005 {
8006   tree fbody, block_body, exception_copy;
8007
8008   current_function_decl = mdecl;
8009   /* Fix constructors before expanding them */
8010   if (DECL_CONSTRUCTOR_P (mdecl))
8011     fix_constructors (mdecl);
8012
8013   /* Expand functions that have a body */
8014   if (!DECL_FUNCTION_BODY (mdecl))
8015     return;
8016
8017   fbody = DECL_FUNCTION_BODY (mdecl);
8018   block_body = BLOCK_EXPR_BODY (fbody);
8019   exception_copy = NULL_TREE;
8020
8021   current_function_decl = mdecl;
8022
8023   if (! quiet_flag)
8024     fprintf (stderr, " [%s.",
8025              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8026   announce_function (mdecl);
8027   if (! quiet_flag)
8028     fprintf (stderr, "]");
8029
8030   /* Prepare the function for tree completion */
8031   start_complete_expand_method (mdecl);
8032
8033   /* Install the current this */
8034   current_this = (!METHOD_STATIC (mdecl) ?
8035                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8036
8037   /* Purge the `throws' list of unchecked exceptions (we save a copy
8038      of the list and re-install it later.) */
8039   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8040   purge_unchecked_exceptions (mdecl);
8041
8042   /* Install exceptions thrown with `throws' */
8043   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8044
8045   if (block_body != NULL_TREE)
8046     {
8047       block_body = java_complete_tree (block_body);
8048
8049       /* Before we check initialization, attached all class initialization
8050          variable to the block_body */
8051       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8052                      attach_init_test_initialization_flags, block_body);
8053
8054       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8055         {
8056           check_for_initialization (block_body, mdecl);
8057
8058           /* Go through all the flags marking the initialization of
8059              static variables and see whether they're definitively
8060              assigned, in which case the type is remembered as
8061              definitively initialized in MDECL. */
8062           if (STATIC_CLASS_INIT_OPT_P ())
8063             {
8064               /* Always register the context as properly initialized in
8065                  MDECL. This used with caution helps removing extra
8066                  initialization of self. */
8067               if (METHOD_STATIC (mdecl))
8068                 {
8069                   *(htab_find_slot
8070                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8071                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8072                 }
8073             }
8074         }
8075       ctxp->explicit_constructor_p = 0;
8076     }
8077
8078   BLOCK_EXPR_BODY (fbody) = block_body;
8079
8080   /* If we saw a return but couldn't evaluate it properly, we'll have
8081      an error_mark_node here. */
8082   if (block_body != error_mark_node
8083       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8084       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8085       && !flag_emit_xref)
8086     missing_return_error (current_function_decl);
8087
8088   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8089   maybe_yank_clinit (mdecl);
8090
8091   /* Pop the current level, with special measures if we found errors. */
8092   if (java_error_count)
8093     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8094   poplevel (1, 0, 1);
8095
8096   /* Pop the exceptions and sanity check */
8097   POP_EXCEPTIONS();
8098   if (currently_caught_type_list)
8099     abort ();
8100
8101   /* Restore the copy of the list of exceptions if emitting xrefs. */
8102   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8103 }
8104
8105 /* For with each class for which there's code to generate. */
8106
8107 static void
8108 java_expand_method_bodies (tree class)
8109 {
8110   tree decl;
8111   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8112     {
8113       tree block;
8114       tree body;
8115
8116       if (! DECL_FUNCTION_BODY (decl))
8117         continue;
8118
8119       current_function_decl = decl;
8120
8121       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8122
8123       if (TREE_CODE (block) != BLOCK)
8124         abort ();
8125
8126       /* Save the function body for inlining.  */
8127       DECL_SAVED_TREE (decl) = block;
8128
8129       body = BLOCK_EXPR_BODY (block);
8130
8131       if (TREE_TYPE (body) == NULL_TREE)
8132         abort ();
8133
8134       /* It's time to assign the variable flagging static class
8135          initialization based on which classes invoked static methods
8136          are definitely initializing. This should be flagged. */
8137       if (STATIC_CLASS_INIT_OPT_P ())
8138         {
8139           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8140           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8141             {
8142               /* Executed for each statement calling a static function.
8143                  LIST is a TREE_LIST whose PURPOSE is the called function
8144                  and VALUE is a compound whose second operand can be patched
8145                  with static class initialization flag assignments.  */
8146
8147               tree called_method = TREE_PURPOSE (list);
8148               tree compound = TREE_VALUE (list);
8149               tree assignment_compound_list
8150                 = build_tree_list (called_method, NULL);
8151
8152               /* For each class definitely initialized in
8153                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8154                  assignment to the class initialization flag. */
8155               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8156                              emit_test_initialization,
8157                              assignment_compound_list);
8158
8159               if (TREE_VALUE (assignment_compound_list))
8160                 TREE_OPERAND (compound, 1)
8161                   = TREE_VALUE (assignment_compound_list);
8162             }
8163         }
8164
8165       /* Prepend class initialization to static methods.  */
8166       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8167           && ! flag_emit_class_files
8168           && ! DECL_CLINIT_P (decl)
8169           && ! CLASS_INTERFACE (TYPE_NAME (class)))
8170         {
8171           tree init = build (CALL_EXPR, void_type_node,
8172                              build_address_of (soft_initclass_node),
8173                              build_tree_list (NULL_TREE,
8174                                               build_class_ref (class)),
8175                              NULL_TREE);
8176           TREE_SIDE_EFFECTS (init) = 1;
8177           body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8178           BLOCK_EXPR_BODY (block) = body;
8179         }
8180
8181       /* Wrap synchronized method bodies in a monitorenter
8182          plus monitorexit cleanup.  */
8183       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8184         {
8185           tree enter, exit, lock;
8186           if (METHOD_STATIC (decl))
8187             lock = build_class_ref (class);
8188           else
8189             lock = DECL_ARGUMENTS (decl);
8190           BUILD_MONITOR_ENTER (enter, lock);
8191           BUILD_MONITOR_EXIT (exit, lock);
8192
8193           body = build (COMPOUND_EXPR, void_type_node,
8194                         enter,
8195                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8196           BLOCK_EXPR_BODY (block) = body;
8197         }
8198
8199       /* Expand the the function body.  */
8200       source_end_java_method ();
8201     }
8202 }
8203
8204 \f
8205
8206 /* This section of the code deals with accessing enclosing context
8207    fields either directly by using the relevant access to this$<n> or
8208    by invoking an access method crafted for that purpose.  */
8209
8210 /* Build the necessary access from an inner class to an outer
8211    class. This routine could be optimized to cache previous result
8212    (decl, current_class and returned access).  When an access method
8213    needs to be generated, it always takes the form of a read. It might
8214    be later turned into a write by calling outer_field_access_fix.  */
8215
8216 static tree
8217 build_outer_field_access (tree id, tree decl)
8218 {
8219   tree access = NULL_TREE;
8220   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8221   tree decl_ctx = DECL_CONTEXT (decl);
8222
8223   /* If the immediate enclosing context of the current class is the
8224      field decl's class or inherits from it; build the access as
8225      `this$<n>.<field>'. Note that we will break the `private' barrier
8226      if we're not emitting bytecodes. */
8227   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8228       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8229     {
8230       tree thisn = build_current_thisn (current_class);
8231       access = make_qualified_primary (build_wfl_node (thisn),
8232                                        id, EXPR_WFL_LINECOL (id));
8233     }
8234   /* Otherwise, generate access methods to outer this and access the
8235      field (either using an access method or by direct access.) */
8236   else
8237     {
8238       int lc = EXPR_WFL_LINECOL (id);
8239
8240       /* Now we chain the required number of calls to the access$0 to
8241          get a hold to the enclosing instance we need, and then we
8242          build the field access. */
8243       access = build_access_to_thisn (current_class, decl_ctx, lc);
8244
8245       /* If the field is private and we're generating bytecode, then
8246          we generate an access method */
8247       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8248         {
8249           tree name = build_outer_field_access_methods (decl);
8250           access = build_outer_field_access_expr (lc, decl_ctx,
8251                                                   name, access, NULL_TREE);
8252         }
8253       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8254          Once again we break the `private' access rule from a foreign
8255          class. */
8256       else
8257         access = make_qualified_primary (access, id, lc);
8258     }
8259   return resolve_expression_name (access, NULL);
8260 }
8261
8262 /* Return a nonzero value if NODE describes an outer field inner
8263    access.  */
8264
8265 static int
8266 outer_field_access_p (tree type, tree decl)
8267 {
8268   if (!INNER_CLASS_TYPE_P (type)
8269       || TREE_CODE (decl) != FIELD_DECL
8270       || DECL_CONTEXT (decl) == type)
8271     return 0;
8272
8273   /* If the inner class extends the declaration context of the field
8274      we're try to acces, then this isn't an outer field access */
8275   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8276     return 0;
8277
8278   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8279        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8280     {
8281       if (type == DECL_CONTEXT (decl))
8282         return 1;
8283
8284       if (!DECL_CONTEXT (TYPE_NAME (type)))
8285         {
8286           /* Before we give up, see whether the field is inherited from
8287              the enclosing context we're considering. */
8288           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8289             return 1;
8290           break;
8291         }
8292     }
8293
8294   return 0;
8295 }
8296
8297 /* Return a nonzero value if NODE represents an outer field inner
8298    access that was been already expanded. As a side effect, it returns
8299    the name of the field being accessed and the argument passed to the
8300    access function, suitable for a regeneration of the access method
8301    call if necessary. */
8302
8303 static int
8304 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8305                                tree *arg)
8306 {
8307   int identified = 0;
8308
8309   if (TREE_CODE (node) != CALL_EXPR)
8310     return 0;
8311
8312   /* Well, gcj generates slightly different tree nodes when compiling
8313      to native or bytecodes. It's the case for function calls. */
8314
8315   if (flag_emit_class_files
8316       && TREE_CODE (node) == CALL_EXPR
8317       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8318     identified = 1;
8319   else if (!flag_emit_class_files)
8320     {
8321       node = TREE_OPERAND (node, 0);
8322
8323       if (node && TREE_OPERAND (node, 0)
8324           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8325         {
8326           node = TREE_OPERAND (node, 0);
8327           if (TREE_OPERAND (node, 0)
8328               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8329               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8330                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8331             identified = 1;
8332         }
8333     }
8334
8335   if (identified && name && arg_type && arg)
8336     {
8337       tree argument = TREE_OPERAND (node, 1);
8338       *name = DECL_NAME (TREE_OPERAND (node, 0));
8339       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8340       *arg = TREE_VALUE (argument);
8341     }
8342   return identified;
8343 }
8344
8345 /* Detect in NODE an outer field read access from an inner class and
8346    transform it into a write with RHS as an argument. This function is
8347    called from the java_complete_lhs when an assignment to a LHS can
8348    be identified. */
8349
8350 static tree
8351 outer_field_access_fix (tree wfl, tree node, tree rhs)
8352 {
8353   tree name, arg_type, arg;
8354
8355   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8356     {
8357       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8358                                             arg_type, name, arg, rhs);
8359       return java_complete_tree (node);
8360     }
8361   return NULL_TREE;
8362 }
8363
8364 /* Construct the expression that calls an access method:
8365      <type>.access$<n>(<arg1> [, <arg2>]);
8366
8367    ARG2 can be NULL and will be omitted in that case. It will denote a
8368    read access.  */
8369
8370 static tree
8371 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8372                                tree arg1, tree arg2)
8373 {
8374   tree args, cn, access;
8375
8376   args = arg1 ? arg1 :
8377     build_wfl_node (build_current_thisn (current_class));
8378   args = build_tree_list (NULL_TREE, args);
8379
8380   if (arg2)
8381     args = tree_cons (NULL_TREE, arg2, args);
8382
8383   access = build_method_invocation (build_wfl_node (access_method_name), args);
8384   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8385   return make_qualified_primary (cn, access, lc);
8386 }
8387
8388 static tree
8389 build_new_access_id (void)
8390 {
8391   static int access_n_counter = 1;
8392   char buffer [128];
8393
8394   sprintf (buffer, "access$%d", access_n_counter++);
8395   return get_identifier (buffer);
8396 }
8397
8398 /* Create the static access functions for the outer field DECL. We define a
8399    read:
8400      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8401        return inst$.field;
8402      }
8403    and a write access:
8404      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8405                                      TREE_TYPE (<field>) value$) {
8406        return inst$.field = value$;
8407      }
8408    We should have a usage flags on the DECL so we can lazily turn the ones
8409    we're using for code generation. FIXME.
8410 */
8411
8412 static tree
8413 build_outer_field_access_methods (tree decl)
8414 {
8415   tree id, args, stmt, mdecl;
8416
8417   if (FIELD_INNER_ACCESS_P (decl))
8418     return FIELD_INNER_ACCESS (decl);
8419
8420   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8421
8422   /* Create the identifier and a function named after it. */
8423   id = build_new_access_id ();
8424
8425   /* The identifier is marked as bearing the name of a generated write
8426      access function for outer field accessed from inner classes. */
8427   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8428
8429   /* Create the read access */
8430   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8431   TREE_CHAIN (args) = end_params_node;
8432   stmt = make_qualified_primary (build_wfl_node (inst_id),
8433                                  build_wfl_node (DECL_NAME (decl)), 0);
8434   stmt = build_return (0, stmt);
8435   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8436                                            TREE_TYPE (decl), id, args, stmt);
8437   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8438
8439   /* Create the write access method. No write access for final variable */
8440   if (!FIELD_FINAL (decl))
8441     {
8442       args = build_tree_list (inst_id,
8443                               build_pointer_type (DECL_CONTEXT (decl)));
8444       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8445       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8446       stmt = make_qualified_primary (build_wfl_node (inst_id),
8447                                      build_wfl_node (DECL_NAME (decl)), 0);
8448       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8449                                                 build_wfl_node (wpv_id)));
8450       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8451                                                TREE_TYPE (decl), id,
8452                                                args, stmt);
8453     }
8454   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8455
8456   /* Return the access name */
8457   return FIELD_INNER_ACCESS (decl) = id;
8458 }
8459
8460 /* Build an field access method NAME.  */
8461
8462 static tree
8463 build_outer_field_access_method (tree class, tree type, tree name,
8464                                  tree args, tree body)
8465 {
8466   tree saved_current_function_decl, mdecl;
8467
8468   /* Create the method */
8469   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8470   fix_method_argument_names (args, mdecl);
8471   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8472
8473   /* Attach the method body. */
8474   saved_current_function_decl = current_function_decl;
8475   start_artificial_method_body (mdecl);
8476   java_method_add_stmt (mdecl, body);
8477   end_artificial_method_body (mdecl);
8478   current_function_decl = saved_current_function_decl;
8479
8480   return mdecl;
8481 }
8482
8483 \f
8484 /* This section deals with building access function necessary for
8485    certain kinds of method invocation from inner classes.  */
8486
8487 static tree
8488 build_outer_method_access_method (tree decl)
8489 {
8490   tree saved_current_function_decl, mdecl;
8491   tree args = NULL_TREE, call_args = NULL_TREE;
8492   tree carg, id, body, class;
8493   char buffer [80];
8494   int parm_id_count = 0;
8495
8496   /* Test this abort with an access to a private field */
8497   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8498     abort ();
8499
8500   /* Check the cache first */
8501   if (DECL_FUNCTION_INNER_ACCESS (decl))
8502     return DECL_FUNCTION_INNER_ACCESS (decl);
8503
8504   class = DECL_CONTEXT (decl);
8505
8506   /* Obtain an access identifier and mark it */
8507   id = build_new_access_id ();
8508   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8509
8510   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8511   /* Create the arguments, as much as the original */
8512   for (; carg && carg != end_params_node;
8513        carg = TREE_CHAIN (carg))
8514     {
8515       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8516       args = chainon (args, build_tree_list (get_identifier (buffer),
8517                                              TREE_VALUE (carg)));
8518     }
8519   args = chainon (args, end_params_node);
8520
8521   /* Create the method */
8522   mdecl = create_artificial_method (class, ACC_STATIC,
8523                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8524   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8525   /* There is a potential bug here. We should be able to use
8526      fix_method_argument_names, but then arg names get mixed up and
8527      eventually a constructor will have its this$0 altered and the
8528      outer context won't be assignment properly. The test case is
8529      stub.java FIXME */
8530   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8531
8532   /* Attach the method body. */
8533   saved_current_function_decl = current_function_decl;
8534   start_artificial_method_body (mdecl);
8535
8536   /* The actual method invocation uses the same args. When invoking a
8537      static methods that way, we don't want to skip the first
8538      argument. */
8539   carg = args;
8540   if (!METHOD_STATIC (decl))
8541     carg = TREE_CHAIN (carg);
8542   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8543     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8544                            call_args);
8545
8546   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8547                                   call_args);
8548   if (!METHOD_STATIC (decl))
8549     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8550                                    body, 0);
8551   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8552     body = build_return (0, body);
8553   java_method_add_stmt (mdecl,body);
8554   end_artificial_method_body (mdecl);
8555   current_function_decl = saved_current_function_decl;
8556
8557   /* Back tag the access function so it know what it accesses */
8558   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8559
8560   /* Tag the current method so it knows it has an access generated */
8561   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8562 }
8563
8564 \f
8565 /* This section of the code deals with building expressions to access
8566    the enclosing instance of an inner class. The enclosing instance is
8567    kept in a generated field called this$<n>, with <n> being the
8568    inner class nesting level (starting from 0.)  */
8569
8570 /* Build an access to a given this$<n>, always chaining access call to
8571    others. Access methods to this$<n> are build on the fly if
8572    necessary. This CAN'T be used to solely access this$<n-1> from
8573    this$<n> (which alway yield to special cases and optimization, see
8574    for example build_outer_field_access).  */
8575
8576 static tree
8577 build_access_to_thisn (tree from, tree to, int lc)
8578 {
8579   tree access = NULL_TREE;
8580
8581   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8582     {
8583       if (!access)
8584         {
8585           access = build_current_thisn (from);
8586           access = build_wfl_node (access);
8587         }
8588       else
8589         {
8590           tree access0_wfl, cn;
8591
8592           maybe_build_thisn_access_method (from);
8593           access0_wfl = build_wfl_node (access0_identifier_node);
8594           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8595           EXPR_WFL_LINECOL (access0_wfl) = lc;
8596           access = build_tree_list (NULL_TREE, access);
8597           access = build_method_invocation (access0_wfl, access);
8598           access = make_qualified_primary (cn, access, lc);
8599         }
8600
8601       /* If FROM isn't an inner class, that's fine, we've done enough.
8602          What we're looking for can be accessed from there.  */
8603       from = DECL_CONTEXT (TYPE_NAME (from));
8604       if (!from)
8605         break;
8606       from = TREE_TYPE (from);
8607     }
8608   return access;
8609 }
8610
8611 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8612    is returned if nothing needs to be generated. Otherwise, the method
8613    generated and a method decl is returned.
8614
8615    NOTE: These generated methods should be declared in a class file
8616    attribute so that they can't be referred to directly.  */
8617
8618 static tree
8619 maybe_build_thisn_access_method (tree type)
8620 {
8621   tree mdecl, args, stmt, rtype;
8622   tree saved_current_function_decl;
8623
8624   /* If TYPE is a top-level class, no access method is required.
8625      If there already is such an access method, bail out. */
8626   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8627     return NULL_TREE;
8628
8629   /* We generate the method. The method looks like:
8630      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8631   */
8632   args = build_tree_list (inst_id, build_pointer_type (type));
8633   TREE_CHAIN (args) = end_params_node;
8634   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8635   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8636                                     access0_identifier_node, args);
8637   fix_method_argument_names (args, mdecl);
8638   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8639   stmt = build_current_thisn (type);
8640   stmt = make_qualified_primary (build_wfl_node (inst_id),
8641                                  build_wfl_node (stmt), 0);
8642   stmt = build_return (0, stmt);
8643
8644   saved_current_function_decl = current_function_decl;
8645   start_artificial_method_body (mdecl);
8646   java_method_add_stmt (mdecl, stmt);
8647   end_artificial_method_body (mdecl);
8648   current_function_decl = saved_current_function_decl;
8649
8650   CLASS_ACCESS0_GENERATED_P (type) = 1;
8651
8652   return mdecl;
8653 }
8654
8655 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8656    the first level of innerclassing. this$1 for the next one, etc...
8657    This function can be invoked with TYPE to NULL, available and then
8658    has to count the parser context.  */
8659
8660 static GTY(()) tree saved_thisn;
8661 static GTY(()) tree saved_type;
8662
8663 static tree
8664 build_current_thisn (tree type)
8665 {
8666   static int saved_i = -1;
8667   static int saved_type_i = 0;
8668   tree decl;
8669   char buffer [24];
8670   int i = 0;
8671
8672   if (type)
8673     {
8674       if (type == saved_type)
8675         i = saved_type_i;
8676       else
8677         {
8678           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8679                decl; decl = DECL_CONTEXT (decl), i++)
8680             ;
8681
8682           saved_type = type;
8683           saved_type_i = i;
8684         }
8685     }
8686   else
8687     i = list_length (GET_CPC_LIST ())-2;
8688
8689   if (i == saved_i)
8690     return saved_thisn;
8691
8692   sprintf (buffer, "this$%d", i);
8693   saved_i = i;
8694   saved_thisn = get_identifier (buffer);
8695   return saved_thisn;
8696 }
8697
8698 /* Return the assignement to the hidden enclosing context `this$<n>'
8699    by the second incoming parameter to the innerclass constructor. The
8700    form used is `this.this$<n> = this$<n>;'.  */
8701
8702 static tree
8703 build_thisn_assign (void)
8704 {
8705   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8706     {
8707       tree thisn = build_current_thisn (current_class);
8708       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8709                                          build_wfl_node (thisn), 0);
8710       tree rhs = build_wfl_node (thisn);
8711       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8712       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8713     }
8714   return NULL_TREE;
8715 }
8716
8717 \f
8718 /* Building the synthetic `class$' used to implement the `.class' 1.1
8719    extension for non primitive types. This method looks like:
8720
8721     static Class class$(String type) throws NoClassDefFoundError
8722     {
8723       try {return (java.lang.Class.forName (String));}
8724       catch (ClassNotFoundException e) {
8725         throw new NoClassDefFoundError(e.getMessage());}
8726     } */
8727
8728 static GTY(()) tree get_message_wfl;
8729 static GTY(()) tree type_parm_wfl;
8730
8731 static tree
8732 build_dot_class_method (tree class)
8733 {
8734 #define BWF(S) build_wfl_node (get_identifier ((S)))
8735 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8736   tree args, tmp, saved_current_function_decl, mdecl;
8737   tree stmt, throw_stmt;
8738
8739   if (!get_message_wfl)
8740     {
8741       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8742       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8743     }
8744
8745   /* Build the arguments */
8746   args = build_tree_list (get_identifier ("type$"),
8747                           build_pointer_type (string_type_node));
8748   TREE_CHAIN (args) = end_params_node;
8749
8750   /* Build the qualified name java.lang.Class.forName */
8751   tmp = MQN (MQN (MQN (BWF ("java"),
8752                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8753   load_class (class_not_found_type_node, 1);
8754   load_class (no_class_def_found_type_node, 1);
8755
8756   /* Create the "class$" function */
8757   mdecl = create_artificial_method (class, ACC_STATIC,
8758                                     build_pointer_type (class_type_node),
8759                                     classdollar_identifier_node, args);
8760   DECL_FUNCTION_THROWS (mdecl) =
8761     build_tree_list (NULL_TREE, no_class_def_found_type_node);
8762
8763   /* We start by building the try block. We need to build:
8764        return (java.lang.Class.forName (type)); */
8765   stmt = build_method_invocation (tmp,
8766                                   build_tree_list (NULL_TREE, type_parm_wfl));
8767   stmt = build_return (0, stmt);
8768
8769   /* Now onto the catch block. We start by building the expression
8770      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8771   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8772                                     get_message_wfl, 0);
8773   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8774
8775   /* Build new NoClassDefFoundError (_.getMessage) */
8776   throw_stmt = build_new_invocation
8777     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8778      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8779
8780   /* Build the throw, (it's too early to use BUILD_THROW) */
8781   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8782
8783   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8784   stmt = encapsulate_with_try_catch (0, class_not_found_type_node,
8785                                      stmt, throw_stmt);
8786
8787   fix_method_argument_names (args, mdecl);
8788   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8789   saved_current_function_decl = current_function_decl;
8790   start_artificial_method_body (mdecl);
8791   java_method_add_stmt (mdecl, stmt);
8792   end_artificial_method_body (mdecl);
8793   current_function_decl = saved_current_function_decl;
8794   TYPE_DOT_CLASS (class) = mdecl;
8795
8796   return mdecl;
8797 }
8798
8799 static tree
8800 build_dot_class_method_invocation (tree type)
8801 {
8802   tree sig_id, s;
8803
8804   if (TYPE_ARRAY_P (type))
8805     sig_id = build_java_signature (type);
8806   else
8807     sig_id = DECL_NAME (TYPE_NAME (type));
8808
8809   /* Ensure that the proper name separator is used */
8810   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8811                                IDENTIFIER_LENGTH (sig_id));
8812
8813   s = build_string (IDENTIFIER_LENGTH (sig_id),
8814                     IDENTIFIER_POINTER (sig_id));
8815   return build_method_invocation (build_wfl_node (classdollar_identifier_node),
8816                                   build_tree_list (NULL_TREE, s));
8817 }
8818
8819 /* This section of the code deals with constructor.  */
8820
8821 /* Craft a body for default constructor. Patch existing constructor
8822    bodies with call to super() and field initialization statements if
8823    necessary.  */
8824
8825 static void
8826 fix_constructors (tree mdecl)
8827 {
8828   tree iii;                     /* Instance Initializer Invocation */
8829   tree body = DECL_FUNCTION_BODY (mdecl);
8830   tree thisn_assign, compound = NULL_TREE;
8831   tree class_type = DECL_CONTEXT (mdecl);
8832
8833   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8834     return;
8835   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8836
8837   if (!body)
8838     {
8839       /* It is an error for the compiler to generate a default
8840          constructor if the superclass doesn't have a constructor that
8841          takes no argument, or the same args for an anonymous class */
8842       if (verify_constructor_super (mdecl))
8843         {
8844           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8845           tree save = DECL_NAME (mdecl);
8846           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8847           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8848           parse_error_context
8849             (lookup_cl (TYPE_NAME (class_type)),
8850              "No constructor matching `%s' found in class `%s'",
8851              lang_printable_name (mdecl, 0), n);
8852           DECL_NAME (mdecl) = save;
8853         }
8854
8855       /* The constructor body must be crafted by hand. It's the
8856          constructor we defined when we realize we didn't have the
8857          CLASSNAME() constructor */
8858       start_artificial_method_body (mdecl);
8859
8860       /* Insert an assignment to the this$<n> hidden field, if
8861          necessary */
8862       if ((thisn_assign = build_thisn_assign ()))
8863         java_method_add_stmt (mdecl, thisn_assign);
8864
8865       /* We don't generate a super constructor invocation if we're
8866          compiling java.lang.Object. build_super_invocation takes care
8867          of that. */
8868       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8869
8870       /* FIXME */
8871       if ((iii = build_instinit_invocation (class_type)))
8872         java_method_add_stmt (mdecl, iii);
8873
8874       end_artificial_method_body (mdecl);
8875     }
8876   /* Search for an explicit constructor invocation */
8877   else
8878     {
8879       int found = 0;
8880       int invokes_this = 0;
8881       tree found_call = NULL_TREE;
8882       tree main_block = BLOCK_EXPR_BODY (body);
8883
8884       while (body)
8885         switch (TREE_CODE (body))
8886           {
8887           case CALL_EXPR:
8888             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8889             if (CALL_THIS_CONSTRUCTOR_P (body))
8890               invokes_this = 1;
8891             body = NULL_TREE;
8892             break;
8893           case COMPOUND_EXPR:
8894           case EXPR_WITH_FILE_LOCATION:
8895             found_call = body;
8896             body = TREE_OPERAND (body, 0);
8897             break;
8898           case BLOCK:
8899             found_call = body;
8900             body = BLOCK_EXPR_BODY (body);
8901             break;
8902           default:
8903             found = 0;
8904             body = NULL_TREE;
8905           }
8906
8907       /* Generate the assignment to this$<n>, if necessary */
8908       if ((thisn_assign = build_thisn_assign ()))
8909         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8910
8911       /* The constructor is missing an invocation of super() */
8912       if (!found)
8913         compound = add_stmt_to_compound (compound, NULL_TREE,
8914                                          build_super_invocation (mdecl));
8915       /* Explicit super() invokation should take place before the
8916          instance initializer blocks. */
8917       else
8918         {
8919           compound = add_stmt_to_compound (compound, NULL_TREE,
8920                                            TREE_OPERAND (found_call, 0));
8921           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8922         }
8923
8924       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8925
8926       /* Insert the instance initializer block right after. */
8927       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8928         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8929
8930       /* Fix the constructor main block if we're adding extra stmts */
8931       if (compound)
8932         {
8933           compound = add_stmt_to_compound (compound, NULL_TREE,
8934                                            BLOCK_EXPR_BODY (main_block));
8935           BLOCK_EXPR_BODY (main_block) = compound;
8936         }
8937     }
8938 }
8939
8940 /* Browse constructors in the super class, searching for a constructor
8941    that doesn't take any argument. Return 0 if one is found, 1
8942    otherwise.  If the current class is an anonymous inner class, look
8943    for something that has the same signature. */
8944
8945 static int
8946 verify_constructor_super (tree mdecl)
8947 {
8948   tree class = CLASSTYPE_SUPER (current_class);
8949   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8950   tree sdecl;
8951
8952   if (!class)
8953     return 0;
8954
8955   if (ANONYMOUS_CLASS_P (current_class))
8956     {
8957       tree mdecl_arg_type;
8958       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8959       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8960         if (DECL_CONSTRUCTOR_P (sdecl))
8961           {
8962             tree m_arg_type;
8963             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8964             if (super_inner)
8965               arg_type = TREE_CHAIN (arg_type);
8966             for (m_arg_type = mdecl_arg_type;
8967                  (arg_type != end_params_node
8968                   && m_arg_type != end_params_node);
8969                  arg_type = TREE_CHAIN (arg_type),
8970                    m_arg_type = TREE_CHAIN (m_arg_type))
8971               if (!valid_method_invocation_conversion_p
8972                      (TREE_VALUE (arg_type),
8973                       TREE_VALUE (m_arg_type)))
8974                 break;
8975
8976             if (arg_type == end_params_node && m_arg_type == end_params_node)
8977               return 0;
8978           }
8979     }
8980   else
8981     {
8982       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8983         {
8984           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8985           if (super_inner)
8986             arg = TREE_CHAIN (arg);
8987           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8988             return 0;
8989         }
8990     }
8991   return 1;
8992 }
8993
8994 /* Generate code for all context remembered for code generation.  */
8995
8996 static GTY(()) tree reversed_class_list;
8997 void
8998 java_expand_classes (void)
8999 {
9000   int save_error_count = 0;
9001   static struct parser_ctxt *cur_ctxp = NULL;
9002
9003   java_parse_abort_on_error ();
9004   if (!(ctxp = ctxp_for_generation))
9005     return;
9006   java_layout_classes ();
9007   java_parse_abort_on_error ();
9008
9009   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9010     {
9011       ctxp = cur_ctxp;
9012       input_filename = ctxp->filename;
9013       lang_init_source (2);            /* Error msgs have method prototypes */
9014       java_complete_expand_classes (); /* Complete and expand classes */
9015       java_parse_abort_on_error ();
9016     }
9017   input_filename = main_input_filename;
9018
9019
9020   /* Find anonymous classes and expand their constructor. This extra pass is
9021      neccessary because the constructor itself is only generated when the
9022      method in which it is defined is expanded. */
9023   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9024     {
9025       tree current;
9026       ctxp = cur_ctxp;
9027       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9028         {
9029           current_class = TREE_TYPE (current);
9030           if (ANONYMOUS_CLASS_P (current_class))
9031             {
9032               tree d;
9033               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9034                 {
9035                   if (DECL_CONSTRUCTOR_P (d))
9036                     {
9037                       restore_line_number_status (1);
9038                       java_complete_expand_method (d);
9039                       restore_line_number_status (0);
9040                       break;    /* There is only one constructor. */
9041                     }
9042                 }
9043             }
9044         }
9045     }
9046
9047   /* Expanding the constructors of anonymous classes generates access
9048      methods.  Scan all the methods looking for null DECL_RESULTs --
9049      this will be the case if a method hasn't been expanded.  */
9050   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9051     {
9052       tree current;
9053       ctxp = cur_ctxp;
9054       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9055         {
9056           tree d;
9057           current_class = TREE_TYPE (current);
9058           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9059             {
9060               if (DECL_RESULT (d) == NULL_TREE)
9061                 {
9062                   restore_line_number_status (1);
9063                   java_complete_expand_method (d);
9064                   restore_line_number_status (0);
9065                 }
9066             }
9067         }
9068     }
9069
9070   /* ???  Instead of all this we could iterate around the list of
9071      classes until there were no more un-expanded methods.  It would
9072      take a little longer -- one pass over the whole list of methods
9073      -- but it would be simpler.  Like this:  */
9074 #if 0
9075     {
9076       int something_changed;
9077
9078       do
9079         {
9080           something_changed = 0;
9081           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9082             {
9083               tree current;
9084               ctxp = cur_ctxp;
9085               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9086                 {
9087                   tree d;
9088                   current_class = TREE_TYPE (current);
9089                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9090                     {
9091                       if (DECL_RESULT (d) == NULL_TREE)
9092                         {
9093                           something_changed = 1;
9094                           restore_line_number_status (1);
9095                           java_complete_expand_method (d);
9096                           restore_line_number_status (0);
9097                         }
9098                     }
9099                 }
9100             }
9101         }
9102       while (something_changed);
9103     }
9104 #endif
9105
9106   /* If we've found error at that stage, don't try to generate
9107      anything, unless we're emitting xrefs or checking the syntax only
9108      (but not using -fsyntax-only for the purpose of generating
9109      bytecode. */
9110   if (java_error_count && !flag_emit_xref
9111       && (!flag_syntax_only && !flag_emit_class_files))
9112     return;
9113
9114   /* Now things are stable, go for generation of the class data. */
9115
9116   /* We pessimistically marked all methods and fields external until
9117      we knew what set of classes we were planning to compile.  Now mark
9118      those that will be generated locally as not external.  */
9119   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9120     {
9121       tree current;
9122       ctxp = cur_ctxp;
9123       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9124         java_mark_class_local (TREE_TYPE (current));
9125     }
9126
9127   /* Compile the classes.  */
9128   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9129     {
9130       tree current;
9131       reversed_class_list = NULL;
9132
9133       ctxp = cur_ctxp;
9134
9135       /* We write out the classes in reverse order.  This ensures that
9136          inner classes are written before their containing classes,
9137          which is important for parallel builds.  Otherwise, the
9138          class file for the outer class may be found, but the class
9139          file for the inner class may not be present.  In that
9140          situation, the compiler cannot fall back to the original
9141          source, having already read the outer class, so we must
9142          prevent that situation.  */
9143       for (current = ctxp->class_list;
9144            current;
9145            current = TREE_CHAIN (current))
9146         reversed_class_list
9147           = tree_cons (NULL_TREE, current, reversed_class_list);
9148
9149       for (current = reversed_class_list;
9150            current;
9151            current = TREE_CHAIN (current))
9152         {
9153           current_class = TREE_TYPE (TREE_VALUE (current));
9154           outgoing_cpool = TYPE_CPOOL (current_class);
9155           if (flag_emit_class_files)
9156             write_classfile (current_class);
9157           if (flag_emit_xref)
9158             expand_xref (current_class);
9159           else if (! flag_syntax_only)
9160             {
9161               java_expand_method_bodies (current_class);
9162               if (!flag_unit_at_a_time)
9163                 finish_class ();
9164             }
9165         }
9166     }
9167 }
9168
9169 void
9170 java_finish_classes (void)
9171 {
9172   static struct parser_ctxt *cur_ctxp = NULL;
9173   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9174     {
9175       tree current;
9176       ctxp = cur_ctxp;
9177       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9178         {
9179           current_class = TREE_TYPE (current);
9180           outgoing_cpool = TYPE_CPOOL (current_class);
9181           finish_class ();
9182         }
9183     }
9184 }
9185
9186 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9187    a tree list node containing RIGHT. Fore coming RIGHTs will be
9188    chained to this hook. LOCATION contains the location of the
9189    separating `.' operator.  */
9190
9191 static tree
9192 make_qualified_primary (tree primary, tree right, int location)
9193 {
9194   tree wfl;
9195
9196   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9197     wfl = build_wfl_wrap (primary, location);
9198   else
9199     {
9200       wfl = primary;
9201       /* If wfl wasn't qualified, we build a first anchor */
9202       if (!EXPR_WFL_QUALIFICATION (wfl))
9203         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9204     }
9205
9206   /* And chain them */
9207   EXPR_WFL_LINECOL (right) = location;
9208   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9209   PRIMARY_P (wfl) =  1;
9210   return wfl;
9211 }
9212
9213 /* Simple merge of two name separated by a `.' */
9214
9215 static tree
9216 merge_qualified_name (tree left, tree right)
9217 {
9218   tree node;
9219   if (!left && !right)
9220     return NULL_TREE;
9221
9222   if (!left)
9223     return right;
9224
9225   if (!right)
9226     return left;
9227
9228   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9229                 IDENTIFIER_LENGTH (left));
9230   obstack_1grow (&temporary_obstack, '.');
9231   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9232                  IDENTIFIER_LENGTH (right));
9233   node =  get_identifier (obstack_base (&temporary_obstack));
9234   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9235   QUALIFIED_P (node) = 1;
9236   return node;
9237 }
9238
9239 /* Merge the two parts of a qualified name into LEFT.  Set the
9240    location information of the resulting node to LOCATION, usually
9241    inherited from the location information of the `.' operator. */
9242
9243 static tree
9244 make_qualified_name (tree left, tree right, int location)
9245 {
9246 #ifdef USE_COMPONENT_REF
9247   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9248   EXPR_WFL_LINECOL (node) = location;
9249   return node;
9250 #else
9251   tree left_id = EXPR_WFL_NODE (left);
9252   tree right_id = EXPR_WFL_NODE (right);
9253   tree wfl, merge;
9254
9255   merge = merge_qualified_name (left_id, right_id);
9256
9257   /* Left wasn't qualified and is now qualified */
9258   if (!QUALIFIED_P (left_id))
9259     {
9260       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9261       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9262       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9263     }
9264
9265   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9266   EXPR_WFL_LINECOL (wfl) = location;
9267   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9268
9269   EXPR_WFL_NODE (left) = merge;
9270   return left;
9271 #endif
9272 }
9273
9274 /* Extract the last identifier component of the qualified in WFL. The
9275    last identifier is removed from the linked list */
9276
9277 static tree
9278 cut_identifier_in_qualified (tree wfl)
9279 {
9280   tree q;
9281   tree previous = NULL_TREE;
9282   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9283     if (!TREE_CHAIN (q))
9284       {
9285         if (!previous)
9286           /* Operating on a non qualified qualified WFL.  */
9287           abort ();
9288
9289         TREE_CHAIN (previous) = NULL_TREE;
9290         return TREE_PURPOSE (q);
9291       }
9292 }
9293
9294 /* Resolve the expression name NAME. Return its decl.  */
9295
9296 static tree
9297 resolve_expression_name (tree id, tree *orig)
9298 {
9299   tree name = EXPR_WFL_NODE (id);
9300   tree decl;
9301
9302   /* 6.5.5.1: Simple expression names */
9303   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9304     {
9305       /* 15.13.1: NAME can appear within the scope of a local variable
9306          declaration */
9307       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9308         return decl;
9309
9310       /* 15.13.1: NAME can appear within a class declaration */
9311       else
9312         {
9313           decl = lookup_field_wrapper (current_class, name);
9314           if (decl)
9315             {
9316               tree access = NULL_TREE;
9317               int fs = FIELD_STATIC (decl);
9318
9319               /* If we're accessing an outer scope local alias, make
9320                  sure we change the name of the field we're going to
9321                  build access to. */
9322               if (FIELD_LOCAL_ALIAS_USED (decl))
9323                 name = DECL_NAME (decl);
9324
9325               check_deprecation (id, decl);
9326
9327               /* Instance variable (8.3.1.1) can't appear within
9328                  static method, static initializer or initializer for
9329                  a static variable. */
9330               if (!fs && METHOD_STATIC (current_function_decl))
9331                 {
9332                   static_ref_err (id, name, current_class);
9333                   return error_mark_node;
9334                 }
9335               /* Instance variables can't appear as an argument of
9336                  an explicit constructor invocation */
9337               if (!fs && ctxp->explicit_constructor_p
9338                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9339                 {
9340                   parse_error_context
9341                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9342                   return error_mark_node;
9343                 }
9344
9345               /* If we're processing an inner class and we're trying
9346                  to access a field belonging to an outer class, build
9347                  the access to the field */
9348               if (!fs && outer_field_access_p (current_class, decl))
9349                 {
9350                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9351                     {
9352                       static_ref_err (id, DECL_NAME (decl), current_class);
9353                       return error_mark_node;
9354                     }
9355                   access = build_outer_field_access (id, decl);
9356                   if (orig)
9357                     *orig = access;
9358                   return access;
9359                 }
9360
9361               /* Otherwise build what it takes to access the field */
9362               access = build_field_ref ((fs ? NULL_TREE : current_this),
9363                                         DECL_CONTEXT (decl), name);
9364               if (fs)
9365                 access = maybe_build_class_init_for_field (decl, access);
9366               /* We may be asked to save the real field access node */
9367               if (orig)
9368                 *orig = access;
9369               /* Last check: can we access the field? */
9370               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9371                 {
9372                   not_accessible_field_error (id, decl);
9373                   return error_mark_node;
9374                 }
9375               /* And we return what we got */
9376               return access;
9377             }
9378           /* Fall down to error report on undefined variable */
9379         }
9380     }
9381   /* 6.5.5.2 Qualified Expression Names */
9382   else
9383     {
9384       if (orig)
9385         *orig = NULL_TREE;
9386       qualify_ambiguous_name (id);
9387       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9388       /* 15.10.2: Accessing Superclass Members using super */
9389       return resolve_field_access (id, orig, NULL);
9390     }
9391
9392   /* We've got an error here */
9393   if (INNER_CLASS_TYPE_P (current_class))
9394     parse_error_context (id,
9395                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9396                          IDENTIFIER_POINTER (name),
9397                          IDENTIFIER_POINTER (DECL_NAME
9398                                              (TYPE_NAME (current_class))));
9399   else
9400     parse_error_context (id, "Undefined variable `%s'",
9401                          IDENTIFIER_POINTER (name));
9402
9403   return error_mark_node;
9404 }
9405
9406 static void
9407 static_ref_err (tree wfl, tree field_id, tree class_type)
9408 {
9409   parse_error_context
9410     (wfl,
9411      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9412      IDENTIFIER_POINTER (field_id),
9413      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9414 }
9415
9416 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9417    We return something suitable to generate the field access. We also
9418    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9419    recipient's address can be null. */
9420
9421 static tree
9422 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9423 {
9424   int is_static = 0;
9425   tree field_ref;
9426   tree decl, where_found, type_found;
9427
9428   if (resolve_qualified_expression_name (qual_wfl, &decl,
9429                                          &where_found, &type_found))
9430     return error_mark_node;
9431
9432   /* Resolve the LENGTH field of an array here */
9433   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9434       && type_found && TYPE_ARRAY_P (type_found)
9435       && ! flag_emit_class_files && ! flag_emit_xref)
9436     {
9437       tree length = build_java_array_length_access (where_found);
9438       field_ref = length;
9439
9440       /* In case we're dealing with a static array, we need to
9441          initialize its class before the array length can be fetched.
9442          It's also a good time to create a DECL_RTL for the field if
9443          none already exists, otherwise if the field was declared in a
9444          class found in an external file and hasn't been (and won't
9445          be) accessed for its value, none will be created. */
9446       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9447         {
9448           build_static_field_ref (where_found);
9449           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9450         }
9451     }
9452   /* We might have been trying to resolve field.method(). In which
9453      case, the resolution is over and decl is the answer */
9454   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9455     field_ref = decl;
9456   else if (JDECL_P (decl))
9457     {
9458       if (!type_found)
9459         type_found = DECL_CONTEXT (decl);
9460       is_static = FIELD_STATIC (decl);
9461       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9462                                     NULL_TREE : where_found),
9463                                    type_found, DECL_NAME (decl));
9464       if (field_ref == error_mark_node)
9465         return error_mark_node;
9466       if (is_static)
9467         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9468
9469       /* If we're looking at a static field, we may need to generate a
9470          class initialization for it.  This can happen when the access
9471          looks like `field.ref', where `field' is a static field in an
9472          interface we implement.  */
9473       if (!flag_emit_class_files
9474           && !flag_emit_xref
9475           && TREE_CODE (where_found) == VAR_DECL
9476           && FIELD_STATIC (where_found))
9477         {
9478           build_static_field_ref (where_found);
9479           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9480         }
9481     }
9482   else
9483     field_ref = decl;
9484
9485   if (field_decl)
9486     *field_decl = decl;
9487   if (field_type)
9488     *field_type = (QUAL_DECL_TYPE (decl) ?
9489                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9490   return field_ref;
9491 }
9492
9493 /* If NODE is an access to f static field, strip out the class
9494    initialization part and return the field decl, otherwise, return
9495    NODE. */
9496
9497 static tree
9498 strip_out_static_field_access_decl (tree node)
9499 {
9500   if (TREE_CODE (node) == COMPOUND_EXPR)
9501     {
9502       tree op1 = TREE_OPERAND (node, 1);
9503       if (TREE_CODE (op1) == COMPOUND_EXPR)
9504          {
9505            tree call = TREE_OPERAND (op1, 0);
9506            if (TREE_CODE (call) == CALL_EXPR
9507                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9508                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9509                == soft_initclass_node)
9510              return TREE_OPERAND (op1, 1);
9511          }
9512       else if (JDECL_P (op1))
9513         return op1;
9514     }
9515   return node;
9516 }
9517
9518 /* 6.5.5.2: Qualified Expression Names */
9519
9520 static int
9521 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9522                                    tree *where_found, tree *type_found)
9523 {
9524   int from_type = 0;            /* Field search initiated from a type */
9525   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9526   int previous_call_static = 0;
9527   int is_static;
9528   tree decl = NULL_TREE, type = NULL_TREE, q;
9529   /* For certain for of inner class instantiation */
9530   tree saved_current, saved_this;
9531 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9532   { current_class = saved_current; current_this = saved_this;}
9533
9534   *type_found = *where_found = NULL_TREE;
9535
9536   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9537     {
9538       tree qual_wfl = QUAL_WFL (q);
9539       tree ret_decl;            /* for EH checking */
9540       int location;             /* for EH checking */
9541
9542       /* 15.10.1 Field Access Using a Primary */
9543       switch (TREE_CODE (qual_wfl))
9544         {
9545         case CALL_EXPR:
9546         case NEW_CLASS_EXPR:
9547           /* If the access to the function call is a non static field,
9548              build the code to access it. */
9549           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9550             {
9551               decl = maybe_access_field (decl, *where_found,
9552                                          DECL_CONTEXT (decl));
9553               if (decl == error_mark_node)
9554                 return 1;
9555             }
9556
9557           /* And code for the function call */
9558           if (complete_function_arguments (qual_wfl))
9559             return 1;
9560
9561           /* We might have to setup a new current class and a new this
9562              for the search of an inner class, relative to the type of
9563              a expression resolved as `decl'. The current values are
9564              saved and restored shortly after */
9565           saved_current = current_class;
9566           saved_this = current_this;
9567           if (decl
9568               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9569                   || from_qualified_this))
9570             {
9571               /* If we still have `from_qualified_this', we have the form
9572                  <T>.this.f() and we need to build <T>.this */
9573               if (from_qualified_this)
9574                 {
9575                   decl = build_access_to_thisn (current_class, type, 0);
9576                   decl = java_complete_tree (decl);
9577                   type = TREE_TYPE (TREE_TYPE (decl));
9578                 }
9579               current_class = type;
9580               current_this = decl;
9581               from_qualified_this = 0;
9582             }
9583
9584           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9585             CALL_USING_SUPER (qual_wfl) = 1;
9586           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9587                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9588           *where_found = patch_method_invocation (qual_wfl, decl, type,
9589                                                   from_super,
9590                                                   &is_static, &ret_decl);
9591           from_super = 0;
9592           if (*where_found == error_mark_node)
9593             {
9594               RESTORE_THIS_AND_CURRENT_CLASS;
9595               return 1;
9596             }
9597           *type_found = type = QUAL_DECL_TYPE (*where_found);
9598
9599           *where_found = force_evaluation_order (*where_found);
9600
9601           /* If we're creating an inner class instance, check for that
9602              an enclosing instance is in scope */
9603           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9604               && INNER_ENCLOSING_SCOPE_CHECK (type))
9605             {
9606               parse_error_context
9607                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9608                  lang_printable_name (type, 0),
9609                  (!current_this ? "" :
9610                   "; an explicit one must be provided when creating this inner class"));
9611               RESTORE_THIS_AND_CURRENT_CLASS;
9612               return 1;
9613             }
9614
9615           /* In case we had to change then to resolve a inner class
9616              instantiation using a primary qualified by a `new' */
9617           RESTORE_THIS_AND_CURRENT_CLASS;
9618
9619           /* EH check. No check on access$<n> functions */
9620           if (location
9621               && !OUTER_FIELD_ACCESS_IDENTIFIER_P
9622                     (DECL_NAME (current_function_decl)))
9623             {
9624               tree arguments = NULL_TREE;
9625               if (TREE_CODE (qual_wfl) == CALL_EXPR
9626                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9627                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9628               check_thrown_exceptions (location, ret_decl, arguments);
9629             }
9630
9631           /* If the previous call was static and this one is too,
9632              build a compound expression to hold the two (because in
9633              that case, previous function calls aren't transported as
9634              forcoming function's argument. */
9635           if (previous_call_static && is_static)
9636             {
9637               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9638                             decl, *where_found);
9639               TREE_SIDE_EFFECTS (decl) = 1;
9640             }
9641           else
9642             {
9643               previous_call_static = is_static;
9644               decl = *where_found;
9645             }
9646           from_type = 0;
9647           continue;
9648
9649         case NEW_ARRAY_EXPR:
9650         case NEW_ANONYMOUS_ARRAY_EXPR:
9651           *where_found = decl = java_complete_tree (qual_wfl);
9652           if (decl == error_mark_node)
9653             return 1;
9654           *type_found = type = QUAL_DECL_TYPE (decl);
9655           continue;
9656
9657         case CONVERT_EXPR:
9658           *where_found = decl = java_complete_tree (qual_wfl);
9659           if (decl == error_mark_node)
9660             return 1;
9661           *type_found = type = QUAL_DECL_TYPE (decl);
9662           from_cast = 1;
9663           continue;
9664
9665         case CONDITIONAL_EXPR:
9666         case STRING_CST:
9667         case MODIFY_EXPR:
9668           *where_found = decl = java_complete_tree (qual_wfl);
9669           if (decl == error_mark_node)
9670             return 1;
9671           *type_found = type = QUAL_DECL_TYPE (decl);
9672           continue;
9673
9674         case ARRAY_REF:
9675           /* If the access to the function call is a non static field,
9676              build the code to access it. */
9677           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9678             {
9679               decl = maybe_access_field (decl, *where_found, type);
9680               if (decl == error_mark_node)
9681                 return 1;
9682             }
9683           /* And code for the array reference expression */
9684           decl = java_complete_tree (qual_wfl);
9685           if (decl == error_mark_node)
9686             return 1;
9687           type = QUAL_DECL_TYPE (decl);
9688           continue;
9689
9690         case PLUS_EXPR:
9691           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9692             return 1;
9693           if ((type = patch_string (decl)))
9694             decl = type;
9695           *where_found = QUAL_RESOLUTION (q) = decl;
9696           *type_found = type = TREE_TYPE (decl);
9697           break;
9698
9699         case CLASS_LITERAL:
9700           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9701             return 1;
9702           *where_found = QUAL_RESOLUTION (q) = decl;
9703           *type_found = type = TREE_TYPE (decl);
9704           break;
9705
9706         default:
9707           /* Fix for -Wall Just go to the next statement. Don't
9708              continue */
9709           break;
9710         }
9711
9712       /* If we fall here, we weren't processing a (static) function call. */
9713       previous_call_static = 0;
9714
9715       /* It can be the keyword THIS */
9716       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9717           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9718         {
9719           if (!current_this)
9720             {
9721               parse_error_context
9722                 (wfl, "Keyword `this' used outside allowed context");
9723               return 1;
9724             }
9725           if (ctxp->explicit_constructor_p
9726               && type == current_class)
9727             {
9728               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9729               return 1;
9730             }
9731           /* We have to generate code for intermediate access */
9732           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9733             {
9734               *where_found = decl = current_this;
9735               *type_found = type = QUAL_DECL_TYPE (decl);
9736             }
9737           /* We're trying to access the this from somewhere else. Make sure
9738              it's allowed before doing so. */
9739           else
9740             {
9741               if (!enclosing_context_p (type, current_class))
9742                 {
9743                   char *p  = xstrdup (lang_printable_name (type, 0));
9744                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9745                                        p, p,
9746                                        lang_printable_name (current_class, 0));
9747                   free (p);
9748                   return 1;
9749                 }
9750               from_qualified_this = 1;
9751               /* If there's nothing else after that, we need to
9752                  produce something now, otherwise, the section of the
9753                  code that needs to produce <T>.this will generate
9754                  what is necessary. */
9755               if (!TREE_CHAIN (q))
9756                 {
9757                   decl = build_access_to_thisn (current_class, type, 0);
9758                   *where_found = decl = java_complete_tree (decl);
9759                   *type_found = type = TREE_TYPE (decl);
9760                 }
9761             }
9762
9763           from_type = 0;
9764           continue;
9765         }
9766
9767       /* 15.10.2 Accessing Superclass Members using SUPER */
9768       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9769           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9770         {
9771           tree node;
9772           /* Check on the restricted use of SUPER */
9773           if (METHOD_STATIC (current_function_decl)
9774               || current_class == object_type_node)
9775             {
9776               parse_error_context
9777                 (wfl, "Keyword `super' used outside allowed context");
9778               return 1;
9779             }
9780           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9781           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9782                              CLASSTYPE_SUPER (current_class),
9783                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9784           *where_found = decl = java_complete_tree (node);
9785           if (decl == error_mark_node)
9786             return 1;
9787           *type_found = type = QUAL_DECL_TYPE (decl);
9788           from_super = from_type = 1;
9789           continue;
9790         }
9791
9792       /* 15.13.1: Can't search for field name in packages, so we
9793          assume a variable/class name was meant. */
9794       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9795         {
9796           tree name;
9797           if ((decl = resolve_package (wfl, &q, &name)))
9798             {
9799               tree list;
9800               *where_found = decl;
9801
9802               /* We want to be absolutely sure that the class is laid
9803                  out. We're going to search something inside it. */
9804               *type_found = type = TREE_TYPE (decl);
9805               layout_class (type);
9806               from_type = 1;
9807
9808               /* Fix them all the way down, if any are left. */
9809               if (q)
9810                 {
9811                   list = TREE_CHAIN (q);
9812                   while (list)
9813                     {
9814                       RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9815                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9816                       list = TREE_CHAIN (list);
9817                     }
9818                 }
9819             }
9820           else
9821             {
9822               if (from_super || from_cast)
9823                 parse_error_context
9824                   ((from_cast ? qual_wfl : wfl),
9825                    "No variable `%s' defined in class `%s'",
9826                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9827                    lang_printable_name (type, 0));
9828               else
9829                 parse_error_context
9830                   (qual_wfl, "Undefined variable or class name: `%s'",
9831                    IDENTIFIER_POINTER (name));
9832               return 1;
9833             }
9834         }
9835
9836       /* We have a type name. It's been already resolved when the
9837          expression was qualified. */
9838       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9839         {
9840           decl = QUAL_RESOLUTION (q);
9841
9842           /* Sneak preview. If next we see a `new', we're facing a
9843              qualification with resulted in a type being selected
9844              instead of a field.  Report the error */
9845           if(TREE_CHAIN (q)
9846              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9847             {
9848               parse_error_context (qual_wfl, "Undefined variable `%s'",
9849                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9850               return 1;
9851             }
9852
9853           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9854             return not_accessible_field_error (qual_wfl, decl);
9855           check_deprecation (qual_wfl, decl);
9856
9857           type = TREE_TYPE (decl);
9858           from_type = 1;
9859         }
9860       /* We resolve an expression name */
9861       else
9862         {
9863           tree field_decl = NULL_TREE;
9864
9865           /* If there exists an early resolution, use it. That occurs
9866              only once and we know that there are more things to
9867              come. Don't do that when processing something after SUPER
9868              (we need more thing to be put in place below */
9869           if (!from_super && QUAL_RESOLUTION (q))
9870             {
9871               decl = QUAL_RESOLUTION (q);
9872               if (!type)
9873                 {
9874                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9875                     {
9876                       if (current_this)
9877                         *where_found = current_this;
9878                       else
9879                         {
9880                           static_ref_err (qual_wfl, DECL_NAME (decl),
9881                                           current_class);
9882                           return 1;
9883                         }
9884                       if (outer_field_access_p (current_class, decl))
9885                         decl = build_outer_field_access (qual_wfl, decl);
9886                     }
9887                   else
9888                     {
9889                       *where_found = TREE_TYPE (decl);
9890                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9891                         *where_found = TREE_TYPE (*where_found);
9892                     }
9893                 }
9894             }
9895
9896           /* Report and error if we're using a numerical litteral as a
9897              qualifier. It can only be an INTEGER_CST. */
9898           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9899             {
9900               parse_error_context
9901                 (wfl, "Can't use type `%s' as a qualifier",
9902                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9903               return 1;
9904             }
9905
9906           /* We have to search for a field, knowing the type of its
9907              container. The flag FROM_TYPE indicates that we resolved
9908              the last member of the expression as a type name, which
9909              means that for the resolution of this field, we'll look
9910              for other errors than if it was resolved as a member of
9911              an other field. */
9912           else
9913             {
9914               int is_static;
9915               tree field_decl_type; /* For layout */
9916
9917               if (!from_type && !JREFERENCE_TYPE_P (type))
9918                 {
9919                   parse_error_context
9920                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9921                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9922                      lang_printable_name (type, 0),
9923                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9924                   return 1;
9925                 }
9926
9927               field_decl = lookup_field_wrapper (type,
9928                                                  EXPR_WFL_NODE (qual_wfl));
9929
9930               /* Maybe what we're trying to access to is an inner
9931                  class, only if decl is a TYPE_DECL. */
9932               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9933                 {
9934                   tree ptr, inner_decl;
9935
9936                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9937                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9938                   if (inner_decl)
9939                     {
9940                       check_inner_class_access (inner_decl, decl, qual_wfl);
9941                       type = TREE_TYPE (inner_decl);
9942                       decl = inner_decl;
9943                       from_type = 1;
9944                       continue;
9945                     }
9946                 }
9947
9948               if (field_decl == NULL_TREE)
9949                 {
9950                   parse_error_context
9951                     (qual_wfl, "No variable `%s' defined in type `%s'",
9952                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9953                      GET_TYPE_NAME (type));
9954                   return 1;
9955                 }
9956               if (field_decl == error_mark_node)
9957                 return 1;
9958
9959               /* Layout the type of field_decl, since we may need
9960                  it. Don't do primitive types or loaded classes. The
9961                  situation of non primitive arrays may not handled
9962                  properly here. FIXME */
9963               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9964                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9965               else
9966                 field_decl_type = TREE_TYPE (field_decl);
9967               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9968                   && !CLASS_LOADED_P (field_decl_type)
9969                   && !TYPE_ARRAY_P (field_decl_type))
9970                 resolve_and_layout (field_decl_type, NULL_TREE);
9971
9972               /* Check on accessibility here */
9973               if (not_accessible_p (current_class, field_decl,
9974                                     DECL_CONTEXT (field_decl), from_super))
9975                 return not_accessible_field_error (qual_wfl,field_decl);
9976               check_deprecation (qual_wfl, field_decl);
9977
9978               /* There are things to check when fields are accessed
9979                  from type. There are no restrictions on a static
9980                  declaration of the field when it is accessed from an
9981                  interface */
9982               is_static = FIELD_STATIC (field_decl);
9983               if (!from_super && from_type
9984                   && !TYPE_INTERFACE_P (type)
9985                   && !is_static
9986                   && (current_function_decl
9987                       && METHOD_STATIC (current_function_decl)))
9988                 {
9989                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9990                   return 1;
9991                 }
9992               from_cast = from_super = 0;
9993
9994               /* It's an access from a type but it isn't static, we
9995                  make it relative to `this'. */
9996               if (!is_static && from_type)
9997                 decl = current_this;
9998
9999               /* If we need to generate something to get a proper
10000                  handle on what this field is accessed from, do it
10001                  now. */
10002               if (!is_static)
10003                 {
10004                   decl = maybe_access_field (decl, *where_found, *type_found);
10005                   if (decl == error_mark_node)
10006                     return 1;
10007                 }
10008
10009               /* We want to keep the location were found it, and the type
10010                  we found. */
10011               *where_found = decl;
10012               *type_found = type;
10013
10014               /* Generate the correct expression for field access from
10015                  qualified this */
10016               if (from_qualified_this)
10017                 {
10018                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10019                   from_qualified_this = 0;
10020                 }
10021
10022               /* This is the decl found and eventually the next one to
10023                  search from */
10024               decl = field_decl;
10025             }
10026           from_type = 0;
10027           type = QUAL_DECL_TYPE (decl);
10028
10029           /* Sneak preview. If decl is qualified by a `new', report
10030              the error here to be accurate on the peculiar construct */
10031           if (TREE_CHAIN (q)
10032               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10033               && !JREFERENCE_TYPE_P (type))
10034             {
10035               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10036                                    lang_printable_name (type, 0));
10037               return 1;
10038             }
10039         }
10040       /* `q' might have changed due to a after package resolution
10041          re-qualification */
10042       if (!q)
10043         break;
10044     }
10045   *found_decl = decl;
10046   return 0;
10047 }
10048
10049 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10050    can't be accessed from REFERENCE (a record type). If MEMBER
10051    features a protected access, we then use WHERE which, if non null,
10052    holds the type of MEMBER's access that is checked against
10053    6.6.2.1. This function should be used when decl is a field or a
10054    method.  */
10055
10056 static int
10057 not_accessible_p (tree reference, tree member, tree where, int from_super)
10058 {
10059   int access_flag = get_access_flags_from_decl (member);
10060
10061   /* Inner classes are processed by check_inner_class_access */
10062   if (INNER_CLASS_TYPE_P (reference))
10063     return 0;
10064
10065   /* Access always granted for members declared public */
10066   if (access_flag & ACC_PUBLIC)
10067     return 0;
10068
10069   /* Check access on protected members */
10070   if (access_flag & ACC_PROTECTED)
10071     {
10072       /* Access granted if it occurs from within the package
10073          containing the class in which the protected member is
10074          declared */
10075       if (class_in_current_package (DECL_CONTEXT (member)))
10076         return 0;
10077
10078       /* If accessed with the form `super.member', then access is granted */
10079       if (from_super)
10080         return 0;
10081
10082       /* If where is active, access was made through a
10083          qualifier. Access is granted if the type of the qualifier is
10084          or is a sublass of the type the access made from (6.6.2.1.)  */
10085       if (where && !inherits_from_p (reference, where))
10086         return 1;
10087
10088       /* Otherwise, access is granted if occurring from the class where
10089          member is declared or a subclass of it. Find the right
10090          context to perform the check */
10091       if (PURE_INNER_CLASS_TYPE_P (reference))
10092         {
10093           while (INNER_CLASS_TYPE_P (reference))
10094             {
10095               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10096                 return 0;
10097               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10098             }
10099         }
10100       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10101         return 0;
10102       return 1;
10103     }
10104
10105   /* Check access on private members. Access is granted only if it
10106      occurs from within the class in which it is declared -- that does
10107      it for innerclasses too. */
10108   if (access_flag & ACC_PRIVATE)
10109     {
10110       if (reference == DECL_CONTEXT (member))
10111         return 0;
10112       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10113         return 0;
10114       return 1;
10115     }
10116
10117   /* Default access are permitted only when occurring within the
10118      package in which the type (REFERENCE) is declared. In other words,
10119      REFERENCE is defined in the current package */
10120   if (ctxp->package)
10121     return !class_in_current_package (reference);
10122
10123   /* Otherwise, access is granted */
10124   return 0;
10125 }
10126
10127 /* Test deprecated decl access.  */
10128 static void
10129 check_deprecation (tree wfl, tree decl)
10130 {
10131   const char *file;
10132   tree elt;
10133
10134   if (! flag_deprecated)
10135     return;
10136
10137   /* We want to look at the element type of arrays here, so we strip
10138      all surrounding array types.  */
10139   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10140     {
10141       elt = TREE_TYPE (decl);
10142       while (TYPE_ARRAY_P (elt))
10143         elt = TYPE_ARRAY_ELEMENT (elt);
10144       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10145          to the record.  */
10146       decl = TYPE_NAME (TREE_TYPE (elt));
10147     }
10148   file = DECL_SOURCE_FILE (decl);
10149
10150   /* Complain if the field is deprecated and the file it was defined
10151      in isn't compiled at the same time the file which contains its
10152      use is */
10153   if (DECL_DEPRECATED (decl)
10154       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10155     {
10156       const char *the;
10157       switch (TREE_CODE (decl))
10158         {
10159         case FUNCTION_DECL:
10160           the = "method";
10161           break;
10162         case FIELD_DECL:
10163         case VAR_DECL:
10164           the = "field";
10165           break;
10166         case TYPE_DECL:
10167           parse_warning_context (wfl, "The class `%s' has been deprecated",
10168                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10169           return;
10170         default:
10171           abort ();
10172         }
10173       /* Don't issue a message if the context as been deprecated as a
10174          whole. */
10175       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10176         parse_warning_context
10177           (wfl, "The %s `%s' in class `%s' has been deprecated",
10178            the, lang_printable_name (decl, 0),
10179            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10180     }
10181 }
10182
10183 /* Returns 1 if class was declared in the current package, 0 otherwise */
10184
10185 static GTY(()) tree cicp_cache;
10186 static int
10187 class_in_current_package (tree class)
10188 {
10189   int qualified_flag;
10190   tree left;
10191
10192   if (cicp_cache == class)
10193     return 1;
10194
10195   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10196
10197   /* If the current package is empty and the name of CLASS is
10198      qualified, class isn't in the current package.  If there is a
10199      current package and the name of the CLASS is not qualified, class
10200      isn't in the current package */
10201   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10202     return 0;
10203
10204   /* If there is not package and the name of CLASS isn't qualified,
10205      they belong to the same unnamed package */
10206   if (!ctxp->package && !qualified_flag)
10207     return 1;
10208
10209   /* Compare the left part of the name of CLASS with the package name */
10210   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10211   if (ctxp->package == left)
10212     {
10213       cicp_cache = class;
10214       return 1;
10215     }
10216   return 0;
10217 }
10218
10219 /* This function may generate code to access DECL from WHERE. This is
10220    done only if certain conditions meet.  */
10221
10222 static tree
10223 maybe_access_field (tree decl, tree where, tree type)
10224 {
10225   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10226       && !FIELD_STATIC (decl))
10227     decl = build_field_ref (where ? where : current_this,
10228                             (type ? type : DECL_CONTEXT (decl)),
10229                             DECL_NAME (decl));
10230   return decl;
10231 }
10232
10233 /* Build a method invocation, by patching PATCH. If non NULL
10234    and according to the situation, PRIMARY and WHERE may be
10235    used. IS_STATIC is set to 1 if the invoked function is static. */
10236
10237 static tree
10238 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10239                          int *is_static, tree *ret_decl)
10240 {
10241   tree wfl = TREE_OPERAND (patch, 0);
10242   tree args = TREE_OPERAND (patch, 1);
10243   tree name = EXPR_WFL_NODE (wfl);
10244   tree list;
10245   int is_static_flag = 0;
10246   int is_super_init = 0;
10247   tree this_arg = NULL_TREE;
10248   int is_array_clone_call = 0;
10249
10250   /* Should be overridden if everything goes well. Otherwise, if
10251      something fails, it should keep this value. It stop the
10252      evaluation of a bogus assignment. See java_complete_tree,
10253      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10254      evaluating an assignment */
10255   TREE_TYPE (patch) = error_mark_node;
10256
10257   /* Since lookup functions are messing with line numbers, save the
10258      context now.  */
10259   java_parser_context_save_global ();
10260
10261   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10262
10263   /* Resolution of qualified name, excluding constructors */
10264   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10265     {
10266       tree identifier, identifier_wfl, type, resolved;
10267       /* Extract the last IDENTIFIER of the qualified
10268          expression. This is a wfl and we will use it's location
10269          data during error report. */
10270       identifier_wfl = cut_identifier_in_qualified (wfl);
10271       identifier = EXPR_WFL_NODE (identifier_wfl);
10272
10273       /* Given the context, IDENTIFIER is syntactically qualified
10274          as a MethodName. We need to qualify what's before */
10275       qualify_ambiguous_name (wfl);
10276       resolved = resolve_field_access (wfl, NULL, NULL);
10277
10278       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10279          && FIELD_FINAL (resolved)
10280          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10281          && !flag_emit_class_files && !flag_emit_xref)
10282        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10283
10284       if (resolved == error_mark_node)
10285         PATCH_METHOD_RETURN_ERROR ();
10286
10287       type = GET_SKIP_TYPE (resolved);
10288       resolve_and_layout (type, NULL_TREE);
10289
10290       if (JPRIMITIVE_TYPE_P (type))
10291         {
10292           parse_error_context
10293             (identifier_wfl,
10294              "Can't invoke a method on primitive type `%s'",
10295              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10296           PATCH_METHOD_RETURN_ERROR ();
10297         }
10298
10299       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10300       args = nreverse (args);
10301
10302       /* We're resolving a call from a type */
10303       if (TREE_CODE (resolved) == TYPE_DECL)
10304         {
10305           if (CLASS_INTERFACE (resolved))
10306             {
10307               parse_error_context
10308                 (identifier_wfl,
10309                 "Can't make static reference to method `%s' in interface `%s'",
10310                  IDENTIFIER_POINTER (identifier),
10311                  IDENTIFIER_POINTER (name));
10312               PATCH_METHOD_RETURN_ERROR ();
10313             }
10314           if (list && !METHOD_STATIC (list))
10315             {
10316               char *fct_name = xstrdup (lang_printable_name (list, 0));
10317               parse_error_context
10318                 (identifier_wfl,
10319                  "Can't make static reference to method `%s %s' in class `%s'",
10320                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10321                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10322               free (fct_name);
10323               PATCH_METHOD_RETURN_ERROR ();
10324             }
10325         }
10326       else
10327         this_arg = primary = resolved;
10328
10329       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10330         is_array_clone_call = 1;
10331
10332       /* IDENTIFIER_WFL will be used to report any problem further */
10333       wfl = identifier_wfl;
10334     }
10335   /* Resolution of simple names, names generated after a primary: or
10336      constructors */
10337   else
10338     {
10339       tree class_to_search = NULL_TREE;
10340       int lc;                   /* Looking for Constructor */
10341
10342       /* We search constructor in their target class */
10343       if (CALL_CONSTRUCTOR_P (patch))
10344         {
10345           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10346             class_to_search = EXPR_WFL_NODE (wfl);
10347           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10348                    this_identifier_node)
10349             class_to_search = NULL_TREE;
10350           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10351                    super_identifier_node)
10352             {
10353               is_super_init = 1;
10354               if (CLASSTYPE_SUPER (current_class))
10355                 class_to_search =
10356                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10357               else
10358                 {
10359                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10360                   PATCH_METHOD_RETURN_ERROR ();
10361                 }
10362             }
10363
10364           /* Class to search is NULL if we're searching the current one */
10365           if (class_to_search)
10366             {
10367               class_to_search = resolve_and_layout (class_to_search, wfl);
10368
10369               if (!class_to_search)
10370                 {
10371                   parse_error_context
10372                     (wfl, "Class `%s' not found in type declaration",
10373                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10374                   PATCH_METHOD_RETURN_ERROR ();
10375                 }
10376
10377               /* Can't instantiate an abstract class, but we can
10378                  invoke it's constructor. It's use within the `new'
10379                  context is denied here. */
10380               if (CLASS_ABSTRACT (class_to_search)
10381                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10382                 {
10383                   parse_error_context
10384                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10385                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10386                   PATCH_METHOD_RETURN_ERROR ();
10387                 }
10388
10389               class_to_search = TREE_TYPE (class_to_search);
10390             }
10391           else
10392             class_to_search = current_class;
10393           lc = 1;
10394         }
10395       /* This is a regular search in the local class, unless an
10396          alternate class is specified. */
10397       else
10398         {
10399           if (where != NULL_TREE)
10400             class_to_search = where;
10401           else if (QUALIFIED_P (name))
10402             class_to_search = current_class;
10403           else
10404             {
10405               class_to_search = current_class;
10406
10407               for (;;)
10408                 {
10409                   if (has_method (class_to_search, name))
10410                     break;
10411                   if (! INNER_CLASS_TYPE_P (class_to_search))
10412                     {
10413                       parse_error_context (wfl,
10414                                            "No method named `%s' in scope",
10415                                            IDENTIFIER_POINTER (name));
10416                       PATCH_METHOD_RETURN_ERROR ();
10417                     }
10418                   class_to_search
10419                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10420                 }
10421             }
10422           lc = 0;
10423         }
10424
10425       /* NAME is a simple identifier or comes from a primary. Search
10426          in the class whose declaration contain the method being
10427          invoked. */
10428       resolve_and_layout (class_to_search, NULL_TREE);
10429
10430       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10431       /* Don't continue if no method were found, as the next statement
10432          can't be executed then. */
10433       if (!list)
10434         PATCH_METHOD_RETURN_ERROR ();
10435
10436       if (TYPE_ARRAY_P (class_to_search)
10437           && DECL_NAME (list) == get_identifier ("clone"))
10438         is_array_clone_call = 1;
10439
10440       /* Check for static reference if non static methods */
10441       if (check_for_static_method_reference (wfl, patch, list,
10442                                              class_to_search, primary))
10443         PATCH_METHOD_RETURN_ERROR ();
10444
10445       /* Check for inner classes creation from illegal contexts */
10446       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10447                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10448           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10449           && !DECL_INIT_P (current_function_decl))
10450         {
10451           parse_error_context
10452             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10453              lang_printable_name (class_to_search, 0),
10454              (!current_this ? "" :
10455               "; an explicit one must be provided when creating this inner class"));
10456           PATCH_METHOD_RETURN_ERROR ();
10457         }
10458
10459       /* Non static methods are called with the current object extra
10460          argument. If patch a `new TYPE()', the argument is the value
10461          returned by the object allocator. If method is resolved as a
10462          primary, use the primary otherwise use the current THIS. */
10463       args = nreverse (args);
10464       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10465         {
10466           this_arg = primary ? primary : current_this;
10467
10468           /* If we're using an access method, things are different.
10469              There are two familly of cases:
10470
10471              1) We're not generating bytecodes:
10472
10473              - LIST is non static. It's invocation is transformed from
10474                x(a1,...,an) into this$<n>.x(a1,....an).
10475              - LIST is static. It's invocation is transformed from
10476                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10477
10478              2) We're generating bytecodes:
10479
10480              - LIST is non static. It's invocation is transformed from
10481                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10482              - LIST is static. It's invocation is transformed from
10483                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10484
10485              Of course, this$<n> can be abitrary complex, ranging from
10486              this$0 (the immediate outer context) to
10487              access$0(access$0(...(this$0))).
10488
10489              maybe_use_access_method returns a nonzero value if the
10490              this_arg has to be moved into the (then generated) stub
10491              argument list. In the meantime, the selected function
10492              might have be replaced by a generated stub. */
10493           if (!primary &&
10494               maybe_use_access_method (is_super_init, &list, &this_arg))
10495             {
10496               args = tree_cons (NULL_TREE, this_arg, args);
10497               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10498             }
10499         }
10500     }
10501
10502   /* Merge point of all resolution schemes. If we have nothing, this
10503      is an error, already signaled */
10504   if (!list)
10505     PATCH_METHOD_RETURN_ERROR ();
10506
10507   /* Check accessibility, position the is_static flag, build and
10508      return the call */
10509   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10510                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10511                          NULL_TREE), from_super)
10512       /* Calls to clone() on array types are permitted as a special-case. */
10513       && !is_array_clone_call)
10514     {
10515       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10516       const char *const access =
10517         java_accstring_lookup (get_access_flags_from_decl (list));
10518       const char *const klass =
10519         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10520       const char *const refklass =
10521         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10522       const char *const what = (DECL_CONSTRUCTOR_P (list)
10523                                 ? "constructor" : "method");
10524       /* FIXME: WFL yields the wrong message here but I don't know
10525          what else to use.  */
10526       parse_error_context (wfl,
10527                            "Can't access %s %s `%s.%s' from `%s'",
10528                            access, what, klass, fct_name, refklass);
10529       PATCH_METHOD_RETURN_ERROR ();
10530     }
10531
10532   /* Deprecation check: check whether the method being invoked or the
10533      instance-being-created's type are deprecated.  */
10534   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10535     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10536   check_deprecation (wfl, list);
10537
10538   /* If invoking a innerclass constructor, there are hidden parameters
10539      to pass */
10540   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10541       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10542     {
10543       /* And make sure we add the accessed local variables to be saved
10544          in field aliases. */
10545       args = build_alias_initializer_parameter_list
10546         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10547
10548       /* Secretly pass the current_this/primary as a second argument */
10549       if (primary || current_this)
10550         {
10551           tree extra_arg;
10552           tree this_type = (current_this ?
10553                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10554           /* Method's (list) enclosing context */
10555           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10556           /* If we have a primary, use it. */
10557           if (primary)
10558             extra_arg = primary;
10559           /* The current `this' is an inner class but isn't a direct
10560              enclosing context for the inner class we're trying to
10561              create. Build an access to the proper enclosing context
10562              and use it. */
10563           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10564                    && this_type != TREE_TYPE (mec))
10565             {
10566
10567               extra_arg = build_access_to_thisn (current_class,
10568                                                  TREE_TYPE (mec), 0);
10569               extra_arg = java_complete_tree (extra_arg);
10570             }
10571           /* Otherwise, just use the current `this' as an enclosing
10572              context. */
10573           else
10574             extra_arg = current_this;
10575           args = tree_cons (NULL_TREE, extra_arg, args);
10576         }
10577       else
10578         args = tree_cons (NULL_TREE, integer_zero_node, args);
10579     }
10580
10581   /* This handles the situation where a constructor invocation needs
10582      to have an enclosing context passed as a second parameter (the
10583      constructor is one of an inner class). */
10584   if ((is_super_init ||
10585        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10586       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10587     {
10588       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10589       tree extra_arg =
10590         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10591       extra_arg = java_complete_tree (extra_arg);
10592       args = tree_cons (NULL_TREE, extra_arg, args);
10593     }
10594
10595   is_static_flag = METHOD_STATIC (list);
10596   if (! is_static_flag && this_arg != NULL_TREE)
10597     args = tree_cons (NULL_TREE, this_arg, args);
10598
10599   /* In the context of an explicit constructor invocation, we can't
10600      invoke any method relying on `this'. Exceptions are: we're
10601      invoking a static function, primary exists and is not the current
10602      this, we're creating a new object. */
10603   if (ctxp->explicit_constructor_p
10604       && !is_static_flag
10605       && (!primary || primary == current_this)
10606       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10607     {
10608       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10609       PATCH_METHOD_RETURN_ERROR ();
10610     }
10611   java_parser_context_restore_global ();
10612   if (is_static)
10613     *is_static = is_static_flag;
10614   /* Sometimes, we want the decl of the selected method. Such as for
10615      EH checking */
10616   if (ret_decl)
10617     *ret_decl = list;
10618   patch = patch_invoke (patch, list, args);
10619
10620   /* Now is a good time to insert the call to finit$ */
10621   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10622     {
10623       tree finit_parms, finit_call;
10624
10625       /* Prepare to pass hidden parameters to finit$, if any. */
10626       finit_parms = build_alias_initializer_parameter_list
10627         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10628
10629       finit_call =
10630         build_method_invocation (build_wfl_node (finit_identifier_node),
10631                                  finit_parms);
10632
10633       /* Generate the code used to initialize fields declared with an
10634          initialization statement and build a compound statement along
10635          with the super constructor invocation. */
10636       CAN_COMPLETE_NORMALLY (patch) = 1;
10637       patch = build (COMPOUND_EXPR, void_type_node, patch,
10638                      java_complete_tree (finit_call));
10639     }
10640   return patch;
10641 }
10642
10643 /* Check that we're not trying to do a static reference to a method in
10644    non static method. Return 1 if it's the case, 0 otherwise. */
10645
10646 static int
10647 check_for_static_method_reference (tree wfl, tree node, tree method,
10648                                    tree where, tree primary)
10649 {
10650   if (METHOD_STATIC (current_function_decl)
10651       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10652     {
10653       char *fct_name = xstrdup (lang_printable_name (method, 0));
10654       parse_error_context
10655         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10656          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10657          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10658       free (fct_name);
10659       return 1;
10660     }
10661   return 0;
10662 }
10663
10664 /* Fix the invocation of *MDECL if necessary in the case of a
10665    invocation from an inner class. *THIS_ARG might be modified
10666    appropriately and an alternative access to *MDECL might be
10667    returned.  */
10668
10669 static int
10670 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10671 {
10672   tree ctx;
10673   tree md = *mdecl, ta = *this_arg;
10674   int to_return = 0;
10675   int non_static_context = !METHOD_STATIC (md);
10676
10677   if (is_super_init
10678       || DECL_CONTEXT (md) == current_class
10679       || !PURE_INNER_CLASS_TYPE_P (current_class)
10680       || DECL_FINIT_P (md)
10681       || DECL_INSTINIT_P (md))
10682     return 0;
10683
10684   /* If we're calling a method found in an enclosing class, generate
10685      what it takes to retrieve the right this. Don't do that if we're
10686      invoking a static method. Note that if MD's type is unrelated to
10687      CURRENT_CLASS, then the current this can be used. */
10688
10689   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10690     {
10691       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10692       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10693         {
10694           ta = build_current_thisn (current_class);
10695           ta = build_wfl_node (ta);
10696         }
10697       else
10698         {
10699           tree type = ctx;
10700           while (type)
10701             {
10702               maybe_build_thisn_access_method (type);
10703               if (inherits_from_p (type, DECL_CONTEXT (md)))
10704                 {
10705                   ta = build_access_to_thisn (ctx, type, 0);
10706                   break;
10707                 }
10708               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10709                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10710             }
10711         }
10712       ta = java_complete_tree (ta);
10713     }
10714
10715   /* We might have to use an access method to get to MD. We can
10716      break the method access rule as far as we're not generating
10717      bytecode */
10718   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10719     {
10720       md = build_outer_method_access_method (md);
10721       to_return = 1;
10722     }
10723
10724   *mdecl = md;
10725   *this_arg = ta;
10726
10727   /* Returnin a nonzero value indicates we were doing a non static
10728      method invokation that is now a static invocation. It will have
10729      callee displace `this' to insert it in the regular argument
10730      list. */
10731   return (non_static_context && to_return);
10732 }
10733
10734 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10735    mode.  */
10736
10737 static tree
10738 patch_invoke (tree patch, tree method, tree args)
10739 {
10740   tree dtable, func;
10741   tree original_call, t, ta;
10742   tree check = NULL_TREE;
10743
10744   /* Last step for args: convert build-in types. If we're dealing with
10745      a new TYPE() type call, the first argument to the constructor
10746      isn't found in the incoming argument list, but delivered by
10747      `new' */
10748   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10749   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10750     t = TREE_CHAIN (t);
10751   for (ta = args; t != end_params_node && ta;
10752        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10753     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10754         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10755       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10756
10757   /* Resolve unresolved returned type isses */
10758   t = TREE_TYPE (TREE_TYPE (method));
10759   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10760     resolve_and_layout (TREE_TYPE (t), NULL);
10761
10762   if (flag_emit_class_files || flag_emit_xref)
10763     func = method;
10764   else
10765     {
10766       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10767         {
10768         case INVOKE_VIRTUAL:
10769           dtable = invoke_build_dtable (0, args);
10770           func = build_invokevirtual (dtable, method);
10771           break;
10772
10773         case INVOKE_NONVIRTUAL:
10774           /* If the object for the method call is null, we throw an
10775              exception.  We don't do this if the object is the current
10776              method's `this'.  In other cases we just rely on an
10777              optimization pass to eliminate redundant checks.  */
10778           if (TREE_VALUE (args) != current_this)
10779             {
10780               /* We use a save_expr here to make sure we only evaluate
10781                  the new `self' expression once.  */
10782               tree save_arg = save_expr (TREE_VALUE (args));
10783               TREE_VALUE (args) = save_arg;
10784               check = java_check_reference (save_arg, 1);
10785             }
10786           /* Fall through.  */
10787
10788         case INVOKE_SUPER:
10789         case INVOKE_STATIC:
10790           {
10791             tree signature = build_java_signature (TREE_TYPE (method));
10792             func = build_known_method_ref (method, TREE_TYPE (method),
10793                                            DECL_CONTEXT (method),
10794                                            signature, args);
10795           }
10796           break;
10797
10798         case INVOKE_INTERFACE:
10799           dtable = invoke_build_dtable (1, args);
10800           func = build_invokeinterface (dtable, method);
10801           break;
10802
10803         default:
10804           abort ();
10805         }
10806
10807       /* Ensure self_type is initialized, (invokestatic). FIXME */
10808       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10809     }
10810
10811   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10812   TREE_OPERAND (patch, 0) = func;
10813   TREE_OPERAND (patch, 1) = args;
10814   patch = check_for_builtin (method, patch);
10815   original_call = patch;
10816
10817   /* We're processing a `new TYPE ()' form. New is called and its
10818      returned value is the first argument to the constructor. We build
10819      a COMPOUND_EXPR and use saved expression so that the overall NEW
10820      expression value is a pointer to a newly created and initialized
10821      class. */
10822   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10823     {
10824       tree class = DECL_CONTEXT (method);
10825       tree c1, saved_new, size, new;
10826       tree alloc_node;
10827
10828       if (flag_emit_class_files || flag_emit_xref)
10829         {
10830           TREE_TYPE (patch) = build_pointer_type (class);
10831           return patch;
10832         }
10833       if (!TYPE_SIZE (class))
10834         safe_layout_class (class);
10835       size = size_in_bytes (class);
10836       alloc_node =
10837         (class_has_finalize_method (class) ? alloc_object_node
10838                                            : alloc_no_finalizer_node);
10839       new = build (CALL_EXPR, promote_type (class),
10840                    build_address_of (alloc_node),
10841                    tree_cons (NULL_TREE, build_class_ref (class),
10842                               build_tree_list (NULL_TREE,
10843                                                size_in_bytes (class))),
10844                    NULL_TREE);
10845       saved_new = save_expr (new);
10846       c1 = build_tree_list (NULL_TREE, saved_new);
10847       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10848       TREE_OPERAND (original_call, 1) = c1;
10849       TREE_SET_CODE (original_call, CALL_EXPR);
10850       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10851     }
10852
10853   /* If CHECK is set, then we are building a check to see if the object
10854      is NULL.  */
10855   if (check != NULL_TREE)
10856     {
10857       /* We have to call force_evaluation_order now because creating a
10858          COMPOUND_EXPR wraps the arg list in a way that makes it
10859          unrecognizable by force_evaluation_order later.  Yuk.  */
10860       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10861                      force_evaluation_order (patch));
10862       TREE_SIDE_EFFECTS (patch) = 1;
10863     }
10864
10865   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10866      put it as the first expression of a COMPOUND_EXPR. The second
10867      expression being an empty statement to be later patched if
10868      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10869      the VALUE is the compound) in a hashtable and return a
10870      COMPOUND_EXPR built so that the result of the evaluation of the
10871      original PATCH node is returned. */
10872   if (STATIC_CLASS_INIT_OPT_P ()
10873       && current_function_decl && METHOD_STATIC (method))
10874     {
10875       tree list;
10876       tree fndecl = current_function_decl;
10877       /* We have to call force_evaluation_order now because creating a
10878          COMPOUND_EXPR wraps the arg list in a way that makes it
10879          unrecognizable by force_evaluation_order later.  Yuk.  */
10880       tree save = save_expr (force_evaluation_order (patch));
10881       tree type = TREE_TYPE (patch);
10882
10883       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10884       list = tree_cons (method, patch,
10885                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10886
10887       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10888
10889       patch = build (COMPOUND_EXPR, type, patch, save);
10890     }
10891
10892   return patch;
10893 }
10894
10895 static int
10896 invocation_mode (tree method, int super)
10897 {
10898   int access = get_access_flags_from_decl (method);
10899
10900   if (super)
10901     return INVOKE_SUPER;
10902
10903   if (access & ACC_STATIC)
10904     return INVOKE_STATIC;
10905
10906   /* We have to look for a constructor before we handle nonvirtual
10907      calls; otherwise the constructor will look nonvirtual.  */
10908   if (DECL_CONSTRUCTOR_P (method))
10909     return INVOKE_STATIC;
10910
10911   if (access & ACC_FINAL || access & ACC_PRIVATE)
10912     return INVOKE_NONVIRTUAL;
10913
10914   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10915     return INVOKE_NONVIRTUAL;
10916
10917   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10918     return INVOKE_INTERFACE;
10919
10920   return INVOKE_VIRTUAL;
10921 }
10922
10923 /* Retrieve a refined list of matching methods. It covers the step
10924    15.11.2 (Compile-Time Step 2) */
10925
10926 static tree
10927 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10928 {
10929   tree atl = end_params_node;           /* Arg Type List */
10930   tree method, signature, list, node;
10931   const char *candidates;               /* Used for error report */
10932   char *dup;
10933
10934   /* Fix the arguments */
10935   for (node = arg_list; node; node = TREE_CHAIN (node))
10936     {
10937       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10938       /* Non primitive type may have to be resolved */
10939       if (!JPRIMITIVE_TYPE_P (current_arg))
10940         resolve_and_layout (current_arg, NULL_TREE);
10941       /* And promoted */
10942       if (TREE_CODE (current_arg) == RECORD_TYPE)
10943         current_arg = promote_type (current_arg);
10944       atl = tree_cons (NULL_TREE, current_arg, atl);
10945     }
10946
10947   /* Presto. If we're dealing with an anonymous class and a
10948      constructor call, generate the right constructor now, since we
10949      know the arguments' types. */
10950
10951   if (lc && ANONYMOUS_CLASS_P (class))
10952     {
10953       tree saved_current_class;
10954       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10955       saved_current_class = current_class;
10956       current_class = class;
10957       fix_constructors (mdecl);
10958       current_class = saved_current_class;
10959     }
10960
10961   /* Find all candidates and then refine the list, searching for the
10962      most specific method. */
10963   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10964   list = find_most_specific_methods_list (list);
10965   if (list && !TREE_CHAIN (list))
10966     return TREE_VALUE (list);
10967
10968   /* Issue an error. List candidates if any. Candidates are listed
10969      only if accessible (non accessible methods may end-up here for
10970      the sake of a better error report). */
10971   candidates = NULL;
10972   if (list)
10973     {
10974       tree current;
10975       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10976       for (current = list; current; current = TREE_CHAIN (current))
10977         {
10978           tree cm = TREE_VALUE (current);
10979           char string [4096];
10980           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10981             continue;
10982           sprintf
10983             (string, "  `%s' in `%s'%s",
10984              get_printable_method_name (cm),
10985              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10986              (TREE_CHAIN (current) ? "\n" : ""));
10987           obstack_grow (&temporary_obstack, string, strlen (string));
10988         }
10989       obstack_1grow (&temporary_obstack, '\0');
10990       candidates = obstack_finish (&temporary_obstack);
10991     }
10992   /* Issue the error message */
10993   method = make_node (FUNCTION_TYPE);
10994   TYPE_ARG_TYPES (method) = atl;
10995   signature = build_java_argument_signature (method);
10996   dup = xstrdup (lang_printable_name (class, 0));
10997   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10998                        (lc ? "constructor" : "method"),
10999                        (lc ? dup : IDENTIFIER_POINTER (name)),
11000                        IDENTIFIER_POINTER (signature), dup,
11001                        (candidates ? candidates : ""));
11002   free (dup);
11003   return NULL_TREE;
11004 }
11005
11006 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11007    when we're looking for a constructor. */
11008
11009 static tree
11010 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11011                                          tree arglist)
11012 {
11013   static htab_t searched_classes;
11014   static int search_not_done = 0;
11015   tree list = NULL_TREE, all_list = NULL_TREE;
11016
11017   /* Check the hash table to determine if this class has been searched
11018      already. */
11019   if (searched_classes)
11020     {
11021       if (htab_find (searched_classes, class) != NULL)
11022         return NULL;
11023     }
11024   else
11025     {
11026       searched_classes = htab_create (10, htab_hash_pointer,
11027                                       htab_eq_pointer, NULL);
11028     }
11029
11030   search_not_done++;
11031   *htab_find_slot (searched_classes, class, INSERT) = class;
11032
11033   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11034     {
11035       load_class (class, 1);
11036       safe_layout_class (class);
11037     }
11038
11039   /* Search interfaces */
11040   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11041       && CLASS_INTERFACE (TYPE_NAME (class)))
11042     {
11043       int i, n;
11044       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11045       search_applicable_methods_list (lc, TYPE_METHODS (class),
11046                                       name, arglist, &list, &all_list);
11047       n = TREE_VEC_LENGTH (basetype_vec);
11048       for (i = 1; i < n; i++)
11049         {
11050           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11051           tree rlist;
11052
11053           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11054                                                            arglist);
11055           list = chainon (rlist, list);
11056         }
11057     }
11058   /* Search classes */
11059   else
11060     {
11061       search_applicable_methods_list (lc, TYPE_METHODS (class),
11062                                       name, arglist, &list, &all_list);
11063
11064       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11065          that we only search in class. Note that we should have found
11066          something at this point. */
11067       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11068         {
11069           lc = 1;
11070           if (!list)
11071             abort ();
11072         }
11073
11074       /* We must search all interfaces of this class */
11075       if (!lc)
11076       {
11077         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11078         int n = TREE_VEC_LENGTH (basetype_vec), i;
11079         for (i = 1; i < n; i++)
11080           {
11081             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11082             if (t != object_type_node)
11083               {
11084                 tree rlist
11085                   = find_applicable_accessible_methods_list (lc, t,
11086                                                              name, arglist);
11087                 list = chainon (rlist, list);
11088               }
11089           }
11090       }
11091
11092       /* Search superclass */
11093       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11094         {
11095           tree rlist;
11096           class = CLASSTYPE_SUPER (class);
11097           rlist = find_applicable_accessible_methods_list (lc, class,
11098                                                            name, arglist);
11099           list = chainon (rlist, list);
11100         }
11101     }
11102
11103   search_not_done--;
11104
11105   /* We're done. Reset the searched classes list and finally search
11106      java.lang.Object if it wasn't searched already. */
11107   if (!search_not_done)
11108     {
11109       if (!lc
11110           && TYPE_METHODS (object_type_node)
11111           && htab_find (searched_classes, object_type_node) == NULL)
11112         {
11113           search_applicable_methods_list (lc,
11114                                           TYPE_METHODS (object_type_node),
11115                                           name, arglist, &list, &all_list);
11116         }
11117       htab_delete (searched_classes);
11118       searched_classes = NULL;
11119     }
11120
11121   /* Either return the list obtained or all selected (but
11122      inaccessible) methods for better error report. */
11123   return (!list ? all_list : list);
11124 }
11125
11126 /* Effectively search for the appropriate method in method */
11127
11128 static void
11129 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11130                                 tree *list, tree *all_list)
11131 {
11132   for (; method; method = TREE_CHAIN (method))
11133     {
11134       /* When dealing with constructor, stop here, otherwise search
11135          other classes */
11136       if (lc && !DECL_CONSTRUCTOR_P (method))
11137         continue;
11138       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11139                        || (DECL_NAME (method) != name)))
11140         continue;
11141
11142       if (argument_types_convertible (method, arglist))
11143         {
11144           /* Retain accessible methods only */
11145           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11146                                  method, NULL_TREE, 0))
11147             *list = tree_cons (NULL_TREE, method, *list);
11148           else
11149             /* Also retain all selected method here */
11150             *all_list = tree_cons (NULL_TREE, method, *list);
11151         }
11152     }
11153 }
11154
11155 /* 15.11.2.2 Choose the Most Specific Method */
11156
11157 static tree
11158 find_most_specific_methods_list (tree list)
11159 {
11160   int max = 0;
11161   int abstract, candidates;
11162   tree current, new_list = NULL_TREE;
11163   for (current = list; current; current = TREE_CHAIN (current))
11164     {
11165       tree method;
11166       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11167
11168       for (method = list; method; method = TREE_CHAIN (method))
11169         {
11170           tree method_v, current_v;
11171           /* Don't test a method against itself */
11172           if (method == current)
11173             continue;
11174
11175           method_v = TREE_VALUE (method);
11176           current_v = TREE_VALUE (current);
11177
11178           /* Compare arguments and location where methods where declared */
11179           if (argument_types_convertible (method_v, current_v))
11180             {
11181               if (valid_method_invocation_conversion_p
11182                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11183                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11184                       && enclosing_context_p (DECL_CONTEXT (method_v),
11185                                               DECL_CONTEXT (current_v))))
11186                 {
11187                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11188                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11189                   max = (v > max ? v : max);
11190                 }
11191             }
11192         }
11193     }
11194
11195   /* Review the list and select the maximally specific methods */
11196   for (current = list, abstract = -1, candidates = -1;
11197        current; current = TREE_CHAIN (current))
11198     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11199       {
11200         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11201         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11202         candidates++;
11203       }
11204
11205   /* If we have several and they're all abstract, just pick the
11206      closest one. */
11207   if (candidates > 0 && candidates == abstract)
11208     {
11209       /* FIXME: merge the throws clauses.  There is no convenient way
11210          to do this in gcj right now, since ideally we'd like to
11211          introduce a new METHOD_DECL here, but that is really not
11212          possible.  */
11213       new_list = nreverse (new_list);
11214       TREE_CHAIN (new_list) = NULL_TREE;
11215       return new_list;
11216     }
11217
11218   /* We have several (we couldn't find a most specific), all but one
11219      are abstract, we pick the only non abstract one. */
11220   if (candidates > 0 && (candidates == abstract+1))
11221     {
11222       for (current = new_list; current; current = TREE_CHAIN (current))
11223         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11224           {
11225             TREE_CHAIN (current) = NULL_TREE;
11226             new_list = current;
11227           }
11228     }
11229
11230   /* If we can't find one, lower expectations and try to gather multiple
11231      maximally specific methods */
11232   while (!new_list && max)
11233     {
11234       while (--max > 0)
11235         {
11236           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11237             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11238         }
11239     }
11240
11241   return new_list;
11242 }
11243
11244 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11245    converted by method invocation conversion (5.3) to the type of the
11246    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11247    to change less often than M1. */
11248
11249 static GTY(()) tree m2_arg_value;
11250 static GTY(()) tree m2_arg_cache;
11251
11252 static int
11253 argument_types_convertible (tree m1, tree m2_or_arglist)
11254 {
11255   register tree m1_arg, m2_arg;
11256
11257   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11258
11259   if (m2_arg_value == m2_or_arglist)
11260     m2_arg = m2_arg_cache;
11261   else
11262     {
11263       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11264          argument types */
11265       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11266         {
11267           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11268           if (!METHOD_STATIC (m2_or_arglist))
11269             m2_arg = TREE_CHAIN (m2_arg);
11270         }
11271       else
11272         m2_arg = m2_or_arglist;
11273
11274       m2_arg_value = m2_or_arglist;
11275       m2_arg_cache = m2_arg;
11276     }
11277
11278   while (m1_arg != end_params_node && m2_arg != end_params_node)
11279     {
11280       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11281       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11282                                                  TREE_VALUE (m2_arg)))
11283         break;
11284       m1_arg = TREE_CHAIN (m1_arg);
11285       m2_arg = TREE_CHAIN (m2_arg);
11286     }
11287   return m1_arg == end_params_node && m2_arg == end_params_node;
11288 }
11289
11290 /* Qualification routines */
11291
11292 static void
11293 qualify_ambiguous_name (tree id)
11294 {
11295   tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
11296     saved_current_class;
11297   int again, super_found = 0, this_found = 0, new_array_found = 0;
11298   int code;
11299
11300   /* We first qualify the first element, then derive qualification of
11301      others based on the first one. If the first element is qualified
11302      by a resolution (field or type), this resolution is stored in the
11303      QUAL_RESOLUTION of the qual element being examined. We need to
11304      save the current_class since the use of SUPER might change the
11305      its value. */
11306   saved_current_class = current_class;
11307   qual = EXPR_WFL_QUALIFICATION (id);
11308   do {
11309
11310     /* Simple qualified expression feature a qual_wfl that is a
11311        WFL. Expression derived from a primary feature more complicated
11312        things like a CALL_EXPR. Expression from primary need to be
11313        worked out to extract the part on which the qualification will
11314        take place. */
11315     qual_wfl = QUAL_WFL (qual);
11316     switch (TREE_CODE (qual_wfl))
11317       {
11318       case CALL_EXPR:
11319         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11320         if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION
11321             || (EXPR_WFL_QUALIFICATION (qual_wfl)
11322                 && TREE_CODE (EXPR_WFL_QUALIFICATION (qual_wfl)) == TREE_LIST))
11323           {
11324             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11325             qual_wfl = QUAL_WFL (qual);
11326           }
11327         break;
11328       case NEW_ARRAY_EXPR:
11329       case NEW_ANONYMOUS_ARRAY_EXPR:
11330         qual = TREE_CHAIN (qual);
11331         again = new_array_found = 1;
11332         continue;
11333       case CONVERT_EXPR:
11334         break;
11335       case NEW_CLASS_EXPR:
11336         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11337         break;
11338       case ARRAY_REF:
11339         while (TREE_CODE (qual_wfl) == ARRAY_REF)
11340           qual_wfl = TREE_OPERAND (qual_wfl, 0);
11341         break;
11342       case STRING_CST:
11343         qual = TREE_CHAIN (qual);
11344         qual_wfl = QUAL_WFL (qual);
11345         break;
11346       case CLASS_LITERAL:
11347         qual = TREE_CHAIN (qual);
11348         qual_wfl = QUAL_WFL (qual);
11349       break;
11350       default:
11351         /* Fix for -Wall. Just break doing nothing */
11352         break;
11353       }
11354
11355     ptr_type = current_class;
11356     again = 0;
11357     code = TREE_CODE (qual_wfl);
11358
11359     /* Pos evaluation: non WFL leading expression nodes */
11360     if (code == CONVERT_EXPR
11361         && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
11362       name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
11363
11364     else if (code == INTEGER_CST)
11365       name = qual_wfl;
11366
11367     else if (code == CONVERT_EXPR &&
11368              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11369       name = TREE_OPERAND (qual_wfl, 0);
11370
11371     else if (code == CONVERT_EXPR
11372              && TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == CALL_EXPR
11373              && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0))
11374                  == EXPR_WITH_FILE_LOCATION))
11375       name = TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0);
11376
11377     else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
11378              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11379       name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
11380
11381     else if (code == TREE_LIST)
11382       name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
11383
11384     else if (code == STRING_CST || code == CONDITIONAL_EXPR
11385              || code == PLUS_EXPR)
11386       {
11387         qual = TREE_CHAIN (qual);
11388         qual_wfl = QUAL_WFL (qual);
11389         again = 1;
11390       }
11391     else
11392       {
11393         name = EXPR_WFL_NODE (qual_wfl);
11394         if (!name)
11395           {
11396             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11397             again = 1;
11398           }
11399       }
11400
11401     /* If we have a THIS (from a primary), we set the context accordingly */
11402     if (name == this_identifier_node)
11403       {
11404         /* This isn't really elegant. One more added irregularity
11405            before I start using COMPONENT_REF (hopefully very soon.)  */
11406         if (TREE_CODE (TREE_PURPOSE (qual)) == ARRAY_REF
11407             && TREE_CODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11408                EXPR_WITH_FILE_LOCATION
11409             && EXPR_WFL_NODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11410                this_identifier_node)
11411             {
11412               qual = TREE_OPERAND (TREE_PURPOSE (qual), 0);
11413               qual = EXPR_WFL_QUALIFICATION (qual);
11414             }
11415         qual = TREE_CHAIN (qual);
11416         qual_wfl = QUAL_WFL (qual);
11417         if (TREE_CODE (qual_wfl) == CALL_EXPR)
11418           again = 1;
11419         else if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION)
11420           name = EXPR_WFL_NODE (qual_wfl);
11421         else if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
11422           name = TREE_OPERAND (qual_wfl, 0);
11423         this_found = 1;
11424       }
11425     /* If we have a SUPER, we set the context accordingly */
11426     if (name == super_identifier_node)
11427       {
11428         current_class = CLASSTYPE_SUPER (ptr_type);
11429         /* Check that there is such a thing as a super class. If not,
11430            return.  The error will be caught later on, during the
11431            resolution */
11432         if (!current_class)
11433           {
11434             current_class = saved_current_class;
11435             return;
11436           }
11437         qual = TREE_CHAIN (qual);
11438         /* Do one more interation to set things up */
11439         super_found = again = 1;
11440       }
11441   } while (again);
11442
11443   /* If name appears within the scope of a local variable declaration
11444      or parameter declaration, then it is an expression name. We don't
11445      carry this test out if we're in the context of the use of SUPER
11446      or THIS */
11447   if (!this_found && !super_found
11448       && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
11449       && (decl = IDENTIFIER_LOCAL_VALUE (name)))
11450     {
11451       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11452       QUAL_RESOLUTION (qual) = decl;
11453     }
11454
11455   /* If within the class/interface NAME was found to be used there
11456      exists a (possibly inherited) field named NAME, then this is an
11457      expression name. If we saw a NEW_ARRAY_EXPR before and want to
11458      address length, it is OK. */
11459   else if ((decl = lookup_field_wrapper (ptr_type, name))
11460            || name == length_identifier_node)
11461     {
11462       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11463       QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
11464     }
11465
11466   /* We reclassify NAME as yielding to a type name resolution if:
11467      - NAME is a class/interface declared within the compilation
11468        unit containing NAME,
11469      - NAME is imported via a single-type-import declaration,
11470      - NAME is declared in an another compilation unit of the package
11471        of the compilation unit containing NAME,
11472      - NAME is declared by exactly on type-import-on-demand declaration
11473      of the compilation unit containing NAME.
11474      - NAME is actually a STRING_CST.
11475      This can't happen if the expression was qualified by `this.' */
11476   else if (! this_found &&
11477            (TREE_CODE (name) == STRING_CST ||
11478             TREE_CODE (name) == INTEGER_CST ||
11479             (decl = resolve_and_layout (name, NULL_TREE))))
11480     {
11481       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11482       QUAL_RESOLUTION (qual) = decl;
11483     }
11484
11485   /* Method call, array references and cast are expression name */
11486   else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
11487            || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
11488            || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR
11489            || TREE_CODE (QUAL_WFL (qual)) == MODIFY_EXPR)
11490     RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11491
11492   /* Check here that NAME isn't declared by more than one
11493      type-import-on-demand declaration of the compilation unit
11494      containing NAME. FIXME */
11495
11496   /* Otherwise, NAME is reclassified as a package name */
11497   else
11498     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11499
11500   /* Propagate the qualification accross other components of the
11501      qualified name */
11502   for (qual = TREE_CHAIN (qual); qual;
11503        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11504     {
11505       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11506         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11507       else
11508         RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
11509     }
11510
11511   /* Store the global qualification for the ambiguous part of ID back
11512      into ID fields */
11513   if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
11514     RESOLVE_EXPRESSION_NAME_P (id) = 1;
11515   else if (RESOLVE_TYPE_NAME_P (qual_wfl))
11516     RESOLVE_TYPE_NAME_P (id) = 1;
11517   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11518     RESOLVE_PACKAGE_NAME_P (id) = 1;
11519
11520   /* Restore the current class */
11521   current_class = saved_current_class;
11522 }
11523
11524 static int
11525 breakdown_qualified (tree *left, tree *right, tree source)
11526 {
11527   char *p, *base;
11528   int l = IDENTIFIER_LENGTH (source);
11529
11530   base = alloca (l + 1);
11531   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11532
11533   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11534   p = base + l - 1;
11535   while (*p != '.' && p != base)
11536     p--;
11537
11538   /* We didn't find a '.'. Return an error.  */
11539   if (p == base)
11540     return 1;
11541
11542   *p = '\0';
11543   if (right)
11544     *right = get_identifier (p+1);
11545   *left = get_identifier (base);
11546
11547   return 0;
11548 }
11549
11550 /* Return TRUE if two classes are from the same package. */
11551
11552 static int
11553 in_same_package (tree name1, tree name2)
11554 {
11555   tree tmp;
11556   tree pkg1;
11557   tree pkg2;
11558
11559   if (TREE_CODE (name1) == TYPE_DECL)
11560     name1 = DECL_NAME (name1);
11561   if (TREE_CODE (name2) == TYPE_DECL)
11562     name2 = DECL_NAME (name2);
11563
11564   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11565     /* One in empty package. */
11566     return 0;
11567
11568   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11569     /* Both in empty package. */
11570     return 1;
11571
11572   breakdown_qualified (&pkg1, &tmp, name1);
11573   breakdown_qualified (&pkg2, &tmp, name2);
11574
11575   return (pkg1 == pkg2);
11576 }
11577
11578 /* Patch tree nodes in a function body. When a BLOCK is found, push
11579    local variable decls if present.
11580    Same as java_complete_lhs, but does resolve static finals to values. */
11581
11582 static tree
11583 java_complete_tree (tree node)
11584 {
11585   node = java_complete_lhs (node);
11586   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11587       && DECL_INITIAL (node) != NULL_TREE
11588       && !flag_emit_xref)
11589     {
11590       tree value = fold_constant_for_init (node, node);
11591       if (value != NULL_TREE)
11592         return value;
11593     }
11594   return node;
11595 }
11596
11597 static tree
11598 java_stabilize_reference (tree node)
11599 {
11600   if (TREE_CODE (node) == COMPOUND_EXPR)
11601     {
11602       tree op0 = TREE_OPERAND (node, 0);
11603       tree op1 = TREE_OPERAND (node, 1);
11604       TREE_OPERAND (node, 0) = save_expr (op0);
11605       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11606       return node;
11607     }
11608   return stabilize_reference (node);
11609 }
11610
11611 /* Patch tree nodes in a function body. When a BLOCK is found, push
11612    local variable decls if present.
11613    Same as java_complete_tree, but does not resolve static finals to values. */
11614
11615 static tree
11616 java_complete_lhs (tree node)
11617 {
11618   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11619   int flag;
11620
11621   /* CONVERT_EXPR always has its type set, even though it needs to be
11622      worked out. */
11623   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11624     return node;
11625
11626   /* The switch block implements cases processing container nodes
11627      first.  Contained nodes are always written back. Leaves come
11628      next and return a value. */
11629   switch (TREE_CODE (node))
11630     {
11631     case BLOCK:
11632
11633       /* 1- Block section.
11634          Set the local values on decl names so we can identify them
11635          faster when they're referenced. At that stage, identifiers
11636          are legal so we don't check for declaration errors. */
11637       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11638         {
11639           DECL_CONTEXT (cn) = current_function_decl;
11640           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11641         }
11642       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11643           CAN_COMPLETE_NORMALLY (node) = 1;
11644       else
11645         {
11646           tree stmt = BLOCK_EXPR_BODY (node);
11647           tree *ptr;
11648           int error_seen = 0;
11649           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11650             {
11651               /* Re-order from (((A; B); C); ...; Z) to
11652                  (A; (B; (C ; (...; Z)))).
11653                  This makes it easier to scan the statements left-to-right
11654                  without using recursion (which might overflow the stack
11655                  if the block has many statements. */
11656               for (;;)
11657                 {
11658                   tree left = TREE_OPERAND (stmt, 0);
11659                   if (TREE_CODE (left) != COMPOUND_EXPR)
11660                     break;
11661                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11662                   TREE_OPERAND (left, 1) = stmt;
11663                   stmt = left;
11664                 }
11665               BLOCK_EXPR_BODY (node) = stmt;
11666             }
11667
11668           /* Now do the actual complete, without deep recursion for
11669              long blocks. */
11670           ptr = &BLOCK_EXPR_BODY (node);
11671           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11672                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11673             {
11674               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11675               tree *next = &TREE_OPERAND (*ptr, 1);
11676               TREE_OPERAND (*ptr, 0) = cur;
11677               if (cur == empty_stmt_node)
11678                 {
11679                   /* Optimization;  makes it easier to detect empty bodies.
11680                      Most useful for <clinit> with all-constant initializer. */
11681                   *ptr = *next;
11682                   continue;
11683                 }
11684               if (TREE_CODE (cur) == ERROR_MARK)
11685                 error_seen++;
11686               else if (! CAN_COMPLETE_NORMALLY (cur))
11687                 {
11688                   wfl_op2 = *next;
11689                   for (;;)
11690                     {
11691                       if (TREE_CODE (wfl_op2) == BLOCK)
11692                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11693                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11694                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11695                       else
11696                         break;
11697                     }
11698                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11699                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11700                     unreachable_stmt_error (*ptr);
11701                 }
11702               if (TREE_TYPE (*ptr) == NULL_TREE)
11703                 TREE_TYPE (*ptr) = void_type_node;
11704               ptr = next;
11705             }
11706           *ptr = java_complete_tree (*ptr);
11707
11708           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11709             return error_mark_node;
11710           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11711         }
11712       /* Turn local bindings to null */
11713       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11714         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11715
11716       TREE_TYPE (node) = void_type_node;
11717       break;
11718
11719       /* 2- They are expressions but ultimately deal with statements */
11720
11721     case THROW_EXPR:
11722       wfl_op1 = TREE_OPERAND (node, 0);
11723       COMPLETE_CHECK_OP_0 (node);
11724       /* 14.19 A throw statement cannot complete normally. */
11725       CAN_COMPLETE_NORMALLY (node) = 0;
11726       return patch_throw_statement (node, wfl_op1);
11727
11728     case SYNCHRONIZED_EXPR:
11729       wfl_op1 = TREE_OPERAND (node, 0);
11730       return patch_synchronized_statement (node, wfl_op1);
11731
11732     case TRY_EXPR:
11733       return patch_try_statement (node);
11734
11735     case TRY_FINALLY_EXPR:
11736       COMPLETE_CHECK_OP_0 (node);
11737       COMPLETE_CHECK_OP_1 (node);
11738       if (TREE_OPERAND (node, 0) == empty_stmt_node)
11739         return TREE_OPERAND (node, 1);
11740       if (TREE_OPERAND (node, 1) == empty_stmt_node)
11741         return TREE_OPERAND (node, 0);
11742       CAN_COMPLETE_NORMALLY (node)
11743         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11744            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11745       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11746       return node;
11747
11748     case LABELED_BLOCK_EXPR:
11749       PUSH_LABELED_BLOCK (node);
11750       if (LABELED_BLOCK_BODY (node))
11751         COMPLETE_CHECK_OP_1 (node);
11752       TREE_TYPE (node) = void_type_node;
11753       POP_LABELED_BLOCK ();
11754
11755       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11756         {
11757           LABELED_BLOCK_BODY (node) = NULL_TREE;
11758           CAN_COMPLETE_NORMALLY (node) = 1;
11759         }
11760       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11761         CAN_COMPLETE_NORMALLY (node) = 1;
11762       return node;
11763
11764     case EXIT_BLOCK_EXPR:
11765       /* We don't complete operand 1, because it's the return value of
11766          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11767       return patch_bc_statement (node);
11768
11769     case CASE_EXPR:
11770       cn = java_complete_tree (TREE_OPERAND (node, 0));
11771       if (cn == error_mark_node)
11772         return cn;
11773
11774       /* First, the case expression must be constant. Values of final
11775          fields are accepted. */
11776       cn = fold (cn);
11777       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11778           && JDECL_P (TREE_OPERAND (cn, 1))
11779           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11780           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11781         {
11782           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11783                                        TREE_OPERAND (cn, 1));
11784         }
11785       /* Accept final locals too. */
11786       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11787         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11788
11789       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11790         {
11791           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11792           parse_error_context (node, "Constant expression required");
11793           return error_mark_node;
11794         }
11795
11796       nn = ctxp->current_loop;
11797
11798       /* It must be assignable to the type of the switch expression. */
11799       if (!try_builtin_assignconv (NULL_TREE,
11800                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11801         {
11802           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11803           parse_error_context
11804             (wfl_operator,
11805              "Incompatible type for case. Can't convert `%s' to `int'",
11806              lang_printable_name (TREE_TYPE (cn), 0));
11807           return error_mark_node;
11808         }
11809
11810       cn = fold (convert (int_type_node, cn));
11811       TREE_CONSTANT_OVERFLOW (cn) = 0;
11812       CAN_COMPLETE_NORMALLY (cn) = 1;
11813
11814       /* Save the label on a list so that we can later check for
11815          duplicates.  */
11816       case_label_list = tree_cons (node, cn, case_label_list);
11817
11818       /* Multiple instance of a case label bearing the same value is
11819          checked later. The case expression is all right so far. */
11820       if (TREE_CODE (cn) == VAR_DECL)
11821         cn = DECL_INITIAL (cn);
11822       TREE_OPERAND (node, 0) = cn;
11823       TREE_TYPE (node) = void_type_node;
11824       CAN_COMPLETE_NORMALLY (node) = 1;
11825       TREE_SIDE_EFFECTS (node) = 1;
11826       break;
11827
11828     case DEFAULT_EXPR:
11829       nn = ctxp->current_loop;
11830       /* Only one default label is allowed per switch statement */
11831       if (SWITCH_HAS_DEFAULT (nn))
11832         {
11833           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11834           parse_error_context (wfl_operator,
11835                                "Duplicate case label: `default'");
11836           return error_mark_node;
11837         }
11838       else
11839         SWITCH_HAS_DEFAULT (nn) = 1;
11840       TREE_TYPE (node) = void_type_node;
11841       TREE_SIDE_EFFECTS (node) = 1;
11842       CAN_COMPLETE_NORMALLY (node) = 1;
11843       break;
11844
11845     case SWITCH_EXPR:
11846     case LOOP_EXPR:
11847       PUSH_LOOP (node);
11848       /* Check whether the loop was enclosed in a labeled
11849          statement. If not, create one, insert the loop in it and
11850          return the node */
11851       nn = patch_loop_statement (node);
11852
11853       /* Anyways, walk the body of the loop */
11854       if (TREE_CODE (node) == LOOP_EXPR)
11855         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11856       /* Switch statement: walk the switch expression and the cases */
11857       else
11858         node = patch_switch_statement (node);
11859
11860       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11861         nn = error_mark_node;
11862       else
11863         {
11864           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11865           /* If we returned something different, that's because we
11866              inserted a label. Pop the label too. */
11867           if (nn != node)
11868             {
11869               if (CAN_COMPLETE_NORMALLY (node))
11870                 CAN_COMPLETE_NORMALLY (nn) = 1;
11871               POP_LABELED_BLOCK ();
11872             }
11873         }
11874       POP_LOOP ();
11875       return nn;
11876
11877     case EXIT_EXPR:
11878       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11879       return patch_exit_expr (node);
11880
11881     case COND_EXPR:
11882       /* Condition */
11883       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11884       if (TREE_OPERAND (node, 0) == error_mark_node)
11885         return error_mark_node;
11886       /* then-else branches */
11887       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11888       if (TREE_OPERAND (node, 1) == error_mark_node)
11889         return error_mark_node;
11890       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11891       if (TREE_OPERAND (node, 2) == error_mark_node)
11892         return error_mark_node;
11893       return patch_if_else_statement (node);
11894       break;
11895
11896     case CONDITIONAL_EXPR:
11897       /* Condition */
11898       wfl_op1 = TREE_OPERAND (node, 0);
11899       COMPLETE_CHECK_OP_0 (node);
11900       wfl_op2 = TREE_OPERAND (node, 1);
11901       COMPLETE_CHECK_OP_1 (node);
11902       wfl_op3 = TREE_OPERAND (node, 2);
11903       COMPLETE_CHECK_OP_2 (node);
11904       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11905
11906       /* 3- Expression section */
11907     case COMPOUND_EXPR:
11908       wfl_op2 = TREE_OPERAND (node, 1);
11909       TREE_OPERAND (node, 0) = nn =
11910         java_complete_tree (TREE_OPERAND (node, 0));
11911       if (wfl_op2 == empty_stmt_node)
11912         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11913       else
11914         {
11915           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11916             {
11917               /* An unreachable condition in a do-while statement
11918                  is *not* (technically) an unreachable statement. */
11919               nn = wfl_op2;
11920               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11921                 nn = EXPR_WFL_NODE (nn);
11922               /* NN can be NULL_TREE exactly when UPDATE is, in
11923                  finish_for_loop.  */
11924               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11925                 {
11926                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11927                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11928                     {
11929                       /* Perhaps this warning should have an
11930                          associated flag.  The code being compiled is
11931                          pedantically correct, but useless.  */
11932                       parse_warning_context (wfl_operator,
11933                                              "Unreachable statement");
11934                     }
11935                   else
11936                     parse_error_context (wfl_operator,
11937                                          "Unreachable statement");
11938                 }
11939             }
11940           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11941           if (TREE_OPERAND (node, 1) == error_mark_node)
11942             return error_mark_node;
11943           /* Even though we might allow the case where the first
11944              operand doesn't return normally, we still should compute
11945              CAN_COMPLETE_NORMALLY correctly.  */
11946           CAN_COMPLETE_NORMALLY (node)
11947             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11948                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11949         }
11950       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11951       break;
11952
11953     case RETURN_EXPR:
11954       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11955       return patch_return (node);
11956
11957     case EXPR_WITH_FILE_LOCATION:
11958       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11959           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11960         {
11961           tree wfl = node;
11962           node = resolve_expression_name (node, NULL);
11963           if (node == error_mark_node)
11964             return node;
11965           /* Keep line number information somewhere were it doesn't
11966              disrupt the completion process. */
11967           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11968             {
11969               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11970               TREE_OPERAND (node, 1) = wfl;
11971             }
11972           CAN_COMPLETE_NORMALLY (node) = 1;
11973         }
11974       else
11975         {
11976           tree body;
11977           int save_lineno = input_line;
11978           input_line = EXPR_WFL_LINENO (node);
11979           body = java_complete_tree (EXPR_WFL_NODE (node));
11980           input_line = save_lineno;
11981           EXPR_WFL_NODE (node) = body;
11982           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11983           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11984           if (body == empty_stmt_node || TREE_CONSTANT (body))
11985             {
11986               /* Makes it easier to constant fold, detect empty bodies. */
11987               return body;
11988             }
11989           if (body == error_mark_node)
11990             {
11991               /* Its important for the evaluation of assignment that
11992                  this mark on the TREE_TYPE is propagated. */
11993               TREE_TYPE (node) = error_mark_node;
11994               return error_mark_node;
11995             }
11996           else
11997             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11998
11999         }
12000       break;
12001
12002     case NEW_ARRAY_EXPR:
12003       /* Patch all the dimensions */
12004       flag = 0;
12005       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12006         {
12007           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
12008           tree dim = convert (int_type_node,
12009                               java_complete_tree (TREE_VALUE (cn)));
12010           if (dim == error_mark_node)
12011             {
12012               flag = 1;
12013               continue;
12014             }
12015           else
12016             {
12017               TREE_VALUE (cn) = dim;
12018               /* Setup the location of the current dimension, for
12019                  later error report. */
12020               TREE_PURPOSE (cn) =
12021                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
12022               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
12023             }
12024         }
12025       /* They complete the array creation expression, if no errors
12026          were found. */
12027       CAN_COMPLETE_NORMALLY (node) = 1;
12028       return (flag ? error_mark_node
12029               : force_evaluation_order (patch_newarray (node)));
12030
12031     case NEW_ANONYMOUS_ARRAY_EXPR:
12032       /* Create the array type if necessary. */
12033       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
12034         {
12035           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
12036           if (!(type = resolve_type_during_patch (type)))
12037             return error_mark_node;
12038           type = build_array_from_name (type, NULL_TREE,
12039                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
12040           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
12041         }
12042       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
12043                                    ANONYMOUS_ARRAY_INITIALIZER (node));
12044       if (node == error_mark_node)
12045         return error_mark_node;
12046       CAN_COMPLETE_NORMALLY (node) = 1;
12047       return node;
12048
12049     case NEW_CLASS_EXPR:
12050     case CALL_EXPR:
12051       /* Complete function's argument(s) first */
12052       if (complete_function_arguments (node))
12053         return error_mark_node;
12054       else
12055         {
12056           tree decl, wfl = TREE_OPERAND (node, 0);
12057           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
12058           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
12059                            super_identifier_node);
12060           tree arguments;
12061
12062           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
12063                                           from_super, 0, &decl);
12064           if (node == error_mark_node)
12065             return error_mark_node;
12066
12067           if (TREE_CODE (node) == CALL_EXPR
12068               && TREE_OPERAND (node, 1) != NULL_TREE)
12069             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
12070           else
12071             arguments = NULL_TREE;
12072           check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl,
12073                                    arguments);
12074           /* If we call this(...), register signature and positions */
12075           if (in_this)
12076             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
12077               tree_cons (wfl, decl,
12078                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
12079           CAN_COMPLETE_NORMALLY (node) = 1;
12080           return force_evaluation_order (node);
12081         }
12082
12083     case MODIFY_EXPR:
12084       /* Save potential wfls */
12085       wfl_op1 = TREE_OPERAND (node, 0);
12086       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
12087
12088       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
12089           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
12090           && DECL_INITIAL (nn) != NULL_TREE)
12091         {
12092           tree value;
12093
12094           value = fold_constant_for_init (nn, nn);
12095
12096           /* When we have a primitype type, or a string and we're not
12097              emitting a class file, we actually don't want to generate
12098              anything for the assignment. */
12099           if (value != NULL_TREE &&
12100               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12101                (TREE_TYPE (value) == string_ptr_type_node &&
12102                 ! flag_emit_class_files)))
12103             {
12104               /* Prepare node for patch_assignment */
12105               TREE_OPERAND (node, 1) = value;
12106               /* Call patch assignment to verify the assignment */
12107               if (patch_assignment (node, wfl_op1) == error_mark_node)
12108                 return error_mark_node;
12109               /* Set DECL_INITIAL properly (a conversion might have
12110                  been decided by patch_assignment) and return the
12111                  empty statement. */
12112               else
12113                 {
12114                   tree patched = patch_string (TREE_OPERAND (node, 1));
12115                   if (patched)
12116                     DECL_INITIAL (nn) = patched;
12117                   else
12118                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12119                   DECL_FIELD_FINAL_IUD (nn) = 1;
12120                   return empty_stmt_node;
12121                 }
12122             }
12123           if (! flag_emit_class_files)
12124             DECL_INITIAL (nn) = NULL_TREE;
12125         }
12126       wfl_op2 = TREE_OPERAND (node, 1);
12127
12128       if (TREE_OPERAND (node, 0) == error_mark_node)
12129         return error_mark_node;
12130
12131       flag = COMPOUND_ASSIGN_P (wfl_op2);
12132       if (flag)
12133         {
12134           /* This might break when accessing outer field from inner
12135              class. TESTME, FIXME */
12136           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12137
12138           /* Hand stabilize the lhs on both places */
12139           TREE_OPERAND (node, 0) = lvalue;
12140           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12141             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12142
12143           /* 15.25.2.a: Left hand is not an array access. FIXME */
12144           /* Now complete the RHS. We write it back later on. */
12145           nn = java_complete_tree (TREE_OPERAND (node, 1));
12146
12147           if ((cn = patch_string (nn)))
12148             nn = cn;
12149
12150           /* The last part of the rewrite for E1 op= E2 is to have
12151              E1 = (T)(E1 op E2), with T being the type of E1. */
12152           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12153                                                TREE_TYPE (lvalue), nn));
12154
12155           /* If the assignment is compound and has reference type,
12156              then ensure the LHS has type String and nothing else.  */
12157           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12158               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12159             parse_error_context (wfl_op2,
12160                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12161                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12162
12163           /* 15.25.2.b: Left hand is an array access. FIXME */
12164         }
12165
12166       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12167          function to complete this RHS. Note that a NEW_ARRAY_INIT
12168          might have been already fully expanded if created as a result
12169          of processing an anonymous array initializer. We avoid doing
12170          the operation twice by testing whether the node already bears
12171          a type. */
12172       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12173         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12174                                    TREE_OPERAND (node, 1));
12175       /* Otherwise we simply complete the RHS */
12176       else
12177         nn = java_complete_tree (TREE_OPERAND (node, 1));
12178
12179       if (nn == error_mark_node)
12180         return error_mark_node;
12181
12182       /* Write back the RHS as we evaluated it. */
12183       TREE_OPERAND (node, 1) = nn;
12184
12185       /* In case we're handling = with a String as a RHS, we need to
12186          produce a String out of the RHS (it might still be a
12187          STRING_CST or a StringBuffer at this stage */
12188       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12189         TREE_OPERAND (node, 1) = nn;
12190
12191       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12192                                         TREE_OPERAND (node, 1))))
12193         {
12194           /* We return error_mark_node if outer_field_access_fix
12195              detects we write into a final. */
12196           if (nn == error_mark_node)
12197             return error_mark_node;
12198           node = nn;
12199         }
12200       else
12201         {
12202           node = patch_assignment (node, wfl_op1);
12203           if (node == error_mark_node)
12204             return error_mark_node;
12205           /* Reorganize the tree if necessary. */
12206           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12207                        || JSTRING_P (TREE_TYPE (node))))
12208             node = java_refold (node);
12209         }
12210
12211       /* Seek to set DECL_INITIAL to a proper value, since it might have
12212          undergone a conversion in patch_assignment. We do that only when
12213          it's necessary to have DECL_INITIAL properly set. */
12214       nn = TREE_OPERAND (node, 0);
12215       if (TREE_CODE (nn) == VAR_DECL
12216           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12217           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12218           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12219               || TREE_TYPE (nn) == string_ptr_type_node))
12220         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12221
12222       CAN_COMPLETE_NORMALLY (node) = 1;
12223       return node;
12224
12225     case MULT_EXPR:
12226     case PLUS_EXPR:
12227     case MINUS_EXPR:
12228     case LSHIFT_EXPR:
12229     case RSHIFT_EXPR:
12230     case URSHIFT_EXPR:
12231     case BIT_AND_EXPR:
12232     case BIT_XOR_EXPR:
12233     case BIT_IOR_EXPR:
12234     case TRUNC_MOD_EXPR:
12235     case TRUNC_DIV_EXPR:
12236     case RDIV_EXPR:
12237     case TRUTH_ANDIF_EXPR:
12238     case TRUTH_ORIF_EXPR:
12239     case EQ_EXPR:
12240     case NE_EXPR:
12241     case GT_EXPR:
12242     case GE_EXPR:
12243     case LT_EXPR:
12244     case LE_EXPR:
12245       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12246          knows how to handle those cases. */
12247       wfl_op1 = TREE_OPERAND (node, 0);
12248       wfl_op2 = TREE_OPERAND (node, 1);
12249
12250       CAN_COMPLETE_NORMALLY (node) = 1;
12251       /* Don't complete string nodes if dealing with the PLUS operand. */
12252       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12253         {
12254           nn = java_complete_tree (wfl_op1);
12255           if (nn == error_mark_node)
12256             return error_mark_node;
12257
12258           TREE_OPERAND (node, 0) = nn;
12259         }
12260       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12261         {
12262           nn = java_complete_tree (wfl_op2);
12263           if (nn == error_mark_node)
12264             return error_mark_node;
12265
12266           TREE_OPERAND (node, 1) = nn;
12267         }
12268       return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
12269
12270     case INSTANCEOF_EXPR:
12271       wfl_op1 = TREE_OPERAND (node, 0);
12272       COMPLETE_CHECK_OP_0 (node);
12273       if (flag_emit_xref)
12274         {
12275           TREE_TYPE (node) = boolean_type_node;
12276           return node;
12277         }
12278       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12279
12280     case UNARY_PLUS_EXPR:
12281     case NEGATE_EXPR:
12282     case TRUTH_NOT_EXPR:
12283     case BIT_NOT_EXPR:
12284     case PREDECREMENT_EXPR:
12285     case PREINCREMENT_EXPR:
12286     case POSTDECREMENT_EXPR:
12287     case POSTINCREMENT_EXPR:
12288     case CONVERT_EXPR:
12289       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12290          how to handle those cases. */
12291       wfl_op1 = TREE_OPERAND (node, 0);
12292       CAN_COMPLETE_NORMALLY (node) = 1;
12293       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12294       if (TREE_OPERAND (node, 0) == error_mark_node)
12295         return error_mark_node;
12296       node = patch_unaryop (node, wfl_op1);
12297       CAN_COMPLETE_NORMALLY (node) = 1;
12298       break;
12299
12300     case ARRAY_REF:
12301       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12302          how to handle those cases. */
12303       wfl_op1 = TREE_OPERAND (node, 0);
12304       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12305       if (TREE_OPERAND (node, 0) == error_mark_node)
12306         return error_mark_node;
12307       if (!flag_emit_class_files && !flag_emit_xref)
12308         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12309       /* The same applies to wfl_op2 */
12310       wfl_op2 = TREE_OPERAND (node, 1);
12311       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12312       if (TREE_OPERAND (node, 1) == error_mark_node)
12313         return error_mark_node;
12314       if (!flag_emit_class_files && !flag_emit_xref)
12315         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12316       return patch_array_ref (node);
12317
12318     case RECORD_TYPE:
12319       return node;;
12320
12321     case COMPONENT_REF:
12322       /* The first step in the re-write of qualified name handling.  FIXME.
12323          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12324       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12325       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12326         {
12327           tree name = TREE_OPERAND (node, 1);
12328           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12329           if (field == NULL_TREE)
12330             {
12331               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12332               return error_mark_node;
12333             }
12334           if (! FIELD_STATIC (field))
12335             {
12336               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12337               return error_mark_node;
12338             }
12339           return field;
12340         }
12341       else
12342         abort ();
12343       break;
12344
12345     case THIS_EXPR:
12346       /* Can't use THIS in a static environment */
12347       if (!current_this)
12348         {
12349           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12350           parse_error_context (wfl_operator,
12351                                "Keyword `this' used outside allowed context");
12352           TREE_TYPE (node) = error_mark_node;
12353           return error_mark_node;
12354         }
12355       if (ctxp->explicit_constructor_p)
12356         {
12357           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12358           parse_error_context
12359             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12360           TREE_TYPE (node) = error_mark_node;
12361           return error_mark_node;
12362         }
12363       return current_this;
12364
12365     case CLASS_LITERAL:
12366       CAN_COMPLETE_NORMALLY (node) = 1;
12367       node = patch_incomplete_class_ref (node);
12368       if (node == error_mark_node)
12369         return error_mark_node;
12370       break;
12371
12372     default:
12373       CAN_COMPLETE_NORMALLY (node) = 1;
12374       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12375          and it's time to turn it into the appropriate String object */
12376       if ((nn = patch_string (node)))
12377         node = nn;
12378       else
12379         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12380     }
12381   return node;
12382 }
12383
12384 /* Complete function call's argument. Return a nonzero value is an
12385    error was found.  */
12386
12387 static int
12388 complete_function_arguments (tree node)
12389 {
12390   int flag = 0;
12391   tree cn;
12392
12393   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12394   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12395     {
12396       tree wfl = TREE_VALUE (cn), parm, temp;
12397       parm = java_complete_tree (wfl);
12398
12399       if (parm == error_mark_node)
12400         {
12401           flag = 1;
12402           continue;
12403         }
12404       /* If have a string literal that we haven't transformed yet or a
12405          crafted string buffer, as a result of use of the the String
12406          `+' operator. Build `parm.toString()' and expand it. */
12407       if ((temp = patch_string (parm)))
12408         parm = temp;
12409
12410       TREE_VALUE (cn) = parm;
12411     }
12412   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12413   return flag;
12414 }
12415
12416 /* Sometimes (for loops and variable initialized during their
12417    declaration), we want to wrap a statement around a WFL and turn it
12418    debugable.  */
12419
12420 static tree
12421 build_debugable_stmt (int location, tree stmt)
12422 {
12423   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12424     {
12425       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12426       EXPR_WFL_LINECOL (stmt) = location;
12427     }
12428   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12429   return stmt;
12430 }
12431
12432 static tree
12433 build_expr_block (tree body, tree decls)
12434
12435 {
12436   tree node = make_node (BLOCK);
12437   BLOCK_EXPR_DECLS (node) = decls;
12438   BLOCK_EXPR_BODY (node) = body;
12439   if (body)
12440     TREE_TYPE (node) = TREE_TYPE (body);
12441   TREE_SIDE_EFFECTS (node) = 1;
12442   return node;
12443 }
12444
12445 /* Create a new function block and link it appropriately to current
12446    function block chain */
12447
12448 static tree
12449 enter_block (void)
12450 {
12451   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12452
12453   /* Link block B supercontext to the previous block. The current
12454      function DECL is used as supercontext when enter_a_block is called
12455      for the first time for a given function. The current function body
12456      (DECL_FUNCTION_BODY) is set to be block B.  */
12457
12458   tree fndecl = current_function_decl;
12459
12460   if (!fndecl) {
12461     BLOCK_SUPERCONTEXT (b) = current_static_block;
12462     current_static_block = b;
12463   }
12464
12465   else if (!DECL_FUNCTION_BODY (fndecl))
12466     {
12467       BLOCK_SUPERCONTEXT (b) = fndecl;
12468       DECL_FUNCTION_BODY (fndecl) = b;
12469     }
12470   else
12471     {
12472       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12473       DECL_FUNCTION_BODY (fndecl) = b;
12474     }
12475   return b;
12476 }
12477
12478 /* Exit a block by changing the current function body
12479    (DECL_FUNCTION_BODY) to the current block super context, only if
12480    the block being exited isn't the method's top level one.  */
12481
12482 static tree
12483 exit_block (void)
12484 {
12485   tree b;
12486   if (current_function_decl)
12487     {
12488       b = DECL_FUNCTION_BODY (current_function_decl);
12489       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12490         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12491     }
12492   else
12493     {
12494       b = current_static_block;
12495
12496       if (BLOCK_SUPERCONTEXT (b))
12497         current_static_block = BLOCK_SUPERCONTEXT (b);
12498     }
12499   return b;
12500 }
12501
12502 /* Lookup for NAME in the nested function's blocks, all the way up to
12503    the current toplevel one. It complies with Java's local variable
12504    scoping rules.  */
12505
12506 static tree
12507 lookup_name_in_blocks (tree name)
12508 {
12509   tree b = GET_CURRENT_BLOCK (current_function_decl);
12510
12511   while (b != current_function_decl)
12512     {
12513       tree current;
12514
12515       /* Paranoid sanity check. To be removed */
12516       if (TREE_CODE (b) != BLOCK)
12517         abort ();
12518
12519       for (current = BLOCK_EXPR_DECLS (b); current;
12520            current = TREE_CHAIN (current))
12521         if (DECL_NAME (current) == name)
12522           return current;
12523       b = BLOCK_SUPERCONTEXT (b);
12524     }
12525   return NULL_TREE;
12526 }
12527
12528 static void
12529 maybe_absorb_scoping_blocks (void)
12530 {
12531   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12532     {
12533       tree b = exit_block ();
12534       java_method_add_stmt (current_function_decl, b);
12535       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12536     }
12537 }
12538
12539 \f
12540 /* This section of the source is reserved to build_* functions that
12541    are building incomplete tree nodes and the patch_* functions that
12542    are completing them.  */
12543
12544 /* Wrap a non WFL node around a WFL.  */
12545
12546 static tree
12547 build_wfl_wrap (tree node, int location)
12548 {
12549   tree wfl, node_to_insert = node;
12550
12551   /* We want to process THIS . xxx symbolicaly, to keep it consistent
12552      with the way we're processing SUPER. A THIS from a primary as a
12553      different form than a SUPER. Turn THIS into something symbolic */
12554   if (TREE_CODE (node) == THIS_EXPR)
12555     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12556   else
12557     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12558
12559   EXPR_WFL_LINECOL (wfl) = location;
12560   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12561   return wfl;
12562 }
12563
12564 /* Build a super() constructor invocation. Returns empty_stmt_node if
12565    we're currently dealing with the class java.lang.Object. */
12566
12567 static tree
12568 build_super_invocation (tree mdecl)
12569 {
12570   if (DECL_CONTEXT (mdecl) == object_type_node)
12571     return empty_stmt_node;
12572   else
12573     {
12574       tree super_wfl = build_wfl_node (super_identifier_node);
12575       tree a = NULL_TREE, t;
12576       /* If we're dealing with an anonymous class, pass the arguments
12577          of the crafted constructor along. */
12578       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12579         {
12580           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12581           for (; t != end_params_node; t = TREE_CHAIN (t))
12582             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12583         }
12584       return build_method_invocation (super_wfl, a);
12585     }
12586 }
12587
12588 /* Build a SUPER/THIS qualified method invocation.  */
12589
12590 static tree
12591 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12592                                        int lloc, int rloc)
12593 {
12594   tree invok;
12595   tree wfl =
12596     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12597   EXPR_WFL_LINECOL (wfl) = lloc;
12598   invok = build_method_invocation (name, args);
12599   return make_qualified_primary (wfl, invok, rloc);
12600 }
12601
12602 /* Build an incomplete CALL_EXPR node. */
12603
12604 static tree
12605 build_method_invocation (tree name, tree args)
12606 {
12607   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12608   TREE_SIDE_EFFECTS (call) = 1;
12609   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12610   return call;
12611 }
12612
12613 /* Build an incomplete new xxx(...) node. */
12614
12615 static tree
12616 build_new_invocation (tree name, tree args)
12617 {
12618   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12619   TREE_SIDE_EFFECTS (call) = 1;
12620   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12621   return call;
12622 }
12623
12624 /* Build an incomplete assignment expression. */
12625
12626 static tree
12627 build_assignment (int op, int op_location, tree lhs, tree rhs)
12628 {
12629   tree assignment;
12630   /* Build the corresponding binop if we deal with a Compound
12631      Assignment operator. Mark the binop sub-tree as part of a
12632      Compound Assignment expression */
12633   if (op != ASSIGN_TK)
12634     {
12635       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12636       COMPOUND_ASSIGN_P (rhs) = 1;
12637     }
12638   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12639   TREE_SIDE_EFFECTS (assignment) = 1;
12640   EXPR_WFL_LINECOL (assignment) = op_location;
12641   return assignment;
12642 }
12643
12644 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12645    the buffer.  This is used only for string conversion.  */
12646 static char *
12647 string_convert_int_cst (tree node)
12648 {
12649   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12650   static char buffer[21];
12651
12652   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12653   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12654   char *p = buffer + sizeof (buffer);
12655   int neg = 0;
12656
12657   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12658                                   << (HOST_BITS_PER_WIDE_INT - 1));
12659
12660   *--p = '\0';
12661
12662   /* If negative, note the fact and negate the value.  */
12663   if ((hi & hibit))
12664     {
12665       lo = ~lo;
12666       hi = ~hi;
12667       if (++lo == 0)
12668         ++hi;
12669       neg = 1;
12670     }
12671
12672   /* Divide by 10 until there are no bits left.  */
12673   do
12674     {
12675       unsigned HOST_WIDE_INT acc = 0;
12676       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12677       unsigned int i;
12678
12679       /* Use long division to compute the result and the remainder.  */
12680       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12681         {
12682           /* Shift a bit into accumulator.  */
12683           acc <<= 1;
12684           if ((hi & hibit))
12685             acc |= 1;
12686
12687           /* Shift the value.  */
12688           hi <<= 1;
12689           if ((lo & hibit))
12690             hi |= 1;
12691           lo <<= 1;
12692
12693           /* Shift the correct bit into the result.  */
12694           outhi <<= 1;
12695           if ((outlo & hibit))
12696             outhi |= 1;
12697           outlo <<= 1;
12698           if (acc >= 10)
12699             {
12700               acc -= 10;
12701               outlo |= 1;
12702             }
12703         }
12704
12705       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12706       *--p = '\060' + acc;
12707
12708       hi = outhi;
12709       lo = outlo;
12710     }
12711   while (hi || lo);
12712
12713   if (neg)
12714     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12715
12716   return p;
12717 }
12718
12719 /* Print an INTEGER_CST node in a static buffer, and return the
12720    buffer.  This is used only for error handling.  */
12721 char *
12722 print_int_node (tree node)
12723 {
12724   static char buffer [80];
12725   if (TREE_CONSTANT_OVERFLOW (node))
12726     sprintf (buffer, "<overflow>");
12727
12728   if (TREE_INT_CST_HIGH (node) == 0)
12729     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12730              TREE_INT_CST_LOW (node));
12731   else if (TREE_INT_CST_HIGH (node) == -1
12732            && TREE_INT_CST_LOW (node) != 0)
12733     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12734              -TREE_INT_CST_LOW (node));
12735   else
12736     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12737              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12738
12739   return buffer;
12740 }
12741
12742 \f
12743 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12744    context.  */
12745
12746 /* 15.25 Assignment operators. */
12747
12748 static tree
12749 patch_assignment (tree node, tree wfl_op1)
12750 {
12751   tree rhs = TREE_OPERAND (node, 1);
12752   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12753   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12754   int error_found = 0;
12755   int lvalue_from_array = 0;
12756   int is_return = 0;
12757
12758   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12759
12760   /* Lhs can be a named variable */
12761   if (JDECL_P (lvalue))
12762     {
12763       lhs_type = TREE_TYPE (lvalue);
12764     }
12765   /* Or Lhs can be an array access. */
12766   else if (TREE_CODE (lvalue) == ARRAY_REF)
12767     {
12768       lhs_type = TREE_TYPE (lvalue);
12769       lvalue_from_array = 1;
12770     }
12771   /* Or a field access */
12772   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12773     lhs_type = TREE_TYPE (lvalue);
12774   /* Or a function return slot */
12775   else if (TREE_CODE (lvalue) == RESULT_DECL)
12776     {
12777       /* If the return type is an integral type, then we create the
12778          RESULT_DECL with a promoted type, but we need to do these
12779          checks against the unpromoted type to ensure type safety.  So
12780          here we look at the real type, not the type of the decl we
12781          are modifying.  */
12782       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12783       is_return = 1;
12784     }
12785   /* Otherwise, we might want to try to write into an optimized static
12786      final, this is an of a different nature, reported further on. */
12787   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12788            && resolve_expression_name (wfl_op1, &llvalue))
12789     {
12790       lhs_type = TREE_TYPE (lvalue);
12791     }
12792   else
12793     {
12794       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12795       error_found = 1;
12796     }
12797
12798   rhs_type = TREE_TYPE (rhs);
12799
12800   /* 5.1 Try the assignment conversion for builtin type. */
12801   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12802
12803   /* 5.2 If it failed, try a reference conversion */
12804   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
12805     lhs_type = promote_type (rhs_type);
12806
12807   /* 15.25.2 If we have a compound assignment, convert RHS into the
12808      type of the LHS */
12809   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12810     new_rhs = convert (lhs_type, rhs);
12811
12812   /* Explicit cast required. This is an error */
12813   if (!new_rhs)
12814     {
12815       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12816       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12817       tree wfl;
12818       char operation [32];      /* Max size known */
12819
12820       /* If the assignment is part of a declaration, we use the WFL of
12821          the declared variable to point out the error and call it a
12822          declaration problem. If the assignment is a genuine =
12823          operator, we call is a operator `=' problem, otherwise we
12824          call it an assignment problem. In both of these last cases,
12825          we use the WFL of the operator to indicate the error. */
12826
12827       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12828         {
12829           wfl = wfl_op1;
12830           strcpy (operation, "declaration");
12831         }
12832       else
12833         {
12834           wfl = wfl_operator;
12835           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12836             strcpy (operation, "assignment");
12837           else if (is_return)
12838             strcpy (operation, "`return'");
12839           else
12840             strcpy (operation, "`='");
12841         }
12842
12843       if (!valid_cast_to_p (rhs_type, lhs_type))
12844         parse_error_context
12845           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12846            operation, t1, t2);
12847       else
12848         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12849                              operation, t1, t2);
12850       free (t1); free (t2);
12851       error_found = 1;
12852     }
12853
12854   if (error_found)
12855     return error_mark_node;
12856
12857   /* If we're processing a `return' statement, promote the actual type
12858      to the promoted type.  */
12859   if (is_return)
12860     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12861
12862   /* 10.10: Array Store Exception runtime check */
12863   if (!flag_emit_class_files
12864       && !flag_emit_xref
12865       && lvalue_from_array
12866       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12867     {
12868       tree array, store_check, base, index_expr;
12869
12870       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12871       new_rhs = save_expr (new_rhs);
12872
12873       /* Get the INDIRECT_REF. */
12874       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12875       /* Get the array pointer expr. */
12876       array = TREE_OPERAND (array, 0);
12877       store_check = build_java_arraystore_check (array, new_rhs);
12878
12879       index_expr = TREE_OPERAND (lvalue, 1);
12880
12881       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12882         {
12883           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12884              happen before the store check, so prepare to insert the store
12885              check within the second operand of the existing COMPOUND_EXPR. */
12886           base = index_expr;
12887         }
12888       else
12889         base = lvalue;
12890
12891       index_expr = TREE_OPERAND (base, 1);
12892       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12893                                       store_check, index_expr);
12894     }
12895
12896   /* Final locals can be used as case values in switch
12897      statement. Prepare them for this eventuality. */
12898   if (TREE_CODE (lvalue) == VAR_DECL
12899       && DECL_FINAL (lvalue)
12900       && TREE_CONSTANT (new_rhs)
12901       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12902       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12903       )
12904     {
12905       TREE_CONSTANT (lvalue) = 1;
12906       DECL_INITIAL (lvalue) = new_rhs;
12907     }
12908
12909   /* Copy the rhs if it's a reference.  */
12910   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12911     {
12912       switch (TREE_CODE (new_rhs))
12913         {
12914         case ARRAY_REF:
12915         case INDIRECT_REF:
12916         case COMPONENT_REF:
12917           /* Transform a = foo.bar
12918              into a = { int tmp; tmp = foo.bar; tmp; ).
12919              We need to ensure that if a read from memory fails
12920              because of a NullPointerException, a destination variable
12921              will remain unchanged.  An explicit temporary does what
12922              we need.
12923
12924              If flag_check_references is set, this is unnecessary
12925              because we'll check each reference before doing any
12926              reads.  If optimize is not set the result will never be
12927              written to a stack slot that contains the LHS.  */
12928           {
12929             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12930                                    TREE_TYPE (new_rhs));
12931             tree block = build (BLOCK, TREE_TYPE (new_rhs), NULL);
12932             tree assignment
12933               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12934             DECL_CONTEXT (tmp) = current_function_decl;
12935             BLOCK_VARS (block) = tmp;
12936             BLOCK_EXPR_BODY (block)
12937               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12938             TREE_SIDE_EFFECTS (block) = 1;
12939             new_rhs = block;
12940           }
12941           break;
12942         default:
12943           break;
12944         }
12945     }
12946
12947   TREE_OPERAND (node, 0) = lvalue;
12948   TREE_OPERAND (node, 1) = new_rhs;
12949   TREE_TYPE (node) = lhs_type;
12950   return node;
12951 }
12952
12953 /* Check that type SOURCE can be cast into type DEST. If the cast
12954    can't occur at all, return NULL; otherwise, return a possibly
12955    modified rhs.  */
12956
12957 static tree
12958 try_reference_assignconv (tree lhs_type, tree rhs)
12959 {
12960   tree new_rhs = NULL_TREE;
12961   tree rhs_type = TREE_TYPE (rhs);
12962
12963   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12964     {
12965       /* `null' may be assigned to any reference type */
12966       if (rhs == null_pointer_node)
12967         new_rhs = null_pointer_node;
12968       /* Try the reference assignment conversion */
12969       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12970         new_rhs = rhs;
12971       /* This is a magic assignment that we process differently */
12972       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12973         new_rhs = rhs;
12974     }
12975   return new_rhs;
12976 }
12977
12978 /* Check that RHS can be converted into LHS_TYPE by the assignment
12979    conversion (5.2), for the cases of RHS being a builtin type. Return
12980    NULL_TREE if the conversion fails or if because RHS isn't of a
12981    builtin type. Return a converted RHS if the conversion is possible.  */
12982
12983 static tree
12984 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12985 {
12986   tree new_rhs = NULL_TREE;
12987   tree rhs_type = TREE_TYPE (rhs);
12988
12989   /* Handle boolean specially.  */
12990   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12991       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12992     {
12993       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12994           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12995         new_rhs = rhs;
12996     }
12997
12998   /* 5.1.1 Try Identity Conversion,
12999      5.1.2 Try Widening Primitive Conversion */
13000   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
13001     new_rhs = convert (lhs_type, rhs);
13002
13003   /* Try a narrowing primitive conversion (5.1.3):
13004        - expression is a constant expression of type byte, short, char,
13005          or int, AND
13006        - variable is byte, short or char AND
13007        - The value of the expression is representable in the type of the
13008          variable */
13009   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
13010             || rhs_type == char_type_node || rhs_type == int_type_node)
13011             && TREE_CONSTANT (rhs)
13012            && (lhs_type == byte_type_node || lhs_type == char_type_node
13013                || lhs_type == short_type_node))
13014     {
13015       if (int_fits_type_p (rhs, lhs_type))
13016         new_rhs = convert (lhs_type, rhs);
13017       else if (wfl_op1)         /* Might be called with a NULL */
13018         parse_warning_context
13019           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
13020            print_int_node (rhs), lang_printable_name (lhs_type, 0));
13021       /* Reported a warning that will turn into an error further
13022          down, so we don't return */
13023     }
13024
13025   return new_rhs;
13026 }
13027
13028 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
13029    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
13030    0 is the conversion test fails.  This implements parts the method
13031    invocation convertion (5.3).  */
13032
13033 static int
13034 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
13035 {
13036   /* 5.1.1: This is the identity conversion part. */
13037   if (lhs_type == rhs_type)
13038     return 1;
13039
13040   /* Reject non primitive types and boolean conversions.  */
13041   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
13042     return 0;
13043
13044   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
13045      than a char can't be converted into a char. Short can't too, but
13046      the < test below takes care of that */
13047   if (lhs_type == char_type_node && rhs_type == byte_type_node)
13048     return 0;
13049
13050   /* Accept all promoted type here. Note, we can't use <= in the test
13051      below, because we still need to bounce out assignments of short
13052      to char and the likes */
13053   if (lhs_type == int_type_node
13054       && (rhs_type == promoted_byte_type_node
13055           || rhs_type == promoted_short_type_node
13056           || rhs_type == promoted_char_type_node
13057           || rhs_type == promoted_boolean_type_node))
13058     return 1;
13059
13060   /* From here, an integral is widened if its precision is smaller
13061      than the precision of the LHS or if the LHS is a floating point
13062      type, or the RHS is a float and the RHS a double. */
13063   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
13064        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
13065       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
13066       || (rhs_type == float_type_node && lhs_type == double_type_node))
13067     return 1;
13068
13069   return 0;
13070 }
13071
13072 /* Check that something of SOURCE type can be assigned or cast to
13073    something of DEST type at runtime. Return 1 if the operation is
13074    valid, 0 otherwise. If CAST is set to 1, we're treating the case
13075    were SOURCE is cast into DEST, which borrows a lot of the
13076    assignment check. */
13077
13078 static int
13079 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
13080 {
13081   /* SOURCE or DEST might be null if not from a declared entity. */
13082   if (!source || !dest)
13083     return 0;
13084   if (JNULLP_TYPE_P (source))
13085     return 1;
13086   if (TREE_CODE (source) == POINTER_TYPE)
13087     source = TREE_TYPE (source);
13088   if (TREE_CODE (dest) == POINTER_TYPE)
13089     dest = TREE_TYPE (dest);
13090
13091   /* If source and dest are being compiled from bytecode, they may need to
13092      be loaded. */
13093   if (CLASS_P (source) && !CLASS_LOADED_P (source))
13094     {
13095       load_class (source, 1);
13096       safe_layout_class (source);
13097     }
13098   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
13099     {
13100       load_class (dest, 1);
13101       safe_layout_class (dest);
13102     }
13103
13104   /* Case where SOURCE is a class type */
13105   if (TYPE_CLASS_P (source))
13106     {
13107       if (TYPE_CLASS_P (dest))
13108         return  (source == dest
13109                  || inherits_from_p (source, dest)
13110                  || (cast && inherits_from_p (dest, source)));
13111       if (TYPE_INTERFACE_P (dest))
13112         {
13113           /* If doing a cast and SOURCE is final, the operation is
13114              always correct a compile time (because even if SOURCE
13115              does not implement DEST, a subclass of SOURCE might). */
13116           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13117             return 1;
13118           /* Otherwise, SOURCE must implement DEST */
13119           return interface_of_p (dest, source);
13120         }
13121       /* DEST is an array, cast permited if SOURCE is of Object type */
13122       return (cast && source == object_type_node ? 1 : 0);
13123     }
13124   if (TYPE_INTERFACE_P (source))
13125     {
13126       if (TYPE_CLASS_P (dest))
13127         {
13128           /* If not casting, DEST must be the Object type */
13129           if (!cast)
13130             return dest == object_type_node;
13131           /* We're doing a cast. The cast is always valid is class
13132              DEST is not final, otherwise, DEST must implement SOURCE */
13133           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13134             return 1;
13135           else
13136             return interface_of_p (source, dest);
13137         }
13138       if (TYPE_INTERFACE_P (dest))
13139         {
13140           /* If doing a cast, then if SOURCE and DEST contain method
13141              with the same signature but different return type, then
13142              this is a (compile time) error */
13143           if (cast)
13144             {
13145               tree method_source, method_dest;
13146               tree source_type;
13147               tree source_sig;
13148               tree source_name;
13149               for (method_source = TYPE_METHODS (source); method_source;
13150                    method_source = TREE_CHAIN (method_source))
13151                 {
13152                   source_sig =
13153                     build_java_argument_signature (TREE_TYPE (method_source));
13154                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13155                   source_name = DECL_NAME (method_source);
13156                   for (method_dest = TYPE_METHODS (dest);
13157                        method_dest; method_dest = TREE_CHAIN (method_dest))
13158                     if (source_sig ==
13159                         build_java_argument_signature (TREE_TYPE (method_dest))
13160                         && source_name == DECL_NAME (method_dest)
13161                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13162                       return 0;
13163                 }
13164               return 1;
13165             }
13166           else
13167             return source == dest || interface_of_p (dest, source);
13168         }
13169       else
13170         {
13171           /* Array */
13172           return (cast
13173                   && (DECL_NAME (TYPE_NAME (source))
13174                       == java_lang_cloneable_identifier_node
13175                       || (DECL_NAME (TYPE_NAME (source))
13176                           == java_io_serializable_identifier_node)));
13177         }
13178     }
13179   if (TYPE_ARRAY_P (source))
13180     {
13181       if (TYPE_CLASS_P (dest))
13182         return dest == object_type_node;
13183       /* Can't cast an array to an interface unless the interface is
13184          java.lang.Cloneable or java.io.Serializable.  */
13185       if (TYPE_INTERFACE_P (dest))
13186         return (DECL_NAME (TYPE_NAME (dest))
13187                 == java_lang_cloneable_identifier_node
13188                 || (DECL_NAME (TYPE_NAME (dest))
13189                     == java_io_serializable_identifier_node));
13190       else                      /* Arrays */
13191         {
13192           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13193           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13194
13195           /* In case of severe errors, they turn out null */
13196           if (!dest_element_type || !source_element_type)
13197             return 0;
13198           if (source_element_type == dest_element_type)
13199             return 1;
13200           return valid_ref_assignconv_cast_p (source_element_type,
13201                                               dest_element_type, cast);
13202         }
13203       return 0;
13204     }
13205   return 0;
13206 }
13207
13208 static int
13209 valid_cast_to_p (tree source, tree dest)
13210 {
13211   if (TREE_CODE (source) == POINTER_TYPE)
13212     source = TREE_TYPE (source);
13213   if (TREE_CODE (dest) == POINTER_TYPE)
13214     dest = TREE_TYPE (dest);
13215
13216   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13217     return valid_ref_assignconv_cast_p (source, dest, 1);
13218
13219   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13220     return 1;
13221
13222   else if (TREE_CODE (source) == BOOLEAN_TYPE
13223            && TREE_CODE (dest) == BOOLEAN_TYPE)
13224     return 1;
13225
13226   return 0;
13227 }
13228
13229 static tree
13230 do_unary_numeric_promotion (tree arg)
13231 {
13232   tree type = TREE_TYPE (arg);
13233   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13234       || TREE_CODE (type) == CHAR_TYPE)
13235     arg = convert (int_type_node, arg);
13236   return arg;
13237 }
13238
13239 /* Return a nonzero value if SOURCE can be converted into DEST using
13240    the method invocation conversion rule (5.3).  */
13241 static int
13242 valid_method_invocation_conversion_p (tree dest, tree source)
13243 {
13244   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13245            && valid_builtin_assignconv_identity_widening_p (dest, source))
13246           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13247               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13248               && valid_ref_assignconv_cast_p (source, dest, 0)));
13249 }
13250
13251 /* Build an incomplete binop expression. */
13252
13253 static tree
13254 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13255 {
13256   tree binop = build (op, NULL_TREE, op1, op2);
13257   TREE_SIDE_EFFECTS (binop) = 1;
13258   /* Store the location of the operator, for better error report. The
13259      string of the operator will be rebuild based on the OP value. */
13260   EXPR_WFL_LINECOL (binop) = op_location;
13261   return binop;
13262 }
13263
13264 /* Build the string of the operator retained by NODE. If NODE is part
13265    of a compound expression, add an '=' at the end of the string. This
13266    function is called when an error needs to be reported on an
13267    operator. The string is returned as a pointer to a static character
13268    buffer. */
13269
13270 static char *
13271 operator_string (tree node)
13272 {
13273 #define BUILD_OPERATOR_STRING(S)                                        \
13274   {                                                                     \
13275     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13276     return buffer;                                                      \
13277   }
13278
13279   static char buffer [10];
13280   switch (TREE_CODE (node))
13281     {
13282     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13283     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13284     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13285     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13286     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13287     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13288     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13289     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13290     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13291     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13292     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13293     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13294     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13295     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13296     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13297     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13298     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13299     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13300     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13301     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13302     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13303     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13304     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13305     case PREINCREMENT_EXPR:     /* Fall through */
13306     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13307     case PREDECREMENT_EXPR:     /* Fall through */
13308     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13309     default:
13310       internal_error ("unregistered operator %s",
13311                       tree_code_name [TREE_CODE (node)]);
13312     }
13313   return NULL;
13314 #undef BUILD_OPERATOR_STRING
13315 }
13316
13317 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13318
13319 static int
13320 java_decl_equiv (tree var_acc1, tree var_acc2)
13321 {
13322   if (JDECL_P (var_acc1))
13323     return (var_acc1 == var_acc2);
13324
13325   return (TREE_CODE (var_acc1) == COMPONENT_REF
13326           && TREE_CODE (var_acc2) == COMPONENT_REF
13327           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13328              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13329           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13330 }
13331
13332 /* Return a nonzero value if CODE is one of the operators that can be
13333    used in conjunction with the `=' operator in a compound assignment.  */
13334
13335 static int
13336 binop_compound_p (enum tree_code code)
13337 {
13338   int i;
13339   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13340     if (binop_lookup [i] == code)
13341       break;
13342
13343   return i < BINOP_COMPOUND_CANDIDATES;
13344 }
13345
13346 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13347
13348 static tree
13349 java_refold (tree t)
13350 {
13351   tree c, b, ns, decl;
13352
13353   if (TREE_CODE (t) != MODIFY_EXPR)
13354     return t;
13355
13356   c = TREE_OPERAND (t, 1);
13357   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13358          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13359          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13360     return t;
13361
13362   /* Now the left branch of the binary operator. */
13363   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13364   if (! (b && TREE_CODE (b) == NOP_EXPR
13365          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13366     return t;
13367
13368   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13369   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13370          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13371     return t;
13372
13373   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13374   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13375       /* It's got to be the an equivalent decl */
13376       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13377     {
13378       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13379       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13380       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13381       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13382       /* Change the right part of the BINOP_EXPR */
13383       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13384     }
13385
13386   return t;
13387 }
13388
13389 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13390    errors but we modify NODE so that it contains the type computed
13391    according to the expression, when it's fixed. Otherwise, we write
13392    error_mark_node as the type. It allows us to further the analysis
13393    of remaining nodes and detects more errors in certain cases.  */
13394
13395 static tree
13396 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13397 {
13398   tree op1 = TREE_OPERAND (node, 0);
13399   tree op2 = TREE_OPERAND (node, 1);
13400   tree op1_type = TREE_TYPE (op1);
13401   tree op2_type = TREE_TYPE (op2);
13402   tree prom_type = NULL_TREE, cn;
13403   enum tree_code code = TREE_CODE (node);
13404
13405   /* If 1, tell the routine that we have to return error_mark_node
13406      after checking for the initialization of the RHS */
13407   int error_found = 0;
13408
13409   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13410
13411   /* If either op<n>_type are NULL, this might be early signs of an
13412      error situation, unless it's too early to tell (in case we're
13413      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13414      correctly so the error can be later on reported accurately. */
13415   if (! (code == PLUS_EXPR || code == NE_EXPR
13416          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13417     {
13418       tree n;
13419       if (! op1_type)
13420         {
13421           n = java_complete_tree (op1);
13422           op1_type = TREE_TYPE (n);
13423         }
13424       if (! op2_type)
13425         {
13426           n = java_complete_tree (op2);
13427           op2_type = TREE_TYPE (n);
13428         }
13429     }
13430
13431   switch (code)
13432     {
13433     /* 15.16 Multiplicative operators */
13434     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13435     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13436     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13437     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13438       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13439         {
13440           if (!JNUMERIC_TYPE_P (op1_type))
13441             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13442           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13443             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13444           TREE_TYPE (node) = error_mark_node;
13445           error_found = 1;
13446           break;
13447         }
13448       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13449
13450       /* Detect integral division by zero */
13451       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13452           && TREE_CODE (prom_type) == INTEGER_TYPE
13453           && (op2 == integer_zero_node || op2 == long_zero_node ||
13454               (TREE_CODE (op2) == INTEGER_CST &&
13455                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13456         {
13457           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13458           TREE_CONSTANT (node) = 0;
13459         }
13460
13461       /* Change the division operator if necessary */
13462       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13463         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13464
13465       /* Before divisions as is disapear, try to simplify and bail if
13466          applicable, otherwise we won't perform even simple
13467          simplifications like (1-1)/3. We can't do that with floating
13468          point number, folds can't handle them at this stage. */
13469       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13470           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13471         {
13472           TREE_TYPE (node) = prom_type;
13473           node = fold (node);
13474           if (TREE_CODE (node) != code)
13475             return node;
13476         }
13477
13478       if (TREE_CODE (prom_type) == INTEGER_TYPE
13479           && flag_use_divide_subroutine
13480           && ! flag_emit_class_files
13481           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13482         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13483
13484       /* This one is more complicated. FLOATs are processed by a
13485          function call to soft_fmod. Duplicate the value of the
13486          COMPOUND_ASSIGN_P flag. */
13487       if (code == TRUNC_MOD_EXPR)
13488         {
13489           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13490           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13491           TREE_SIDE_EFFECTS (mod)
13492             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13493           return mod;
13494         }
13495       break;
13496
13497     /* 15.17 Additive Operators */
13498     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13499
13500       /* Operation is valid if either one argument is a string
13501          constant, a String object or a StringBuffer crafted for the
13502          purpose of the a previous usage of the String concatenation
13503          operator */
13504
13505       if (TREE_CODE (op1) == STRING_CST
13506           || TREE_CODE (op2) == STRING_CST
13507           || JSTRING_TYPE_P (op1_type)
13508           || JSTRING_TYPE_P (op2_type)
13509           || IS_CRAFTED_STRING_BUFFER_P (op1)
13510           || IS_CRAFTED_STRING_BUFFER_P (op2))
13511         return build_string_concatenation (op1, op2);
13512
13513     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13514                                    Numeric Types */
13515       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13516         {
13517           if (!JNUMERIC_TYPE_P (op1_type))
13518             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13519           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13520             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13521           TREE_TYPE (node) = error_mark_node;
13522           error_found = 1;
13523           break;
13524         }
13525       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13526       break;
13527
13528     /* 15.18 Shift Operators */
13529     case LSHIFT_EXPR:
13530     case RSHIFT_EXPR:
13531     case URSHIFT_EXPR:
13532       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13533         {
13534           if (!JINTEGRAL_TYPE_P (op1_type))
13535             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13536           else
13537             {
13538               if (JNUMERIC_TYPE_P (op2_type))
13539                 parse_error_context (wfl_operator,
13540                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13541                                      operator_string (node),
13542                                      lang_printable_name (op2_type, 0));
13543               else
13544                 parse_error_context (wfl_operator,
13545                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13546                                      operator_string (node),
13547                                      lang_printable_name (op2_type, 0));
13548             }
13549           TREE_TYPE (node) = error_mark_node;
13550           error_found = 1;
13551           break;
13552         }
13553
13554       /* Unary numeric promotion (5.6.1) is performed on each operand
13555          separately */
13556       op1 = do_unary_numeric_promotion (op1);
13557       op2 = do_unary_numeric_promotion (op2);
13558
13559       /* If the right hand side is of type `long', first cast it to
13560          `int'.  */
13561       if (TREE_TYPE (op2) == long_type_node)
13562         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13563
13564       /* The type of the shift expression is the type of the promoted
13565          type of the left-hand operand */
13566       prom_type = TREE_TYPE (op1);
13567
13568       /* Shift int only up to 0x1f and long up to 0x3f */
13569       if (prom_type == int_type_node)
13570         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13571                            build_int_2 (0x1f, 0)));
13572       else
13573         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13574                            build_int_2 (0x3f, 0)));
13575
13576       /* The >>> operator is a >> operating on unsigned quantities */
13577       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13578         {
13579           tree to_return;
13580           tree utype = java_unsigned_type (prom_type);
13581           op1 = convert (utype, op1);
13582           TREE_SET_CODE (node, RSHIFT_EXPR);
13583           TREE_OPERAND (node, 0) = op1;
13584           TREE_OPERAND (node, 1) = op2;
13585           TREE_TYPE (node) = utype;
13586           to_return = convert (prom_type, node);
13587           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13588           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13589           TREE_SIDE_EFFECTS (to_return)
13590             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13591           return to_return;
13592         }
13593       break;
13594
13595       /* 15.19.1 Type Comparison Operator instanceof */
13596     case INSTANCEOF_EXPR:
13597
13598       TREE_TYPE (node) = boolean_type_node;
13599
13600       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13601       if ((cn = patch_string (op1)))
13602         {
13603           op1 = cn;
13604           op1_type = TREE_TYPE (op1);
13605         }
13606       if (op1_type == NULL_TREE)
13607         abort ();
13608
13609       if (!(op2_type = resolve_type_during_patch (op2)))
13610         return error_mark_node;
13611
13612       /* The first operand must be a reference type or the null type */
13613       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13614         error_found = 1;        /* Error reported further below */
13615
13616       /* The second operand must be a reference type */
13617       if (!JREFERENCE_TYPE_P (op2_type))
13618         {
13619           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13620           parse_error_context
13621             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13622              lang_printable_name (op2_type, 0));
13623           error_found = 1;
13624         }
13625
13626       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13627         {
13628           /* If the first operand is null, the result is always false */
13629           if (op1 == null_pointer_node)
13630             return boolean_false_node;
13631           else if (flag_emit_class_files)
13632             {
13633               TREE_OPERAND (node, 1) = op2_type;
13634               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13635               return node;
13636             }
13637           /* Otherwise we have to invoke instance of to figure it out */
13638           else
13639             return build_instanceof (op1, op2_type);
13640         }
13641       /* There is no way the expression operand can be an instance of
13642          the type operand. This is a compile time error. */
13643       else
13644         {
13645           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13646           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13647           parse_error_context
13648             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13649              t1, lang_printable_name (op2_type, 0));
13650           free (t1);
13651           error_found = 1;
13652         }
13653
13654       break;
13655
13656       /* 15.21 Bitwise and Logical Operators */
13657     case BIT_AND_EXPR:
13658     case BIT_XOR_EXPR:
13659     case BIT_IOR_EXPR:
13660       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13661         /* Binary numeric promotion is performed on both operand and the
13662            expression retain that type */
13663         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13664
13665       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13666                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13667         /* The type of the bitwise operator expression is BOOLEAN */
13668         prom_type = boolean_type_node;
13669       else
13670         {
13671           if (!JINTEGRAL_TYPE_P (op1_type))
13672             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13673           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13674             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13675           TREE_TYPE (node) = error_mark_node;
13676           error_found = 1;
13677           /* Insert a break here if adding thing before the switch's
13678              break for this case */
13679         }
13680       break;
13681
13682       /* 15.22 Conditional-And Operator */
13683     case TRUTH_ANDIF_EXPR:
13684       /* 15.23 Conditional-Or Operator */
13685     case TRUTH_ORIF_EXPR:
13686       /* Operands must be of BOOLEAN type */
13687       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13688           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13689         {
13690           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13691             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13692           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13693             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13694           TREE_TYPE (node) = boolean_type_node;
13695           error_found = 1;
13696           break;
13697         }
13698       else if (integer_zerop (op1))
13699         {
13700           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13701         }
13702       else if (integer_onep (op1))
13703         {
13704           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13705         }
13706       /* The type of the conditional operators is BOOLEAN */
13707       prom_type = boolean_type_node;
13708       break;
13709
13710       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13711     case LT_EXPR:
13712     case GT_EXPR:
13713     case LE_EXPR:
13714     case GE_EXPR:
13715       /* The type of each of the operands must be a primitive numeric
13716          type */
13717       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13718         {
13719           if (!JNUMERIC_TYPE_P (op1_type))
13720             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13721           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13722             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13723           TREE_TYPE (node) = boolean_type_node;
13724           error_found = 1;
13725           break;
13726         }
13727       /* Binary numeric promotion is performed on the operands */
13728       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13729       /* The type of the relation expression is always BOOLEAN */
13730       prom_type = boolean_type_node;
13731       break;
13732
13733       /* 15.20 Equality Operator */
13734     case EQ_EXPR:
13735     case NE_EXPR:
13736       /* It's time for us to patch the strings. */
13737       if ((cn = patch_string (op1)))
13738        {
13739          op1 = cn;
13740          op1_type = TREE_TYPE (op1);
13741        }
13742       if ((cn = patch_string (op2)))
13743        {
13744          op2 = cn;
13745          op2_type = TREE_TYPE (op2);
13746        }
13747
13748       /* 15.20.1 Numerical Equality Operators == and != */
13749       /* Binary numeric promotion is performed on the operands */
13750       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13751         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13752
13753       /* 15.20.2 Boolean Equality Operators == and != */
13754       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13755           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13756         ;                       /* Nothing to do here */
13757
13758       /* 15.20.3 Reference Equality Operators == and != */
13759       /* Types have to be either references or the null type. If
13760          they're references, it must be possible to convert either
13761          type to the other by casting conversion. */
13762       else if (op1 == null_pointer_node || op2 == null_pointer_node
13763                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13764                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13765                        || valid_ref_assignconv_cast_p (op2_type,
13766                                                        op1_type, 1))))
13767         ;                       /* Nothing to do here */
13768
13769       /* Else we have an error figure what can't be converted into
13770          what and report the error */
13771       else
13772         {
13773           char *t1;
13774           t1 = xstrdup (lang_printable_name (op1_type, 0));
13775           parse_error_context
13776             (wfl_operator,
13777              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13778              operator_string (node), t1,
13779              lang_printable_name (op2_type, 0));
13780           free (t1);
13781           TREE_TYPE (node) = boolean_type_node;
13782           error_found = 1;
13783           break;
13784         }
13785       prom_type = boolean_type_node;
13786       break;
13787     default:
13788       abort ();
13789     }
13790
13791   if (error_found)
13792     return error_mark_node;
13793
13794   TREE_OPERAND (node, 0) = op1;
13795   TREE_OPERAND (node, 1) = op2;
13796   TREE_TYPE (node) = prom_type;
13797   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13798
13799   if (flag_emit_xref)
13800     return node;
13801
13802   /* fold does not respect side-effect order as required for Java but not C.
13803    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13804    * bytecode.
13805    */
13806   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13807       : ! TREE_SIDE_EFFECTS (node))
13808     node = fold (node);
13809   return node;
13810 }
13811
13812 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13813    zero value, the value of CSTE comes after the valude of STRING */
13814
13815 static tree
13816 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13817 {
13818   const char *old = TREE_STRING_POINTER (cste);
13819   int old_len = TREE_STRING_LENGTH (cste);
13820   int len = old_len + string_len;
13821   char *new = alloca (len+1);
13822
13823   if (after)
13824     {
13825       memcpy (new, string, string_len);
13826       memcpy (&new [string_len], old, old_len);
13827     }
13828   else
13829     {
13830       memcpy (new, old, old_len);
13831       memcpy (&new [old_len], string, string_len);
13832     }
13833   new [len] = '\0';
13834   return build_string (len, new);
13835 }
13836
13837 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13838    new STRING_CST on success, NULL_TREE on failure.  */
13839
13840 static tree
13841 merge_string_cste (tree op1, tree op2, int after)
13842 {
13843   /* Handle two string constants right away.  */
13844   if (TREE_CODE (op2) == STRING_CST)
13845     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13846                                  TREE_STRING_LENGTH (op2), after);
13847
13848   /* Reasonable integer constant can be treated right away.  */
13849   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13850     {
13851       static const char *const boolean_true = "true";
13852       static const char *const boolean_false = "false";
13853       static const char *const null_pointer = "null";
13854       char ch[4];
13855       const char *string;
13856
13857       if (op2 == boolean_true_node)
13858         string = boolean_true;
13859       else if (op2 == boolean_false_node)
13860         string = boolean_false;
13861       else if (op2 == null_pointer_node)
13862         /* FIXME: null is not a compile-time constant, so it is only safe to
13863            merge if the overall expression is non-constant. However, this
13864            code always merges without checking the overall expression.  */
13865         string = null_pointer;
13866       else if (TREE_TYPE (op2) == char_type_node)
13867         {
13868           /* Convert the character into UTF-8.  */
13869           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13870           unsigned char *p = (unsigned char *) ch;
13871           if (0x01 <= c && c <= 0x7f)
13872             *p++ = (unsigned char) c;
13873           else if (c < 0x7ff)
13874             {
13875               *p++ = (unsigned char) (c >> 6 | 0xc0);
13876               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13877             }
13878           else
13879             {
13880               *p++ = (unsigned char) (c >> 12 | 0xe0);
13881               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13882               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13883             }
13884           *p = '\0';
13885
13886           string = ch;
13887         }
13888       else
13889         string = string_convert_int_cst (op2);
13890
13891       return do_merge_string_cste (op1, string, strlen (string), after);
13892     }
13893   return NULL_TREE;
13894 }
13895
13896 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13897    has to be a STRING_CST and the other part must be a STRING_CST or a
13898    INTEGRAL constant. Return a new STRING_CST if the operation
13899    succeed, NULL_TREE otherwise.
13900
13901    If the case we want to optimize for space, we might want to return
13902    NULL_TREE for each invocation of this routine. FIXME */
13903
13904 static tree
13905 string_constant_concatenation (tree op1, tree op2)
13906 {
13907   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13908     {
13909       tree string, rest;
13910       int invert;
13911
13912       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13913       rest   = (string == op1 ? op2 : op1);
13914       invert = (string == op1 ? 0 : 1 );
13915
13916       /* Walk REST, only if it looks reasonable */
13917       if (TREE_CODE (rest) != STRING_CST
13918           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13919           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13920           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13921         {
13922           rest = java_complete_tree (rest);
13923           if (rest == error_mark_node)
13924             return error_mark_node;
13925           rest = fold (rest);
13926         }
13927       return merge_string_cste (string, rest, invert);
13928     }
13929   return NULL_TREE;
13930 }
13931
13932 /* Implement the `+' operator. Does static optimization if possible,
13933    otherwise create (if necessary) and append elements to a
13934    StringBuffer. The StringBuffer will be carried around until it is
13935    used for a function call or an assignment. Then toString() will be
13936    called on it to turn it into a String object. */
13937
13938 static tree
13939 build_string_concatenation (tree op1, tree op2)
13940 {
13941   tree result;
13942   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13943
13944   if (flag_emit_xref)
13945     return build (PLUS_EXPR, string_type_node, op1, op2);
13946
13947   /* Try to do some static optimization */
13948   if ((result = string_constant_concatenation (op1, op2)))
13949     return result;
13950
13951   /* Discard empty strings on either side of the expression */
13952   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13953     {
13954       op1 = op2;
13955       op2 = NULL_TREE;
13956     }
13957   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13958     op2 = NULL_TREE;
13959
13960   /* If operands are string constant, turn then into object references */
13961   if (TREE_CODE (op1) == STRING_CST)
13962     op1 = patch_string_cst (op1);
13963   if (op2 && TREE_CODE (op2) == STRING_CST)
13964     op2 = patch_string_cst (op2);
13965
13966   /* If either one of the constant is null and the other non null
13967      operand is a String constant, return it. */
13968   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13969     return op1;
13970
13971   /* If OP1 isn't already a StringBuffer, create and
13972      initialize a new one */
13973   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13974     {
13975       /* Two solutions here:
13976          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13977          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13978       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13979         op1 = BUILD_STRING_BUFFER (op1);
13980       else
13981         {
13982           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13983           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13984         }
13985     }
13986
13987   if (op2)
13988     {
13989       /* OP1 is no longer the last node holding a crafted StringBuffer */
13990       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13991       /* Create a node for `{new...,xxx}.append (op2)' */
13992       if (op2)
13993         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13994     }
13995
13996   /* Mark the last node holding a crafted StringBuffer */
13997   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13998
13999   TREE_SIDE_EFFECTS (op1) = side_effects;
14000   return op1;
14001 }
14002
14003 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
14004    StringBuffer. If no string were found to be patched, return
14005    NULL. */
14006
14007 static tree
14008 patch_string (tree node)
14009 {
14010   if (node == error_mark_node)
14011     return error_mark_node;
14012   if (TREE_CODE (node) == STRING_CST)
14013     return patch_string_cst (node);
14014   else if (IS_CRAFTED_STRING_BUFFER_P (node))
14015     {
14016       int saved = ctxp->explicit_constructor_p;
14017       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
14018       tree ret;
14019       /* Temporary disable forbid the use of `this'. */
14020       ctxp->explicit_constructor_p = 0;
14021       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
14022       /* String concatenation arguments must be evaluated in order too. */
14023       ret = force_evaluation_order (ret);
14024       /* Restore it at its previous value */
14025       ctxp->explicit_constructor_p = saved;
14026       return ret;
14027     }
14028   return NULL_TREE;
14029 }
14030
14031 /* Build the internal representation of a string constant.  */
14032
14033 static tree
14034 patch_string_cst (tree node)
14035 {
14036   int location;
14037   if (! flag_emit_class_files)
14038     {
14039       node = get_identifier (TREE_STRING_POINTER (node));
14040       location = alloc_name_constant (CONSTANT_String, node);
14041       node = build_ref_from_constant_pool (location);
14042     }
14043   TREE_TYPE (node) = string_ptr_type_node;
14044   TREE_CONSTANT (node) = 1;
14045   return node;
14046 }
14047
14048 /* Build an incomplete unary operator expression. */
14049
14050 static tree
14051 build_unaryop (int op_token, int op_location, tree op1)
14052 {
14053   enum tree_code op;
14054   tree unaryop;
14055   switch (op_token)
14056     {
14057     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
14058     case MINUS_TK: op = NEGATE_EXPR; break;
14059     case NEG_TK: op = TRUTH_NOT_EXPR; break;
14060     case NOT_TK: op = BIT_NOT_EXPR; break;
14061     default: abort ();
14062     }
14063
14064   unaryop = build1 (op, NULL_TREE, op1);
14065   TREE_SIDE_EFFECTS (unaryop) = 1;
14066   /* Store the location of the operator, for better error report. The
14067      string of the operator will be rebuild based on the OP value. */
14068   EXPR_WFL_LINECOL (unaryop) = op_location;
14069   return unaryop;
14070 }
14071
14072 /* Special case for the ++/-- operators, since they require an extra
14073    argument to build, which is set to NULL and patched
14074    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
14075
14076 static tree
14077 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
14078 {
14079   static const enum tree_code lookup [2][2] =
14080     {
14081       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
14082       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
14083     };
14084   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
14085                      NULL_TREE, op1, NULL_TREE);
14086   TREE_SIDE_EFFECTS (node) = 1;
14087   /* Store the location of the operator, for better error report. The
14088      string of the operator will be rebuild based on the OP value. */
14089   EXPR_WFL_LINECOL (node) = op_location;
14090   return node;
14091 }
14092
14093 /* Build an incomplete cast operator, based on the use of the
14094    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14095    set. java_complete_tree is trained to walk a CONVERT_EXPR even
14096    though its type is already set.  */
14097
14098 static tree
14099 build_cast (int location, tree type, tree exp)
14100 {
14101   tree node = build1 (CONVERT_EXPR, type, exp);
14102   EXPR_WFL_LINECOL (node) = location;
14103   return node;
14104 }
14105
14106 /* Build an incomplete class reference operator.  */
14107 static tree
14108 build_incomplete_class_ref (int location, tree class_name)
14109 {
14110   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
14111   EXPR_WFL_LINECOL (node) = location;
14112   return node;
14113 }
14114
14115 /* Complete an incomplete class reference operator.  */
14116 static tree
14117 patch_incomplete_class_ref (tree node)
14118 {
14119   tree type = TREE_OPERAND (node, 0);
14120   tree ref_type;
14121
14122   if (!(ref_type = resolve_type_during_patch (type)))
14123     return error_mark_node;
14124
14125   /* Generate the synthetic static method `class$'.  (Previously we
14126      deferred this, causing different method tables to be emitted
14127      for native code and bytecode.)  */
14128   if (!TYPE_DOT_CLASS (current_class))
14129       build_dot_class_method (current_class);
14130
14131   /* If we're not emitting class files and we know ref_type is a
14132      compiled class, build a direct reference.  */
14133   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14134       || JPRIMITIVE_TYPE_P (ref_type)
14135       || TREE_CODE (ref_type) == VOID_TYPE)
14136     {
14137       tree dot = build_class_ref (ref_type);
14138       /* A class referenced by `foo.class' is initialized.  */
14139       if (!flag_emit_class_files)
14140        dot = build_class_init (ref_type, dot);
14141       return java_complete_tree (dot);
14142     }
14143
14144   /* If we're emitting class files and we have to deal with non
14145      primitive types, we invoke the synthetic static method `class$'.  */
14146   ref_type = build_dot_class_method_invocation (ref_type);
14147   return java_complete_tree (ref_type);
14148 }
14149
14150 /* 15.14 Unary operators. We return error_mark_node in case of error,
14151    but preserve the type of NODE if the type is fixed.  */
14152
14153 static tree
14154 patch_unaryop (tree node, tree wfl_op)
14155 {
14156   tree op = TREE_OPERAND (node, 0);
14157   tree op_type = TREE_TYPE (op);
14158   tree prom_type = NULL_TREE, value, decl;
14159   int outer_field_flag = 0;
14160   int code = TREE_CODE (node);
14161   int error_found = 0;
14162
14163   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14164
14165   switch (code)
14166     {
14167       /* 15.13.2 Postfix Increment Operator ++ */
14168     case POSTINCREMENT_EXPR:
14169       /* 15.13.3 Postfix Increment Operator -- */
14170     case POSTDECREMENT_EXPR:
14171       /* 15.14.1 Prefix Increment Operator ++ */
14172     case PREINCREMENT_EXPR:
14173       /* 15.14.2 Prefix Decrement Operator -- */
14174     case PREDECREMENT_EXPR:
14175       op = decl = strip_out_static_field_access_decl (op);
14176       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14177       /* We might be trying to change an outer field accessed using
14178          access method. */
14179       if (outer_field_flag)
14180         {
14181           /* Retrieve the decl of the field we're trying to access. We
14182              do that by first retrieving the function we would call to
14183              access the field. It has been already verified that this
14184              field isn't final */
14185           if (flag_emit_class_files)
14186             decl = TREE_OPERAND (op, 0);
14187           else
14188             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14189           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14190         }
14191       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14192       else if (!JDECL_P (decl)
14193           && TREE_CODE (decl) != COMPONENT_REF
14194           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14195           && TREE_CODE (decl) != INDIRECT_REF
14196           && !(TREE_CODE (decl) == COMPOUND_EXPR
14197                && TREE_OPERAND (decl, 1)
14198                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14199         {
14200           TREE_TYPE (node) = error_mark_node;
14201           error_found = 1;
14202         }
14203
14204       /* From now on, we know that op if a variable and that it has a
14205          valid wfl. We use wfl_op to locate errors related to the
14206          ++/-- operand. */
14207       if (!JNUMERIC_TYPE_P (op_type))
14208         {
14209           parse_error_context
14210             (wfl_op, "Invalid argument type `%s' to `%s'",
14211              lang_printable_name (op_type, 0), operator_string (node));
14212           TREE_TYPE (node) = error_mark_node;
14213           error_found = 1;
14214         }
14215       else
14216         {
14217           /* Before the addition, binary numeric promotion is performed on
14218              both operands, if really necessary */
14219           if (JINTEGRAL_TYPE_P (op_type))
14220             {
14221               value = build_int_2 (1, 0);
14222               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14223             }
14224           else
14225             {
14226               value = build_int_2 (1, 0);
14227               TREE_TYPE (node) =
14228                 binary_numeric_promotion (op_type,
14229                                           TREE_TYPE (value), &op, &value);
14230             }
14231
14232           /* We remember we might be accessing an outer field */
14233           if (outer_field_flag)
14234             {
14235               /* We re-generate an access to the field */
14236               value = build (PLUS_EXPR, TREE_TYPE (op),
14237                              build_outer_field_access (wfl_op, decl), value);
14238
14239               /* And we patch the original access$() into a write
14240                  with plus_op as a rhs */
14241               return outer_field_access_fix (node, op, value);
14242             }
14243
14244           /* And write back into the node. */
14245           TREE_OPERAND (node, 0) = op;
14246           TREE_OPERAND (node, 1) = value;
14247           /* Convert the overall back into its original type, if
14248              necessary, and return */
14249           if (JINTEGRAL_TYPE_P (op_type))
14250             return fold (node);
14251           else
14252             return fold (convert (op_type, node));
14253         }
14254       break;
14255
14256       /* 15.14.3 Unary Plus Operator + */
14257     case UNARY_PLUS_EXPR:
14258       /* 15.14.4 Unary Minus Operator - */
14259     case NEGATE_EXPR:
14260       if (!JNUMERIC_TYPE_P (op_type))
14261         {
14262           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14263           TREE_TYPE (node) = error_mark_node;
14264           error_found = 1;
14265         }
14266       /* Unary numeric promotion is performed on operand */
14267       else
14268         {
14269           op = do_unary_numeric_promotion (op);
14270           prom_type = TREE_TYPE (op);
14271           if (code == UNARY_PLUS_EXPR)
14272             return fold (op);
14273         }
14274       break;
14275
14276       /* 15.14.5 Bitwise Complement Operator ~ */
14277     case BIT_NOT_EXPR:
14278       if (!JINTEGRAL_TYPE_P (op_type))
14279         {
14280           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14281           TREE_TYPE (node) = error_mark_node;
14282           error_found = 1;
14283         }
14284       else
14285         {
14286           op = do_unary_numeric_promotion (op);
14287           prom_type = TREE_TYPE (op);
14288         }
14289       break;
14290
14291       /* 15.14.6 Logical Complement Operator ! */
14292     case TRUTH_NOT_EXPR:
14293       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14294         {
14295           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14296           /* But the type is known. We will report an error if further
14297              attempt of a assignment is made with this rhs */
14298           TREE_TYPE (node) = boolean_type_node;
14299           error_found = 1;
14300         }
14301       else
14302         prom_type = boolean_type_node;
14303       break;
14304
14305       /* 15.15 Cast Expression */
14306     case CONVERT_EXPR:
14307       value = patch_cast (node, wfl_operator);
14308       if (value == error_mark_node)
14309         {
14310           /* If this cast is part of an assignment, we tell the code
14311              that deals with it not to complain about a mismatch,
14312              because things have been cast, anyways */
14313           TREE_TYPE (node) = error_mark_node;
14314           error_found = 1;
14315         }
14316       else
14317         {
14318           value = fold (value);
14319           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14320           return value;
14321         }
14322       break;
14323     }
14324
14325   if (error_found)
14326     return error_mark_node;
14327
14328   /* There are cases where node has been replaced by something else
14329      and we don't end up returning here: UNARY_PLUS_EXPR,
14330      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14331   TREE_OPERAND (node, 0) = fold (op);
14332   TREE_TYPE (node) = prom_type;
14333   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14334   return fold (node);
14335 }
14336
14337 /* Generic type resolution that sometimes takes place during node
14338    patching. Returned the resolved type or generate an error
14339    message. Return the resolved type or NULL_TREE.  */
14340
14341 static tree
14342 resolve_type_during_patch (tree type)
14343 {
14344   if (unresolved_type_p (type, NULL))
14345     {
14346       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14347       if (!type_decl)
14348         {
14349           parse_error_context (type,
14350                                "Class `%s' not found in type declaration",
14351                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14352           return NULL_TREE;
14353         }
14354
14355       check_deprecation (type, type_decl);
14356
14357       return TREE_TYPE (type_decl);
14358     }
14359   return type;
14360 }
14361
14362 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14363    found. Otherwise NODE or something meant to replace it is returned.  */
14364
14365 static tree
14366 patch_cast (tree node, tree wfl_op)
14367 {
14368   tree op = TREE_OPERAND (node, 0);
14369   tree cast_type = TREE_TYPE (node);
14370   tree patched, op_type;
14371   char *t1;
14372
14373   /* Some string patching might be necessary at this stage */
14374   if ((patched = patch_string (op)))
14375     TREE_OPERAND (node, 0) = op = patched;
14376   op_type = TREE_TYPE (op);
14377
14378   /* First resolve OP_TYPE if unresolved */
14379   if (!(cast_type = resolve_type_during_patch (cast_type)))
14380     return error_mark_node;
14381
14382   /* Check on cast that are proven correct at compile time */
14383   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14384     {
14385       /* Same type */
14386       if (cast_type == op_type)
14387         return node;
14388
14389       /* A narrowing conversion from a floating-point number to an
14390          integral type requires special handling (5.1.3).  */
14391       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14392         if (cast_type != long_type_node)
14393           op = convert (integer_type_node, op);
14394
14395       /* Try widening/narrowing convertion.  Potentially, things need
14396          to be worked out in gcc so we implement the extreme cases
14397          correctly.  fold_convert() needs to be fixed.  */
14398       return convert (cast_type, op);
14399     }
14400
14401   /* It's also valid to cast a boolean into a boolean */
14402   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14403     return node;
14404
14405   /* null can be casted to references */
14406   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14407     return build_null_of_type (cast_type);
14408
14409   /* The remaining legal casts involve conversion between reference
14410      types. Check for their compile time correctness. */
14411   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14412       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14413     {
14414       TREE_TYPE (node) = promote_type (cast_type);
14415       /* Now, the case can be determined correct at compile time if
14416          OP_TYPE can be converted into CAST_TYPE by assignment
14417          conversion (5.2) */
14418
14419       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14420         {
14421           TREE_SET_CODE (node, NOP_EXPR);
14422           return node;
14423         }
14424
14425       if (flag_emit_class_files)
14426         {
14427           TREE_SET_CODE (node, CONVERT_EXPR);
14428           return node;
14429         }
14430
14431       /* The cast requires a run-time check */
14432       return build (CALL_EXPR, promote_type (cast_type),
14433                     build_address_of (soft_checkcast_node),
14434                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14435                                build_tree_list (NULL_TREE, op)),
14436                     NULL_TREE);
14437     }
14438
14439   /* Any other casts are proven incorrect at compile time */
14440   t1 = xstrdup (lang_printable_name (op_type, 0));
14441   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14442                        t1, lang_printable_name (cast_type, 0));
14443   free (t1);
14444   return error_mark_node;
14445 }
14446
14447 /* Build a null constant and give it the type TYPE.  */
14448
14449 static tree
14450 build_null_of_type (tree type)
14451 {
14452   tree node = build_int_2 (0, 0);
14453   TREE_TYPE (node) = promote_type (type);
14454   return node;
14455 }
14456
14457 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14458    a list of indices. */
14459 static tree
14460 build_array_ref (int location, tree array, tree index)
14461 {
14462   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14463   EXPR_WFL_LINECOL (node) = location;
14464   return node;
14465 }
14466
14467 /* 15.12 Array Access Expression */
14468
14469 static tree
14470 patch_array_ref (tree node)
14471 {
14472   tree array = TREE_OPERAND (node, 0);
14473   tree array_type  = TREE_TYPE (array);
14474   tree index = TREE_OPERAND (node, 1);
14475   tree index_type = TREE_TYPE (index);
14476   int error_found = 0;
14477
14478   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14479
14480   if (TREE_CODE (array_type) == POINTER_TYPE)
14481     array_type = TREE_TYPE (array_type);
14482
14483   /* The array reference must be an array */
14484   if (!TYPE_ARRAY_P (array_type))
14485     {
14486       parse_error_context
14487         (wfl_operator,
14488          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14489          lang_printable_name (array_type, 0));
14490       TREE_TYPE (node) = error_mark_node;
14491       error_found = 1;
14492     }
14493
14494   /* The array index undergoes unary numeric promotion. The promoted
14495      type must be int */
14496   index = do_unary_numeric_promotion (index);
14497   if (TREE_TYPE (index) != int_type_node)
14498     {
14499       if (valid_cast_to_p (index_type, int_type_node))
14500         parse_error_context (wfl_operator,
14501    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14502                              lang_printable_name (index_type, 0));
14503       else
14504         parse_error_context (wfl_operator,
14505           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14506                              lang_printable_name (index_type, 0));
14507       TREE_TYPE (node) = error_mark_node;
14508       error_found = 1;
14509     }
14510
14511   if (error_found)
14512     return error_mark_node;
14513
14514   array_type = TYPE_ARRAY_ELEMENT (array_type);
14515
14516   if (flag_emit_class_files || flag_emit_xref)
14517     {
14518       TREE_OPERAND (node, 0) = array;
14519       TREE_OPERAND (node, 1) = index;
14520     }
14521   else
14522     node = build_java_arrayaccess (array, array_type, index);
14523   TREE_TYPE (node) = array_type;
14524   return node;
14525 }
14526
14527 /* 15.9 Array Creation Expressions */
14528
14529 static tree
14530 build_newarray_node (tree type, tree dims, int extra_dims)
14531 {
14532   tree node =
14533     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14534            build_int_2 (extra_dims, 0));
14535   return node;
14536 }
14537
14538 static tree
14539 patch_newarray (tree node)
14540 {
14541   tree type = TREE_OPERAND (node, 0);
14542   tree dims = TREE_OPERAND (node, 1);
14543   tree cdim, array_type;
14544   int error_found = 0;
14545   int ndims = 0;
14546   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14547
14548   /* Dimension types are verified. It's better for the types to be
14549      verified in order. */
14550   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14551     {
14552       int dim_error = 0;
14553       tree dim = TREE_VALUE (cdim);
14554
14555       /* Dim might have been saved during its evaluation */
14556       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14557
14558       /* The type of each specified dimension must be an integral type. */
14559       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14560         dim_error = 1;
14561
14562       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14563          promoted type must be int. */
14564       else
14565         {
14566           dim = do_unary_numeric_promotion (dim);
14567           if (TREE_TYPE (dim) != int_type_node)
14568             dim_error = 1;
14569         }
14570
14571       /* Report errors on types here */
14572       if (dim_error)
14573         {
14574           parse_error_context
14575             (TREE_PURPOSE (cdim),
14576              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14577              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14578               "Explicit cast needed to" : "Can't"),
14579              lang_printable_name (TREE_TYPE (dim), 0));
14580           error_found = 1;
14581         }
14582
14583       TREE_PURPOSE (cdim) = NULL_TREE;
14584     }
14585
14586   /* Resolve array base type if unresolved */
14587   if (!(type = resolve_type_during_patch (type)))
14588     error_found = 1;
14589
14590   if (error_found)
14591     {
14592       /* We don't want further evaluation of this bogus array creation
14593          operation */
14594       TREE_TYPE (node) = error_mark_node;
14595       return error_mark_node;
14596     }
14597
14598   /* Set array_type to the actual (promoted) array type of the result. */
14599   if (TREE_CODE (type) == RECORD_TYPE)
14600     type = build_pointer_type (type);
14601   while (--xdims >= 0)
14602     {
14603       type = promote_type (build_java_array_type (type, -1));
14604     }
14605   dims = nreverse (dims);
14606   array_type = type;
14607   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14608     {
14609       type = array_type;
14610       array_type
14611         = build_java_array_type (type,
14612                                  TREE_CODE (cdim) == INTEGER_CST
14613                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14614                                  : -1);
14615       array_type = promote_type (array_type);
14616     }
14617   dims = nreverse (dims);
14618
14619   /* The node is transformed into a function call. Things are done
14620      differently according to the number of dimensions. If the number
14621      of dimension is equal to 1, then the nature of the base type
14622      (primitive or not) matters. */
14623   if (ndims == 1)
14624     return build_new_array (type, TREE_VALUE (dims));
14625
14626   /* Can't reuse what's already written in expr.c because it uses the
14627      JVM stack representation. Provide a build_multianewarray. FIXME */
14628   return build (CALL_EXPR, array_type,
14629                 build_address_of (soft_multianewarray_node),
14630                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14631                            tree_cons (NULL_TREE,
14632                                       build_int_2 (ndims, 0), dims )),
14633                 NULL_TREE);
14634 }
14635
14636 /* 10.6 Array initializer.  */
14637
14638 /* Build a wfl for array element that don't have one, so we can
14639    pin-point errors.  */
14640
14641 static tree
14642 maybe_build_array_element_wfl (tree node)
14643 {
14644   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14645     return build_expr_wfl (NULL_TREE, ctxp->filename,
14646                            ctxp->elc.line, ctxp->elc.prev_col);
14647   else
14648     return NULL_TREE;
14649 }
14650
14651 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14652    identification of initialized arrays easier to detect during walk
14653    and expansion.  */
14654
14655 static tree
14656 build_new_array_init (int location, tree values)
14657 {
14658   tree constructor = build_constructor (NULL_TREE, values);
14659   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14660   EXPR_WFL_LINECOL (to_return) = location;
14661   return to_return;
14662 }
14663
14664 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14665    occurred.  Otherwise return NODE after having set its type
14666    appropriately.  */
14667
14668 static tree
14669 patch_new_array_init (tree type, tree node)
14670 {
14671   int error_seen = 0;
14672   tree current, element_type;
14673   HOST_WIDE_INT length;
14674   int all_constant = 1;
14675   tree init = TREE_OPERAND (node, 0);
14676
14677   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14678     {
14679       parse_error_context (node,
14680                            "Invalid array initializer for non-array type `%s'",
14681                            lang_printable_name (type, 1));
14682       return error_mark_node;
14683     }
14684   type = TREE_TYPE (type);
14685   element_type = TYPE_ARRAY_ELEMENT (type);
14686
14687   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14688
14689   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14690        current;  length++, current = TREE_CHAIN (current))
14691     {
14692       tree elt = TREE_VALUE (current);
14693       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14694         {
14695           error_seen |= array_constructor_check_entry (element_type, current);
14696           elt = TREE_VALUE (current);
14697           /* When compiling to native code, STRING_CST is converted to
14698              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14699           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14700             all_constant = 0;
14701         }
14702       else
14703         {
14704           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14705           TREE_PURPOSE (current) = NULL_TREE;
14706           all_constant = 0;
14707         }
14708       if (elt && TREE_CODE (elt) == TREE_LIST
14709           && TREE_VALUE (elt) == error_mark_node)
14710         error_seen = 1;
14711     }
14712
14713   if (error_seen)
14714     return error_mark_node;
14715
14716   /* Create a new type. We can't reuse the one we have here by
14717      patching its dimension because it originally is of dimension -1
14718      hence reused by gcc. This would prevent triangular arrays. */
14719   type = build_java_array_type (element_type, length);
14720   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14721   TREE_TYPE (node) = promote_type (type);
14722   TREE_CONSTANT (init) = all_constant;
14723   TREE_CONSTANT (node) = all_constant;
14724   return node;
14725 }
14726
14727 /* Verify that one entry of the initializer element list can be
14728    assigned to the array base type. Report 1 if an error occurred, 0
14729    otherwise.  */
14730
14731 static int
14732 array_constructor_check_entry (tree type, tree entry)
14733 {
14734   char *array_type_string = NULL;       /* For error reports */
14735   tree value, type_value, new_value, wfl_value, patched;
14736   int error_seen = 0;
14737
14738   new_value = NULL_TREE;
14739   wfl_value = TREE_VALUE (entry);
14740
14741   value = java_complete_tree (TREE_VALUE (entry));
14742   /* patch_string return error_mark_node if arg is error_mark_node */
14743   if ((patched = patch_string (value)))
14744     value = patched;
14745   if (value == error_mark_node)
14746     return 1;
14747
14748   type_value = TREE_TYPE (value);
14749
14750   /* At anytime, try_builtin_assignconv can report a warning on
14751      constant overflow during narrowing. */
14752   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14753   new_value = try_builtin_assignconv (wfl_operator, type, value);
14754   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14755     type_value = promote_type (type);
14756
14757   /* Check and report errors */
14758   if (!new_value)
14759     {
14760       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14761                    "Can't" : "Explicit cast needed to");
14762       if (!array_type_string)
14763         array_type_string = xstrdup (lang_printable_name (type, 1));
14764       parse_error_context
14765         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14766          msg, lang_printable_name (type_value, 1), array_type_string);
14767       error_seen = 1;
14768     }
14769
14770   if (new_value)
14771     TREE_VALUE (entry) = new_value;
14772
14773   if (array_type_string)
14774     free (array_type_string);
14775
14776   TREE_PURPOSE (entry) = NULL_TREE;
14777   return error_seen;
14778 }
14779
14780 static tree
14781 build_this (int location)
14782 {
14783   tree node = build_wfl_node (this_identifier_node);
14784   TREE_SET_CODE (node, THIS_EXPR);
14785   EXPR_WFL_LINECOL (node) = location;
14786   return node;
14787 }
14788
14789 /* 14.15 The return statement. It builds a modify expression that
14790    assigns the returned value to the RESULT_DECL that hold the value
14791    to be returned. */
14792
14793 static tree
14794 build_return (int location, tree op)
14795 {
14796   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14797   EXPR_WFL_LINECOL (node) = location;
14798   node = build_debugable_stmt (location, node);
14799   return node;
14800 }
14801
14802 static tree
14803 patch_return (tree node)
14804 {
14805   tree return_exp = TREE_OPERAND (node, 0);
14806   tree meth = current_function_decl;
14807   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14808   int error_found = 0;
14809
14810   TREE_TYPE (node) = error_mark_node;
14811   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14812
14813   /* It's invalid to have a return value within a function that is
14814      declared with the keyword void or that is a constructor */
14815   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14816     error_found = 1;
14817
14818   /* It's invalid to use a return statement in a static block */
14819   if (DECL_CLINIT_P (current_function_decl))
14820     error_found = 1;
14821
14822   /* It's invalid to have a no return value within a function that
14823      isn't declared with the keyword `void' */
14824   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14825     error_found = 2;
14826
14827   if (DECL_INSTINIT_P (current_function_decl))
14828     error_found = 1;
14829
14830   if (error_found)
14831     {
14832       if (DECL_INSTINIT_P (current_function_decl))
14833         parse_error_context (wfl_operator,
14834                              "`return' inside instance initializer");
14835
14836       else if (DECL_CLINIT_P (current_function_decl))
14837         parse_error_context (wfl_operator,
14838                              "`return' inside static initializer");
14839
14840       else if (!DECL_CONSTRUCTOR_P (meth))
14841         {
14842           char *t = xstrdup (lang_printable_name (mtype, 0));
14843           parse_error_context (wfl_operator,
14844                                "`return' with%s value from `%s %s'",
14845                                (error_found == 1 ? "" : "out"),
14846                                t, lang_printable_name (meth, 0));
14847           free (t);
14848         }
14849       else
14850         parse_error_context (wfl_operator,
14851                              "`return' with value from constructor `%s'",
14852                              lang_printable_name (meth, 0));
14853       return error_mark_node;
14854     }
14855
14856   /* If we have a return_exp, build a modify expression and expand
14857      it. Note: at that point, the assignment is declared valid, but we
14858      may want to carry some more hacks */
14859   if (return_exp)
14860     {
14861       tree exp = java_complete_tree (return_exp);
14862       tree modify, patched;
14863
14864       if ((patched = patch_string (exp)))
14865         exp = patched;
14866
14867       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14868       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14869       modify = java_complete_tree (modify);
14870
14871       if (modify != error_mark_node)
14872         {
14873           TREE_SIDE_EFFECTS (modify) = 1;
14874           TREE_OPERAND (node, 0) = modify;
14875         }
14876       else
14877         return error_mark_node;
14878     }
14879   TREE_TYPE (node) = void_type_node;
14880   TREE_SIDE_EFFECTS (node) = 1;
14881   return node;
14882 }
14883
14884 /* 14.8 The if Statement */
14885
14886 static tree
14887 build_if_else_statement (int location, tree expression, tree if_body,
14888                          tree else_body)
14889 {
14890   tree node;
14891   if (!else_body)
14892     else_body = empty_stmt_node;
14893   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14894   EXPR_WFL_LINECOL (node) = location;
14895   node = build_debugable_stmt (location, node);
14896   return node;
14897 }
14898
14899 static tree
14900 patch_if_else_statement (tree node)
14901 {
14902   tree expression = TREE_OPERAND (node, 0);
14903   int can_complete_normally
14904     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14905        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14906
14907   TREE_TYPE (node) = error_mark_node;
14908   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14909
14910   /* The type of expression must be boolean */
14911   if (TREE_TYPE (expression) != boolean_type_node
14912       && TREE_TYPE (expression) != promoted_boolean_type_node)
14913     {
14914       parse_error_context
14915         (wfl_operator,
14916          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14917          lang_printable_name (TREE_TYPE (expression), 0));
14918       return error_mark_node;
14919     }
14920
14921   if (TREE_CODE (expression) == INTEGER_CST)
14922     {
14923       if (integer_zerop (expression))
14924         node = TREE_OPERAND (node, 2);
14925       else
14926         node = TREE_OPERAND (node, 1);
14927       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14928         {
14929           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14930           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14931         }
14932       return node;
14933     }
14934   TREE_TYPE (node) = void_type_node;
14935   TREE_SIDE_EFFECTS (node) = 1;
14936   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14937   return node;
14938 }
14939
14940 /* 14.6 Labeled Statements */
14941
14942 /* Action taken when a lableled statement is parsed. a new
14943    LABELED_BLOCK_EXPR is created. No statement is attached to the
14944    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14945
14946 static tree
14947 build_labeled_block (int location, tree label)
14948 {
14949   tree label_name ;
14950   tree label_decl, node;
14951   if (label == NULL_TREE || label == continue_identifier_node)
14952     label_name = label;
14953   else
14954     {
14955       label_name = merge_qualified_name (label_id, label);
14956       /* Issue an error if we try to reuse a label that was previously
14957          declared */
14958       if (IDENTIFIER_LOCAL_VALUE (label_name))
14959         {
14960           EXPR_WFL_LINECOL (wfl_operator) = location;
14961           parse_error_context (wfl_operator,
14962             "Declaration of `%s' shadows a previous label declaration",
14963                                IDENTIFIER_POINTER (label));
14964           EXPR_WFL_LINECOL (wfl_operator) =
14965             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14966           parse_error_context (wfl_operator,
14967             "This is the location of the previous declaration of label `%s'",
14968                                IDENTIFIER_POINTER (label));
14969           java_error_count--;
14970         }
14971     }
14972
14973   label_decl = create_label_decl (label_name);
14974   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14975   EXPR_WFL_LINECOL (node) = location;
14976   TREE_SIDE_EFFECTS (node) = 1;
14977   return node;
14978 }
14979
14980 /* A labeled statement LBE is attached a statement.  */
14981
14982 static tree
14983 finish_labeled_statement (tree lbe, /* Labeled block expr */
14984                           tree statement)
14985 {
14986   /* In anyways, tie the loop to its statement */
14987   LABELED_BLOCK_BODY (lbe) = statement;
14988   pop_labeled_block ();
14989   POP_LABELED_BLOCK ();
14990   return lbe;
14991 }
14992
14993 /* 14.10, 14.11, 14.12 Loop Statements */
14994
14995 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14996    list. */
14997
14998 static tree
14999 build_new_loop (tree loop_body)
15000 {
15001   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
15002   TREE_SIDE_EFFECTS (loop) = 1;
15003   PUSH_LOOP (loop);
15004   return loop;
15005 }
15006
15007 /* Create a loop body according to the following structure:
15008      COMPOUND_EXPR
15009        COMPOUND_EXPR            (loop main body)
15010          EXIT_EXPR              (this order is for while/for loops.
15011          LABELED_BLOCK_EXPR      the order is reversed for do loops)
15012            LABEL_DECL           (a continue occurring here branches at the
15013            BODY                  end of this labeled block)
15014        INCREMENT                (if any)
15015
15016   REVERSED, if nonzero, tells that the loop condition expr comes
15017   after the body, like in the do-while loop.
15018
15019   To obtain a loop, the loop body structure described above is
15020   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
15021
15022    LABELED_BLOCK_EXPR
15023      LABEL_DECL                   (use this label to exit the loop)
15024      LOOP_EXPR
15025        <structure described above> */
15026
15027 static tree
15028 build_loop_body (int location, tree condition, int reversed)
15029 {
15030   tree first, second, body;
15031
15032   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
15033   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
15034   condition = build_debugable_stmt (location, condition);
15035   TREE_SIDE_EFFECTS (condition) = 1;
15036
15037   body = build_labeled_block (0, continue_identifier_node);
15038   first = (reversed ? body : condition);
15039   second = (reversed ? condition : body);
15040   return
15041     build (COMPOUND_EXPR, NULL_TREE,
15042            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
15043 }
15044
15045 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15046    their order) on the current loop. Unlink the current loop from the
15047    loop list.  */
15048
15049 static tree
15050 finish_loop_body (int location, tree condition, tree body, int reversed)
15051 {
15052   tree to_return = ctxp->current_loop;
15053   tree loop_body = LOOP_EXPR_BODY (to_return);
15054   if (condition)
15055     {
15056       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
15057       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15058          The real EXIT_EXPR is one operand further. */
15059       EXPR_WFL_LINECOL (cnode) = location;
15060       /* This one is for accurate error reports */
15061       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
15062       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
15063     }
15064   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
15065   POP_LOOP ();
15066   return to_return;
15067 }
15068
15069 /* Tailored version of finish_loop_body for FOR loops, when FOR
15070    loops feature the condition part */
15071
15072 static tree
15073 finish_for_loop (int location, tree condition, tree update, tree body)
15074 {
15075   /* Put the condition and the loop body in place */
15076   tree loop = finish_loop_body (location, condition, body, 0);
15077   /* LOOP is the current loop which has been now popped of the loop
15078      stack.  Mark the update block as reachable and install it.  We do
15079      this because the (current interpretation of the) JLS requires
15080      that the update expression be considered reachable even if the
15081      for loop's body doesn't complete normally.  */
15082   if (update != NULL_TREE && update != empty_stmt_node)
15083     {
15084       tree up2 = update;
15085       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15086         up2 = EXPR_WFL_NODE (up2);
15087       /* It is possible for the update expression to be an
15088          EXPR_WFL_NODE wrapping nothing.  */
15089       if (up2 != NULL_TREE && up2 != empty_stmt_node)
15090         {
15091           /* Try to detect constraint violations.  These would be
15092              programming errors somewhere.  */
15093           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
15094               || TREE_CODE (up2) == LOOP_EXPR)
15095             abort ();
15096           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15097         }
15098     }
15099   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15100   return loop;
15101 }
15102
15103 /* Try to find the loop a block might be related to. This comprises
15104    the case where the LOOP_EXPR is found as the second operand of a
15105    COMPOUND_EXPR, because the loop happens to have an initialization
15106    part, then expressed as the first operand of the COMPOUND_EXPR. If
15107    the search finds something, 1 is returned. Otherwise, 0 is
15108    returned. The search is assumed to start from a
15109    LABELED_BLOCK_EXPR's block.  */
15110
15111 static tree
15112 search_loop (tree statement)
15113 {
15114   if (TREE_CODE (statement) == LOOP_EXPR)
15115     return statement;
15116
15117   if (TREE_CODE (statement) == BLOCK)
15118     statement = BLOCK_SUBBLOCKS (statement);
15119   else
15120     return NULL_TREE;
15121
15122   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15123     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15124       statement = TREE_OPERAND (statement, 1);
15125
15126   return (TREE_CODE (statement) == LOOP_EXPR
15127           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15128 }
15129
15130 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15131    returned otherwise.  */
15132
15133 static int
15134 labeled_block_contains_loop_p (tree block, tree loop)
15135 {
15136   if (!block)
15137     return 0;
15138
15139   if (LABELED_BLOCK_BODY (block) == loop)
15140     return 1;
15141
15142   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15143     return 1;
15144
15145   return 0;
15146 }
15147
15148 /* If the loop isn't surrounded by a labeled statement, create one and
15149    insert LOOP as its body.  */
15150
15151 static tree
15152 patch_loop_statement (tree loop)
15153 {
15154   tree loop_label;
15155
15156   TREE_TYPE (loop) = void_type_node;
15157   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15158     return loop;
15159
15160   loop_label = build_labeled_block (0, NULL_TREE);
15161   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15162      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15163   LABELED_BLOCK_BODY (loop_label) = loop;
15164   PUSH_LABELED_BLOCK (loop_label);
15165   return loop_label;
15166 }
15167
15168 /* 14.13, 14.14: break and continue Statements */
15169
15170 /* Build a break or a continue statement. a null NAME indicates an
15171    unlabeled break/continue statement.  */
15172
15173 static tree
15174 build_bc_statement (int location, int is_break, tree name)
15175 {
15176   tree break_continue, label_block_expr = NULL_TREE;
15177
15178   if (name)
15179     {
15180       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15181             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15182         /* Null means that we don't have a target for this named
15183            break/continue. In this case, we make the target to be the
15184            label name, so that the error can be reported accuratly in
15185            patch_bc_statement. */
15186         label_block_expr = EXPR_WFL_NODE (name);
15187     }
15188   /* Unlabeled break/continue will be handled during the
15189      break/continue patch operation */
15190   break_continue
15191     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15192
15193   IS_BREAK_STMT_P (break_continue) = is_break;
15194   TREE_SIDE_EFFECTS (break_continue) = 1;
15195   EXPR_WFL_LINECOL (break_continue) = location;
15196   break_continue = build_debugable_stmt (location, break_continue);
15197   return break_continue;
15198 }
15199
15200 /* Verification of a break/continue statement. */
15201
15202 static tree
15203 patch_bc_statement (tree node)
15204 {
15205   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15206   tree labeled_block = ctxp->current_labeled_block;
15207   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15208
15209   /* Having an identifier here means that the target is unknown. */
15210   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15211     {
15212       parse_error_context (wfl_operator, "No label definition found for `%s'",
15213                            IDENTIFIER_POINTER (bc_label));
15214       return error_mark_node;
15215     }
15216   if (! IS_BREAK_STMT_P (node))
15217     {
15218       /* It's a continue statement. */
15219       for (;; labeled_block = TREE_CHAIN (labeled_block))
15220         {
15221           if (labeled_block == NULL_TREE)
15222             {
15223               if (bc_label == NULL_TREE)
15224                 parse_error_context (wfl_operator,
15225                                      "`continue' must be in loop");
15226               else
15227                 parse_error_context
15228                   (wfl_operator, "continue label `%s' does not name a loop",
15229                    IDENTIFIER_POINTER (bc_label));
15230               return error_mark_node;
15231             }
15232           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15233                == continue_identifier_node)
15234               && (bc_label == NULL_TREE
15235                   || TREE_CHAIN (labeled_block) == bc_label))
15236             {
15237               bc_label = labeled_block;
15238               break;
15239             }
15240         }
15241     }
15242   else if (!bc_label)
15243     {
15244       for (;; labeled_block = TREE_CHAIN (labeled_block))
15245         {
15246           if (labeled_block == NULL_TREE)
15247             {
15248               parse_error_context (wfl_operator,
15249                                      "`break' must be in loop or switch");
15250               return error_mark_node;
15251             }
15252           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15253           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15254               || search_loop (target_stmt))
15255             {
15256               bc_label = labeled_block;
15257               break;
15258             }
15259         }
15260     }
15261
15262   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15263   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15264
15265   /* Our break/continue don't return values. */
15266   TREE_TYPE (node) = void_type_node;
15267   /* Encapsulate the break within a compound statement so that it's
15268      expanded all the times by expand_expr (and not clobbered
15269      sometimes, like after a if statement) */
15270   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15271   TREE_SIDE_EFFECTS (node) = 1;
15272   return node;
15273 }
15274
15275 /* Process the exit expression belonging to a loop. Its type must be
15276    boolean.  */
15277
15278 static tree
15279 patch_exit_expr (tree node)
15280 {
15281   tree expression = TREE_OPERAND (node, 0);
15282   TREE_TYPE (node) = error_mark_node;
15283   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15284
15285   /* The type of expression must be boolean */
15286   if (TREE_TYPE (expression) != boolean_type_node)
15287     {
15288       parse_error_context
15289         (wfl_operator,
15290     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15291          lang_printable_name (TREE_TYPE (expression), 0));
15292       return error_mark_node;
15293     }
15294   /* Now we know things are allright, invert the condition, fold and
15295      return */
15296   TREE_OPERAND (node, 0) =
15297     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15298
15299   if (! integer_zerop (TREE_OPERAND (node, 0))
15300       && ctxp->current_loop != NULL_TREE
15301       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15302     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15303   if (! integer_onep (TREE_OPERAND (node, 0)))
15304     CAN_COMPLETE_NORMALLY (node) = 1;
15305
15306
15307   TREE_TYPE (node) = void_type_node;
15308   return node;
15309 }
15310
15311 /* 14.9 Switch statement */
15312
15313 static tree
15314 patch_switch_statement (tree node)
15315 {
15316   tree se = TREE_OPERAND (node, 0), se_type;
15317   tree save, iter;
15318
15319   /* Complete the switch expression */
15320   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15321   se_type = TREE_TYPE (se);
15322   /* The type of the switch expression must be char, byte, short or
15323      int */
15324   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15325     {
15326       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15327       parse_error_context (wfl_operator,
15328           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15329                            lang_printable_name (se_type, 0));
15330       /* This is what java_complete_tree will check */
15331       TREE_OPERAND (node, 0) = error_mark_node;
15332       return error_mark_node;
15333     }
15334
15335   /* Save and restore the outer case label list.  */
15336   save = case_label_list;
15337   case_label_list = NULL_TREE;
15338
15339   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15340
15341   /* See if we've found a duplicate label.  We can't leave this until
15342      code generation, because in `--syntax-only' and `-C' modes we
15343      don't do ordinary code generation.  */
15344   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15345     {
15346       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15347       tree subiter;
15348       for (subiter = TREE_CHAIN (iter);
15349            subiter != NULL_TREE;
15350            subiter = TREE_CHAIN (subiter))
15351         {
15352           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15353           if (val == subval)
15354             {
15355               EXPR_WFL_LINECOL (wfl_operator)
15356                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15357               /* The case_label_list is in reverse order, so print the
15358                  outer label first.  */
15359               parse_error_context (wfl_operator, "duplicate case label: `"
15360                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15361               EXPR_WFL_LINECOL (wfl_operator)
15362                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15363               parse_error_context (wfl_operator, "original label is here");
15364
15365               break;
15366             }
15367         }
15368     }
15369
15370   case_label_list = save;
15371
15372   /* Ready to return */
15373   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15374     {
15375       TREE_TYPE (node) = error_mark_node;
15376       return error_mark_node;
15377     }
15378   TREE_TYPE (node) = void_type_node;
15379   TREE_SIDE_EFFECTS (node) = 1;
15380   CAN_COMPLETE_NORMALLY (node)
15381     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15382       || ! SWITCH_HAS_DEFAULT (node);
15383   return node;
15384 }
15385
15386 /* Assertions.  */
15387
15388 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15389    might be NULL_TREE.  */
15390 static tree
15391 build_assertion (int location, tree condition, tree value)
15392 {
15393   tree node;
15394   tree klass = GET_CPC ();
15395
15396   if (! CLASS_USES_ASSERTIONS (klass))
15397     {
15398       tree field, classdollar, id, call;
15399       tree class_type = TREE_TYPE (klass);
15400
15401       field = add_field (class_type,
15402                          get_identifier ("$assertionsDisabled"),
15403                          boolean_type_node,
15404                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15405       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15406       FIELD_SYNTHETIC (field) = 1;
15407
15408       if (!TYPE_DOT_CLASS (class_type))
15409         build_dot_class_method (class_type);
15410       classdollar = build_dot_class_method_invocation (class_type);
15411
15412       /* Call CLASS.desiredAssertionStatus().  */
15413       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15414       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15415       call = make_qualified_primary (classdollar, call, location);
15416       TREE_SIDE_EFFECTS (call) = 1;
15417
15418       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15419          seem odd, but we do it to generate code identical to that of
15420          the JDK.  */
15421       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15422       TREE_SIDE_EFFECTS (call) = 1;
15423       DECL_INITIAL (field) = call;
15424
15425       /* Record the initializer in the initializer statement list.  */
15426       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15427       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15428       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15429       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15430
15431       CLASS_USES_ASSERTIONS (klass) = 1;
15432     }
15433
15434   if (value != NULL_TREE)
15435     value = tree_cons (NULL_TREE, value, NULL_TREE);
15436
15437   node = build_wfl_node (get_identifier ("java"));
15438   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15439                               location);
15440   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15441                               location);
15442
15443   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15444   TREE_SIDE_EFFECTS (node) = 1;
15445   /* It is too early to use BUILD_THROW.  */
15446   node = build1 (THROW_EXPR, NULL_TREE, node);
15447   TREE_SIDE_EFFECTS (node) = 1;
15448
15449   /* We invert the condition; if we just put NODE as the `else' part
15450      then we generate weird-looking bytecode.  */
15451   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15452   /* Check $assertionsDisabled.  */
15453   condition
15454     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15455              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15456                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15457              condition);
15458   node = build_if_else_statement (location, condition, node, NULL_TREE);
15459   return node;
15460 }
15461
15462 /* 14.18 The try/catch statements */
15463
15464 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15465    catches TYPE and executes CATCH_STMTS.  */
15466
15467 static tree
15468 encapsulate_with_try_catch (int location, tree type, tree try_stmts,
15469                             tree catch_stmts)
15470 {
15471   tree try_block, catch_clause_param, catch_block, catch;
15472
15473   /* First build a try block */
15474   try_block = build_expr_block (try_stmts, NULL_TREE);
15475
15476   /* Build a catch block: we need a catch clause parameter */
15477   catch_clause_param = build_decl (VAR_DECL,
15478                                    wpv_id, build_pointer_type (type));
15479   /* And a block */
15480   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15481
15482   /* Initialize the variable and store in the block */
15483   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15484                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15485   add_stmt_to_block (catch_block, NULL_TREE, catch);
15486
15487   /* Add the catch statements */
15488   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15489
15490   /* Now we can build a CATCH_EXPR */
15491   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15492
15493   return build_try_statement (location, try_block, catch_block);
15494 }
15495
15496 static tree
15497 build_try_statement (int location, tree try_block, tree catches)
15498 {
15499   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15500   EXPR_WFL_LINECOL (node) = location;
15501   return node;
15502 }
15503
15504 static tree
15505 build_try_finally_statement (int location, tree try_block, tree finally)
15506 {
15507   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15508   EXPR_WFL_LINECOL (node) = location;
15509   return node;
15510 }
15511
15512 static tree
15513 patch_try_statement (tree node)
15514 {
15515   int error_found = 0;
15516   tree try = TREE_OPERAND (node, 0);
15517   /* Exception handlers are considered in left to right order */
15518   tree catch = nreverse (TREE_OPERAND (node, 1));
15519   tree current, caught_type_list = NULL_TREE;
15520
15521   /* Check catch clauses, if any. Every time we find an error, we try
15522      to process the next catch clause. We process the catch clause before
15523      the try block so that when processing the try block we can check thrown
15524      exceptions againts the caught type list. */
15525   for (current = catch; current; current = TREE_CHAIN (current))
15526     {
15527       tree carg_decl, carg_type;
15528       tree sub_current, catch_block, catch_clause;
15529       int unreachable;
15530
15531       /* At this point, the structure of the catch clause is
15532            CATCH_EXPR           (catch node)
15533              BLOCK              (with the decl of the parameter)
15534                COMPOUND_EXPR
15535                  MODIFY_EXPR   (assignment of the catch parameter)
15536                  BLOCK          (catch clause block)
15537        */
15538       catch_clause = TREE_OPERAND (current, 0);
15539       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15540       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15541
15542       /* Catch clauses can't have more than one parameter declared,
15543          but it's already enforced by the grammar. Make sure that the
15544          only parameter of the clause statement in of class Throwable
15545          or a subclass of Throwable, but that was done earlier. The
15546          catch clause parameter type has also been resolved. */
15547
15548       /* Just make sure that the catch clause parameter type inherits
15549          from java.lang.Throwable */
15550       if (!inherits_from_p (carg_type, throwable_type_node))
15551         {
15552           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15553           parse_error_context (wfl_operator,
15554                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15555                                lang_printable_name (carg_type, 0));
15556           error_found = 1;
15557           continue;
15558         }
15559
15560       /* Partial check for unreachable catch statement: The catch
15561          clause is reachable iff is no earlier catch block A in
15562          the try statement such that the type of the catch
15563          clause's parameter is the same as or a subclass of the
15564          type of A's parameter */
15565       unreachable = 0;
15566       for (sub_current = catch;
15567            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15568         {
15569           tree sub_catch_clause, decl;
15570           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15571           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15572
15573           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15574             {
15575               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15576               parse_error_context
15577                 (wfl_operator,
15578                  "`catch' not reached because of the catch clause at line %d",
15579                  EXPR_WFL_LINENO (sub_current));
15580               unreachable = error_found = 1;
15581               break;
15582             }
15583         }
15584       /* Complete the catch clause block */
15585       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15586       if (catch_block == error_mark_node)
15587         {
15588           error_found = 1;
15589           continue;
15590         }
15591       if (CAN_COMPLETE_NORMALLY (catch_block))
15592         CAN_COMPLETE_NORMALLY (node) = 1;
15593       TREE_OPERAND (current, 0) = catch_block;
15594
15595       if (unreachable)
15596         continue;
15597
15598       /* Things to do here: the exception must be thrown */
15599
15600       /* Link this type to the caught type list */
15601       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15602     }
15603
15604   PUSH_EXCEPTIONS (caught_type_list);
15605   if ((try = java_complete_tree (try)) == error_mark_node)
15606     error_found = 1;
15607   if (CAN_COMPLETE_NORMALLY (try))
15608     CAN_COMPLETE_NORMALLY (node) = 1;
15609   POP_EXCEPTIONS ();
15610
15611   /* Verification ends here */
15612   if (error_found)
15613     return error_mark_node;
15614
15615   TREE_OPERAND (node, 0) = try;
15616   TREE_OPERAND (node, 1) = catch;
15617   TREE_TYPE (node) = void_type_node;
15618   return node;
15619 }
15620
15621 /* 14.17 The synchronized Statement */
15622
15623 static tree
15624 patch_synchronized_statement (tree node, tree wfl_op1)
15625 {
15626   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15627   tree block = TREE_OPERAND (node, 1);
15628
15629   tree tmp, enter, exit, expr_decl, assignment;
15630
15631   if (expr == error_mark_node)
15632     {
15633       block = java_complete_tree (block);
15634       return expr;
15635     }
15636
15637   /* We might be trying to synchronize on a STRING_CST */
15638   if ((tmp = patch_string (expr)))
15639     expr = tmp;
15640
15641   /* The TYPE of expr must be a reference type */
15642   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15643     {
15644       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15645       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15646                            lang_printable_name (TREE_TYPE (expr), 0));
15647       return error_mark_node;
15648     }
15649
15650   if (flag_emit_xref)
15651     {
15652       TREE_OPERAND (node, 0) = expr;
15653       TREE_OPERAND (node, 1) = java_complete_tree (block);
15654       CAN_COMPLETE_NORMALLY (node) = 1;
15655       return node;
15656     }
15657
15658   /* Generate a try-finally for the synchronized statement, except
15659      that the handler that catches all throw exception calls
15660      _Jv_MonitorExit and then rethrow the exception.
15661      The synchronized statement is then implemented as:
15662      TRY
15663        {
15664          _Jv_MonitorEnter (expression)
15665          synchronized_block
15666          _Jv_MonitorExit (expression)
15667        }
15668      CATCH_ALL
15669        {
15670          e = _Jv_exception_info ();
15671          _Jv_MonitorExit (expression)
15672          Throw (e);
15673        } */
15674
15675   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15676   BUILD_MONITOR_ENTER (enter, expr_decl);
15677   BUILD_MONITOR_EXIT (exit, expr_decl);
15678   CAN_COMPLETE_NORMALLY (enter) = 1;
15679   CAN_COMPLETE_NORMALLY (exit) = 1;
15680   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15681   TREE_SIDE_EFFECTS (assignment) = 1;
15682   node = build (COMPOUND_EXPR, NULL_TREE,
15683                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15684                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15685   node = build_expr_block (node, expr_decl);
15686
15687   return java_complete_tree (node);
15688 }
15689
15690 /* 14.16 The throw Statement */
15691
15692 static tree
15693 patch_throw_statement (tree node, tree wfl_op1)
15694 {
15695   tree expr = TREE_OPERAND (node, 0);
15696   tree type = TREE_TYPE (expr);
15697   int unchecked_ok = 0, tryblock_throws_ok = 0;
15698
15699   /* Thrown expression must be assignable to java.lang.Throwable */
15700   if (!try_reference_assignconv (throwable_type_node, expr))
15701     {
15702       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15703       parse_error_context (wfl_operator,
15704     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15705                            lang_printable_name (type, 0));
15706       /* If the thrown expression was a reference, we further the
15707          compile-time check. */
15708       if (!JREFERENCE_TYPE_P (type))
15709         return error_mark_node;
15710     }
15711
15712   /* At least one of the following must be true */
15713
15714   /* The type of the throw expression is a not checked exception,
15715      i.e. is a unchecked expression. */
15716   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15717
15718   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15719   /* An instance can't throw a checked exception unless that exception
15720      is explicitly declared in the `throws' clause of each
15721      constructor. This doesn't apply to anonymous classes, since they
15722      don't have declared constructors. */
15723   if (!unchecked_ok
15724       && DECL_INSTINIT_P (current_function_decl)
15725       && !ANONYMOUS_CLASS_P (current_class))
15726     {
15727       tree current;
15728       for (current = TYPE_METHODS (current_class); current;
15729            current = TREE_CHAIN (current))
15730         if (DECL_CONSTRUCTOR_P (current)
15731             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15732           {
15733             parse_error_context (wfl_operator, "Checked exception `%s' can't be thrown in instance initializer (not all declared constructor are declaring it in their `throws' clause)",
15734                                  lang_printable_name (TREE_TYPE (expr), 0));
15735             return error_mark_node;
15736           }
15737     }
15738
15739   /* Throw is contained in a try statement and at least one catch
15740      clause can receive the thrown expression or the current method is
15741      declared to throw such an exception. Or, the throw statement is
15742      contained in a method or constructor declaration and the type of
15743      the Expression is assignable to at least one type listed in the
15744      throws clause the declaration. */
15745   if (!unchecked_ok)
15746     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15747   if (!(unchecked_ok || tryblock_throws_ok))
15748     {
15749       /* If there is a surrounding try block that has no matching
15750          clatch clause, report it first. A surrounding try block exits
15751          only if there is something after the list of checked
15752          exception thrown by the current function (if any). */
15753       if (IN_TRY_BLOCK_P ())
15754         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15755                              lang_printable_name (type, 0));
15756       /* If we have no surrounding try statement and the method doesn't have
15757          any throws, report it now. FIXME */
15758
15759       /* We report that the exception can't be throw from a try block
15760          in all circumstances but when the `throw' is inside a static
15761          block. */
15762       else if (!EXCEPTIONS_P (currently_caught_type_list)
15763                && !tryblock_throws_ok)
15764         {
15765           if (DECL_CLINIT_P (current_function_decl))
15766             parse_error_context (wfl_operator,
15767                    "Checked exception `%s' can't be thrown in initializer",
15768                                  lang_printable_name (type, 0));
15769           else
15770             parse_error_context (wfl_operator,
15771                    "Checked exception `%s' isn't thrown from a `try' block",
15772                                  lang_printable_name (type, 0));
15773         }
15774       /* Otherwise, the current method doesn't have the appropriate
15775          throws declaration */
15776       else
15777         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15778                              lang_printable_name (type, 0));
15779       return error_mark_node;
15780     }
15781
15782   if (! flag_emit_class_files && ! flag_emit_xref)
15783     BUILD_THROW (node, expr);
15784
15785   /* If doing xrefs, keep the location where the `throw' was seen. */
15786   if (flag_emit_xref)
15787     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15788   return node;
15789 }
15790
15791 /* Check that exception said to be thrown by method DECL can be
15792    effectively caught from where DECL is invoked.  THIS_EXPR is the
15793    expression that computes `this' for the method call.  */
15794 static void
15795 check_thrown_exceptions (int location, tree decl, tree this_expr)
15796 {
15797   tree throws;
15798   int is_array_call = 0;
15799
15800   if (this_expr != NULL_TREE
15801       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15802       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15803     is_array_call = 1;
15804
15805   /* For all the unchecked exceptions thrown by DECL.  */
15806   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15807        throws = TREE_CHAIN (throws))
15808     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15809       {
15810         /* Suppress errors about cloning arrays.  */
15811         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15812           continue;
15813
15814         EXPR_WFL_LINECOL (wfl_operator) = location;
15815         if (DECL_FINIT_P (current_function_decl))
15816           parse_error_context
15817             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15818              lang_printable_name (TREE_VALUE (throws), 0));
15819         else
15820           {
15821             parse_error_context
15822               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15823                lang_printable_name (TREE_VALUE (throws), 0),
15824                (DECL_INIT_P (current_function_decl) ?
15825                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15826                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15827           }
15828       }
15829 }
15830
15831 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15832    try-catch blocks, OR is listed in the `throws' clause of the
15833    current method.  */
15834
15835 static int
15836 check_thrown_exceptions_do (tree exception)
15837 {
15838   tree list = currently_caught_type_list;
15839   resolve_and_layout (exception, NULL_TREE);
15840   /* First, all the nested try-catch-finally at that stage. The
15841      last element contains `throws' clause exceptions, if any. */
15842   if (IS_UNCHECKED_EXCEPTION_P (exception))
15843     return 1;
15844   while (list)
15845     {
15846       tree caught;
15847       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15848         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15849           return 1;
15850       list = TREE_CHAIN (list);
15851     }
15852   return 0;
15853 }
15854
15855 static void
15856 purge_unchecked_exceptions (tree mdecl)
15857 {
15858   tree throws = DECL_FUNCTION_THROWS (mdecl);
15859   tree new = NULL_TREE;
15860
15861   while (throws)
15862     {
15863       tree next = TREE_CHAIN (throws);
15864       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15865         {
15866           TREE_CHAIN (throws) = new;
15867           new = throws;
15868         }
15869       throws = next;
15870     }
15871   /* List is inverted here, but it doesn't matter */
15872   DECL_FUNCTION_THROWS (mdecl) = new;
15873 }
15874
15875 /* This function goes over all of CLASS_TYPE ctors and checks whether
15876    each of them features at least one unchecked exception in its
15877    `throws' clause. If it's the case, it returns `true', `false'
15878    otherwise.  */
15879
15880 static bool
15881 ctors_unchecked_throws_clause_p (tree class_type)
15882 {
15883   tree current;
15884
15885   for (current = TYPE_METHODS (class_type); current;
15886        current = TREE_CHAIN (current))
15887     {
15888       bool ctu = false; /* Ctor Throws Unchecked */
15889       if (DECL_CONSTRUCTOR_P (current))
15890         {
15891           tree throws;
15892           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15893                throws = TREE_CHAIN (throws))
15894             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15895               ctu = true;
15896         }
15897       /* We return false as we found one ctor that is unfit. */
15898       if (!ctu && DECL_CONSTRUCTOR_P (current))
15899         return false;
15900     }
15901   /* All ctors feature at least one unchecked exception in their
15902      `throws' clause. */
15903   return true;
15904 }
15905
15906 /* 15.24 Conditional Operator ?: */
15907
15908 static tree
15909 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15910 {
15911   tree cond = TREE_OPERAND (node, 0);
15912   tree op1 = TREE_OPERAND (node, 1);
15913   tree op2 = TREE_OPERAND (node, 2);
15914   tree resulting_type = NULL_TREE;
15915   tree t1, t2, patched;
15916   int error_found = 0;
15917
15918   /* Operands of ?: might be StringBuffers crafted as a result of a
15919      string concatenation. Obtain a descent operand here.  */
15920   if ((patched = patch_string (op1)))
15921     TREE_OPERAND (node, 1) = op1 = patched;
15922   if ((patched = patch_string (op2)))
15923     TREE_OPERAND (node, 2) = op2 = patched;
15924
15925   t1 = TREE_TYPE (op1);
15926   t2 = TREE_TYPE (op2);
15927
15928   /* The first expression must be a boolean */
15929   if (TREE_TYPE (cond) != boolean_type_node)
15930     {
15931       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15932       parse_error_context (wfl_operator,
15933                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15934                            lang_printable_name (TREE_TYPE (cond), 0));
15935       error_found = 1;
15936     }
15937
15938   /* Second and third can be numeric, boolean (i.e. primitive),
15939      references or null. Anything else results in an error */
15940   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15941         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15942             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15943         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15944     error_found = 1;
15945
15946   /* Determine the type of the conditional expression. Same types are
15947      easy to deal with */
15948   else if (t1 == t2)
15949     resulting_type = t1;
15950
15951   /* There are different rules for numeric types */
15952   else if (JNUMERIC_TYPE_P (t1))
15953     {
15954       /* if byte/short found, the resulting type is short */
15955       if ((t1 == byte_type_node && t2 == short_type_node)
15956           || (t1 == short_type_node && t2 == byte_type_node))
15957         resulting_type = short_type_node;
15958
15959       /* If t1 is a constant int and t2 is of type byte, short or char
15960          and t1's value fits in t2, then the resulting type is t2 */
15961       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15962           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15963         resulting_type = t2;
15964
15965       /* If t2 is a constant int and t1 is of type byte, short or char
15966          and t2's value fits in t1, then the resulting type is t1 */
15967       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15968           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15969         resulting_type = t1;
15970
15971       /* Otherwise, binary numeric promotion is applied and the
15972          resulting type is the promoted type of operand 1 and 2 */
15973       else
15974         resulting_type = binary_numeric_promotion (t1, t2,
15975                                                    &TREE_OPERAND (node, 1),
15976                                                    &TREE_OPERAND (node, 2));
15977     }
15978
15979   /* Cases of a reference and a null type */
15980   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15981     resulting_type = t1;
15982
15983   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15984     resulting_type = t2;
15985
15986   /* Last case: different reference types. If a type can be converted
15987      into the other one by assignment conversion, the latter
15988      determines the type of the expression */
15989   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15990     resulting_type = promote_type (t1);
15991
15992   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15993     resulting_type = promote_type (t2);
15994
15995   /* If we don't have any resulting type, we're in trouble */
15996   if (!resulting_type)
15997     {
15998       char *t = xstrdup (lang_printable_name (t1, 0));
15999       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
16000       parse_error_context (wfl_operator,
16001                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
16002                            t, lang_printable_name (t2, 0));
16003       free (t);
16004       error_found = 1;
16005     }
16006
16007   if (error_found)
16008     {
16009       TREE_TYPE (node) = error_mark_node;
16010       return error_mark_node;
16011     }
16012
16013   TREE_TYPE (node) = resulting_type;
16014   TREE_SET_CODE (node, COND_EXPR);
16015   CAN_COMPLETE_NORMALLY (node) = 1;
16016   return node;
16017 }
16018
16019 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16020
16021 static tree
16022 maybe_build_class_init_for_field (tree decl, tree expr)
16023 {
16024   tree clas = DECL_CONTEXT (decl);
16025   if (flag_emit_class_files || flag_emit_xref)
16026     return expr;
16027
16028   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
16029       && FIELD_FINAL (decl))
16030     {
16031       tree init = DECL_INITIAL (decl);
16032       if (init != NULL_TREE)
16033         init = fold_constant_for_init (init, decl);
16034       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
16035         return expr;
16036     }
16037
16038   return build_class_init (clas, expr);
16039 }
16040
16041 /* Try to constant fold NODE.
16042    If NODE is not a constant expression, return NULL_EXPR.
16043    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16044
16045 static tree
16046 fold_constant_for_init (tree node, tree context)
16047 {
16048   tree op0, op1, val;
16049   enum tree_code code = TREE_CODE (node);
16050
16051   switch (code)
16052     {
16053     case INTEGER_CST:
16054       if (node == null_pointer_node)
16055         return NULL_TREE;
16056     case STRING_CST:
16057     case REAL_CST:
16058       return node;
16059
16060     case PLUS_EXPR:
16061     case MINUS_EXPR:
16062     case MULT_EXPR:
16063     case TRUNC_MOD_EXPR:
16064     case RDIV_EXPR:
16065     case LSHIFT_EXPR:
16066     case RSHIFT_EXPR:
16067     case URSHIFT_EXPR:
16068     case BIT_AND_EXPR:
16069     case BIT_XOR_EXPR:
16070     case BIT_IOR_EXPR:
16071     case TRUTH_ANDIF_EXPR:
16072     case TRUTH_ORIF_EXPR:
16073     case EQ_EXPR:
16074     case NE_EXPR:
16075     case GT_EXPR:
16076     case GE_EXPR:
16077     case LT_EXPR:
16078     case LE_EXPR:
16079       op0 = TREE_OPERAND (node, 0);
16080       op1 = TREE_OPERAND (node, 1);
16081       val = fold_constant_for_init (op0, context);
16082       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16083         return NULL_TREE;
16084       TREE_OPERAND (node, 0) = val;
16085       val = fold_constant_for_init (op1, context);
16086       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16087         return NULL_TREE;
16088       TREE_OPERAND (node, 1) = val;
16089       return patch_binop (node, op0, op1);
16090
16091     case UNARY_PLUS_EXPR:
16092     case NEGATE_EXPR:
16093     case TRUTH_NOT_EXPR:
16094     case BIT_NOT_EXPR:
16095     case CONVERT_EXPR:
16096       op0 = TREE_OPERAND (node, 0);
16097       val = fold_constant_for_init (op0, context);
16098       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16099         return NULL_TREE;
16100       TREE_OPERAND (node, 0) = val;
16101       return patch_unaryop (node, op0);
16102       break;
16103
16104     case COND_EXPR:
16105       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16106       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16107         return NULL_TREE;
16108       TREE_OPERAND (node, 0) = val;
16109       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16110       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16111         return NULL_TREE;
16112       TREE_OPERAND (node, 1) = val;
16113       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16114       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16115         return NULL_TREE;
16116       TREE_OPERAND (node, 2) = val;
16117       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16118         : TREE_OPERAND (node, 2);
16119
16120     case VAR_DECL:
16121     case FIELD_DECL:
16122       if (! FIELD_FINAL (node)
16123           || DECL_INITIAL (node) == NULL_TREE)
16124         return NULL_TREE;
16125       val = DECL_INITIAL (node);
16126       /* Guard against infinite recursion. */
16127       DECL_INITIAL (node) = NULL_TREE;
16128       val = fold_constant_for_init (val, node);
16129       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16130         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16131       DECL_INITIAL (node) = val;
16132       return val;
16133
16134     case EXPR_WITH_FILE_LOCATION:
16135       /* Compare java_complete_tree and resolve_expression_name. */
16136       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16137           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16138         {
16139           tree name = EXPR_WFL_NODE (node);
16140           tree decl;
16141           if (PRIMARY_P (node))
16142             return NULL_TREE;
16143           else if (! QUALIFIED_P (name))
16144             {
16145               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16146               if (decl == NULL_TREE
16147                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16148                 return NULL_TREE;
16149               return fold_constant_for_init (decl, decl);
16150             }
16151           else
16152             {
16153               /* Install the proper context for the field resolution.
16154                  The prior context is restored once the name is
16155                  properly qualified. */
16156               tree saved_current_class = current_class;
16157               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16158               current_class = DECL_CONTEXT (context);
16159               qualify_ambiguous_name (node);
16160               current_class = saved_current_class;
16161               if (resolve_field_access (node, &decl, NULL)
16162                   && decl != NULL_TREE)
16163                 return fold_constant_for_init (decl, decl);
16164               return NULL_TREE;
16165             }
16166         }
16167       else
16168         {
16169           op0 = TREE_OPERAND (node, 0);
16170           val = fold_constant_for_init (op0, context);
16171           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16172             return NULL_TREE;
16173           TREE_OPERAND (node, 0) = val;
16174           return val;
16175         }
16176
16177 #ifdef USE_COMPONENT_REF
16178     case IDENTIFIER:
16179     case COMPONENT_REF:
16180       ?;
16181 #endif
16182
16183     default:
16184       return NULL_TREE;
16185     }
16186 }
16187
16188 #ifdef USE_COMPONENT_REF
16189 /* Context is 'T' for TypeName, 'P' for PackageName,
16190    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16191
16192 tree
16193 resolve_simple_name (tree name, int context)
16194 {
16195 }
16196
16197 tree
16198 resolve_qualified_name (tree name, int context)
16199 {
16200 }
16201 #endif
16202
16203 void
16204 init_src_parse (void)
16205 {
16206   /* Sanity check; we've been bit by this before.  */
16207   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16208     abort ();
16209 }
16210
16211 \f
16212
16213 /* This section deals with the functions that are called when tables
16214    recording class initialization information are traversed.  */
16215
16216 /* Attach to PTR (a block) the declaration found in ENTRY. */
16217
16218 static int
16219 attach_init_test_initialization_flags (void **entry, void *ptr)
16220 {
16221   tree block = (tree)ptr;
16222   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16223
16224   if (block != error_mark_node)
16225     {
16226       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16227       BLOCK_EXPR_DECLS (block) = ite->value;
16228     }
16229   return true;
16230 }
16231
16232 /* This function is called for each classes that is known definitely
16233    assigned when a given static method was called. This function
16234    augments a compound expression (INFO) storing all assignment to
16235    initialized static class flags if a flag already existed, otherwise
16236    a new one is created.  */
16237
16238 static int
16239 emit_test_initialization (void **entry_p, void *info)
16240 {
16241   tree l = (tree) info;
16242   tree decl, init;
16243   tree key = (tree) *entry_p;
16244   tree *ite;
16245   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16246
16247   /* If we haven't found a flag and we're dealing with self registered
16248      with current_function_decl, then don't do anything. Self is
16249      always added as definitely initialized but this information is
16250      valid only if used outside the current function. */
16251   if (current_function_decl == TREE_PURPOSE (l)
16252       && java_treetreehash_find (cf_ht, key) == NULL)
16253     return true;
16254
16255   ite = java_treetreehash_new (cf_ht, key);
16256
16257   /* If we don't have a variable, create one and install it. */
16258   if (*ite == NULL)
16259     {
16260       tree block;
16261
16262       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16263       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16264       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16265       DECL_CONTEXT (decl) = current_function_decl;
16266       DECL_INITIAL (decl) = boolean_true_node;
16267       /* Don't emit any symbolic debugging info for this decl.  */
16268       DECL_IGNORED_P (decl) = 1;
16269
16270       /* The trick is to find the right context for it. */
16271       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16272       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16273       BLOCK_EXPR_DECLS (block) = decl;
16274       *ite = decl;
16275     }
16276   else
16277     decl = *ite;
16278
16279   /* Now simply augment the compound that holds all the assignments
16280      pertaining to this method invocation. */
16281   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16282   TREE_SIDE_EFFECTS (init) = 1;
16283   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16284   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16285
16286   return true;
16287 }
16288
16289 #include "gt-java-parse.h"
16290 #include "gtype-java.h"