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 Free Software Foundation, Inc.
   4    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.
  22
  23 Java and all Java-based marks are trademarks or registered trademarks
  24 of Sun Microsystems, Inc. in the United States and other countries.
  25 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  26
  27 /* This file parses java source code and issues a tree node image
  28 suitable for code generation (byte code and targeted CPU assembly
  29 language).
  30
  31 The grammar conforms to the Java grammar described in "The Java(TM)
  32 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  33 1996, ISBN 0-201-63451-1"
  34
  35 The following modifications were brought to the original grammar:
  36
  37 method_body: added the rule '| block SC_TK'
  38 static_initializer: added the rule 'static block SC_TK'.
  39
  40 Note: All the extra rules described above should go away when the
  41       empty_statement rule will work.
  42
  43 statement_nsi: 'nsi' should be read no_short_if.
  44
  45 Some rules have been modified to support JDK1.1 inner classes
  46 definitions and other extensions.  */
  47
  48 %{
  49 #include "config.h"
  50 #include "system.h"
  51 #include <dirent.h>
  52 #include "tree.h"
  53 #include "rtl.h"
  54 #include "obstack.h"
  55 #include "toplev.h"
  56 #include "flags.h"
  57 #include "java-tree.h"
  58 #include "jcf.h"
  59 #include "lex.h"
  60 #include "parse.h"
  61 #include "zipfile.h"
  62 #include "convert.h"
  63 #include "buffer.h"
  64 #include "xref.h"
  65 #include "function.h"
  66 #include "except.h"
  67 #include "ggc.h"
  68
  69 #ifndef DIR_SEPARATOR
  70 #define DIR_SEPARATOR '/'
  71 #endif
  72
  73 /* Local function prototypes */
  74 static char *java_accstring_lookup PARAMS ((int));
  75 static void  classitf_redefinition_error PARAMS ((const char *,tree, tree, tree));
  76 static void  variable_redefinition_error PARAMS ((tree, tree, tree, int));
  77 static tree  create_class PARAMS ((int, tree, tree, tree));
  78 static tree  create_interface PARAMS ((int, tree, tree));
  79 static void  end_class_declaration PARAMS ((int));
  80 static tree  find_field PARAMS ((tree, tree));
  81 static tree lookup_field_wrapper PARAMS ((tree, tree));
  82 static int   duplicate_declaration_error_p PARAMS ((tree, tree, tree));
  83 static void  register_fields PARAMS ((int, tree, tree));
  84 static tree parser_qualified_classname PARAMS ((tree));
  85 static int  parser_check_super PARAMS ((tree, tree, tree));
  86 static int  parser_check_super_interface PARAMS ((tree, tree, tree));
  87 static void check_modifiers_consistency PARAMS ((int));
  88 static tree lookup_cl PARAMS ((tree));
  89 static tree lookup_java_method2 PARAMS ((tree, tree, int));
  90 static tree method_header PARAMS ((int, tree, tree, tree));
  91 static void fix_method_argument_names PARAMS ((tree ,tree));
  92 static tree method_declarator PARAMS ((tree, tree));
  93 static void parse_warning_context PARAMS ((tree cl, const char *msg, ...))
  94   ATTRIBUTE_PRINTF_2;
  95 static void issue_warning_error_from_context PARAMS ((tree, const char *msg, va_list))
  96   ATTRIBUTE_PRINTF (2, 0);
  97 static void parse_ctor_invocation_error PARAMS ((void));
  98 static tree parse_jdk1_1_error PARAMS ((const char *));
  99 static void complete_class_report_errors PARAMS ((jdep *));
 100 static int process_imports PARAMS ((void));
 101 static void read_import_dir PARAMS ((tree));
 102 static int find_in_imports_on_demand PARAMS ((tree, tree));
 103 static void find_in_imports PARAMS ((tree, tree));
 104 static void check_inner_class_access PARAMS ((tree, tree, tree));
 105 static int check_pkg_class_access PARAMS ((tree, tree, bool));
 106 static void register_package PARAMS ((tree));
 107 static tree resolve_package PARAMS ((tree, tree *, tree *));
 108 static tree lookup_package_type PARAMS ((const char *, int));
 109 static tree resolve_class PARAMS ((tree, tree, tree, tree));
 110 static void declare_local_variables PARAMS ((int, tree, tree));
 111 static void dump_java_tree PARAMS ((enum tree_dump_index, tree));
 112 static void source_start_java_method PARAMS ((tree));
 113 static void source_end_java_method PARAMS ((void));
 114 static tree find_name_in_single_imports PARAMS ((tree));
 115 static void check_abstract_method_header PARAMS ((tree));
 116 static tree lookup_java_interface_method2 PARAMS ((tree, tree));
 117 static tree resolve_expression_name PARAMS ((tree, tree *));
 118 static tree maybe_create_class_interface_decl PARAMS ((tree, tree, tree, tree));
 119 static int check_class_interface_creation PARAMS ((int, int, tree,
 120                                                   tree, tree, tree));
 121 static tree patch_method_invocation PARAMS ((tree, tree, tree, int,
 122                                             int *, tree *));
 123 static int breakdown_qualified PARAMS ((tree *, tree *, tree));
 124 static int in_same_package PARAMS ((tree, tree));
 125 static tree resolve_and_layout PARAMS ((tree, tree));
 126 static tree qualify_and_find PARAMS ((tree, tree, tree));
 127 static tree resolve_no_layout PARAMS ((tree, tree));
 128 static int invocation_mode PARAMS ((tree, int));
 129 static tree find_applicable_accessible_methods_list PARAMS ((int, tree,
 130                                                             tree, tree));
 131 static void search_applicable_methods_list PARAMS ((int, tree, tree, tree,
 132                                                    tree *, tree *));
 133 static tree find_most_specific_methods_list PARAMS ((tree));
 134 static int argument_types_convertible PARAMS ((tree, tree));
 135 static tree patch_invoke PARAMS ((tree, tree, tree));
 136 static int maybe_use_access_method PARAMS ((int, tree *, tree *));
 137 static tree lookup_method_invoke PARAMS ((int, tree, tree, tree, tree));
 138 static tree register_incomplete_type PARAMS ((int, tree, tree, tree));
 139 static tree check_inner_circular_reference PARAMS ((tree, tree));
 140 static tree check_circular_reference PARAMS ((tree));
 141 static tree obtain_incomplete_type PARAMS ((tree));
 142 static tree java_complete_lhs PARAMS ((tree));
 143 static tree java_complete_tree PARAMS ((tree));
 144 static tree maybe_generate_pre_expand_clinit PARAMS ((tree));
 145 static int analyze_clinit_body PARAMS ((tree, tree));
 146 static int maybe_yank_clinit PARAMS ((tree));
 147 static void start_complete_expand_method PARAMS ((tree));
 148 static void java_complete_expand_method PARAMS ((tree));
 149 static void java_expand_method_bodies PARAMS ((tree));
 150 static int  unresolved_type_p PARAMS ((tree, tree *));
 151 static void create_jdep_list PARAMS ((struct parser_ctxt *));
 152 static tree build_expr_block PARAMS ((tree, tree));
 153 static tree enter_block PARAMS ((void));
 154 static tree exit_block PARAMS ((void));
 155 static tree lookup_name_in_blocks PARAMS ((tree));
 156 static void maybe_absorb_scoping_blocks PARAMS ((void));
 157 static tree build_method_invocation PARAMS ((tree, tree));
 158 static tree build_new_invocation PARAMS ((tree, tree));
 159 static tree build_assignment PARAMS ((int, int, tree, tree));
 160 static tree build_binop PARAMS ((enum tree_code, int, tree, tree));
 161 static tree patch_assignment PARAMS ((tree, tree));
 162 static tree patch_binop PARAMS ((tree, tree, tree));
 163 static tree build_unaryop PARAMS ((int, int, tree));
 164 static tree build_incdec PARAMS ((int, int, tree, int));
 165 static tree patch_unaryop PARAMS ((tree, tree));
 166 static tree build_cast PARAMS ((int, tree, tree));
 167 static tree build_null_of_type PARAMS ((tree));
 168 static tree patch_cast PARAMS ((tree, tree));
 169 static int valid_ref_assignconv_cast_p PARAMS ((tree, tree, int));
 170 static int valid_builtin_assignconv_identity_widening_p PARAMS ((tree, tree));
 171 static int valid_cast_to_p PARAMS ((tree, tree));
 172 static int valid_method_invocation_conversion_p PARAMS ((tree, tree));
 173 static tree try_builtin_assignconv PARAMS ((tree, tree, tree));
 174 static tree try_reference_assignconv PARAMS ((tree, tree));
 175 static tree build_unresolved_array_type PARAMS ((tree));
 176 static int build_type_name_from_array_name PARAMS ((tree, tree *));
 177 static tree build_array_from_name PARAMS ((tree, tree, tree, tree *));
 178 static tree build_array_ref PARAMS ((int, tree, tree));
 179 static tree patch_array_ref PARAMS ((tree));
 180 static tree make_qualified_name PARAMS ((tree, tree, int));
 181 static tree merge_qualified_name PARAMS ((tree, tree));
 182 static tree make_qualified_primary PARAMS ((tree, tree, int));
 183 static int resolve_qualified_expression_name PARAMS ((tree, tree *,
 184                                                      tree *, tree *));
 185 static void qualify_ambiguous_name PARAMS ((tree));
 186 static tree resolve_field_access PARAMS ((tree, tree *, tree *));
 187 static tree build_newarray_node PARAMS ((tree, tree, int));
 188 static tree patch_newarray PARAMS ((tree));
 189 static tree resolve_type_during_patch PARAMS ((tree));
 190 static tree build_this PARAMS ((int));
 191 static tree build_wfl_wrap PARAMS ((tree, int));
 192 static tree build_return PARAMS ((int, tree));
 193 static tree patch_return PARAMS ((tree));
 194 static tree maybe_access_field PARAMS ((tree, tree, tree));
 195 static int complete_function_arguments PARAMS ((tree));
 196 static int check_for_static_method_reference PARAMS ((tree, tree, tree,
 197                                                       tree, tree));
 198 static int not_accessible_p PARAMS ((tree, tree, tree, int));
 199 static void check_deprecation PARAMS ((tree, tree));
 200 static int class_in_current_package PARAMS ((tree));
 201 static tree build_if_else_statement PARAMS ((int, tree, tree, tree));
 202 static tree patch_if_else_statement PARAMS ((tree));
 203 static tree add_stmt_to_compound PARAMS ((tree, tree, tree));
 204 static tree add_stmt_to_block PARAMS ((tree, tree, tree));
 205 static tree patch_exit_expr PARAMS ((tree));
 206 static tree build_labeled_block PARAMS ((int, tree));
 207 static tree finish_labeled_statement PARAMS ((tree, tree));
 208 static tree build_bc_statement PARAMS ((int, int, tree));
 209 static tree patch_bc_statement PARAMS ((tree));
 210 static tree patch_loop_statement PARAMS ((tree));
 211 static tree build_new_loop PARAMS ((tree));
 212 static tree build_loop_body PARAMS ((int, tree, int));
 213 static tree finish_loop_body PARAMS ((int, tree, tree, int));
 214 static tree build_debugable_stmt PARAMS ((int, tree));
 215 static tree finish_for_loop PARAMS ((int, tree, tree, tree));
 216 static tree patch_switch_statement PARAMS ((tree));
 217 static tree string_constant_concatenation PARAMS ((tree, tree));
 218 static tree build_string_concatenation PARAMS ((tree, tree));
 219 static tree patch_string_cst PARAMS ((tree));
 220 static tree patch_string PARAMS ((tree));
 221 static tree encapsulate_with_try_catch PARAMS ((int, tree, tree, tree));
 222 static tree build_try_statement PARAMS ((int, tree, tree));
 223 static tree build_try_finally_statement PARAMS ((int, tree, tree));
 224 static tree patch_try_statement PARAMS ((tree));
 225 static tree patch_synchronized_statement PARAMS ((tree, tree));
 226 static tree patch_throw_statement PARAMS ((tree, tree));
 227 static void check_thrown_exceptions PARAMS ((int, tree));
 228 static int check_thrown_exceptions_do PARAMS ((tree));
 229 static void purge_unchecked_exceptions PARAMS ((tree));
 230 static bool ctors_unchecked_throws_clause_p PARAMS ((tree));
 231 static void check_throws_clauses PARAMS ((tree, tree, tree));
 232 static void finish_method_declaration PARAMS ((tree));
 233 static tree build_super_invocation PARAMS ((tree));
 234 static int verify_constructor_circularity PARAMS ((tree, tree));
 235 static char *constructor_circularity_msg PARAMS ((tree, tree));
 236 static tree build_this_super_qualified_invocation PARAMS ((int, tree, tree,
 237                                                           int, int));
 238 static const char *get_printable_method_name PARAMS ((tree));
 239 static tree patch_conditional_expr PARAMS ((tree, tree, tree));
 240 static tree generate_finit PARAMS ((tree));
 241 static tree generate_instinit PARAMS ((tree));
 242 static tree build_instinit_invocation PARAMS ((tree));
 243 static void fix_constructors PARAMS ((tree));
 244 static tree build_alias_initializer_parameter_list PARAMS ((int, tree,
 245                                                             tree, int *));
 246 static tree craft_constructor PARAMS ((tree, tree));
 247 static int verify_constructor_super PARAMS ((tree));
 248 static tree create_artificial_method PARAMS ((tree, int, tree, tree, tree));
 249 static void start_artificial_method_body PARAMS ((tree));
 250 static void end_artificial_method_body PARAMS ((tree));
 251 static int check_method_redefinition PARAMS ((tree, tree));
 252 static int check_method_types_complete PARAMS ((tree));
 253 static void java_check_regular_methods PARAMS ((tree));
 254 static void java_check_abstract_methods PARAMS ((tree));
 255 static void unreachable_stmt_error PARAMS ((tree));
 256 static tree find_expr_with_wfl PARAMS ((tree));
 257 static void missing_return_error PARAMS ((tree));
 258 static tree build_new_array_init PARAMS ((int, tree));
 259 static tree patch_new_array_init PARAMS ((tree, tree));
 260 static tree maybe_build_array_element_wfl PARAMS ((tree));
 261 static int array_constructor_check_entry PARAMS ((tree, tree));
 262 static const char *purify_type_name PARAMS ((const char *));
 263 static tree fold_constant_for_init PARAMS ((tree, tree));
 264 static tree strip_out_static_field_access_decl PARAMS ((tree));
 265 static jdeplist *reverse_jdep_list PARAMS ((struct parser_ctxt *));
 266 static void static_ref_err PARAMS ((tree, tree, tree));
 267 static void parser_add_interface PARAMS ((tree, tree, tree));
 268 static void add_superinterfaces PARAMS ((tree, tree));
 269 static tree jdep_resolve_class PARAMS ((jdep *));
 270 static int note_possible_classname PARAMS ((const char *, int));
 271 static void java_complete_expand_classes PARAMS ((void));
 272 static void java_complete_expand_class PARAMS ((tree));
 273 static void java_complete_expand_methods PARAMS ((tree));
 274 static tree cut_identifier_in_qualified PARAMS ((tree));
 275 static tree java_stabilize_reference PARAMS ((tree));
 276 static tree do_unary_numeric_promotion PARAMS ((tree));
 277 static char * operator_string PARAMS ((tree));
 278 static tree do_merge_string_cste PARAMS ((tree, const char *, int, int));
 279 static tree merge_string_cste PARAMS ((tree, tree, int));
 280 static tree java_refold PARAMS ((tree));
 281 static int java_decl_equiv PARAMS ((tree, tree));
 282 static int binop_compound_p PARAMS ((enum tree_code));
 283 static tree search_loop PARAMS ((tree));
 284 static int labeled_block_contains_loop_p PARAMS ((tree, tree));
 285 static int check_abstract_method_definitions PARAMS ((int, tree, tree));
 286 static void java_check_abstract_method_definitions PARAMS ((tree));
 287 static void java_debug_context_do PARAMS ((int));
 288 static void java_parser_context_push_initialized_field PARAMS ((void));
 289 static void java_parser_context_pop_initialized_field PARAMS ((void));
 290 static tree reorder_static_initialized PARAMS ((tree));
 291 static void java_parser_context_suspend PARAMS ((void));
 292 static void java_parser_context_resume PARAMS ((void));
 293 static int pop_current_osb PARAMS ((struct parser_ctxt *));
 294
 295 /* JDK 1.1 work. FIXME */
 296
 297 static tree maybe_make_nested_class_name PARAMS ((tree));
 298 static void make_nested_class_name PARAMS ((tree));
 299 static void set_nested_class_simple_name_value PARAMS ((tree, int));
 300 static void link_nested_class_to_enclosing PARAMS ((void));
 301 static tree resolve_inner_class PARAMS ((struct hash_table *, tree, tree *,
 302                                          tree *, tree));
 303 static tree find_as_inner_class PARAMS ((tree, tree, tree));
 304 static tree find_as_inner_class_do PARAMS ((tree, tree));
 305 static int check_inner_class_redefinition PARAMS ((tree, tree));
 306
 307 static tree build_thisn_assign PARAMS ((void));
 308 static tree build_current_thisn PARAMS ((tree));
 309 static tree build_access_to_thisn PARAMS ((tree, tree, int));
 310 static tree maybe_build_thisn_access_method PARAMS ((tree));
 311
 312 static tree build_outer_field_access PARAMS ((tree, tree));
 313 static tree build_outer_field_access_methods PARAMS ((tree));
 314 static tree build_outer_field_access_expr PARAMS ((int, tree, tree,
 315                                                   tree, tree));
 316 static tree build_outer_method_access_method PARAMS ((tree));
 317 static tree build_new_access_id PARAMS ((void));
 318 static tree build_outer_field_access_method PARAMS ((tree, tree, tree,
 319                                                     tree, tree));
 320
 321 static int outer_field_access_p PARAMS ((tree, tree));
 322 static int outer_field_expanded_access_p PARAMS ((tree, tree *,
 323                                                  tree *, tree *));
 324 static tree outer_field_access_fix PARAMS ((tree, tree, tree));
 325 static tree build_incomplete_class_ref PARAMS ((int, tree));
 326 static tree patch_incomplete_class_ref PARAMS ((tree));
 327 static tree create_anonymous_class PARAMS ((int, tree));
 328 static void patch_anonymous_class PARAMS ((tree, tree, tree));
 329 static void add_inner_class_fields PARAMS ((tree, tree));
 330
 331 static tree build_dot_class_method PARAMS ((tree));
 332 static tree build_dot_class_method_invocation PARAMS ((tree));
 333 static void create_new_parser_context PARAMS ((int));
 334 static void mark_parser_ctxt PARAMS ((void *));
 335 static tree maybe_build_class_init_for_field PARAMS ((tree, tree));
 336
 337 static bool attach_init_test_initialization_flags PARAMS ((struct hash_entry *,
 338                                                           PTR));
 339 static bool emit_test_initialization PARAMS ((struct hash_entry *, PTR));
 340
 341 /* Number of error found so far. */
 342 int java_error_count;
 343 /* Number of warning found so far. */
 344 int java_warning_count;
 345 /* Tell when not to fold, when doing xrefs */
 346 int do_not_fold;
 347 /* Cyclic inheritance report, as it can be set by layout_class */
 348 const char *cyclic_inheritance_report;
 349
 350 /* The current parser context */
 351 struct parser_ctxt *ctxp;
 352
 353 /* List of things that were analyzed for which code will be generated */
 354 struct parser_ctxt *ctxp_for_generation = NULL;
 355
 356 /* binop_lookup maps token to tree_code. It is used where binary
 357    operations are involved and required by the parser. RDIV_EXPR
 358    covers both integral/floating point division. The code is changed
 359    once the type of both operator is worked out.  */
 360
 361 static const enum tree_code binop_lookup[19] =
 362   {
 363     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 364     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 365     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 366     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 367     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 368    };
 369 #define BINOP_LOOKUP(VALUE)                                             \
 370   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 371
 372 /* This is the end index for binary operators that can also be used
 373    in compound assignements. */
 374 #define BINOP_COMPOUND_CANDIDATES 11
 375
 376 /* The "$L" identifier we use to create labels.  */
 377 static tree label_id = NULL_TREE;
 378
 379 /* The "StringBuffer" identifier used for the String `+' operator. */
 380 static tree wfl_string_buffer = NULL_TREE;
 381
 382 /* The "append" identifier used for String `+' operator.  */
 383 static tree wfl_append = NULL_TREE;
 384
 385 /* The "toString" identifier used for String `+' operator. */
 386 static tree wfl_to_string = NULL_TREE;
 387
 388 /* The "java.lang" import qualified name.  */
 389 static tree java_lang_id = NULL_TREE;
 390
 391 /* The generated `inst$' identifier used for generated enclosing
 392    instance/field access functions.  */
 393 static tree inst_id = NULL_TREE;
 394
 395 /* The "java.lang.Cloneable" qualified name.  */
 396 static tree java_lang_cloneable = NULL_TREE;
 397
 398 /* The "java.io.Serializable" qualified name.  */
 399 static tree java_io_serializable = NULL_TREE;
 400
 401 /* Context and flag for static blocks */
 402 static tree current_static_block = NULL_TREE;
 403
 404 /* The generated `write_parm_value$' identifier.  */
 405 static tree wpv_id;
 406
 407 /* The list of all packages we've seen so far */
 408 static tree package_list = NULL_TREE;
 409
 410 /* Hold THIS for the scope of the current method decl.  */
 411 static tree current_this;
 412
 413 /* Hold a list of catch clauses list. The first element of this list is
 414    the list of the catch clauses of the currently analysed try block. */
 415 static tree currently_caught_type_list;
 416
 417 /* This holds a linked list of all the case labels for the current
 418    switch statement.  It is only used when checking to see if there
 419    are duplicate labels.  FIXME: probably this should just be attached
 420    to the switch itself; then it could be referenced via
 421    `ctxp->current_loop'.  */
 422 static tree case_label_list;
 423
 424 static tree src_parse_roots[1];
 425
 426 /* All classes seen from source code */
 427 #define gclass_list src_parse_roots[0]
 428
 429 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 430    line and point it out.  */
 431 /* Should point out the one that don't fit. ASCII/unicode, going
 432    backward. FIXME */
 433
 434 #define check_modifiers(__message, __value, __mask) do {        \
 435   if ((__value) & ~(__mask))                                    \
 436     {                                                           \
 437       int i, remainder = (__value) & ~(__mask);                 \
 438       for (i = 0; i <= 10; i++)                                 \
 439         if ((1 << i) & remainder)                               \
 440           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 441                                java_accstring_lookup (1 << i)); \
 442     }                                                           \
 443 } while (0)
 444
 445 %}
 446
 447 %union {
 448   tree node;
 449   int sub_token;
 450   struct {
 451     int token;
 452     int location;
 453   } operator;
 454   int value;
 455 }
 456
 457 %{
 458 #include "lex.c"
 459 %}
 460
 461 %pure_parser
 462
 463 /* Things defined here have to match the order of what's in the
 464    binop_lookup table.  */
 465
 466 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 467 %token   LS_TK           SRS_TK          ZRS_TK
 468 %token   AND_TK          XOR_TK          OR_TK
 469 %token   BOOL_AND_TK BOOL_OR_TK
 470 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 471
 472 /* This maps to the same binop_lookup entry than the token above */
 473
 474 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 475 %token   REM_ASSIGN_TK
 476 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 477 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 478
 479
 480 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 481
 482 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 483 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 484 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 485 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 486 %token   MODIFIER_TK
 487
 488 /* Keep those two in order, too */
 489 %token   DECR_TK INCR_TK
 490
 491 /* From now one, things can be in any order */
 492
 493 %token   DEFAULT_TK      IF_TK              THROW_TK
 494 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 495 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 496 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 497 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 498 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 499 %token   SUPER_TK        WHILE_TK           CLASS_TK
 500 %token   SWITCH_TK       CONST_TK           TRY_TK
 501 %token   FOR_TK          NEW_TK             CONTINUE_TK
 502 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 503
 504 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 505 %token   CHAR_TK         INTEGRAL_TK
 506
 507 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 508
 509 %token   ID_TK
 510
 511 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 512
 513 %token   ASSIGN_ANY_TK   ASSIGN_TK
 514 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 515
 516 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 517 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 518
 519 %type    <value>        modifiers MODIFIER_TK final synchronized
 520
 521 %type    <node>         super ID_TK identifier
 522 %type    <node>         name simple_name qualified_name
 523 %type    <node>         type_declaration compilation_unit
 524                         field_declaration method_declaration extends_interfaces
 525                         interfaces interface_type_list
 526                         class_member_declaration
 527                         import_declarations package_declaration
 528                         type_declarations interface_body
 529                         interface_member_declaration constant_declaration
 530                         interface_member_declarations interface_type
 531                         abstract_method_declaration interface_type_list
 532 %type    <node>         class_body_declaration class_member_declaration
 533                         static_initializer constructor_declaration block
 534 %type    <node>         class_body_declarations constructor_header
 535 %type    <node>         class_or_interface_type class_type class_type_list
 536                         constructor_declarator explicit_constructor_invocation
 537 %type    <node>         dim_expr dim_exprs this_or_super throws
 538
 539 %type    <node>         variable_declarator_id variable_declarator
 540                         variable_declarators variable_initializer
 541                         variable_initializers constructor_body
 542                         array_initializer
 543
 544 %type    <node>         class_body block_end constructor_block_end
 545 %type    <node>         statement statement_without_trailing_substatement
 546                         labeled_statement if_then_statement label_decl
 547                         if_then_else_statement while_statement for_statement
 548                         statement_nsi labeled_statement_nsi do_statement
 549                         if_then_else_statement_nsi while_statement_nsi
 550                         for_statement_nsi statement_expression_list for_init
 551                         for_update statement_expression expression_statement
 552                         primary_no_new_array expression primary
 553                         array_creation_expression array_type
 554                         class_instance_creation_expression field_access
 555                         method_invocation array_access something_dot_new
 556                         argument_list postfix_expression while_expression
 557                         post_increment_expression post_decrement_expression
 558                         unary_expression_not_plus_minus unary_expression
 559                         pre_increment_expression pre_decrement_expression
 560                         unary_expression_not_plus_minus cast_expression
 561                         multiplicative_expression additive_expression
 562                         shift_expression relational_expression
 563                         equality_expression and_expression
 564                         exclusive_or_expression inclusive_or_expression
 565                         conditional_and_expression conditional_or_expression
 566                         conditional_expression assignment_expression
 567                         left_hand_side assignment for_header for_begin
 568                         constant_expression do_statement_begin empty_statement
 569                         switch_statement synchronized_statement throw_statement
 570                         try_statement switch_expression switch_block
 571                         catches catch_clause catch_clause_parameter finally
 572                         anonymous_class_creation trap_overflow_corner_case
 573 %type    <node>         return_statement break_statement continue_statement
 574
 575 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 576 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 577 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 578 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 579 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 580 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 581 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 582 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 583 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 584 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 585 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 586 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 587 %type    <operator>     NEW_TK
 588
 589 %type    <node>         method_body
 590
 591 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 592                         STRING_LIT_TK NULL_TK VOID_TK
 593
 594 %type    <node>         IF_TK WHILE_TK FOR_TK
 595
 596 %type    <node>         formal_parameter_list formal_parameter
 597                         method_declarator method_header
 598
 599 %type    <node>         primitive_type reference_type type
 600                         BOOLEAN_TK INTEGRAL_TK FP_TK
 601
 602 /* Added or modified JDK 1.1 rule types  */
 603 %type    <node>         type_literals
 604
 605 %%
 606 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 607 goal:
 608                 {
 609                   /* Register static variables with the garbage
 610                      collector.  */
 611                   ggc_add_tree_root (&label_id, 1);
 612                   ggc_add_tree_root (&wfl_string_buffer, 1);
 613                   ggc_add_tree_root (&wfl_append, 1);
 614                   ggc_add_tree_root (&wfl_to_string, 1);
 615                   ggc_add_tree_root (&java_lang_id, 1);
 616                   ggc_add_tree_root (&inst_id, 1);
 617                   ggc_add_tree_root (&java_lang_cloneable, 1);
 618                   ggc_add_tree_root (&java_io_serializable, 1);
 619                   ggc_add_tree_root (&current_static_block, 1);
 620                   ggc_add_tree_root (&wpv_id, 1);
 621                   ggc_add_tree_root (&package_list, 1);
 622                   ggc_add_tree_root (&current_this, 1);
 623                   ggc_add_tree_root (&currently_caught_type_list, 1);
 624                   ggc_add_tree_root (&case_label_list, 1);
 625                   ggc_add_root (&ctxp, 1,
 626                                 sizeof (struct parser_ctxt *),
 627                                 mark_parser_ctxt);
 628                   ggc_add_root (&ctxp_for_generation, 1,
 629                                 sizeof (struct parser_ctxt *),
 630                                 mark_parser_ctxt);
 631                 }
 632         compilation_unit
 633                 {}
 634 ;
 635
 636 /* 19.3 Productions from 3: Lexical structure  */
 637 literal:
 638         INT_LIT_TK
 639 |       FP_LIT_TK
 640 |       BOOL_LIT_TK
 641 |       CHAR_LIT_TK
 642 |       STRING_LIT_TK
 643 |       NULL_TK
 644 ;
 645
 646 /* 19.4 Productions from 4: Types, Values and Variables  */
 647 type:
 648         primitive_type
 649 |       reference_type
 650 ;
 651
 652 primitive_type:
 653         INTEGRAL_TK
 654 |       FP_TK
 655 |       BOOLEAN_TK
 656 ;
 657
 658 reference_type:
 659         class_or_interface_type
 660 |       array_type
 661 ;
 662
 663 class_or_interface_type:
 664         name
 665 ;
 666
 667 class_type:
 668         class_or_interface_type /* Default rule */
 669 ;
 670
 671 interface_type:
 672          class_or_interface_type
 673 ;
 674
 675 array_type:
 676         primitive_type dims
 677                 {
 678                   int osb = pop_current_osb (ctxp);
 679                   tree t = build_java_array_type (($1), -1);
 680                   while (--osb)
 681                     t = build_unresolved_array_type (t);
 682                   $$ = t;
 683                 }
 684 |       name dims
 685                 {
 686                   int osb = pop_current_osb (ctxp);
 687                   tree t = $1;
 688                   while (osb--)
 689                     t = build_unresolved_array_type (t);
 690                   $$ = t;
 691                 }
 692 ;
 693
 694 /* 19.5 Productions from 6: Names  */
 695 name:
 696         simple_name             /* Default rule */
 697 |       qualified_name          /* Default rule */
 698 ;
 699
 700 simple_name:
 701         identifier              /* Default rule */
 702 ;
 703
 704 qualified_name:
 705         name DOT_TK identifier
 706                 { $$ = make_qualified_name ($1, $3, $2.location); }
 707 ;
 708
 709 identifier:
 710         ID_TK
 711 ;
 712
 713 /* 19.6: Production from 7: Packages  */
 714 compilation_unit:
 715                 {$$ = NULL;}
 716 |       package_declaration
 717 |       import_declarations
 718 |       type_declarations
 719 |       package_declaration import_declarations
 720 |       package_declaration type_declarations
 721 |       import_declarations type_declarations
 722 |       package_declaration import_declarations type_declarations
 723 ;
 724
 725 import_declarations:
 726         import_declaration
 727                 {
 728                   $$ = NULL;
 729                 }
 730 |       import_declarations import_declaration
 731                 {
 732                   $$ = NULL;
 733                 }
 734 ;
 735
 736 type_declarations:
 737         type_declaration
 738 |       type_declarations type_declaration
 739 ;
 740
 741 package_declaration:
 742         PACKAGE_TK name SC_TK
 743                 {
 744                   ctxp->package = EXPR_WFL_NODE ($2);
 745                   register_package (ctxp->package);
 746                 }
 747 |       PACKAGE_TK error
 748                 {yyerror ("Missing name"); RECOVER;}
 749 |       PACKAGE_TK name error
 750                 {yyerror ("';' expected"); RECOVER;}
 751 ;
 752
 753 import_declaration:
 754         single_type_import_declaration
 755 |       type_import_on_demand_declaration
 756 ;
 757
 758 single_type_import_declaration:
 759         IMPORT_TK name SC_TK
 760                 {
 761                   tree name = EXPR_WFL_NODE ($2), last_name;
 762                   int   i = IDENTIFIER_LENGTH (name)-1;
 763                   const char *last = &IDENTIFIER_POINTER (name)[i];
 764                   while (last != IDENTIFIER_POINTER (name))
 765                     {
 766                       if (last [0] == '.')
 767                         break;
 768                       last--;
 769                     }
 770                   last_name = get_identifier (++last);
 771                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 772                     {
 773                       tree err = find_name_in_single_imports (last_name);
 774                       if (err && err != name)
 775                         parse_error_context
 776                           ($2, "Ambiguous class: `%s' and `%s'",
 777                            IDENTIFIER_POINTER (name),
 778                            IDENTIFIER_POINTER (err));
 779                       else
 780                         REGISTER_IMPORT ($2, last_name);
 781                     }
 782                   else
 783                     REGISTER_IMPORT ($2, last_name);
 784                 }
 785 |       IMPORT_TK error
 786                 {yyerror ("Missing name"); RECOVER;}
 787 |       IMPORT_TK name error
 788                 {yyerror ("';' expected"); RECOVER;}
 789 ;
 790
 791 type_import_on_demand_declaration:
 792         IMPORT_TK name DOT_TK MULT_TK SC_TK
 793                 {
 794                   tree name = EXPR_WFL_NODE ($2);
 795                   tree it;
 796                   /* Search for duplicates. */
 797                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 798                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 799                       break;
 800                   /* Don't import the same thing more than once, just ignore
 801                      duplicates (7.5.2) */
 802                   if (! it)
 803                     {
 804                       read_import_dir ($2);
 805                       ctxp->import_demand_list =
 806                         chainon (ctxp->import_demand_list,
 807                                  build_tree_list ($2, NULL_TREE));
 808                     }
 809                 }
 810 |       IMPORT_TK name DOT_TK error
 811                 {yyerror ("'*' expected"); RECOVER;}
 812 |       IMPORT_TK name DOT_TK MULT_TK error
 813                 {yyerror ("';' expected"); RECOVER;}
 814 ;
 815
 816 type_declaration:
 817         class_declaration
 818                 { end_class_declaration (0); }
 819 |       interface_declaration
 820                 { end_class_declaration (0); }
 821 |       empty_statement
 822 |       error
 823                 {
 824                   YYERROR_NOW;
 825                   yyerror ("Class or interface declaration expected");
 826                 }
 827 ;
 828
 829 /* 19.7 Shortened from the original:
 830    modifiers: modifier | modifiers modifier
 831    modifier: any of public...  */
 832 modifiers:
 833         MODIFIER_TK
 834                 {
 835                   $$ = (1 << $1);
 836                 }
 837 |       modifiers MODIFIER_TK
 838                 {
 839                   int acc = (1 << $2);
 840                   if ($$ & acc)
 841                     parse_error_context
 842                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 843                        java_accstring_lookup (acc));
 844                   else
 845                     {
 846                       $$ |= acc;
 847                     }
 848                 }
 849 ;
 850
 851 /* 19.8.1 Production from $8.1: Class Declaration */
 852 class_declaration:
 853         modifiers CLASS_TK identifier super interfaces
 854                 { create_class ($1, $3, $4, $5); }
 855         class_body
 856 |       CLASS_TK identifier super interfaces
 857                 { create_class (0, $2, $3, $4); }
 858         class_body
 859 |       modifiers CLASS_TK error
 860                 {yyerror ("Missing class name"); RECOVER;}
 861 |       CLASS_TK error
 862                 {yyerror ("Missing class name"); RECOVER;}
 863 |       CLASS_TK identifier error
 864                 {
 865                   if (!ctxp->class_err) yyerror ("'{' expected");
 866                   DRECOVER(class1);
 867                 }
 868 |       modifiers CLASS_TK identifier error
 869                 {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
 870 ;
 871
 872 super:
 873                 { $$ = NULL; }
 874 |       EXTENDS_TK class_type
 875                 { $$ = $2; }
 876 |       EXTENDS_TK class_type error
 877                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 878 |       EXTENDS_TK error
 879                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 880 ;
 881
 882 interfaces:
 883                 { $$ = NULL_TREE; }
 884 |       IMPLEMENTS_TK interface_type_list
 885                 { $$ = $2; }
 886 |       IMPLEMENTS_TK error
 887                 {
 888                   ctxp->class_err=1;
 889                   yyerror ("Missing interface name");
 890                 }
 891 ;
 892
 893 interface_type_list:
 894         interface_type
 895                 {
 896                   ctxp->interface_number = 1;
 897                   $$ = build_tree_list ($1, NULL_TREE);
 898                 }
 899 |       interface_type_list C_TK interface_type
 900                 {
 901                   ctxp->interface_number++;
 902                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 903                 }
 904 |       interface_type_list C_TK error
 905                 {yyerror ("Missing interface name"); RECOVER;}
 906 ;
 907
 908 class_body:
 909         OCB_TK CCB_TK
 910                 {
 911                   /* Store the location of the `}' when doing xrefs */
 912                   if (flag_emit_xref)
 913                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 914                       EXPR_WFL_ADD_COL ($2.location, 1);
 915                   $$ = GET_CPC ();
 916                 }
 917 |       OCB_TK class_body_declarations CCB_TK
 918                 {
 919                   /* Store the location of the `}' when doing xrefs */
 920                   if (flag_emit_xref)
 921                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 922                       EXPR_WFL_ADD_COL ($3.location, 1);
 923                   $$ = GET_CPC ();
 924                 }
 925 ;
 926
 927 class_body_declarations:
 928         class_body_declaration
 929 |       class_body_declarations class_body_declaration
 930 ;
 931
 932 class_body_declaration:
 933         class_member_declaration
 934 |       static_initializer
 935 |       constructor_declaration
 936 |       block                   /* Added, JDK1.1, instance initializer */
 937                 {
 938                   if ($1 != empty_stmt_node)
 939                     {
 940                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 941                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 942                     }
 943                 }
 944 ;
 945
 946 class_member_declaration:
 947         field_declaration
 948 |       method_declaration
 949 |       class_declaration       /* Added, JDK1.1 inner classes */
 950                 { end_class_declaration (1); }
 951 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 952                 { end_class_declaration (1); }
 953 |       empty_statement
 954 ;
 955
 956 /* 19.8.2 Productions from 8.3: Field Declarations  */
 957 field_declaration:
 958         type variable_declarators SC_TK
 959                 { register_fields (0, $1, $2); }
 960 |       modifiers type variable_declarators SC_TK
 961                 {
 962                   check_modifiers
 963                     ("Illegal modifier `%s' for field declaration",
 964                      $1, FIELD_MODIFIERS);
 965                   check_modifiers_consistency ($1);
 966                   register_fields ($1, $2, $3);
 967                 }
 968 ;
 969
 970 variable_declarators:
 971         /* Should we use build_decl_list () instead ? FIXME */
 972         variable_declarator     /* Default rule */
 973 |       variable_declarators C_TK variable_declarator
 974                 { $$ = chainon ($1, $3); }
 975 |       variable_declarators C_TK error
 976                 {yyerror ("Missing term"); RECOVER;}
 977 ;
 978
 979 variable_declarator:
 980         variable_declarator_id
 981                 { $$ = build_tree_list ($1, NULL_TREE); }
 982 |       variable_declarator_id ASSIGN_TK variable_initializer
 983                 {
 984                   if (java_error_count)
 985                     $3 = NULL_TREE;
 986                   $$ = build_tree_list
 987                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 988                 }
 989 |       variable_declarator_id ASSIGN_TK error
 990                 {
 991                   yyerror ("Missing variable initializer");
 992                   $$ = build_tree_list ($1, NULL_TREE);
 993                   RECOVER;
 994                 }
 995 |       variable_declarator_id ASSIGN_TK variable_initializer error
 996                 {
 997                   yyerror ("';' expected");
 998                   $$ = build_tree_list ($1, NULL_TREE);
 999                   RECOVER;
1000                 }
1001 ;
1002
1003 variable_declarator_id:
1004         identifier
1005 |       variable_declarator_id OSB_TK CSB_TK
1006                 { $$ = build_unresolved_array_type ($1); }
1007 |       identifier error
1008                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
1009 |       variable_declarator_id OSB_TK error
1010                 {
1011                   tree node = java_lval.node;
1012                   if (node && (TREE_CODE (node) == INTEGER_CST
1013                                || TREE_CODE (node) == EXPR_WITH_FILE_LOCATION))
1014                     yyerror ("Can't specify array dimension in a declaration");
1015                   else
1016                     yyerror ("']' expected");
1017                   DRECOVER(vdi);
1018                 }
1019 |       variable_declarator_id CSB_TK error
1020                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
1021 ;
1022
1023 variable_initializer:
1024         expression
1025 |       array_initializer
1026 ;
1027
1028 /* 19.8.3 Productions from 8.4: Method Declarations  */
1029 method_declaration:
1030         method_header
1031                 {
1032                   current_function_decl = $1;
1033                   if (current_function_decl
1034                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1035                     source_start_java_method (current_function_decl);
1036                   else
1037                     current_function_decl = NULL_TREE;
1038                 }
1039         method_body
1040                 { finish_method_declaration ($3); }
1041 |       method_header error
1042                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1043 ;
1044
1045 method_header:
1046         type method_declarator throws
1047                 { $$ = method_header (0, $1, $2, $3); }
1048 |       VOID_TK method_declarator throws
1049                 { $$ = method_header (0, void_type_node, $2, $3); }
1050 |       modifiers type method_declarator throws
1051                 { $$ = method_header ($1, $2, $3, $4); }
1052 |       modifiers VOID_TK method_declarator throws
1053                 { $$ = method_header ($1, void_type_node, $3, $4); }
1054 |       type error
1055                 {
1056                   yyerror ("Invalid method declaration, method name required");
1057                   RECOVER;
1058                 }
1059 |       modifiers type error
1060                 {RECOVER;}
1061 |       VOID_TK error
1062                 {yyerror ("Identifier expected"); RECOVER;}
1063 |       modifiers VOID_TK error
1064                 {yyerror ("Identifier expected"); RECOVER;}
1065 |       modifiers error
1066                 {
1067                   yyerror ("Invalid method declaration, return type required");
1068                   RECOVER;
1069                 }
1070 ;
1071
1072 method_declarator:
1073         identifier OP_TK CP_TK
1074                 {
1075                   ctxp->formal_parameter_number = 0;
1076                   $$ = method_declarator ($1, NULL_TREE);
1077                 }
1078 |       identifier OP_TK formal_parameter_list CP_TK
1079                 { $$ = method_declarator ($1, $3); }
1080 |       method_declarator OSB_TK CSB_TK
1081                 {
1082                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1083                   TREE_PURPOSE ($1) =
1084                     build_unresolved_array_type (TREE_PURPOSE ($1));
1085                   parse_warning_context
1086                     (wfl_operator,
1087                      "Discouraged form of returned type specification");
1088                 }
1089 |       identifier OP_TK error
1090                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1091 |       method_declarator OSB_TK error
1092                 {yyerror ("']' expected"); RECOVER;}
1093 ;
1094
1095 formal_parameter_list:
1096         formal_parameter
1097                 {
1098                   ctxp->formal_parameter_number = 1;
1099                 }
1100 |       formal_parameter_list C_TK formal_parameter
1101                 {
1102                   ctxp->formal_parameter_number += 1;
1103                   $$ = chainon ($1, $3);
1104                 }
1105 |       formal_parameter_list C_TK error
1106                 { yyerror ("Missing formal parameter term"); RECOVER; }
1107 ;
1108
1109 formal_parameter:
1110         type variable_declarator_id
1111                 {
1112                   $$ = build_tree_list ($2, $1);
1113                 }
1114 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1115                 {
1116                   $$ = build_tree_list ($3, $2);
1117                   ARG_FINAL_P ($$) = 1;
1118                 }
1119 |       type error
1120                 {
1121                   yyerror ("Missing identifier"); RECOVER;
1122                   $$ = NULL_TREE;
1123                 }
1124 |       final type error
1125                 {
1126                   yyerror ("Missing identifier"); RECOVER;
1127                   $$ = NULL_TREE;
1128                 }
1129 ;
1130
1131 final:
1132         modifiers
1133                 {
1134                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1135                                    $1, ACC_FINAL);
1136                   if ($1 != ACC_FINAL)
1137                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1138                 }
1139 ;
1140
1141 throws:
1142                 { $$ = NULL_TREE; }
1143 |       THROWS_TK class_type_list
1144                 { $$ = $2; }
1145 |       THROWS_TK error
1146                 {yyerror ("Missing class type term"); RECOVER;}
1147 ;
1148
1149 class_type_list:
1150         class_type
1151                 { $$ = build_tree_list ($1, $1); }
1152 |       class_type_list C_TK class_type
1153                 { $$ = tree_cons ($3, $3, $1); }
1154 |       class_type_list C_TK error
1155                 {yyerror ("Missing class type term"); RECOVER;}
1156 ;
1157
1158 method_body:
1159         block
1160 |       SC_TK { $$ = NULL_TREE; }
1161 ;
1162
1163 /* 19.8.4 Productions from 8.5: Static Initializers  */
1164 static_initializer:
1165         static block
1166                 {
1167                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1168                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1169                   current_static_block = NULL_TREE;
1170                 }
1171 ;
1172
1173 static:                         /* Test lval.sub_token here */
1174         modifiers
1175                 {
1176                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1177                   /* Can't have a static initializer in an innerclass */
1178                   if ($1 | ACC_STATIC &&
1179                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1180                     parse_error_context
1181                       (MODIFIER_WFL (STATIC_TK),
1182                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1183                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1184                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1185                 }
1186 ;
1187
1188 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1189 constructor_declaration:
1190         constructor_header
1191                 {
1192                   current_function_decl = $1;
1193                   source_start_java_method (current_function_decl);
1194                 }
1195         constructor_body
1196                 { finish_method_declaration ($3); }
1197 ;
1198
1199 constructor_header:
1200         constructor_declarator throws
1201                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1202 |       modifiers constructor_declarator throws
1203                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1204 ;
1205
1206 constructor_declarator:
1207         simple_name OP_TK CP_TK
1208                 {
1209                   ctxp->formal_parameter_number = 0;
1210                   $$ = method_declarator ($1, NULL_TREE);
1211                 }
1212 |       simple_name OP_TK formal_parameter_list CP_TK
1213                 { $$ = method_declarator ($1, $3); }
1214 ;
1215
1216 constructor_body:
1217         /* Unlike regular method, we always need a complete (empty)
1218            body so we can safely perform all the required code
1219            addition (super invocation and field initialization) */
1220         block_begin constructor_block_end
1221                 {
1222                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1223                   $$ = $2;
1224                 }
1225 |       block_begin explicit_constructor_invocation constructor_block_end
1226                 { $$ = $3; }
1227 |       block_begin block_statements constructor_block_end
1228                 { $$ = $3; }
1229 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1230                 { $$ = $4; }
1231 ;
1232
1233 constructor_block_end:
1234         block_end
1235 ;
1236
1237 /* Error recovery for that rule moved down expression_statement: rule.  */
1238 explicit_constructor_invocation:
1239         this_or_super OP_TK CP_TK SC_TK
1240                 {
1241                   $$ = build_method_invocation ($1, NULL_TREE);
1242                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1243                   $$ = java_method_add_stmt (current_function_decl, $$);
1244                 }
1245 |       this_or_super OP_TK argument_list CP_TK SC_TK
1246                 {
1247                   $$ = build_method_invocation ($1, $3);
1248                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1249                   $$ = java_method_add_stmt (current_function_decl, $$);
1250                 }
1251         /* Added, JDK1.1 inner classes. Modified because the rule
1252            'primary' couldn't work.  */
1253 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1254                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1255 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1256                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1257 ;
1258
1259 this_or_super:                  /* Added, simplifies error diagnostics */
1260         THIS_TK
1261                 {
1262                   tree wfl = build_wfl_node (this_identifier_node);
1263                   EXPR_WFL_LINECOL (wfl) = $1.location;
1264                   $$ = wfl;
1265                 }
1266 |       SUPER_TK
1267                 {
1268                   tree wfl = build_wfl_node (super_identifier_node);
1269                   EXPR_WFL_LINECOL (wfl) = $1.location;
1270                   $$ = wfl;
1271                 }
1272 ;
1273
1274 /* 19.9 Productions from 9: Interfaces  */
1275 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1276 interface_declaration:
1277         INTERFACE_TK identifier
1278                 { create_interface (0, $2, NULL_TREE); }
1279         interface_body
1280 |       modifiers INTERFACE_TK identifier
1281                 { create_interface ($1, $3, NULL_TREE); }
1282         interface_body
1283 |       INTERFACE_TK identifier extends_interfaces
1284                 { create_interface (0, $2, $3); }
1285         interface_body
1286 |       modifiers INTERFACE_TK identifier extends_interfaces
1287                 { create_interface ($1, $3, $4); }
1288         interface_body
1289 |       INTERFACE_TK identifier error
1290                 {yyerror ("'{' expected"); RECOVER;}
1291 |       modifiers INTERFACE_TK identifier error
1292                 {yyerror ("'{' expected"); RECOVER;}
1293 ;
1294
1295 extends_interfaces:
1296         EXTENDS_TK interface_type
1297                 {
1298                   ctxp->interface_number = 1;
1299                   $$ = build_tree_list ($2, NULL_TREE);
1300                 }
1301 |       extends_interfaces C_TK interface_type
1302                 {
1303                   ctxp->interface_number++;
1304                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1305                 }
1306 |       EXTENDS_TK error
1307                 {yyerror ("Invalid interface type"); RECOVER;}
1308 |       extends_interfaces C_TK error
1309                 {yyerror ("Missing term"); RECOVER;}
1310 ;
1311
1312 interface_body:
1313         OCB_TK CCB_TK
1314                 { $$ = NULL_TREE; }
1315 |       OCB_TK interface_member_declarations CCB_TK
1316                 { $$ = NULL_TREE; }
1317 ;
1318
1319 interface_member_declarations:
1320         interface_member_declaration
1321 |       interface_member_declarations interface_member_declaration
1322 ;
1323
1324 interface_member_declaration:
1325         constant_declaration
1326 |       abstract_method_declaration
1327 |       class_declaration       /* Added, JDK1.1 inner classes */
1328                 { end_class_declaration (1); }
1329 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1330                 { end_class_declaration (1); }
1331 ;
1332
1333 constant_declaration:
1334         field_declaration
1335 ;
1336
1337 abstract_method_declaration:
1338         method_header SC_TK
1339                 {
1340                   check_abstract_method_header ($1);
1341                   current_function_decl = NULL_TREE; /* FIXME ? */
1342                 }
1343 |       method_header error
1344                 {yyerror ("';' expected"); RECOVER;}
1345 ;
1346
1347 /* 19.10 Productions from 10: Arrays  */
1348 array_initializer:
1349         OCB_TK CCB_TK
1350                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1351 |       OCB_TK C_TK CCB_TK
1352                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1353 |       OCB_TK variable_initializers CCB_TK
1354                 { $$ = build_new_array_init ($1.location, $2); }
1355 |       OCB_TK variable_initializers C_TK CCB_TK
1356                 { $$ = build_new_array_init ($1.location, $2); }
1357 ;
1358
1359 variable_initializers:
1360         variable_initializer
1361                 {
1362                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1363                                   $1, NULL_TREE);
1364                 }
1365 |       variable_initializers C_TK variable_initializer
1366                 {
1367                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1368                 }
1369 |       variable_initializers C_TK error
1370                 {yyerror ("Missing term"); RECOVER;}
1371 ;
1372
1373 /* 19.11 Production from 14: Blocks and Statements  */
1374 block:
1375         OCB_TK CCB_TK
1376                 {
1377                   /* Store the location of the `}' when doing xrefs */
1378                   if (current_function_decl && flag_emit_xref)
1379                     DECL_END_SOURCE_LINE (current_function_decl) =
1380                       EXPR_WFL_ADD_COL ($2.location, 1);
1381                   $$ = empty_stmt_node;
1382                 }
1383 |       block_begin block_statements block_end
1384                 { $$ = $3; }
1385 ;
1386
1387 block_begin:
1388         OCB_TK
1389                 { enter_block (); }
1390 ;
1391
1392 block_end:
1393         CCB_TK
1394                 {
1395                   maybe_absorb_scoping_blocks ();
1396                   /* Store the location of the `}' when doing xrefs */
1397                   if (current_function_decl && flag_emit_xref)
1398                     DECL_END_SOURCE_LINE (current_function_decl) =
1399                       EXPR_WFL_ADD_COL ($1.location, 1);
1400                   $$ = exit_block ();
1401                   if (!BLOCK_SUBBLOCKS ($$))
1402                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1403                 }
1404 ;
1405
1406 block_statements:
1407         block_statement
1408 |       block_statements block_statement
1409 ;
1410
1411 block_statement:
1412         local_variable_declaration_statement
1413 |       statement
1414                 { java_method_add_stmt (current_function_decl, $1); }
1415 |       class_declaration       /* Added, JDK1.1 local classes */
1416                 {
1417                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1418                   end_class_declaration (1);
1419                 }
1420 ;
1421
1422 local_variable_declaration_statement:
1423         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1424 ;
1425
1426 local_variable_declaration:
1427         type variable_declarators
1428                 { declare_local_variables (0, $1, $2); }
1429 |       final type variable_declarators /* Added, JDK1.1 final locals */
1430                 { declare_local_variables ($1, $2, $3); }
1431 ;
1432
1433 statement:
1434         statement_without_trailing_substatement
1435 |       labeled_statement
1436 |       if_then_statement
1437 |       if_then_else_statement
1438 |       while_statement
1439 |       for_statement
1440                 { $$ = exit_block (); }
1441 ;
1442
1443 statement_nsi:
1444         statement_without_trailing_substatement
1445 |       labeled_statement_nsi
1446 |       if_then_else_statement_nsi
1447 |       while_statement_nsi
1448 |       for_statement_nsi
1449                 { $$ = exit_block (); }
1450 ;
1451
1452 statement_without_trailing_substatement:
1453         block
1454 |       empty_statement
1455 |       expression_statement
1456 |       switch_statement
1457 |       do_statement
1458 |       break_statement
1459 |       continue_statement
1460 |       return_statement
1461 |       synchronized_statement
1462 |       throw_statement
1463 |       try_statement
1464 ;
1465
1466 empty_statement:
1467         SC_TK
1468                 {
1469                   if (flag_extraneous_semicolon
1470                       && ! current_static_block
1471                       && (! current_function_decl ||
1472                           /* Verify we're not in a inner class declaration */
1473                           (GET_CPC () != TYPE_NAME
1474                            (DECL_CONTEXT (current_function_decl)))))
1475
1476                     {
1477                       EXPR_WFL_SET_LINECOL (wfl_operator, lineno, -1);
1478                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1479                     }
1480                   $$ = empty_stmt_node;
1481                 }
1482 ;
1483
1484 label_decl:
1485         identifier REL_CL_TK
1486                 {
1487                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1488                                             EXPR_WFL_NODE ($1));
1489                   pushlevel (2);
1490                   push_labeled_block ($$);
1491                   PUSH_LABELED_BLOCK ($$);
1492                 }
1493 ;
1494
1495 labeled_statement:
1496         label_decl statement
1497                 { $$ = finish_labeled_statement ($1, $2); }
1498 |       identifier error
1499                 {yyerror ("':' expected"); RECOVER;}
1500 ;
1501
1502 labeled_statement_nsi:
1503         label_decl statement_nsi
1504                 { $$ = finish_labeled_statement ($1, $2); }
1505 ;
1506
1507 /* We concentrate here a bunch of error handling rules that we couldn't write
1508    earlier, because expression_statement catches a missing ';'.  */
1509 expression_statement:
1510         statement_expression SC_TK
1511                 {
1512                   /* We have a statement. Generate a WFL around it so
1513                      we can debug it */
1514                   $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1515                   /* We know we have a statement, so set the debug
1516                      info to be eventually generate here. */
1517                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1518                 }
1519 |       error SC_TK
1520                 {
1521                   YYNOT_TWICE yyerror ("Invalid expression statement");
1522                   DRECOVER (expr_stmt);
1523                 }
1524 |       error OCB_TK
1525                 {
1526                   YYNOT_TWICE yyerror ("Invalid expression statement");
1527                   DRECOVER (expr_stmt);
1528                 }
1529 |       error CCB_TK
1530                 {
1531                   YYNOT_TWICE yyerror ("Invalid expression statement");
1532                   DRECOVER (expr_stmt);
1533                 }
1534 |       this_or_super OP_TK error
1535                 {yyerror ("')' expected"); RECOVER;}
1536 |       this_or_super OP_TK CP_TK error
1537                 {
1538                   parse_ctor_invocation_error ();
1539                   RECOVER;
1540                 }
1541 |       this_or_super OP_TK argument_list error
1542                 {yyerror ("')' expected"); RECOVER;}
1543 |       this_or_super OP_TK argument_list CP_TK error
1544                 {
1545                   parse_ctor_invocation_error ();
1546                   RECOVER;
1547                 }
1548 |       name DOT_TK SUPER_TK error
1549                 {yyerror ("'(' expected"); RECOVER;}
1550 |       name DOT_TK SUPER_TK OP_TK error
1551                 {yyerror ("')' expected"); RECOVER;}
1552 |       name DOT_TK SUPER_TK OP_TK argument_list error
1553                 {yyerror ("')' expected"); RECOVER;}
1554 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1555                 {yyerror ("';' expected"); RECOVER;}
1556 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1557                 {yyerror ("';' expected"); RECOVER;}
1558 ;
1559
1560 statement_expression:
1561         assignment
1562 |       pre_increment_expression
1563 |       pre_decrement_expression
1564 |       post_increment_expression
1565 |       post_decrement_expression
1566 |       method_invocation
1567 |       class_instance_creation_expression
1568 ;
1569
1570 if_then_statement:
1571         IF_TK OP_TK expression CP_TK statement
1572                 {
1573                   $$ = build_if_else_statement ($2.location, $3,
1574                                                 $5, NULL_TREE);
1575                 }
1576 |       IF_TK error
1577                 {yyerror ("'(' expected"); RECOVER;}
1578 |       IF_TK OP_TK error
1579                 {yyerror ("Missing term"); RECOVER;}
1580 |       IF_TK OP_TK expression error
1581                 {yyerror ("')' expected"); RECOVER;}
1582 ;
1583
1584 if_then_else_statement:
1585         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1586                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1587 ;
1588
1589 if_then_else_statement_nsi:
1590         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1591                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1592 ;
1593
1594 switch_statement:
1595         switch_expression
1596                 {
1597                   enter_block ();
1598                 }
1599         switch_block
1600                 {
1601                   /* Make into "proper list" of COMPOUND_EXPRs.
1602                      I.e. make the last statement also have its own
1603                      COMPOUND_EXPR. */
1604                   maybe_absorb_scoping_blocks ();
1605                   TREE_OPERAND ($1, 1) = exit_block ();
1606                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1607                 }
1608 ;
1609
1610 switch_expression:
1611         SWITCH_TK OP_TK expression CP_TK
1612                 {
1613                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1614                   EXPR_WFL_LINECOL ($$) = $2.location;
1615                 }
1616 |       SWITCH_TK error
1617                 {yyerror ("'(' expected"); RECOVER;}
1618 |       SWITCH_TK OP_TK error
1619                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1620 |       SWITCH_TK OP_TK expression CP_TK error
1621                 {yyerror ("'{' expected"); RECOVER;}
1622 ;
1623
1624 /* Default assignment is there to avoid type node on switch_block
1625    node. */
1626
1627 switch_block:
1628         OCB_TK CCB_TK
1629                 { $$ = NULL_TREE; }
1630 |       OCB_TK switch_labels CCB_TK
1631                 { $$ = NULL_TREE; }
1632 |       OCB_TK switch_block_statement_groups CCB_TK
1633                 { $$ = NULL_TREE; }
1634 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1635                 { $$ = NULL_TREE; }
1636 ;
1637
1638 switch_block_statement_groups:
1639         switch_block_statement_group
1640 |       switch_block_statement_groups switch_block_statement_group
1641 ;
1642
1643 switch_block_statement_group:
1644         switch_labels block_statements
1645 ;
1646
1647 switch_labels:
1648         switch_label
1649 |       switch_labels switch_label
1650 ;
1651
1652 switch_label:
1653         CASE_TK constant_expression REL_CL_TK
1654                 {
1655                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1656                   EXPR_WFL_LINECOL (lab) = $1.location;
1657                   java_method_add_stmt (current_function_decl, lab);
1658                 }
1659 |       DEFAULT_TK REL_CL_TK
1660                 {
1661                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1662                   EXPR_WFL_LINECOL (lab) = $1.location;
1663                   java_method_add_stmt (current_function_decl, lab);
1664                 }
1665 |       CASE_TK error
1666                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1667 |       CASE_TK constant_expression error
1668                 {yyerror ("':' expected"); RECOVER;}
1669 |       DEFAULT_TK error
1670                 {yyerror ("':' expected"); RECOVER;}
1671 ;
1672
1673 while_expression:
1674         WHILE_TK OP_TK expression CP_TK
1675                 {
1676                   tree body = build_loop_body ($2.location, $3, 0);
1677                   $$ = build_new_loop (body);
1678                 }
1679 ;
1680
1681 while_statement:
1682         while_expression statement
1683                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1684 |       WHILE_TK error
1685                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1686 |       WHILE_TK OP_TK error
1687                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1688 |       WHILE_TK OP_TK expression error
1689                 {yyerror ("')' expected"); RECOVER;}
1690 ;
1691
1692 while_statement_nsi:
1693         while_expression statement_nsi
1694                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1695 ;
1696
1697 do_statement_begin:
1698         DO_TK
1699                 {
1700                   tree body = build_loop_body (0, NULL_TREE, 1);
1701                   $$ = build_new_loop (body);
1702                 }
1703         /* Need error handing here. FIXME */
1704 ;
1705
1706 do_statement:
1707         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1708                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1709 ;
1710
1711 for_statement:
1712         for_begin SC_TK expression SC_TK for_update CP_TK statement
1713                 {
1714                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1715                     $3 = build_wfl_node ($3);
1716                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1717                 }
1718 |       for_begin SC_TK SC_TK for_update CP_TK statement
1719                 {
1720                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1721                   /* We have not condition, so we get rid of the EXIT_EXPR */
1722                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1723                     empty_stmt_node;
1724                 }
1725 |       for_begin SC_TK error
1726                 {yyerror ("Invalid control expression"); RECOVER;}
1727 |       for_begin SC_TK expression SC_TK error
1728                 {yyerror ("Invalid update expression"); RECOVER;}
1729 |       for_begin SC_TK SC_TK error
1730                 {yyerror ("Invalid update expression"); RECOVER;}
1731 ;
1732
1733 for_statement_nsi:
1734         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1735                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1736 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1737                 {
1738                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1739                   /* We have not condition, so we get rid of the EXIT_EXPR */
1740                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1741                     empty_stmt_node;
1742                 }
1743 ;
1744
1745 for_header:
1746         FOR_TK OP_TK
1747                 {
1748                   /* This scope defined for local variable that may be
1749                      defined within the scope of the for loop */
1750                   enter_block ();
1751                 }
1752 |       FOR_TK error
1753                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1754 |       FOR_TK OP_TK error
1755                 {yyerror ("Invalid init statement"); RECOVER;}
1756 ;
1757
1758 for_begin:
1759         for_header for_init
1760                 {
1761                   /* We now declare the loop body. The loop is
1762                      declared as a for loop. */
1763                   tree body = build_loop_body (0, NULL_TREE, 0);
1764                   $$ =  build_new_loop (body);
1765                   FOR_LOOP_P ($$) = 1;
1766                   /* The loop is added to the current block the for
1767                      statement is defined within */
1768                   java_method_add_stmt (current_function_decl, $$);
1769                 }
1770 ;
1771 for_init:                       /* Can be empty */
1772                 { $$ = empty_stmt_node; }
1773 |       statement_expression_list
1774                 {
1775                   /* Init statement recorded within the previously
1776                      defined block scope */
1777                   $$ = java_method_add_stmt (current_function_decl, $1);
1778                 }
1779 |       local_variable_declaration
1780                 {
1781                   /* Local variable are recorded within the previously
1782                      defined block scope */
1783                   $$ = NULL_TREE;
1784                 }
1785 |       statement_expression_list error
1786                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1787 ;
1788
1789 for_update:                     /* Can be empty */
1790                 {$$ = empty_stmt_node;}
1791 |       statement_expression_list
1792                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1793 ;
1794
1795 statement_expression_list:
1796         statement_expression
1797                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1798 |       statement_expression_list C_TK statement_expression
1799                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1800 |       statement_expression_list C_TK error
1801                 {yyerror ("Missing term"); RECOVER;}
1802 ;
1803
1804 break_statement:
1805         BREAK_TK SC_TK
1806                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1807 |       BREAK_TK identifier SC_TK
1808                 { $$ = build_bc_statement ($1.location, 1, $2); }
1809 |       BREAK_TK error
1810                 {yyerror ("Missing term"); RECOVER;}
1811 |       BREAK_TK identifier error
1812                 {yyerror ("';' expected"); RECOVER;}
1813 ;
1814
1815 continue_statement:
1816         CONTINUE_TK SC_TK
1817                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1818 |       CONTINUE_TK identifier SC_TK
1819                 { $$ = build_bc_statement ($1.location, 0, $2); }
1820 |       CONTINUE_TK error
1821                 {yyerror ("Missing term"); RECOVER;}
1822 |       CONTINUE_TK identifier error
1823                 {yyerror ("';' expected"); RECOVER;}
1824 ;
1825
1826 return_statement:
1827         RETURN_TK SC_TK
1828                 { $$ = build_return ($1.location, NULL_TREE); }
1829 |       RETURN_TK expression SC_TK
1830                 { $$ = build_return ($1.location, $2); }
1831 |       RETURN_TK error
1832                 {yyerror ("Missing term"); RECOVER;}
1833 |       RETURN_TK expression error
1834                 {yyerror ("';' expected"); RECOVER;}
1835 ;
1836
1837 throw_statement:
1838         THROW_TK expression SC_TK
1839                 {
1840                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1841                   EXPR_WFL_LINECOL ($$) = $1.location;
1842                 }
1843 |       THROW_TK error
1844                 {yyerror ("Missing term"); RECOVER;}
1845 |       THROW_TK expression error
1846                 {yyerror ("';' expected"); RECOVER;}
1847 ;
1848
1849 synchronized_statement:
1850         synchronized OP_TK expression CP_TK block
1851                 {
1852                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1853                   EXPR_WFL_LINECOL ($$) =
1854                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1855                 }
1856 |       synchronized OP_TK expression CP_TK error
1857                 {yyerror ("'{' expected"); RECOVER;}
1858 |       synchronized error
1859                 {yyerror ("'(' expected"); RECOVER;}
1860 |       synchronized OP_TK error CP_TK
1861                 {yyerror ("Missing term"); RECOVER;}
1862 |       synchronized OP_TK error
1863                 {yyerror ("Missing term"); RECOVER;}
1864 ;
1865
1866 synchronized:
1867         modifiers
1868                 {
1869                   check_modifiers (
1870              "Illegal modifier `%s'. Only `synchronized' was expected here",
1871                                    $1, ACC_SYNCHRONIZED);
1872                   if ($1 != ACC_SYNCHRONIZED)
1873                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1874                       build_wfl_node (NULL_TREE);
1875                 }
1876 ;
1877
1878 try_statement:
1879         TRY_TK block catches
1880                 { $$ = build_try_statement ($1.location, $2, $3); }
1881 |       TRY_TK block finally
1882                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1883 |       TRY_TK block catches finally
1884                 { $$ = build_try_finally_statement
1885                     ($1.location, build_try_statement ($1.location,
1886                                                        $2, $3), $4);
1887                 }
1888 |       TRY_TK error
1889                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1890 ;
1891
1892 catches:
1893         catch_clause
1894 |       catches catch_clause
1895                 {
1896                   TREE_CHAIN ($2) = $1;
1897                   $$ = $2;
1898                 }
1899 ;
1900
1901 catch_clause:
1902         catch_clause_parameter block
1903                 {
1904                   java_method_add_stmt (current_function_decl, $2);
1905                   exit_block ();
1906                   $$ = $1;
1907                 }
1908
1909 catch_clause_parameter:
1910         CATCH_TK OP_TK formal_parameter CP_TK
1911                 {
1912                   /* We add a block to define a scope for
1913                      formal_parameter (CCBP). The formal parameter is
1914                      declared initialized by the appropriate function
1915                      call */
1916                   tree ccpb = enter_block ();
1917                   tree init = build_assignment
1918                     (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1919                      build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1920                   declare_local_variables (0, TREE_VALUE ($3),
1921                                            build_tree_list (TREE_PURPOSE ($3),
1922                                                             init));
1923                   $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1924                   EXPR_WFL_LINECOL ($$) = $1.location;
1925                 }
1926 |       CATCH_TK error
1927                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1928 |       CATCH_TK OP_TK error
1929                 {
1930                   yyerror ("Missing term or ')' expected");
1931                   RECOVER; $$ = NULL_TREE;
1932                 }
1933 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1934                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1935 ;
1936
1937 finally:
1938         FINALLY_TK block
1939                 { $$ = $2; }
1940 |       FINALLY_TK error
1941                 {yyerror ("'{' expected"); RECOVER; }
1942 ;
1943
1944 /* 19.12 Production from 15: Expressions  */
1945 primary:
1946         primary_no_new_array
1947 |       array_creation_expression
1948 ;
1949
1950 primary_no_new_array:
1951         literal
1952 |       THIS_TK
1953                 { $$ = build_this ($1.location); }
1954 |       OP_TK expression CP_TK
1955                 {$$ = $2;}
1956 |       class_instance_creation_expression
1957 |       field_access
1958 |       method_invocation
1959 |       array_access
1960 |       type_literals
1961         /* Added, JDK1.1 inner classes. Documentation is wrong
1962            refering to a 'ClassName' (class_name) rule that doesn't
1963            exist. Used name: instead.  */
1964 |       name DOT_TK THIS_TK
1965                 {
1966                   tree wfl = build_wfl_node (this_identifier_node);
1967                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1968                 }
1969 |       OP_TK expression error
1970                 {yyerror ("')' expected"); RECOVER;}
1971 |       name DOT_TK error
1972                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1973 |       primitive_type DOT_TK error
1974                 {yyerror ("'class' expected" ); RECOVER;}
1975 |       VOID_TK DOT_TK error
1976                 {yyerror ("'class' expected" ); RECOVER;}
1977 ;
1978
1979 type_literals:
1980         name DOT_TK CLASS_TK
1981                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1982 |       array_type DOT_TK CLASS_TK
1983                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1984 |       primitive_type DOT_TK CLASS_TK
1985                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1986 |       VOID_TK DOT_TK CLASS_TK
1987                 {
1988                    $$ = build_incomplete_class_ref ($2.location,
1989                                                    void_type_node);
1990                 }
1991 ;
1992
1993 class_instance_creation_expression:
1994         NEW_TK class_type OP_TK argument_list CP_TK
1995                 { $$ = build_new_invocation ($2, $4); }
1996 |       NEW_TK class_type OP_TK CP_TK
1997                 { $$ = build_new_invocation ($2, NULL_TREE); }
1998 |       anonymous_class_creation
1999         /* Added, JDK1.1 inner classes, modified to use name or
2000            primary instead of primary solely which couldn't work in
2001            all situations.  */
2002 |       something_dot_new identifier OP_TK CP_TK
2003                 {
2004                   tree ctor = build_new_invocation ($2, NULL_TREE);
2005                   $$ = make_qualified_primary ($1, ctor,
2006                                                EXPR_WFL_LINECOL ($1));
2007                 }
2008 |       something_dot_new identifier OP_TK CP_TK class_body
2009 |       something_dot_new identifier OP_TK argument_list CP_TK
2010                 {
2011                   tree ctor = build_new_invocation ($2, $4);
2012                   $$ = make_qualified_primary ($1, ctor,
2013                                                EXPR_WFL_LINECOL ($1));
2014                 }
2015 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2016 |       NEW_TK error SC_TK
2017                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2018 |       NEW_TK class_type error
2019                 {yyerror ("'(' expected"); RECOVER;}
2020 |       NEW_TK class_type OP_TK error
2021                 {yyerror ("')' or term expected"); RECOVER;}
2022 |       NEW_TK class_type OP_TK argument_list error
2023                 {yyerror ("')' expected"); RECOVER;}
2024 |       something_dot_new error
2025                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2026 |       something_dot_new identifier error
2027                 {yyerror ("'(' expected"); RECOVER;}
2028 ;
2029
2030 /* Created after JDK1.1 rules originally added to
2031    class_instance_creation_expression, but modified to use
2032    'class_type' instead of 'TypeName' (type_name) which is mentionned
2033    in the documentation but doesn't exist. */
2034
2035 anonymous_class_creation:
2036         NEW_TK class_type OP_TK argument_list CP_TK
2037                 { create_anonymous_class ($1.location, $2); }
2038         class_body
2039                 {
2040                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2041                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2042
2043                   end_class_declaration (1);
2044
2045                   /* Now we can craft the new expression */
2046                   $$ = build_new_invocation (id, $4);
2047
2048                   /* Note that we can't possibly be here if
2049                      `class_type' is an interface (in which case the
2050                      anonymous class extends Object and implements
2051                      `class_type', hence its constructor can't have
2052                      arguments.) */
2053
2054                   /* Otherwise, the innerclass must feature a
2055                      constructor matching `argument_list'. Anonymous
2056                      classes are a bit special: it's impossible to
2057                      define constructor for them, hence constructors
2058                      must be generated following the hints provided by
2059                      the `new' expression. Whether a super constructor
2060                      of that nature exists or not is to be verified
2061                      later on in verify_constructor_super.
2062
2063                      It's during the expansion of a `new' statement
2064                      refering to an anonymous class that a ctor will
2065                      be generated for the anonymous class, with the
2066                      right arguments. */
2067
2068                 }
2069 |       NEW_TK class_type OP_TK CP_TK
2070                 { create_anonymous_class ($1.location, $2); }
2071         class_body
2072                 {
2073                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2074                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2075
2076                   end_class_declaration (1);
2077
2078                   /* Now we can craft the new expression. The
2079                      statement doesn't need to be remember so that a
2080                      constructor can be generated, since its signature
2081                      is already known. */
2082                   $$ = build_new_invocation (id, NULL_TREE);
2083                 }
2084 ;
2085
2086 something_dot_new:              /* Added, not part of the specs. */
2087         name DOT_TK NEW_TK
2088                 { $$ = $1; }
2089 |       primary DOT_TK NEW_TK
2090                 { $$ = $1; }
2091 ;
2092
2093 argument_list:
2094         expression
2095                 {
2096                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2097                   ctxp->formal_parameter_number = 1;
2098                 }
2099 |       argument_list C_TK expression
2100                 {
2101                   ctxp->formal_parameter_number += 1;
2102                   $$ = tree_cons (NULL_TREE, $3, $1);
2103                 }
2104 |       argument_list C_TK error
2105                 {yyerror ("Missing term"); RECOVER;}
2106 ;
2107
2108 array_creation_expression:
2109         NEW_TK primitive_type dim_exprs
2110                 { $$ = build_newarray_node ($2, $3, 0); }
2111 |       NEW_TK class_or_interface_type dim_exprs
2112                 { $$ = build_newarray_node ($2, $3, 0); }
2113 |       NEW_TK primitive_type dim_exprs dims
2114                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2115 |       NEW_TK class_or_interface_type dim_exprs dims
2116                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2117         /* Added, JDK1.1 anonymous array. Initial documentation rule
2118            modified */
2119 |       NEW_TK class_or_interface_type dims array_initializer
2120                 {
2121                   char *sig;
2122                   int osb = pop_current_osb (ctxp);
2123                   while (osb--)
2124                     obstack_grow (&temporary_obstack, "[]", 2);
2125                   obstack_1grow (&temporary_obstack, '\0');
2126                   sig = obstack_finish (&temporary_obstack);
2127                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2128                               $2, get_identifier (sig), $4);
2129                 }
2130 |       NEW_TK primitive_type dims array_initializer
2131                 {
2132                   int osb = pop_current_osb (ctxp);
2133                   tree type = $2;
2134                   while (osb--)
2135                     type = build_java_array_type (type, -1);
2136                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2137                               build_pointer_type (type), NULL_TREE, $4);
2138                 }
2139 |       NEW_TK error CSB_TK
2140                 {yyerror ("'[' expected"); DRECOVER ("]");}
2141 |       NEW_TK error OSB_TK
2142                 {yyerror ("']' expected"); RECOVER;}
2143 ;
2144
2145 dim_exprs:
2146         dim_expr
2147                 { $$ = build_tree_list (NULL_TREE, $1); }
2148 |       dim_exprs dim_expr
2149                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2150 ;
2151
2152 dim_expr:
2153         OSB_TK expression CSB_TK
2154                 {
2155                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2156                     {
2157                       $2 = build_wfl_node ($2);
2158                       TREE_TYPE ($2) = NULL_TREE;
2159                     }
2160                   EXPR_WFL_LINECOL ($2) = $1.location;
2161                   $$ = $2;
2162                 }
2163 |       OSB_TK expression error
2164                 {yyerror ("']' expected"); RECOVER;}
2165 |       OSB_TK error
2166                 {
2167                   yyerror ("Missing term");
2168                   yyerror ("']' expected");
2169                   RECOVER;
2170                 }
2171 ;
2172
2173 dims:
2174         OSB_TK CSB_TK
2175                 {
2176                   int allocate = 0;
2177                   /* If not initialized, allocate memory for the osb
2178                      numbers stack */
2179                   if (!ctxp->osb_limit)
2180                     {
2181                       allocate = ctxp->osb_limit = 32;
2182                       ctxp->osb_depth = -1;
2183                     }
2184                   /* If capacity overflown, reallocate a bigger chunk */
2185                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2186                     allocate = ctxp->osb_limit << 1;
2187
2188                   if (allocate)
2189                     {
2190                       allocate *= sizeof (int);
2191                       if (ctxp->osb_number)
2192                         ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
2193                                                             allocate);
2194                       else
2195                         ctxp->osb_number = (int *)xmalloc (allocate);
2196                     }
2197                   ctxp->osb_depth++;
2198                   CURRENT_OSB (ctxp) = 1;
2199                 }
2200 |       dims OSB_TK CSB_TK
2201                 { CURRENT_OSB (ctxp)++; }
2202 |       dims OSB_TK error
2203                 { yyerror ("']' expected"); RECOVER;}
2204 ;
2205
2206 field_access:
2207         primary DOT_TK identifier
2208                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2209                 /*  FIXME - REWRITE TO:
2210                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2211 |       SUPER_TK DOT_TK identifier
2212                 {
2213                   tree super_wfl = build_wfl_node (super_identifier_node);
2214                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2215                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2216                 }
2217 |       SUPER_TK error
2218                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2219 ;
2220
2221 method_invocation:
2222         name OP_TK CP_TK
2223                 { $$ = build_method_invocation ($1, NULL_TREE); }
2224 |       name OP_TK argument_list CP_TK
2225                 { $$ = build_method_invocation ($1, $3); }
2226 |       primary DOT_TK identifier OP_TK CP_TK
2227                 {
2228                   if (TREE_CODE ($1) == THIS_EXPR)
2229                     $$ = build_this_super_qualified_invocation
2230                       (1, $3, NULL_TREE, 0, $2.location);
2231                   else
2232                     {
2233                       tree invok = build_method_invocation ($3, NULL_TREE);
2234                       $$ = make_qualified_primary ($1, invok, $2.location);
2235                     }
2236                 }
2237 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2238                 {
2239                   if (TREE_CODE ($1) == THIS_EXPR)
2240                     $$ = build_this_super_qualified_invocation
2241                       (1, $3, $5, 0, $2.location);
2242                   else
2243                     {
2244                       tree invok = build_method_invocation ($3, $5);
2245                       $$ = make_qualified_primary ($1, invok, $2.location);
2246                     }
2247                 }
2248 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2249                 {
2250                   $$ = build_this_super_qualified_invocation
2251                     (0, $3, NULL_TREE, $1.location, $2.location);
2252                 }
2253 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2254                 {
2255                   $$ = build_this_super_qualified_invocation
2256                     (0, $3, $5, $1.location, $2.location);
2257                 }
2258         /* Screws up thing. I let it here until I'm convinced it can
2259            be removed. FIXME
2260 |       primary DOT_TK error
2261                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2262 |       SUPER_TK DOT_TK error CP_TK
2263                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2264 |       SUPER_TK DOT_TK error DOT_TK
2265                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2266 ;
2267
2268 array_access:
2269         name OSB_TK expression CSB_TK
2270                 { $$ = build_array_ref ($2.location, $1, $3); }
2271 |       primary_no_new_array OSB_TK expression CSB_TK
2272                 { $$ = build_array_ref ($2.location, $1, $3); }
2273 |       name OSB_TK error
2274                 {
2275                   yyerror ("Missing term and ']' expected");
2276                   DRECOVER(array_access);
2277                 }
2278 |       name OSB_TK expression error
2279                 {
2280                   yyerror ("']' expected");
2281                   DRECOVER(array_access);
2282                 }
2283 |       primary_no_new_array OSB_TK error
2284                 {
2285                   yyerror ("Missing term and ']' expected");
2286                   DRECOVER(array_access);
2287                 }
2288 |       primary_no_new_array OSB_TK expression error
2289                 {
2290                   yyerror ("']' expected");
2291                   DRECOVER(array_access);
2292                 }
2293 ;
2294
2295 postfix_expression:
2296         primary
2297 |       name
2298 |       post_increment_expression
2299 |       post_decrement_expression
2300 ;
2301
2302 post_increment_expression:
2303         postfix_expression INCR_TK
2304                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2305 ;
2306
2307 post_decrement_expression:
2308         postfix_expression DECR_TK
2309                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2310 ;
2311
2312 trap_overflow_corner_case:
2313         pre_increment_expression
2314 |       pre_decrement_expression
2315 |       PLUS_TK unary_expression
2316                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2317 |       unary_expression_not_plus_minus
2318 |       PLUS_TK error
2319                 {yyerror ("Missing term"); RECOVER}
2320 ;
2321
2322 unary_expression:
2323         trap_overflow_corner_case
2324                 {
2325                   error_if_numeric_overflow ($1);
2326                   $$ = $1;
2327                 }
2328 |       MINUS_TK trap_overflow_corner_case
2329                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2330 |       MINUS_TK error
2331                 {yyerror ("Missing term"); RECOVER}
2332 ;
2333
2334 pre_increment_expression:
2335         INCR_TK unary_expression
2336                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2337 |       INCR_TK error
2338                 {yyerror ("Missing term"); RECOVER}
2339 ;
2340
2341 pre_decrement_expression:
2342         DECR_TK unary_expression
2343                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2344 |       DECR_TK error
2345                 {yyerror ("Missing term"); RECOVER}
2346 ;
2347
2348 unary_expression_not_plus_minus:
2349         postfix_expression
2350 |       NOT_TK unary_expression
2351                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2352 |       NEG_TK unary_expression
2353                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2354 |       cast_expression
2355 |       NOT_TK error
2356                 {yyerror ("Missing term"); RECOVER}
2357 |       NEG_TK error
2358                 {yyerror ("Missing term"); RECOVER}
2359 ;
2360
2361 cast_expression:                /* Error handling here is potentially weak */
2362         OP_TK primitive_type dims CP_TK unary_expression
2363                 {
2364                   tree type = $2;
2365                   int osb = pop_current_osb (ctxp);
2366                   while (osb--)
2367                     type = build_java_array_type (type, -1);
2368                   $$ = build_cast ($1.location, type, $5);
2369                 }
2370 |       OP_TK primitive_type CP_TK unary_expression
2371                 { $$ = build_cast ($1.location, $2, $4); }
2372 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2373                 { $$ = build_cast ($1.location, $2, $4); }
2374 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2375                 {
2376                   const char *ptr;
2377                   int osb = pop_current_osb (ctxp);
2378                   obstack_grow (&temporary_obstack,
2379                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2380                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2381                   while (osb--)
2382                     obstack_grow (&temporary_obstack, "[]", 2);
2383                   obstack_1grow (&temporary_obstack, '\0');
2384                   ptr = obstack_finish (&temporary_obstack);
2385                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2386                   $$ = build_cast ($1.location, $2, $5);
2387                 }
2388 |       OP_TK primitive_type OSB_TK error
2389                 {yyerror ("']' expected, invalid type expression");}
2390 |       OP_TK error
2391                 {
2392                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2393                   RECOVER;
2394                 }
2395 |       OP_TK primitive_type dims CP_TK error
2396                 {yyerror ("Missing term"); RECOVER;}
2397 |       OP_TK primitive_type CP_TK error
2398                 {yyerror ("Missing term"); RECOVER;}
2399 |       OP_TK name dims CP_TK error
2400                 {yyerror ("Missing term"); RECOVER;}
2401 ;
2402
2403 multiplicative_expression:
2404         unary_expression
2405 |       multiplicative_expression MULT_TK unary_expression
2406                 {
2407                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2408                                     $2.location, $1, $3);
2409                 }
2410 |       multiplicative_expression DIV_TK unary_expression
2411                 {
2412                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2413                                     $1, $3);
2414                 }
2415 |       multiplicative_expression REM_TK unary_expression
2416                 {
2417                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2418                                     $1, $3);
2419                 }
2420 |       multiplicative_expression MULT_TK error
2421                 {yyerror ("Missing term"); RECOVER;}
2422 |       multiplicative_expression DIV_TK error
2423                 {yyerror ("Missing term"); RECOVER;}
2424 |       multiplicative_expression REM_TK error
2425                 {yyerror ("Missing term"); RECOVER;}
2426 ;
2427
2428 additive_expression:
2429         multiplicative_expression
2430 |       additive_expression PLUS_TK multiplicative_expression
2431                 {
2432                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2433                                     $1, $3);
2434                 }
2435 |       additive_expression MINUS_TK multiplicative_expression
2436                 {
2437                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2438                                     $1, $3);
2439                 }
2440 |       additive_expression PLUS_TK error
2441                 {yyerror ("Missing term"); RECOVER;}
2442 |       additive_expression MINUS_TK error
2443                 {yyerror ("Missing term"); RECOVER;}
2444 ;
2445
2446 shift_expression:
2447         additive_expression
2448 |       shift_expression LS_TK additive_expression
2449                 {
2450                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2451                                     $1, $3);
2452                 }
2453 |       shift_expression SRS_TK additive_expression
2454                 {
2455                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2456                                     $1, $3);
2457                 }
2458 |       shift_expression ZRS_TK additive_expression
2459                 {
2460                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2461                                     $1, $3);
2462                 }
2463 |       shift_expression LS_TK error
2464                 {yyerror ("Missing term"); RECOVER;}
2465 |       shift_expression SRS_TK error
2466                 {yyerror ("Missing term"); RECOVER;}
2467 |       shift_expression ZRS_TK error
2468                 {yyerror ("Missing term"); RECOVER;}
2469 ;
2470
2471 relational_expression:
2472         shift_expression
2473 |       relational_expression LT_TK shift_expression
2474                 {
2475                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2476                                     $1, $3);
2477                 }
2478 |       relational_expression GT_TK shift_expression
2479                 {
2480                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2481                                     $1, $3);
2482                 }
2483 |       relational_expression LTE_TK shift_expression
2484                 {
2485                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2486                                     $1, $3);
2487                 }
2488 |       relational_expression GTE_TK shift_expression
2489                 {
2490                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2491                                     $1, $3);
2492                 }
2493 |       relational_expression INSTANCEOF_TK reference_type
2494                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2495 |       relational_expression LT_TK error
2496                 {yyerror ("Missing term"); RECOVER;}
2497 |       relational_expression GT_TK error
2498                 {yyerror ("Missing term"); RECOVER;}
2499 |       relational_expression LTE_TK error
2500                 {yyerror ("Missing term"); RECOVER;}
2501 |       relational_expression GTE_TK error
2502                 {yyerror ("Missing term"); RECOVER;}
2503 |       relational_expression INSTANCEOF_TK error
2504                 {yyerror ("Invalid reference type"); RECOVER;}
2505 ;
2506
2507 equality_expression:
2508         relational_expression
2509 |       equality_expression EQ_TK relational_expression
2510                 {
2511                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2512                                     $1, $3);
2513                 }
2514 |       equality_expression NEQ_TK relational_expression
2515                 {
2516                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2517                                     $1, $3);
2518                 }
2519 |       equality_expression EQ_TK error
2520                 {yyerror ("Missing term"); RECOVER;}
2521 |       equality_expression NEQ_TK error
2522                 {yyerror ("Missing term"); RECOVER;}
2523 ;
2524
2525 and_expression:
2526         equality_expression
2527 |       and_expression AND_TK equality_expression
2528                 {
2529                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2530                                     $1, $3);
2531                 }
2532 |       and_expression AND_TK error
2533                 {yyerror ("Missing term"); RECOVER;}
2534 ;
2535
2536 exclusive_or_expression:
2537         and_expression
2538 |       exclusive_or_expression XOR_TK and_expression
2539                 {
2540                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2541                                     $1, $3);
2542                 }
2543 |       exclusive_or_expression XOR_TK error
2544                 {yyerror ("Missing term"); RECOVER;}
2545 ;
2546
2547 inclusive_or_expression:
2548         exclusive_or_expression
2549 |       inclusive_or_expression OR_TK exclusive_or_expression
2550                 {
2551                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2552                                     $1, $3);
2553                 }
2554 |       inclusive_or_expression OR_TK error
2555                 {yyerror ("Missing term"); RECOVER;}
2556 ;
2557
2558 conditional_and_expression:
2559         inclusive_or_expression
2560 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2561                 {
2562                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2563                                     $1, $3);
2564                 }
2565 |       conditional_and_expression BOOL_AND_TK error
2566                 {yyerror ("Missing term"); RECOVER;}
2567 ;
2568
2569 conditional_or_expression:
2570         conditional_and_expression
2571 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2572                 {
2573                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2574                                     $1, $3);
2575                 }
2576 |       conditional_or_expression BOOL_OR_TK error
2577                 {yyerror ("Missing term"); RECOVER;}
2578 ;
2579
2580 conditional_expression:         /* Error handling here is weak */
2581         conditional_or_expression
2582 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2583                 {
2584                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2585                   EXPR_WFL_LINECOL ($$) = $2.location;
2586                 }
2587 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2588                 {
2589                   YYERROR_NOW;
2590                   yyerror ("Missing term");
2591                   DRECOVER (1);
2592                 }
2593 |       conditional_or_expression REL_QM_TK error
2594                 {yyerror ("Missing term"); DRECOVER (2);}
2595 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2596                 {yyerror ("Missing term"); DRECOVER (3);}
2597 ;
2598
2599 assignment_expression:
2600         conditional_expression
2601 |       assignment
2602 ;
2603
2604 assignment:
2605         left_hand_side assignment_operator assignment_expression
2606                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2607 |       left_hand_side assignment_operator error
2608                 {
2609                   YYNOT_TWICE yyerror ("Missing term");
2610                   DRECOVER (assign);
2611                 }
2612 ;
2613
2614 left_hand_side:
2615         name
2616 |       field_access
2617 |       array_access
2618 ;
2619
2620 assignment_operator:
2621         ASSIGN_ANY_TK
2622 |       ASSIGN_TK
2623 ;
2624
2625 expression:
2626         assignment_expression
2627 ;
2628
2629 constant_expression:
2630         expression
2631 ;
2632
2633 %%
2634
2635 /* Helper function to retrieve an OSB count. Should be used when the
2636    `dims:' rule is being used.  */
2637
2638 static int
2639 pop_current_osb (ctxp)
2640      struct parser_ctxt *ctxp;
2641 {
2642   int to_return;
2643
2644   if (ctxp->osb_depth < 0)
2645     abort ();
2646
2647   to_return = CURRENT_OSB (ctxp);
2648   ctxp->osb_depth--;
2649
2650   return to_return;
2651 }
2652
2653 \f
2654
2655 /* This section of the code deal with save/restoring parser contexts.
2656    Add mode documentation here. FIXME */
2657
2658 /* Helper function. Create a new parser context. With
2659    COPY_FROM_PREVIOUS set to a non zero value, content of the previous
2660    context is copied, otherwise, the new context is zeroed. The newly
2661    created context becomes the current one.  */
2662
2663 static void
2664 create_new_parser_context (copy_from_previous)
2665     int copy_from_previous;
2666 {
2667   struct parser_ctxt *new;
2668
2669   new =  (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2670   if (copy_from_previous)
2671     {
2672       memcpy ((PTR)new, (PTR)ctxp, sizeof (struct parser_ctxt));
2673       new->saved_data_ctx = 1;
2674     }
2675   else
2676     memset ((PTR) new, 0, sizeof (struct parser_ctxt));
2677
2678   new->next = ctxp;
2679   ctxp = new;
2680 }
2681
2682 /* Create a new parser context and make it the current one. */
2683
2684 void
2685 java_push_parser_context ()
2686 {
2687   create_new_parser_context (0);
2688 }
2689
2690 void
2691 java_pop_parser_context (generate)
2692      int generate;
2693 {
2694   tree current;
2695   struct parser_ctxt *toFree, *next;
2696
2697   if (!ctxp)
2698     return;
2699
2700   toFree = ctxp;
2701   next = ctxp->next;
2702   if (next)
2703     {
2704       lineno = ctxp->lineno;
2705       current_class = ctxp->class_type;
2706     }
2707
2708   /* If the old and new lexers differ, then free the old one.  */
2709   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2710     java_destroy_lexer (ctxp->lexer);
2711
2712   /* Set the single import class file flag to 0 for the current list
2713      of imported things */
2714   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2715     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2716
2717   /* And restore those of the previous context */
2718   if ((ctxp = next))            /* Assignment is really meant here */
2719     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2720       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2721
2722   /* If we pushed a context to parse a class intended to be generated,
2723      we keep it so we can remember the class. What we could actually
2724      do is to just update a list of class names.  */
2725   if (generate)
2726     {
2727       toFree->next = ctxp_for_generation;
2728       ctxp_for_generation = toFree;
2729     }
2730   else
2731     free (toFree);
2732 }
2733
2734 /* Create a parser context for the use of saving some global
2735    variables.  */
2736
2737 void
2738 java_parser_context_save_global ()
2739 {
2740   if (!ctxp)
2741     {
2742       java_push_parser_context ();
2743       ctxp->saved_data_ctx = 1;
2744     }
2745
2746   /* If this context already stores data, create a new one suitable
2747      for data storage. */
2748   else if (ctxp->saved_data)
2749     create_new_parser_context (1);
2750
2751   ctxp->lineno = lineno;
2752   ctxp->class_type = current_class;
2753   ctxp->filename = input_filename;
2754   ctxp->function_decl = current_function_decl;
2755   ctxp->saved_data = 1;
2756 }
2757
2758 /* Restore some global variables from the previous context. Make the
2759    previous context the current one.  */
2760
2761 void
2762 java_parser_context_restore_global ()
2763 {
2764   lineno = ctxp->lineno;
2765   current_class = ctxp->class_type;
2766   input_filename = ctxp->filename;
2767   if (wfl_operator)
2768     {
2769       tree s;
2770       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2771       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2772     }
2773   current_function_decl = ctxp->function_decl;
2774   ctxp->saved_data = 0;
2775   if (ctxp->saved_data_ctx)
2776     java_pop_parser_context (0);
2777 }
2778
2779 /* Suspend vital data for the current class/function being parsed so
2780    that an other class can be parsed. Used to let local/anonymous
2781    classes be parsed.  */
2782
2783 static void
2784 java_parser_context_suspend ()
2785 {
2786   /* This makes debugging through java_debug_context easier */
2787   static const char *const name = "<inner buffer context>";
2788
2789   /* Duplicate the previous context, use it to save the globals we're
2790      interested in */
2791   create_new_parser_context (1);
2792   ctxp->function_decl = current_function_decl;
2793   ctxp->class_type = current_class;
2794
2795   /* Then create a new context which inherits all data from the
2796      previous one. This will be the new current context  */
2797   create_new_parser_context (1);
2798
2799   /* Help debugging */
2800   ctxp->next->filename = name;
2801 }
2802
2803 /* Resume vital data for the current class/function being parsed so
2804    that an other class can be parsed. Used to let local/anonymous
2805    classes be parsed.  The trick is the data storing file position
2806    informations must be restored to their current value, so parsing
2807    can resume as if no context was ever saved. */
2808
2809 static void
2810 java_parser_context_resume ()
2811 {
2812   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2813   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2814   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2815
2816   /* We need to inherit the list of classes to complete/generate */
2817   restored->classd_list = old->classd_list;
2818   restored->class_list = old->class_list;
2819
2820   /* Restore the current class and function from the saver */
2821   current_class = saver->class_type;
2822   current_function_decl = saver->function_decl;
2823
2824   /* Retrive the restored context */
2825   ctxp = restored;
2826
2827   /* Re-installed the data for the parsing to carry on */
2828   memcpy (&ctxp->marker_begining, &old->marker_begining,
2829           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2830
2831   /* Buffer context can now be discarded */
2832   free (saver);
2833   free (old);
2834 }
2835
2836 /* Add a new anchor node to which all statement(s) initializing static
2837    and non static initialized upon declaration field(s) will be
2838    linked.  */
2839
2840 static void
2841 java_parser_context_push_initialized_field ()
2842 {
2843   tree node;
2844
2845   node = build_tree_list (NULL_TREE, NULL_TREE);
2846   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2847   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2848
2849   node = build_tree_list (NULL_TREE, NULL_TREE);
2850   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2851   CPC_INITIALIZER_LIST (ctxp) = node;
2852
2853   node = build_tree_list (NULL_TREE, NULL_TREE);
2854   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2855   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2856 }
2857
2858 /* Pop the lists of initialized field. If this lists aren't empty,
2859    remember them so we can use it to create and populate the finit$
2860    or <clinit> functions. */
2861
2862 static void
2863 java_parser_context_pop_initialized_field ()
2864 {
2865   tree stmts;
2866   tree class_type = TREE_TYPE (GET_CPC ());
2867
2868   if (CPC_INITIALIZER_LIST (ctxp))
2869     {
2870       stmts = CPC_INITIALIZER_STMT (ctxp);
2871       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2872       if (stmts && !java_error_count)
2873         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2874     }
2875
2876   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2877     {
2878       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2879       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2880         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2881       /* Keep initialization in order to enforce 8.5 */
2882       if (stmts && !java_error_count)
2883         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2884     }
2885
2886   /* JDK 1.1 instance initializers */
2887   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2888     {
2889       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2890       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2891         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2892       if (stmts && !java_error_count)
2893         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2894     }
2895 }
2896
2897 static tree
2898 reorder_static_initialized (list)
2899      tree list;
2900 {
2901   /* We have to keep things in order. The alias initializer have to
2902      come first, then the initialized regular field, in reverse to
2903      keep them in lexical order. */
2904   tree marker, previous = NULL_TREE;
2905   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2906     if (TREE_CODE (marker) == TREE_LIST
2907         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2908       break;
2909
2910   /* No static initialized, the list is fine as is */
2911   if (!previous)
2912     list = TREE_CHAIN (marker);
2913
2914   /* No marker? reverse the whole list */
2915   else if (!marker)
2916     list = nreverse (list);
2917
2918   /* Otherwise, reverse what's after the marker and the new reordered
2919      sublist will replace the marker. */
2920   else
2921     {
2922       TREE_CHAIN (previous) = NULL_TREE;
2923       list = nreverse (list);
2924       list = chainon (TREE_CHAIN (marker), list);
2925     }
2926   return list;
2927 }
2928
2929 /* Helper functions to dump the parser context stack.  */
2930
2931 #define TAB_CONTEXT(C) \
2932   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2933
2934 static void
2935 java_debug_context_do (tab)
2936      int tab;
2937 {
2938   struct parser_ctxt *copy = ctxp;
2939   while (copy)
2940     {
2941       TAB_CONTEXT (tab);
2942       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2943       TAB_CONTEXT (tab);
2944       fprintf (stderr, "filename: %s\n", copy->filename);
2945       TAB_CONTEXT (tab);
2946       fprintf (stderr, "lineno: %d\n", copy->lineno);
2947       TAB_CONTEXT (tab);
2948       fprintf (stderr, "package: %s\n",
2949                (copy->package ?
2950                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2951       TAB_CONTEXT (tab);
2952       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2953       TAB_CONTEXT (tab);
2954       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2955       copy = copy->next;
2956       tab += 2;
2957     }
2958 }
2959
2960 /* Dump the stacked up parser contexts. Intended to be called from a
2961    debugger.  */
2962
2963 void
2964 java_debug_context ()
2965 {
2966   java_debug_context_do (0);
2967 }
2968
2969 \f
2970
2971 /* Flag for the error report routine to issue the error the first time
2972    it's called (overriding the default behavior which is to drop the
2973    first invocation and honor the second one, taking advantage of a
2974    richer context.  */
2975 static int force_error = 0;
2976
2977 /* Reporting an constructor invocation error.  */
2978 static void
2979 parse_ctor_invocation_error ()
2980 {
2981   if (DECL_CONSTRUCTOR_P (current_function_decl))
2982     yyerror ("Constructor invocation must be first thing in a constructor");
2983   else
2984     yyerror ("Only constructors can invoke constructors");
2985 }
2986
2987 /* Reporting JDK1.1 features not implemented.  */
2988
2989 static tree
2990 parse_jdk1_1_error (msg)
2991     const char *msg;
2992 {
2993   sorry (": `%s' JDK1.1(TM) feature", msg);
2994   java_error_count++;
2995   return empty_stmt_node;
2996 }
2997
2998 static int do_warning = 0;
2999
3000 void
3001 yyerror (msg)
3002      const char *msg;
3003 {
3004   static java_lc elc;
3005   static int  prev_lineno;
3006   static const char *prev_msg;
3007
3008   int save_lineno;
3009   char *remainder, *code_from_source;
3010
3011   if (!force_error && prev_lineno == lineno)
3012     return;
3013
3014   /* Save current error location but report latter, when the context is
3015      richer.  */
3016   if (ctxp->java_error_flag == 0)
3017     {
3018       ctxp->java_error_flag = 1;
3019       elc = ctxp->elc;
3020       /* Do something to use the previous line if we're reaching the
3021          end of the file... */
3022 #ifdef VERBOSE_SKELETON
3023       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3024 #endif
3025       return;
3026     }
3027
3028   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3029   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3030     return;
3031
3032   ctxp->java_error_flag = 0;
3033   if (do_warning)
3034     java_warning_count++;
3035   else
3036     java_error_count++;
3037
3038   if (elc.col == 0 && msg && msg[1] == ';')
3039     {
3040       elc.col  = ctxp->p_line->char_col-1;
3041       elc.line = ctxp->p_line->lineno;
3042     }
3043
3044   save_lineno = lineno;
3045   prev_lineno = lineno = elc.line;
3046   prev_msg = msg;
3047
3048   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3049   obstack_grow0 (&temporary_obstack,
3050                  code_from_source, strlen (code_from_source));
3051   remainder = obstack_finish (&temporary_obstack);
3052   if (do_warning)
3053     warning ("%s.\n%s", msg, remainder);
3054   else
3055     error ("%s.\n%s", msg, remainder);
3056
3057   /* This allow us to cheaply avoid an extra 'Invalid expression
3058      statement' error report when errors have been already reported on
3059      the same line. This occurs when we report an error but don't have
3060      a synchronization point other than ';', which
3061      expression_statement is the only one to take care of.  */
3062   ctxp->prevent_ese = lineno = save_lineno;
3063 }
3064
3065 static void
3066 issue_warning_error_from_context (cl, msg, ap)
3067      tree cl;
3068      const char *msg;
3069      va_list ap;
3070 {
3071   const char *saved, *saved_input_filename;
3072   char buffer [4096];
3073   vsprintf (buffer, msg, ap);
3074   force_error = 1;
3075
3076   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3077   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3078                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3079
3080   /* We have a CL, that's a good reason for using it if it contains data */
3081   saved = ctxp->filename;
3082   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3083     ctxp->filename = EXPR_WFL_FILENAME (cl);
3084   saved_input_filename = input_filename;
3085   input_filename = ctxp->filename;
3086   java_error (NULL);
3087   java_error (buffer);
3088   ctxp->filename = saved;
3089   input_filename = saved_input_filename;
3090   force_error = 0;
3091 }
3092
3093 /* Issue an error message at a current source line CL */
3094
3095 void
3096 parse_error_context VPARAMS ((tree cl, const char *msg, ...))
3097 {
3098   VA_OPEN (ap, msg);
3099   VA_FIXEDARG (ap, tree, cl);
3100   VA_FIXEDARG (ap, const char *, msg);
3101   issue_warning_error_from_context (cl, msg, ap);
3102   VA_CLOSE (ap);
3103 }
3104
3105 /* Issue a warning at a current source line CL */
3106
3107 static void
3108 parse_warning_context VPARAMS ((tree cl, const char *msg, ...))
3109 {
3110   VA_OPEN (ap, msg);
3111   VA_FIXEDARG (ap, tree, cl);
3112   VA_FIXEDARG (ap, const char *, msg);
3113
3114   force_error = do_warning = 1;
3115   issue_warning_error_from_context (cl, msg, ap);
3116   do_warning = force_error = 0;
3117   VA_CLOSE (ap);
3118 }
3119
3120 static tree
3121 find_expr_with_wfl (node)
3122      tree node;
3123 {
3124   while (node)
3125     {
3126       char code;
3127       tree to_return;
3128
3129       switch (TREE_CODE (node))
3130         {
3131         case BLOCK:
3132           node = BLOCK_EXPR_BODY (node);
3133           continue;
3134
3135         case COMPOUND_EXPR:
3136           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3137           if (to_return)
3138             return to_return;
3139           node = TREE_OPERAND (node, 1);
3140           continue;
3141
3142         case LOOP_EXPR:
3143           node = TREE_OPERAND (node, 0);
3144           continue;
3145
3146         case LABELED_BLOCK_EXPR:
3147           node = TREE_OPERAND (node, 1);
3148           continue;
3149
3150         default:
3151           code = TREE_CODE_CLASS (TREE_CODE (node));
3152           if (((code == '1') || (code == '2') || (code == 'e'))
3153               && EXPR_WFL_LINECOL (node))
3154             return node;
3155           return NULL_TREE;
3156         }
3157     }
3158   return NULL_TREE;
3159 }
3160
3161 /* Issue a missing return statement error. Uses METHOD to figure the
3162    last line of the method the error occurs in.  */
3163
3164 static void
3165 missing_return_error (method)
3166      tree method;
3167 {
3168   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
3169   parse_error_context (wfl_operator, "Missing return statement");
3170 }
3171
3172 /* Issue an unreachable statement error. From NODE, find the next
3173    statement to report appropriately.  */
3174 static void
3175 unreachable_stmt_error (node)
3176      tree node;
3177 {
3178   /* Browse node to find the next expression node that has a WFL. Use
3179      the location to report the error */
3180   if (TREE_CODE (node) == COMPOUND_EXPR)
3181     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3182   else
3183     node = find_expr_with_wfl (node);
3184
3185   if (node)
3186     {
3187       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3188       parse_error_context (wfl_operator, "Unreachable statement");
3189     }
3190   else
3191     abort ();
3192 }
3193
3194 int
3195 java_report_errors ()
3196 {
3197   if (java_error_count)
3198     fprintf (stderr, "%d error%s",
3199              java_error_count, (java_error_count == 1 ? "" : "s"));
3200   if (java_warning_count)
3201     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3202              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3203   if (java_error_count || java_warning_count)
3204     putc ('\n', stderr);
3205   return java_error_count;
3206 }
3207
3208 static char *
3209 java_accstring_lookup (flags)
3210      int flags;
3211 {
3212   static char buffer [80];
3213 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3214
3215   /* Access modifier looked-up first for easier report on forbidden
3216      access. */
3217   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3218   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3219   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3220   if (flags & ACC_STATIC) COPY_RETURN ("static");
3221   if (flags & ACC_FINAL) COPY_RETURN ("final");
3222   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3223   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3224   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3225   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3226   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3227   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3228
3229   buffer [0] = '\0';
3230   return buffer;
3231 #undef COPY_RETURN
3232 }
3233
3234 /* Issuing error messages upon redefinition of classes, interfaces or
3235    variables. */
3236
3237 static void
3238 classitf_redefinition_error (context, id, decl, cl)
3239      const char *context;
3240      tree id, decl, cl;
3241 {
3242   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3243                        context, IDENTIFIER_POINTER (id),
3244                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3245   /* Here we should point out where its redefined. It's a unicode. FIXME */
3246 }
3247
3248 static void
3249 variable_redefinition_error (context, name, type, line)
3250      tree context, name, type;
3251      int line;
3252 {
3253   const char *type_name;
3254
3255   /* Figure a proper name for type. We might haven't resolved it */
3256   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3257     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3258   else
3259     type_name = lang_printable_name (type, 0);
3260
3261   parse_error_context (context,
3262                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3263                        IDENTIFIER_POINTER (name),
3264                        type_name, IDENTIFIER_POINTER (name), line);
3265 }
3266
3267 /* If ANAME is terminated with `[]', it indicates an array. This
3268    function returns the number of `[]' found and if this number is
3269    greater than zero, it extracts the array type name and places it in
3270    the node pointed to by TRIMMED unless TRIMMED is null.  */
3271
3272 static int
3273 build_type_name_from_array_name (aname, trimmed)
3274      tree aname;
3275      tree *trimmed;
3276 {
3277   const char *name = IDENTIFIER_POINTER (aname);
3278   int len = IDENTIFIER_LENGTH (aname);
3279   int array_dims;
3280
3281   STRING_STRIP_BRACKETS (name, len, array_dims);
3282
3283   if (array_dims && trimmed)
3284     *trimmed = get_identifier_with_length (name, len);
3285
3286   return array_dims;
3287 }
3288
3289 static tree
3290 build_array_from_name (type, type_wfl, name, ret_name)
3291      tree type, type_wfl, name, *ret_name;
3292 {
3293   int more_dims = 0;
3294
3295   /* Eventually get more dims */
3296   more_dims = build_type_name_from_array_name (name, &name);
3297
3298   /* If we have, then craft a new type for this variable */
3299   if (more_dims)
3300     {
3301       tree save = type;
3302
3303       /* If we have a pointer, use its type */
3304       if (TREE_CODE (type) == POINTER_TYPE)
3305         type = TREE_TYPE (type);
3306
3307       /* Building the first dimension of a primitive type uses this
3308          function */
3309       if (JPRIMITIVE_TYPE_P (type))
3310         {
3311           type = build_java_array_type (type, -1);
3312           more_dims--;
3313         }
3314       /* Otherwise, if we have a WFL for this type, use it (the type
3315          is already an array on an unresolved type, and we just keep
3316          on adding dimensions) */
3317       else if (type_wfl)
3318         {
3319           type = type_wfl;
3320           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3321                                                         NULL);
3322         }
3323
3324       /* Add all the dimensions */
3325       while (more_dims--)
3326         type = build_unresolved_array_type (type);
3327
3328       /* The type may have been incomplete in the first place */
3329       if (type_wfl)
3330         type = obtain_incomplete_type (type);
3331     }
3332
3333   if (ret_name)
3334     *ret_name = name;
3335   return type;
3336 }
3337
3338 /* Build something that the type identifier resolver will identify as
3339    being an array to an unresolved type. TYPE_WFL is a WFL on a
3340    identifier. */
3341
3342 static tree
3343 build_unresolved_array_type (type_or_wfl)
3344      tree type_or_wfl;
3345 {
3346   const char *ptr;
3347   tree wfl;
3348
3349   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3350      just create a array type */
3351   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3352     return build_java_array_type (type_or_wfl, -1);
3353
3354   obstack_grow (&temporary_obstack,
3355                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3356                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3357   obstack_grow0 (&temporary_obstack, "[]", 2);
3358   ptr = obstack_finish (&temporary_obstack);
3359   wfl = build_expr_wfl (get_identifier (ptr),
3360                         EXPR_WFL_FILENAME (type_or_wfl),
3361                         EXPR_WFL_LINENO (type_or_wfl),
3362                         EXPR_WFL_COLNO (type_or_wfl));
3363   /* Re-install the existing qualifications so that the type can be
3364      resolved properly. */
3365   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3366   return wfl;
3367 }
3368
3369 static void
3370 parser_add_interface (class_decl, interface_decl, wfl)
3371      tree class_decl, interface_decl, wfl;
3372 {
3373   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3374     parse_error_context (wfl, "Interface `%s' repeated",
3375                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3376 }
3377
3378 /* Bulk of common class/interface checks. Return 1 if an error was
3379    encountered. TAG is 0 for a class, 1 for an interface.  */
3380
3381 static int
3382 check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
3383      int is_interface, flags;
3384      tree raw_name, qualified_name, decl, cl;
3385 {
3386   tree node;
3387   int sca = 0;                  /* Static class allowed */
3388   int icaf = 0;                 /* Inner class allowed flags */
3389   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3390
3391   if (!quiet_flag)
3392     fprintf (stderr, " %s%s %s",
3393              (CPC_INNER_P () ? "inner" : ""),
3394              (is_interface ? "interface" : "class"),
3395              IDENTIFIER_POINTER (qualified_name));
3396
3397   /* Scope of an interface/class type name:
3398        - Can't be imported by a single type import
3399        - Can't already exists in the package */
3400   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3401       && (node = find_name_in_single_imports (raw_name))
3402       && !CPC_INNER_P ())
3403     {
3404       parse_error_context
3405         (cl, "%s name `%s' clashes with imported type `%s'",
3406          (is_interface ? "Interface" : "Class"),
3407          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3408       return 1;
3409     }
3410   if (decl && CLASS_COMPLETE_P (decl))
3411     {
3412       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3413                                    qualified_name, decl, cl);
3414       return 1;
3415     }
3416
3417   if (check_inner_class_redefinition (raw_name, cl))
3418     return 1;
3419
3420   /* If public, file name should match class/interface name, except
3421      when dealing with an inner class */
3422   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3423     {
3424       const char *f;
3425
3426       /* Contains OS dependent assumption on path separator. FIXME */
3427       for (f = &input_filename [strlen (input_filename)];
3428            f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR;
3429            f--)
3430         ;
3431       if (f[0] == '/' || f[0] == DIR_SEPARATOR)
3432         f++;
3433       if (strncmp (IDENTIFIER_POINTER (raw_name),
3434                    f , IDENTIFIER_LENGTH (raw_name)) ||
3435           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3436         parse_error_context
3437           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3438                              (is_interface ? "interface" : "class"),
3439                              IDENTIFIER_POINTER (qualified_name),
3440                              IDENTIFIER_POINTER (raw_name));
3441     }
3442
3443   /* Static classes can be declared only in top level classes. Note:
3444      once static, a inner class is a top level class. */
3445   if (flags & ACC_STATIC)
3446     {
3447       /* Catch the specific error of declaring an class inner class
3448          with no toplevel enclosing class. Prevent check_modifiers from
3449          complaining a second time */
3450       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3451         {
3452           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3453                                IDENTIFIER_POINTER (qualified_name));
3454           sca = ACC_STATIC;
3455         }
3456       /* Else, in the context of a top-level class declaration, let
3457          `check_modifiers' do its job, otherwise, give it a go */
3458       else
3459         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3460     }
3461
3462   /* Inner classes can be declared private or protected
3463      within their enclosing classes. */
3464   if (CPC_INNER_P ())
3465     {
3466       /* A class which is local to a block can't be public, private,
3467          protected or static. But it is created final, so allow this
3468          one. */
3469       if (current_function_decl)
3470         icaf = sca = uaaf = ACC_FINAL;
3471       else
3472         {
3473           check_modifiers_consistency (flags);
3474           icaf = ACC_PROTECTED;
3475           if (! CLASS_INTERFACE (GET_CPC ()))
3476             icaf |= ACC_PRIVATE;
3477         }
3478     }
3479
3480   if (is_interface)
3481     {
3482       if (CPC_INNER_P ())
3483         uaaf = INTERFACE_INNER_MODIFIERS;
3484       else
3485         uaaf = INTERFACE_MODIFIERS;
3486
3487       check_modifiers ("Illegal modifier `%s' for interface declaration",
3488                        flags, uaaf);
3489     }
3490   else
3491     check_modifiers ((current_function_decl ?
3492                       "Illegal modifier `%s' for local class declaration" :
3493                       "Illegal modifier `%s' for class declaration"),
3494                      flags, uaaf|sca|icaf);
3495   return 0;
3496 }
3497
3498 static void
3499 make_nested_class_name (cpc_list)
3500      tree cpc_list;
3501 {
3502   tree name;
3503
3504   if (!cpc_list)
3505     return;
3506   else
3507     make_nested_class_name (TREE_CHAIN (cpc_list));
3508
3509   /* Pick the qualified name when dealing with the first upmost
3510      enclosing class */
3511   name = (TREE_CHAIN (cpc_list) ?
3512           TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3513   obstack_grow (&temporary_obstack,
3514                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3515   obstack_1grow (&temporary_obstack, '$');
3516 }
3517
3518 /* Can't redefine a class already defined in an earlier scope. */
3519
3520 static int
3521 check_inner_class_redefinition (raw_name, cl)
3522      tree raw_name, cl;
3523 {
3524   tree scope_list;
3525
3526   for (scope_list = GET_CPC_LIST (); scope_list;
3527        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3528     if (raw_name == GET_CPC_UN_NODE (scope_list))
3529       {
3530         parse_error_context
3531           (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",
3532            IDENTIFIER_POINTER (raw_name));
3533         return 1;
3534       }
3535   return 0;
3536 }
3537
3538 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3539    we remember ENCLOSING and SUPER.  */
3540
3541 static tree
3542 resolve_inner_class (circularity_hash, cl, enclosing, super, class_type)
3543      struct hash_table *circularity_hash;
3544      tree cl, *enclosing, *super, class_type;
3545 {
3546   tree local_enclosing = *enclosing;
3547   tree local_super = NULL_TREE;
3548
3549   while (local_enclosing)
3550     {
3551       tree intermediate, decl;
3552
3553       hash_lookup (circularity_hash,
3554                    (const  hash_table_key) local_enclosing, TRUE, NULL);
3555
3556       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3557         return decl;
3558
3559       intermediate = local_enclosing;
3560       /* Explore enclosing contexts. */
3561       while (INNER_CLASS_DECL_P (intermediate))
3562         {
3563           intermediate = DECL_CONTEXT (intermediate);
3564           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3565             return decl;
3566         }
3567
3568       /* Now go to the upper classes, bail out if necessary. We will
3569          analyze the returned SUPER and act accordingly (see
3570          do_resolve_class.) */
3571       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3572       if (!local_super || local_super == object_type_node)
3573         break;
3574
3575       if (TREE_CODE (local_super) == POINTER_TYPE)
3576         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3577       else
3578         local_super = TYPE_NAME (local_super);
3579
3580       /* We may not have checked for circular inheritance yet, so do so
3581          here to prevent an infinite loop. */
3582       if (hash_lookup (circularity_hash,
3583                        (const hash_table_key) local_super, FALSE, NULL))
3584         {
3585           if (!cl)
3586             cl = lookup_cl (local_enclosing);
3587
3588           parse_error_context
3589             (cl, "Cyclic inheritance involving %s",
3590              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3591           local_enclosing = NULL_TREE;
3592         }
3593       else
3594         local_enclosing = local_super;
3595     }
3596
3597   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3598   *super = local_super;
3599   *enclosing = local_enclosing;
3600
3601   return NULL_TREE;
3602 }
3603
3604 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3605    qualified. */
3606
3607 static tree
3608 find_as_inner_class (enclosing, name, cl)
3609      tree enclosing, name, cl;
3610 {
3611   tree qual, to_return;
3612   if (!enclosing)
3613     return NULL_TREE;
3614
3615   name = TYPE_NAME (name);
3616
3617   /* First search: within the scope of `enclosing', search for name */
3618   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3619     qual = EXPR_WFL_QUALIFICATION (cl);
3620   else if (cl)
3621     qual = build_tree_list (cl, NULL_TREE);
3622   else
3623     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3624
3625   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3626     return to_return;
3627
3628   /* We're dealing with a qualified name. Try to resolve thing until
3629      we get something that is an enclosing class. */
3630   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3631     {
3632       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3633
3634       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3635            qual = TREE_CHAIN (qual))
3636         {
3637           acc = merge_qualified_name (acc,
3638                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3639           BUILD_PTR_FROM_NAME (ptr, acc);
3640           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3641         }
3642
3643       /* A NULL qual and a decl means that the search ended
3644          successfully?!? We have to do something then. FIXME */
3645
3646       if (decl)
3647         enclosing = decl;
3648       else
3649         qual = EXPR_WFL_QUALIFICATION (cl);
3650     }
3651   /* Otherwise, create a qual for the other part of the resolution. */
3652   else
3653     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3654
3655   return find_as_inner_class_do (qual, enclosing);
3656 }
3657
3658 /* We go inside the list of sub classes and try to find a way
3659    through. */
3660
3661 static tree
3662 find_as_inner_class_do (qual, enclosing)
3663      tree qual, enclosing;
3664 {
3665   if (!qual)
3666     return NULL_TREE;
3667
3668   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3669     {
3670       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3671       tree next_enclosing = NULL_TREE;
3672       tree inner_list;
3673
3674       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3675            inner_list; inner_list = TREE_CHAIN (inner_list))
3676         {
3677           if (TREE_VALUE (inner_list) == name_to_match)
3678             {
3679               next_enclosing = TREE_PURPOSE (inner_list);
3680               break;
3681             }
3682         }
3683       enclosing = next_enclosing;
3684     }
3685
3686   return (!qual && enclosing ? enclosing : NULL_TREE);
3687 }
3688
3689 /* Reach all inner classes and tie their unqualified name to a
3690    DECL. */
3691
3692 static void
3693 set_nested_class_simple_name_value (outer, set)
3694      tree outer;
3695      int set;
3696 {
3697   tree l;
3698
3699   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3700     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3701                                                 TREE_PURPOSE (l) : NULL_TREE);
3702 }
3703
3704 static void
3705 link_nested_class_to_enclosing ()
3706 {
3707   if (GET_ENCLOSING_CPC ())
3708     {
3709       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3710       DECL_INNER_CLASS_LIST (enclosing) =
3711         tree_cons (GET_CPC (), GET_CPC_UN (),
3712                    DECL_INNER_CLASS_LIST (enclosing));
3713     }
3714 }
3715
3716 static tree
3717 maybe_make_nested_class_name (name)
3718      tree name;
3719 {
3720   tree id = NULL_TREE;
3721
3722   if (CPC_INNER_P ())
3723     {
3724       make_nested_class_name (GET_CPC_LIST ());
3725       obstack_grow0 (&temporary_obstack,
3726                      IDENTIFIER_POINTER (name),
3727                      IDENTIFIER_LENGTH (name));
3728       id = get_identifier (obstack_finish (&temporary_obstack));
3729       if (ctxp->package)
3730         QUALIFIED_P (id) = 1;
3731     }
3732   return id;
3733 }
3734
3735 /* If DECL is NULL, create and push a new DECL, record the current
3736    line CL and do other maintenance things.  */
3737
3738 static tree
3739 maybe_create_class_interface_decl (decl, raw_name, qualified_name, cl)
3740      tree decl, raw_name, qualified_name, cl;
3741 {
3742   if (!decl)
3743     decl = push_class (make_class (), qualified_name);
3744
3745   /* Take care of the file and line business */
3746   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3747   /* If we're emiting xrefs, store the line/col number information */
3748   if (flag_emit_xref)
3749     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3750   else
3751     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3752   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3753   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3754   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3755     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3756
3757   PUSH_CPC (decl, raw_name);
3758   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3759
3760   /* Link the declaration to the already seen ones */
3761   TREE_CHAIN (decl) = ctxp->class_list;
3762   ctxp->class_list = decl;
3763
3764   /* Create a new nodes in the global lists */
3765   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3766   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3767
3768   /* Install a new dependency list element */
3769   create_jdep_list (ctxp);
3770
3771   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3772                           IDENTIFIER_POINTER (qualified_name)));
3773   return decl;
3774 }
3775
3776 static void
3777 add_superinterfaces (decl, interface_list)
3778      tree decl, interface_list;
3779 {
3780   tree node;
3781   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3782      takes care of ensuring that:
3783        - This is an accessible interface type,
3784        - Circularity detection.
3785    parser_add_interface is then called. If present but not defined,
3786    the check operation is delayed until the super interface gets
3787    defined.  */
3788   for (node = interface_list; node; node = TREE_CHAIN (node))
3789     {
3790       tree current = TREE_PURPOSE (node);
3791       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3792       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3793         {
3794           if (!parser_check_super_interface (idecl, decl, current))
3795             parser_add_interface (decl, idecl, current);
3796         }
3797       else
3798         register_incomplete_type (JDEP_INTERFACE,
3799                                   current, decl, NULL_TREE);
3800     }
3801 }
3802
3803 /* Create an interface in pass1 and return its decl. Return the
3804    interface's decl in pass 2.  */
3805
3806 static tree
3807 create_interface (flags, id, super)
3808      int flags;
3809      tree id, super;
3810 {
3811   tree raw_name = EXPR_WFL_NODE (id);
3812   tree q_name = parser_qualified_classname (raw_name);
3813   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3814
3815   /* Certain syntax errors are making SUPER be like ID. Avoid this
3816      case. */
3817   if (ctxp->class_err && id == super)
3818     super = NULL;
3819
3820   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3821
3822   /* Basic checks: scope, redefinition, modifiers */
3823   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3824     {
3825       PUSH_ERROR ();
3826       return NULL_TREE;
3827     }
3828
3829   /* Suspend the current parsing context if we're parsing an inner
3830      interface */
3831   if (CPC_INNER_P ())
3832     {
3833       java_parser_context_suspend ();
3834       /* Interface members are public. */
3835       if (CLASS_INTERFACE (GET_CPC ()))
3836         flags |= ACC_PUBLIC;
3837     }
3838
3839   /* Push a new context for (static) initialized upon declaration fields */
3840   java_parser_context_push_initialized_field ();
3841
3842   /* Interface modifiers check
3843        - public/abstract allowed (already done at that point)
3844        - abstract is obsolete (comes first, it's a warning, or should be)
3845        - Can't use twice the same (checked in the modifier rule) */
3846   if ((flags & ACC_ABSTRACT) && flag_redundant)
3847     parse_warning_context
3848       (MODIFIER_WFL (ABSTRACT_TK),
3849        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3850
3851   /* Create a new decl if DECL is NULL, otherwise fix it */
3852   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3853
3854   /* Set super info and mark the class a complete */
3855   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3856                   object_type_node, ctxp->interface_number);
3857   ctxp->interface_number = 0;
3858   CLASS_COMPLETE_P (decl) = 1;
3859   add_superinterfaces (decl, super);
3860
3861   return decl;
3862 }
3863
3864 /* Anonymous class counter. Will be reset to 1 every time a non
3865    anonymous class gets created. */
3866 static int anonymous_class_counter = 1;
3867
3868 /* Patch anonymous class CLASS, by either extending or implementing
3869    DEP.  */
3870
3871 static void
3872 patch_anonymous_class (type_decl, class_decl, wfl)
3873     tree type_decl, class_decl, wfl;
3874 {
3875   tree class = TREE_TYPE (class_decl);
3876   tree type =  TREE_TYPE (type_decl);
3877   tree binfo = TYPE_BINFO (class);
3878
3879   /* If it's an interface, implement it */
3880   if (CLASS_INTERFACE (type_decl))
3881     {
3882       tree s_binfo;
3883       int length;
3884
3885       if (parser_check_super_interface (type_decl, class_decl, wfl))
3886         return;
3887
3888       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3889       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3890       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3891       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3892       /* And add the interface */
3893       parser_add_interface (class_decl, type_decl, wfl);
3894     }
3895   /* Otherwise, it's a type we want to extend */
3896   else
3897     {
3898       if (parser_check_super (type_decl, class_decl, wfl))
3899         return;
3900       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3901     }
3902 }
3903
3904 static tree
3905 create_anonymous_class (location, type_name)
3906     int location;
3907     tree type_name;
3908 {
3909   char buffer [80];
3910   tree super = NULL_TREE, itf = NULL_TREE;
3911   tree id, type_decl, class;
3912
3913   /* The unqualified name of the anonymous class. It's just a number. */
3914   sprintf (buffer, "%d", anonymous_class_counter++);
3915   id = build_wfl_node (get_identifier (buffer));
3916   EXPR_WFL_LINECOL (id) = location;
3917
3918   /* We know about the type to extend/implement. We go ahead */
3919   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3920     {
3921       /* Create a class which either implements on extends the designated
3922          class. The class bears an innacessible name. */
3923       if (CLASS_INTERFACE (type_decl))
3924         {
3925           /* It's OK to modify it here. It's been already used and
3926              shouldn't be reused */
3927           ctxp->interface_number = 1;
3928           /* Interfaces should presented as a list of WFLs */
3929           itf = build_tree_list (type_name, NULL_TREE);
3930         }
3931       else
3932         super = type_name;
3933     }
3934
3935   class = create_class (ACC_FINAL, id, super, itf);
3936
3937   /* We didn't know anything about the stuff. We register a dependence. */
3938   if (!type_decl)
3939     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3940
3941   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3942   return class;
3943 }
3944
3945 /* Create a class in pass1 and return its decl. Return class
3946    interface's decl in pass 2.  */
3947
3948 static tree
3949 create_class (flags, id, super, interfaces)
3950      int flags;
3951      tree id, super, interfaces;
3952 {
3953   tree raw_name = EXPR_WFL_NODE (id);
3954   tree class_id, decl;
3955   tree super_decl_type;
3956
3957   /* Certain syntax errors are making SUPER be like ID. Avoid this
3958      case. */
3959   if (ctxp->class_err && id == super)
3960     super = NULL;
3961
3962   class_id = parser_qualified_classname (raw_name);
3963   decl = IDENTIFIER_CLASS_VALUE (class_id);
3964   EXPR_WFL_NODE (id) = class_id;
3965
3966   /* Basic check: scope, redefinition, modifiers */
3967   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3968     {
3969       PUSH_ERROR ();
3970       return NULL_TREE;
3971     }
3972
3973   /* Suspend the current parsing context if we're parsing an inner
3974      class or an anonymous class. */
3975   if (CPC_INNER_P ())
3976     {
3977       java_parser_context_suspend ();
3978       /* Interface members are public. */
3979       if (CLASS_INTERFACE (GET_CPC ()))
3980         flags |= ACC_PUBLIC;
3981     }
3982
3983   /* Push a new context for (static) initialized upon declaration fields */
3984   java_parser_context_push_initialized_field ();
3985
3986   /* Class modifier check:
3987        - Allowed modifier (already done at that point)
3988        - abstract AND final forbidden
3989        - Public classes defined in the correct file */
3990   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3991     parse_error_context
3992       (id, "Class `%s' can't be declared both abstract and final",
3993        IDENTIFIER_POINTER (raw_name));
3994
3995   /* Create a new decl if DECL is NULL, otherwise fix it */
3996   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3997
3998   /* If SUPER exists, use it, otherwise use Object */
3999   if (super)
4000     {
4001       /* Can't extend java.lang.Object */
4002       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4003         {
4004           parse_error_context (id, "Can't extend `java.lang.Object'");
4005           return NULL_TREE;
4006         }
4007
4008       super_decl_type =
4009         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4010     }
4011   else if (TREE_TYPE (decl) != object_type_node)
4012     super_decl_type = object_type_node;
4013   /* We're defining java.lang.Object */
4014   else
4015     super_decl_type = NULL_TREE;
4016
4017   /* A class nested in an interface is implicitly static. */
4018   if (INNER_CLASS_DECL_P (decl)
4019       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4020     {
4021       flags |= ACC_STATIC;
4022     }
4023
4024   /* Set super info and mark the class as complete. */
4025   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4026                   ctxp->interface_number);
4027   ctxp->interface_number = 0;
4028   CLASS_COMPLETE_P (decl) = 1;
4029   add_superinterfaces (decl, interfaces);
4030
4031   /* Add the private this$<n> field, Replicate final locals still in
4032      scope as private final fields mangled like val$<local_name>.
4033      This doesn't not occur for top level (static) inner classes. */
4034   if (PURE_INNER_CLASS_DECL_P (decl))
4035     add_inner_class_fields (decl, current_function_decl);
4036
4037   /* If doing xref, store the location at which the inherited class
4038      (if any) was seen. */
4039   if (flag_emit_xref && super)
4040     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4041
4042   /* Eventually sets the @deprecated tag flag */
4043   CHECK_DEPRECATED (decl);
4044
4045   /* Reset the anonymous class counter when declaring non inner classes */
4046   if (!INNER_CLASS_DECL_P (decl))
4047     anonymous_class_counter = 1;
4048
4049   return decl;
4050 }
4051
4052 /* End a class declaration: register the statements used to create
4053    finit$ and <clinit>, pop the current class and resume the prior
4054    parser context if necessary.  */
4055
4056 static void
4057 end_class_declaration (resume)
4058      int resume;
4059 {
4060   /* If an error occurred, context weren't pushed and won't need to be
4061      popped by a resume. */
4062   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4063
4064   if (GET_CPC () != error_mark_node)
4065     dump_java_tree (TDI_class, GET_CPC ());
4066
4067   java_parser_context_pop_initialized_field ();
4068   POP_CPC ();
4069   if (resume && no_error_occurred)
4070     java_parser_context_resume ();
4071
4072   /* We're ending a class declaration, this is a good time to reset
4073      the interface cout. Note that might have been already done in
4074      create_interface, but if at that time an inner class was being
4075      dealt with, the interface count was reset in a context created
4076      for the sake of handling inner classes declaration. */
4077   ctxp->interface_number = 0;
4078 }
4079
4080 static void
4081 add_inner_class_fields (class_decl, fct_decl)
4082      tree class_decl;
4083      tree fct_decl;
4084 {
4085   tree block, marker, f;
4086
4087   f = add_field (TREE_TYPE (class_decl),
4088                  build_current_thisn (TREE_TYPE (class_decl)),
4089                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4090                  ACC_PRIVATE);
4091   FIELD_THISN (f) = 1;
4092
4093   if (!fct_decl)
4094     return;
4095
4096   for (block = GET_CURRENT_BLOCK (fct_decl);
4097        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4098     {
4099       tree decl;
4100       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4101         {
4102           tree name, pname;
4103           tree wfl, init, list;
4104
4105           /* Avoid non final arguments. */
4106           if (!LOCAL_FINAL_P (decl))
4107             continue;
4108
4109           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4110           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4111           wfl = build_wfl_node (name);
4112           init = build_wfl_node (pname);
4113           /* Build an initialization for the field: it will be
4114              initialized by a parameter added to finit$, bearing a
4115              mangled name of the field itself (param$<n>.) The
4116              parameter is provided to finit$ by the constructor
4117              invoking it (hence the constructor will also feature a
4118              hidden parameter, set to the value of the outer context
4119              local at the time the inner class is created.)
4120
4121              Note: we take into account all possible locals that can
4122              be accessed by the inner class. It's actually not trivial
4123              to minimize these aliases down to the ones really
4124              used. One way to do that would be to expand all regular
4125              methods first, then finit$ to get a picture of what's
4126              used.  It works with the exception that we would have to
4127              go back on all constructor invoked in regular methods to
4128              have their invokation reworked (to include the right amount
4129              of alias initializer parameters.)
4130
4131              The only real way around, I think, is a first pass to
4132              identify locals really used in the inner class. We leave
4133              the flag FIELD_LOCAL_ALIAS_USED around for that future
4134              use.
4135
4136              On the other hand, it only affect local inner classes,
4137              whose constructors (and finit$ call) will be featuring
4138              unecessary arguments. It's easy for a developper to keep
4139              this number of parameter down by using the `final'
4140              keyword only when necessary. For the time being, we can
4141              issue a warning on unecessary finals. FIXME */
4142           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4143                                    wfl, init);
4144
4145           /* Register the field. The TREE_LIST holding the part
4146              initialized/initializer will be marked ARG_FINAL_P so
4147              that the created field can be marked
4148              FIELD_LOCAL_ALIAS. */
4149           list = build_tree_list (wfl, init);
4150           ARG_FINAL_P (list) = 1;
4151           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4152         }
4153     }
4154
4155   if (!CPC_INITIALIZER_STMT (ctxp))
4156     return;
4157
4158   /* If we ever registered an alias field, insert and marker to
4159      remeber where the list ends. The second part of the list (the one
4160      featuring initialized fields) so it can be later reversed to
4161      enforce 8.5. The marker will be removed during that operation. */
4162   marker = build_tree_list (NULL_TREE, NULL_TREE);
4163   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4164   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4165 }
4166
4167 /* Can't use lookup_field () since we don't want to load the class and
4168    can't set the CLASS_LOADED_P flag */
4169
4170 static tree
4171 find_field (class, name)
4172      tree class;
4173      tree name;
4174 {
4175   tree decl;
4176   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4177     {
4178       if (DECL_NAME (decl) == name)
4179         return decl;
4180     }
4181   return NULL_TREE;
4182 }
4183
4184 /* Wrap around lookup_field that doesn't potentially upset the value
4185    of CLASS */
4186
4187 static tree
4188 lookup_field_wrapper (class, name)
4189      tree class, name;
4190 {
4191   tree type = class;
4192   tree decl = NULL_TREE;
4193   java_parser_context_save_global ();
4194
4195   /* Last chance: if we're within the context of an inner class, we
4196      might be trying to access a local variable defined in an outer
4197      context. We try to look for it now. */
4198   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4199     {
4200       tree new_name;
4201       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4202       decl = lookup_field (&type, new_name);
4203       if (decl && decl != error_mark_node)
4204         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4205     }
4206   if (!decl || decl == error_mark_node)
4207     {
4208       type = class;
4209       decl = lookup_field (&type, name);
4210     }
4211
4212   /* If the field still hasn't been found, try the next enclosing context. */
4213   if (!decl && INNER_CLASS_TYPE_P (class))
4214     {
4215       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4216       decl = lookup_field_wrapper (outer_type, name);
4217     }
4218
4219   java_parser_context_restore_global ();
4220   return decl == error_mark_node ? NULL : decl;
4221 }
4222
4223 /* Find duplicate field within the same class declarations and report
4224    the error. Returns 1 if a duplicated field was found, 0
4225    otherwise.  */
4226
4227 static int
4228 duplicate_declaration_error_p (new_field_name, new_type, cl)
4229      tree new_field_name, new_type, cl;
4230 {
4231   /* This might be modified to work with method decl as well */
4232   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4233   if (decl)
4234     {
4235       char *t1 = xstrdup (purify_type_name
4236                          ((TREE_CODE (new_type) == POINTER_TYPE
4237                            && TREE_TYPE (new_type) == NULL_TREE) ?
4238                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4239                           lang_printable_name (new_type, 1)));
4240       /* The type may not have been completed by the time we report
4241          the error */
4242       char *t2 = xstrdup (purify_type_name
4243                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4244                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4245                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4246                           lang_printable_name (TREE_TYPE (decl), 1)));
4247       parse_error_context
4248         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4249          t1, IDENTIFIER_POINTER (new_field_name),
4250          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4251          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4252       free (t1);
4253       free (t2);
4254       return 1;
4255     }
4256   return 0;
4257 }
4258
4259 /* Field registration routine. If TYPE doesn't exist, field
4260    declarations are linked to the undefined TYPE dependency list, to
4261    be later resolved in java_complete_class () */
4262
4263 static void
4264 register_fields (flags, type, variable_list)
4265      int flags;
4266      tree type, variable_list;
4267 {
4268   tree current, saved_type;
4269   tree class_type = NULL_TREE;
4270   int saved_lineno = lineno;
4271   int must_chain = 0;
4272   tree wfl = NULL_TREE;
4273
4274   if (GET_CPC ())
4275     class_type = TREE_TYPE (GET_CPC ());
4276
4277   if (!class_type || class_type == error_mark_node)
4278     return;
4279
4280   /* If we're adding fields to interfaces, those fields are public,
4281      static, final */
4282   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4283     {
4284       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4285                                  flags, ACC_PUBLIC, "interface field(s)");
4286       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4287                                  flags, ACC_STATIC, "interface field(s)");
4288       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4289                                  flags, ACC_FINAL, "interface field(s)");
4290       check_modifiers ("Illegal interface member modifier `%s'", flags,
4291                        INTERFACE_FIELD_MODIFIERS);
4292       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4293     }
4294
4295   /* Obtain a suitable type for resolution, if necessary */
4296   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4297
4298   /* If TYPE is fully resolved and we don't have a reference, make one */
4299   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4300
4301   for (current = variable_list, saved_type = type; current;
4302        current = TREE_CHAIN (current), type = saved_type)
4303     {
4304       tree real_type;
4305       tree field_decl;
4306       tree cl = TREE_PURPOSE (current);
4307       tree init = TREE_VALUE (current);
4308       tree current_name = EXPR_WFL_NODE (cl);
4309
4310       /* Can't declare non-final static fields in inner classes */
4311       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4312           && !(flags & ACC_FINAL))
4313         parse_error_context
4314           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4315            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4316            lang_printable_name (class_type, 0));
4317
4318       /* Process NAME, as it may specify extra dimension(s) for it */
4319       type = build_array_from_name (type, wfl, current_name, &current_name);
4320
4321       /* Type adjustment. We may have just readjusted TYPE because
4322          the variable specified more dimensions. Make sure we have
4323          a reference if we can and don't have one already. Also
4324          change the name if we have an init. */
4325       if (type != saved_type)
4326         {
4327           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4328           if (init)
4329             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4330         }
4331
4332       real_type = GET_REAL_TYPE (type);
4333       /* Check for redeclarations */
4334       if (duplicate_declaration_error_p (current_name, real_type, cl))
4335         continue;
4336
4337       /* Set lineno to the line the field was found and create a
4338          declaration for it. Eventually sets the @deprecated tag flag. */
4339       if (flag_emit_xref)
4340         lineno = EXPR_WFL_LINECOL (cl);
4341       else
4342         lineno = EXPR_WFL_LINENO (cl);
4343       field_decl = add_field (class_type, current_name, real_type, flags);
4344       CHECK_DEPRECATED (field_decl);
4345
4346       /* If the field denotes a final instance variable, then we
4347          allocate a LANG_DECL_SPECIFIC part to keep track of its
4348          initialization. We also mark whether the field was
4349          initialized upon its declaration. We don't do that if the
4350          created field is an alias to a final local. */
4351       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4352         {
4353           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4354           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4355         }
4356
4357       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4358          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4359          hide parameters to this inner class finit$ and
4360          constructors. It also means that the field isn't final per
4361          say. */
4362       if (ARG_FINAL_P (current))
4363         {
4364           FIELD_LOCAL_ALIAS (field_decl) = 1;
4365           FIELD_FINAL (field_decl) = 0;
4366         }
4367
4368       /* Check if we must chain. */
4369       if (must_chain)
4370         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4371
4372       /* If we have an initialization value tied to the field */
4373       if (init)
4374         {
4375           /* The field is declared static */
4376           if (flags & ACC_STATIC)
4377             {
4378               /* We include the field and its initialization part into
4379                  a list used to generate <clinit>. After <clinit> is
4380                  walked, field initializations will be processed and
4381                  fields initialized with known constants will be taken
4382                  out of <clinit> and have their DECL_INITIAL set
4383                  appropriately. */
4384               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4385               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4386               if (TREE_OPERAND (init, 1)
4387                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4388                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4389             }
4390           /* A non-static field declared with an immediate initialization is
4391              to be initialized in <init>, if any.  This field is remembered
4392              to be processed at the time of the generation of <init>. */
4393           else
4394             {
4395               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4396               SET_CPC_INITIALIZER_STMT (ctxp, init);
4397             }
4398           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4399           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4400         }
4401     }
4402   lineno = saved_lineno;
4403 }
4404
4405 /* Generate finit$, using the list of initialized fields to populate
4406    its body. finit$'s parameter(s) list is adjusted to include the
4407    one(s) used to initialized the field(s) caching outer context
4408    local(s).  */
4409
4410 static tree
4411 generate_finit (class_type)
4412      tree class_type;
4413 {
4414   int count = 0;
4415   tree list = TYPE_FINIT_STMT_LIST (class_type);
4416   tree mdecl, current, parms;
4417
4418   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4419                                                   class_type, NULL_TREE,
4420                                                   &count);
4421   CRAFTED_PARAM_LIST_FIXUP (parms);
4422   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4423                                     finit_identifier_node, parms);
4424   fix_method_argument_names (parms, mdecl);
4425   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4426                        mdecl, NULL_TREE);
4427   DECL_FUNCTION_NAP (mdecl) = count;
4428   start_artificial_method_body (mdecl);
4429
4430   for (current = list; current; current = TREE_CHAIN (current))
4431     java_method_add_stmt (mdecl,
4432                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4433                                                 current));
4434   end_artificial_method_body (mdecl);
4435   return mdecl;
4436 }
4437
4438 /* Generate a function to run the instance initialization code. The
4439    private method is called `instinit$'. Unless we're dealing with an
4440    anonymous class, we determine whether all ctors of CLASS_TYPE
4441    declare a checked exception in their `throws' clause in order to
4442    see whether it's necessary to encapsulate the instance initializer
4443    statements in a try/catch/rethrow sequence.  */
4444
4445 static tree
4446 generate_instinit (class_type)
4447      tree class_type;
4448 {
4449   tree current;
4450   tree compound = NULL_TREE;
4451   tree parms = tree_cons (this_identifier_node,
4452                           build_pointer_type (class_type), end_params_node);
4453   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4454                                          void_type_node,
4455                                          instinit_identifier_node, parms);
4456
4457   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4458                        mdecl, NULL_TREE);
4459
4460   /* Gather all the statements in a compound */
4461   for (current = TYPE_II_STMT_LIST (class_type);
4462        current; current = TREE_CHAIN (current))
4463     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4464
4465   /* We need to encapsulate COMPOUND by a try/catch statement to
4466      rethrow exceptions that might occur in the instance initializer.
4467      We do that only if all ctors of CLASS_TYPE are set to catch a
4468      checked exception. This doesn't apply to anonymous classes (since
4469      they don't have declared ctors.) */
4470   if (!ANONYMOUS_CLASS_P (class_type) &&
4471       ctors_unchecked_throws_clause_p (class_type))
4472     {
4473       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4474                                              build1 (THROW_EXPR, NULL_TREE,
4475                                                      build_wfl_node (wpv_id)));
4476       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4477                                                       exception_type_node);
4478     }
4479
4480   start_artificial_method_body (mdecl);
4481   java_method_add_stmt (mdecl, compound);
4482   end_artificial_method_body (mdecl);
4483
4484   return mdecl;
4485 }
4486
4487 /* FIXME */
4488 static tree
4489 build_instinit_invocation (class_type)
4490      tree class_type;
4491 {
4492   tree to_return = NULL_TREE;
4493
4494   if (TYPE_II_STMT_LIST (class_type))
4495     {
4496       tree parm = build_tree_list (NULL_TREE,
4497                                    build_wfl_node (this_identifier_node));
4498       to_return =
4499         build_method_invocation (build_wfl_node (instinit_identifier_node),
4500                                  parm);
4501     }
4502   return to_return;
4503 }
4504
4505 /* Shared accros method_declarator and method_header to remember the
4506    patch stage that was reached during the declaration of the method.
4507    A method DECL is built differently is there is no patch
4508    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4509    pending on the currently defined method.  */
4510
4511 static int patch_stage;
4512
4513 /* Check the method declaration and add the method to its current
4514    class.  If the argument list is known to contain incomplete types,
4515    the method is partially added and the registration will be resume
4516    once the method arguments resolved. If TYPE is NULL, we're dealing
4517    with a constructor.  */
4518
4519 static tree
4520 method_header (flags, type, mdecl, throws)
4521      int flags;
4522      tree type, mdecl, throws;
4523 {
4524   tree type_wfl = NULL_TREE;
4525   tree meth_name = NULL_TREE;
4526   tree current, orig_arg, this_class = NULL;
4527   tree id, meth;
4528   int saved_lineno;
4529   int constructor_ok = 0, must_chain;
4530   int count;
4531
4532   if (mdecl == error_mark_node)
4533     return error_mark_node;
4534   meth = TREE_VALUE (mdecl);
4535   id = TREE_PURPOSE (mdecl);
4536
4537   check_modifiers_consistency (flags);
4538
4539   if (GET_CPC ())
4540     this_class = TREE_TYPE (GET_CPC ());
4541
4542   if (!this_class || this_class == error_mark_node)
4543     return NULL_TREE;
4544
4545   /* There are some forbidden modifiers for an abstract method and its
4546      class must be abstract as well.  */
4547   if (type && (flags & ACC_ABSTRACT))
4548     {
4549       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4550       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4551       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4552       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4553       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4554       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4555       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4556           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4557         parse_error_context
4558           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4559            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4560            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4561     }
4562
4563   /* Things to be checked when declaring a constructor */
4564   if (!type)
4565     {
4566       int ec = java_error_count;
4567       /* 8.6: Constructor declarations: we might be trying to define a
4568          method without specifying a return type. */
4569       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4570         parse_error_context
4571           (id, "Invalid method declaration, return type required");
4572       /* 8.6.3: Constructor modifiers */
4573       else
4574         {
4575           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4576           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4577           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4578           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4579           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4580           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4581         }
4582       /* If we found error here, we don't consider it's OK to tread
4583          the method definition as a constructor, for the rest of this
4584          function */
4585       if (ec == java_error_count)
4586         constructor_ok = 1;
4587     }
4588
4589   /* Method declared within the scope of an interface are implicitly
4590      abstract and public. Conflicts with other erroneously provided
4591      modifiers are checked right after. */
4592
4593   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4594     {
4595       /* If FLAGS isn't set because of a modifier, turn the
4596          corresponding modifier WFL to NULL so we issue a warning on
4597          the obsolete use of the modifier */
4598       if (!(flags & ACC_PUBLIC))
4599         MODIFIER_WFL (PUBLIC_TK) = NULL;
4600       if (!(flags & ACC_ABSTRACT))
4601         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4602       flags |= ACC_PUBLIC;
4603       flags |= ACC_ABSTRACT;
4604     }
4605
4606   /* Inner class can't declare static methods */
4607   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4608     {
4609       parse_error_context
4610         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4611          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4612          lang_printable_name (this_class, 0));
4613     }
4614
4615   /* Modifiers context reset moved up, so abstract method declaration
4616      modifiers can be later checked.  */
4617
4618   /* Set constructor returned type to void and method name to <init>,
4619      unless we found an error identifier the constructor (in which
4620      case we retain the original name) */
4621   if (!type)
4622     {
4623       type = void_type_node;
4624       if (constructor_ok)
4625         meth_name = init_identifier_node;
4626     }
4627   else
4628     meth_name = EXPR_WFL_NODE (id);
4629
4630   /* Do the returned type resolution and registration if necessary */
4631   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4632
4633   if (meth_name)
4634     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4635   EXPR_WFL_NODE (id) = meth_name;
4636   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4637
4638   if (must_chain)
4639     {
4640       patch_stage = JDEP_METHOD_RETURN;
4641       register_incomplete_type (patch_stage, type_wfl, id, type);
4642       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4643     }
4644   else
4645     TREE_TYPE (meth) = type;
4646
4647   saved_lineno = lineno;
4648   /* When defining an abstract or interface method, the curly
4649      bracket at level 1 doesn't exist because there is no function
4650      body */
4651   lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4652             EXPR_WFL_LINENO (id));
4653
4654   /* Remember the original argument list */
4655   orig_arg = TYPE_ARG_TYPES (meth);
4656
4657   if (patch_stage)              /* includes ret type and/or all args */
4658     {
4659       jdep *jdep;
4660       meth = add_method_1 (this_class, flags, meth_name, meth);
4661       /* Patch for the return type */
4662       if (patch_stage == JDEP_METHOD_RETURN)
4663         {
4664           jdep = CLASSD_LAST (ctxp->classd_list);
4665           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4666         }
4667       /* This is the stop JDEP. METH allows the function's signature
4668          to be computed. */
4669       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4670     }
4671   else
4672     meth = add_method (this_class, flags, meth_name,
4673                        build_java_signature (meth));
4674
4675   /* Remember final parameters */
4676   MARK_FINAL_PARMS (meth, orig_arg);
4677
4678   /* Fix the method argument list so we have the argument name
4679      information */
4680   fix_method_argument_names (orig_arg, meth);
4681
4682   /* Register the parameter number and re-install the current line
4683      number */
4684   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4685   lineno = saved_lineno;
4686
4687   /* Register exception specified by the `throws' keyword for
4688      resolution and set the method decl appropriate field to the list.
4689      Note: the grammar ensures that what we get here are class
4690      types. */
4691   if (throws)
4692     {
4693       throws = nreverse (throws);
4694       for (current = throws; current; current = TREE_CHAIN (current))
4695         {
4696           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4697                                     NULL_TREE, NULL_TREE);
4698           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4699             &TREE_VALUE (current);
4700         }
4701       DECL_FUNCTION_THROWS (meth) = throws;
4702     }
4703
4704   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4705     DECL_FUNCTION_WFL (meth) = id;
4706
4707   /* Set the flag if we correctly processed a constructor */
4708   if (constructor_ok)
4709     {
4710       DECL_CONSTRUCTOR_P (meth) = 1;
4711       /* Compute and store the number of artificial parameters declared
4712          for this constructor */
4713       for (count = 0, current = TYPE_FIELDS (this_class); current;
4714            current = TREE_CHAIN (current))
4715         if (FIELD_LOCAL_ALIAS (current))
4716           count++;
4717       DECL_FUNCTION_NAP (meth) = count;
4718     }
4719
4720   /* Eventually set the @deprecated tag flag */
4721   CHECK_DEPRECATED (meth);
4722
4723   /* If doing xref, store column and line number information instead
4724      of the line number only. */
4725   if (flag_emit_xref)
4726     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4727
4728   return meth;
4729 }
4730
4731 static void
4732 fix_method_argument_names (orig_arg, meth)
4733     tree orig_arg, meth;
4734 {
4735   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4736   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4737     {
4738       TREE_PURPOSE (arg) = this_identifier_node;
4739       arg = TREE_CHAIN (arg);
4740     }
4741   while (orig_arg != end_params_node)
4742     {
4743       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4744       orig_arg = TREE_CHAIN (orig_arg);
4745       arg = TREE_CHAIN (arg);
4746     }
4747 }
4748
4749 /* Complete the method declaration with METHOD_BODY.  */
4750
4751 static void
4752 finish_method_declaration (method_body)
4753      tree method_body;
4754 {
4755   int flags;
4756
4757   if (!current_function_decl)
4758     return;
4759
4760   flags = get_access_flags_from_decl (current_function_decl);
4761
4762   /* 8.4.5 Method Body */
4763   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4764     {
4765       tree name = DECL_NAME (current_function_decl);
4766       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4767                            "%s method `%s' can't have a body defined",
4768                            (METHOD_NATIVE (current_function_decl) ?
4769                             "Native" : "Abstract"),
4770                            IDENTIFIER_POINTER (name));
4771       method_body = NULL_TREE;
4772     }
4773   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4774     {
4775       tree name = DECL_NAME (current_function_decl);
4776       parse_error_context
4777         (DECL_FUNCTION_WFL (current_function_decl),
4778          "Non native and non abstract method `%s' must have a body defined",
4779          IDENTIFIER_POINTER (name));
4780       method_body = NULL_TREE;
4781     }
4782
4783   if (flag_emit_class_files && method_body
4784       && TREE_CODE (method_body) == NOP_EXPR
4785       && TREE_TYPE (current_function_decl)
4786       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4787     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4788
4789   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4790   maybe_absorb_scoping_blocks ();
4791   /* Exit function's body */
4792   exit_block ();
4793   /* Merge last line of the function with first line, directly in the
4794      function decl. It will be used to emit correct debug info. */
4795   if (!flag_emit_xref)
4796     DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
4797
4798   /* Since function's argument's list are shared, reset the
4799      ARG_FINAL_P parameter that might have been set on some of this
4800      function parameters. */
4801   UNMARK_FINAL_PARMS (current_function_decl);
4802
4803   /* So we don't have an irrelevant function declaration context for
4804      the next static block we'll see. */
4805   current_function_decl = NULL_TREE;
4806 }
4807
4808 /* Build a an error message for constructor circularity errors.  */
4809
4810 static char *
4811 constructor_circularity_msg (from, to)
4812      tree from, to;
4813 {
4814   static char string [4096];
4815   char *t = xstrdup (lang_printable_name (from, 0));
4816   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4817   free (t);
4818   return string;
4819 }
4820
4821 /* Verify a circular call to METH. Return 1 if an error is found, 0
4822    otherwise.  */
4823
4824 static int
4825 verify_constructor_circularity (meth, current)
4826      tree meth, current;
4827 {
4828   static tree list = NULL_TREE;
4829   static int initialized_p;
4830   tree c;
4831
4832   /* If we haven't already registered LIST with the garbage collector,
4833      do so now.  */
4834   if (!initialized_p)
4835     {
4836       ggc_add_tree_root (&list, 1);
4837       initialized_p = 1;
4838     }
4839
4840   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4841     {
4842       if (TREE_VALUE (c) == meth)
4843         {
4844           char *t;
4845           if (list)
4846             {
4847               tree liste;
4848               list = nreverse (list);
4849               for (liste = list; liste; liste = TREE_CHAIN (liste))
4850                 {
4851                   parse_error_context
4852                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4853                      constructor_circularity_msg
4854                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4855                   java_error_count--;
4856                 }
4857             }
4858           t = xstrdup (lang_printable_name (meth, 0));
4859           parse_error_context (TREE_PURPOSE (c),
4860                                "%s: recursive invocation of constructor `%s'",
4861                                constructor_circularity_msg (current, meth), t);
4862           free (t);
4863           list = NULL_TREE;
4864           return 1;
4865         }
4866     }
4867   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4868     {
4869       list = tree_cons (c, current, list);
4870       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4871         return 1;
4872       list = TREE_CHAIN (list);
4873     }
4874   return 0;
4875 }
4876
4877 /* Check modifiers that can be declared but exclusively */
4878
4879 static void
4880 check_modifiers_consistency (flags)
4881      int flags;
4882 {
4883   int acc_count = 0;
4884   tree cl = NULL_TREE;
4885
4886   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4887   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4888   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4889   if (acc_count > 1)
4890     parse_error_context
4891       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4892
4893   acc_count = 0;
4894   cl = NULL_TREE;
4895   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4896   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4897   if (acc_count > 1)
4898     parse_error_context (cl,
4899                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4900 }
4901
4902 /* Check the methode header METH for abstract specifics features */
4903
4904 static void
4905 check_abstract_method_header (meth)
4906      tree meth;
4907 {
4908   int flags = get_access_flags_from_decl (meth);
4909
4910   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4911                               ACC_ABSTRACT, "abstract method",
4912                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4913   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4914                               ACC_PUBLIC, "abstract method",
4915                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4916
4917   check_modifiers ("Illegal modifier `%s' for interface method",
4918                   flags, INTERFACE_METHOD_MODIFIERS);
4919 }
4920
4921 /* Create a FUNCTION_TYPE node and start augmenting it with the
4922    declared function arguments. Arguments type that can't be resolved
4923    are left as they are, but the returned node is marked as containing
4924    incomplete types.  */
4925
4926 static tree
4927 method_declarator (id, list)
4928      tree id, list;
4929 {
4930   tree arg_types = NULL_TREE, current, node;
4931   tree meth = make_node (FUNCTION_TYPE);
4932   jdep *jdep;
4933
4934   patch_stage = JDEP_NO_PATCH;
4935
4936   if (GET_CPC () == error_mark_node)
4937     return error_mark_node;
4938
4939   /* If we're dealing with an inner class constructor, we hide the
4940      this$<n> decl in the name field of its parameter declaration.  We
4941      also might have to hide the outer context local alias
4942      initializers. Not done when the class is a toplevel class. */
4943   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4944       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4945     {
4946       tree aliases_list, type, thisn;
4947       /* First the aliases, linked to the regular parameters */
4948       aliases_list =
4949         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4950                                                 TREE_TYPE (GET_CPC ()),
4951                                                 NULL_TREE, NULL);
4952       list = chainon (nreverse (aliases_list), list);
4953
4954       /* Then this$<n> */
4955       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4956       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4957       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4958                         list);
4959     }
4960
4961   for (current = list; current; current = TREE_CHAIN (current))
4962     {
4963       int must_chain = 0;
4964       tree wfl_name = TREE_PURPOSE (current);
4965       tree type = TREE_VALUE (current);
4966       tree name = EXPR_WFL_NODE (wfl_name);
4967       tree already, arg_node;
4968       tree type_wfl = NULL_TREE;
4969       tree real_type;
4970
4971       /* Obtain a suitable type for resolution, if necessary */
4972       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4973
4974       /* Process NAME, as it may specify extra dimension(s) for it */
4975       type = build_array_from_name (type, type_wfl, name, &name);
4976       EXPR_WFL_NODE (wfl_name) = name;
4977
4978       real_type = GET_REAL_TYPE (type);
4979       if (TREE_CODE (real_type) == RECORD_TYPE)
4980         {
4981           real_type = promote_type (real_type);
4982           if (TREE_CODE (type) == TREE_LIST)
4983             TREE_PURPOSE (type) = real_type;
4984         }
4985
4986       /* Check redefinition */
4987       for (already = arg_types; already; already = TREE_CHAIN (already))
4988         if (TREE_PURPOSE (already) == name)
4989           {
4990             parse_error_context
4991               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4992                IDENTIFIER_POINTER (name),
4993                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4994             break;
4995           }
4996
4997       /* If we've an incomplete argument type, we know there is a location
4998          to patch when the type get resolved, later.  */
4999       jdep = NULL;
5000       if (must_chain)
5001         {
5002           patch_stage = JDEP_METHOD;
5003           type = register_incomplete_type (patch_stage,
5004                                            type_wfl, wfl_name, type);
5005           jdep = CLASSD_LAST (ctxp->classd_list);
5006           JDEP_MISC (jdep) = id;
5007         }
5008
5009       /* The argument node: a name and a (possibly) incomplete type.  */
5010       arg_node = build_tree_list (name, real_type);
5011       /* Remeber arguments declared final. */
5012       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5013
5014       if (jdep)
5015         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5016       TREE_CHAIN (arg_node) = arg_types;
5017       arg_types = arg_node;
5018     }
5019   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5020   node = build_tree_list (id, meth);
5021   return node;
5022 }
5023
5024 static int
5025 unresolved_type_p (wfl, returned)
5026      tree wfl;
5027      tree *returned;
5028
5029 {
5030   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5031     {
5032       if (returned)
5033         {
5034           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5035           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5036             *returned = TREE_TYPE (decl);
5037           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5038             *returned = TREE_TYPE (GET_CPC ());
5039           else
5040             *returned = NULL_TREE;
5041         }
5042       return 1;
5043     }
5044   if (returned)
5045     *returned = wfl;
5046   return 0;
5047 }
5048
5049 /* From NAME, build a qualified identifier node using the
5050    qualification from the current package definition. */
5051
5052 static tree
5053 parser_qualified_classname (name)
5054      tree name;
5055 {
5056   tree nested_class_name;
5057
5058   if ((nested_class_name = maybe_make_nested_class_name (name)))
5059     return nested_class_name;
5060
5061   if (ctxp->package)
5062     return merge_qualified_name (ctxp->package, name);
5063   else
5064     return name;
5065 }
5066
5067 /* Called once the type a interface extends is resolved. Returns 0 if
5068    everything is OK.  */
5069
5070 static int
5071 parser_check_super_interface (super_decl, this_decl, this_wfl)
5072      tree super_decl, this_decl, this_wfl;
5073 {
5074   tree super_type = TREE_TYPE (super_decl);
5075
5076   /* Has to be an interface */
5077   if (!CLASS_INTERFACE (super_decl))
5078     {
5079       parse_error_context
5080         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5081          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5082           "Interface" : "Class"),
5083          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5084          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5085          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5086       return 1;
5087     }
5088
5089   /* Check top-level interface access. Inner classes are subject to member
5090      access rules (6.6.1). */
5091   if (! INNER_CLASS_P (super_type)
5092       && check_pkg_class_access (DECL_NAME (super_decl),
5093                                  lookup_cl (this_decl), true))
5094     return 1;
5095
5096   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5097                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5098                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5099   return 0;
5100 }
5101
5102 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5103    0 if everthing is OK.  */
5104
5105 static int
5106 parser_check_super (super_decl, this_decl, wfl)
5107      tree super_decl, this_decl, wfl;
5108 {
5109   tree super_type = TREE_TYPE (super_decl);
5110
5111   /* SUPER should be a CLASS (neither an array nor an interface) */
5112   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5113     {
5114       parse_error_context
5115         (wfl, "Class `%s' can't subclass %s `%s'",
5116          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5117          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5118          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5119       return 1;
5120     }
5121
5122   if (CLASS_FINAL (TYPE_NAME (super_type)))
5123     {
5124       parse_error_context (wfl, "Can't subclass final classes: %s",
5125                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5126       return 1;
5127     }
5128
5129   /* Check top-level class scope. Inner classes are subject to member access
5130      rules (6.6.1). */
5131   if (! INNER_CLASS_P (super_type)
5132       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5133     return 1;
5134
5135   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5136                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5137                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5138   return 0;
5139 }
5140
5141 /* Create a new dependency list and link it (in a LIFO manner) to the
5142    CTXP list of type dependency list.  */
5143
5144 static void
5145 create_jdep_list (ctxp)
5146      struct parser_ctxt *ctxp;
5147 {
5148   jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
5149   new->first = new->last = NULL;
5150   new->next = ctxp->classd_list;
5151   ctxp->classd_list = new;
5152 }
5153
5154 static jdeplist *
5155 reverse_jdep_list (ctxp)
5156      struct parser_ctxt *ctxp;
5157 {
5158   register jdeplist *prev = NULL, *current, *next;
5159   for (current = ctxp->classd_list; current; current = next)
5160     {
5161       next = current->next;
5162       current->next = prev;
5163       prev = current;
5164     }
5165   return prev;
5166 }
5167
5168 /* Create a fake pointer based on the ID stored in
5169    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5170    registered again. */
5171
5172 static tree
5173 obtain_incomplete_type (type_name)
5174      tree type_name;
5175 {
5176   tree ptr = NULL_TREE, name;
5177
5178   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5179     name = EXPR_WFL_NODE (type_name);
5180   else if (INCOMPLETE_TYPE_P (type_name))
5181     name = TYPE_NAME (type_name);
5182   else
5183     abort ();
5184
5185   BUILD_PTR_FROM_NAME (ptr, name);
5186   layout_type (ptr);
5187
5188   return ptr;
5189 }
5190
5191 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5192    non NULL instead of computing a new fake type based on WFL. The new
5193    dependency is inserted in the current type dependency list, in FIFO
5194    manner.  */
5195
5196 static tree
5197 register_incomplete_type (kind, wfl, decl, ptr)
5198      int kind;
5199      tree wfl, decl, ptr;
5200 {
5201   jdep *new = (jdep *)xmalloc (sizeof (jdep));
5202
5203   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5204     ptr = obtain_incomplete_type (wfl);
5205
5206   JDEP_KIND (new) = kind;
5207   JDEP_DECL (new) = decl;
5208   JDEP_TO_RESOLVE (new) = ptr;
5209   JDEP_WFL (new) = wfl;
5210   JDEP_CHAIN (new) = NULL;
5211   JDEP_MISC (new) = NULL_TREE;
5212   /* For some dependencies, set the enclosing class of the current
5213      class to be the enclosing context */
5214   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5215       && GET_ENCLOSING_CPC ())
5216     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5217   else if (kind == JDEP_SUPER)
5218     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5219                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5220   else
5221     JDEP_ENCLOSING (new) = GET_CPC ();
5222   JDEP_GET_PATCH (new) = (tree *)NULL;
5223
5224   JDEP_INSERT (ctxp->classd_list, new);
5225
5226   return ptr;
5227 }
5228
5229 /* This checks for circular references with innerclasses. We start
5230    from SOURCE and should never reach TARGET. Extended/implemented
5231    types in SOURCE have their enclosing context checked not to reach
5232    TARGET. When the last enclosing context of SOURCE is reached, its
5233    extended/implemented types are also checked not to reach TARGET.
5234    In case of error, WFL of the offending type is returned; NULL_TREE
5235    otherwise.  */
5236
5237 static tree
5238 check_inner_circular_reference (source, target)
5239      tree source;
5240      tree target;
5241 {
5242   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5243   tree ctx, cl;
5244   int i;
5245
5246   if (!basetype_vec)
5247     return NULL_TREE;
5248
5249   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5250     {
5251       tree su;
5252
5253       /* We can end up with a NULL_TREE or an incomplete type here if
5254          we encountered previous type resolution errors. It's safe to
5255          simply ignore these cases.  */
5256       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5257         continue;
5258       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5259       if (INCOMPLETE_TYPE_P (su))
5260         continue;
5261
5262       if (inherits_from_p (su, target))
5263         return lookup_cl (TYPE_NAME (su));
5264
5265       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5266         {
5267           /* An enclosing context shouldn't be TARGET */
5268           if (ctx == TYPE_NAME (target))
5269             return lookup_cl (TYPE_NAME (su));
5270
5271           /* When we reach the enclosing last context, start a check
5272              on it, with the same target */
5273           if (! DECL_CONTEXT (ctx) &&
5274               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5275             return cl;
5276         }
5277     }
5278   return NULL_TREE;
5279 }
5280
5281 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5282    offending type if a circularity is detected. NULL_TREE is returned
5283    otherwise. TYPE can be an interface or a class.   */
5284
5285 static tree
5286 check_circular_reference (type)
5287      tree type;
5288 {
5289   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5290   int i;
5291
5292   if (!basetype_vec)
5293     return NULL_TREE;
5294
5295   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5296     {
5297       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5298         return lookup_cl (TYPE_NAME (type));
5299       return NULL_TREE;
5300     }
5301
5302   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5303     {
5304       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5305       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5306           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5307         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5308     }
5309   return NULL_TREE;
5310 }
5311
5312 void
5313 java_check_circular_reference ()
5314 {
5315   tree current;
5316   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5317     {
5318       tree type = TREE_TYPE (current);
5319       tree cl;
5320
5321       cl = check_circular_reference (type);
5322       if (! cl)
5323         cl = check_inner_circular_reference (type, type);
5324       if (cl)
5325         parse_error_context (cl, "Cyclic class inheritance%s",
5326                              (cyclic_inheritance_report ?
5327                               cyclic_inheritance_report : ""));
5328     }
5329 }
5330
5331 /* Augment the parameter list PARM with parameters crafted to
5332    initialize outer context locals aliases. Through ARTIFICIAL, a
5333    count is kept of the number of crafted parameters. MODE governs
5334    what eventually gets created: something suitable for a function
5335    creation or a function invocation, either the constructor or
5336    finit$.  */
5337
5338 static tree
5339 build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
5340     int mode;
5341     tree class_type, parm;
5342     int *artificial;
5343 {
5344   tree field;
5345   tree additional_parms = NULL_TREE;
5346
5347   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5348     if (FIELD_LOCAL_ALIAS (field))
5349       {
5350         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5351         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5352         tree mangled_id;
5353
5354         switch (mode)
5355           {
5356           case AIPL_FUNCTION_DECLARATION:
5357             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5358                                                          &buffer [4]);
5359             purpose = build_wfl_node (mangled_id);
5360             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5361               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5362             else
5363               value = TREE_TYPE (field);
5364             break;
5365
5366           case AIPL_FUNCTION_CREATION:
5367             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5368                                                          &buffer [4]);
5369             value = TREE_TYPE (field);
5370             break;
5371
5372           case AIPL_FUNCTION_FINIT_INVOCATION:
5373             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5374                                                          &buffer [4]);
5375             /* Now, this is wrong. purpose should always be the NAME
5376                of something and value its matching value (decl, type,
5377                etc...) FIXME -- but there is a lot to fix. */
5378
5379             /* When invoked for this kind of operation, we already
5380                know whether a field is used or not. */
5381             purpose = TREE_TYPE (field);
5382             value = build_wfl_node (mangled_id);
5383             break;
5384
5385           case AIPL_FUNCTION_CTOR_INVOCATION:
5386             /* There are two case: the constructor invokation happends
5387                outside the local inner, in which case, locales from the outer
5388                context are directly used.
5389
5390                Otherwise, we fold to using the alias directly. */
5391             if (class_type == current_class)
5392               value = field;
5393             else
5394               {
5395                 name = get_identifier (&buffer[4]);
5396                 value = IDENTIFIER_LOCAL_VALUE (name);
5397               }
5398             break;
5399           }
5400         additional_parms = tree_cons (purpose, value, additional_parms);
5401         if (artificial)
5402           *artificial +=1;
5403       }
5404   if (additional_parms)
5405     {
5406       if (ANONYMOUS_CLASS_P (class_type)
5407           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5408         additional_parms = nreverse (additional_parms);
5409       parm = chainon (additional_parms, parm);
5410     }
5411
5412    return parm;
5413 }
5414
5415 /* Craft a constructor for CLASS_DECL -- what we should do when none
5416    where found. ARGS is non NULL when a special signature must be
5417    enforced. This is the case for anonymous classes.  */
5418
5419 static tree
5420 craft_constructor (class_decl, args)
5421      tree class_decl, args;
5422 {
5423   tree class_type = TREE_TYPE (class_decl);
5424   tree parm = NULL_TREE;
5425   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5426                ACC_PUBLIC : 0);
5427   int i = 0, artificial = 0;
5428   tree decl, ctor_name;
5429   char buffer [80];
5430
5431   /* The constructor name is <init> unless we're dealing with an
5432      anonymous class, in which case the name will be fixed after having
5433      be expanded. */
5434   if (ANONYMOUS_CLASS_P (class_type))
5435     ctor_name = DECL_NAME (class_decl);
5436   else
5437     ctor_name = init_identifier_node;
5438
5439   /* If we're dealing with an inner class constructor, we hide the
5440      this$<n> decl in the name field of its parameter declaration. */
5441   if (PURE_INNER_CLASS_TYPE_P (class_type))
5442     {
5443       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5444       parm = tree_cons (build_current_thisn (class_type),
5445                         build_pointer_type (type), parm);
5446
5447       /* Some more arguments to be hidden here. The values of the local
5448          variables of the outer context that the inner class needs to see. */
5449       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5450                                                      class_type, parm,
5451                                                      &artificial);
5452     }
5453
5454   /* Then if there are any args to be enforced, enforce them now */
5455   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5456     {
5457       sprintf (buffer, "parm%d", i++);
5458       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5459     }
5460
5461   CRAFTED_PARAM_LIST_FIXUP (parm);
5462   decl = create_artificial_method (class_type, flags, void_type_node,
5463                                    ctor_name, parm);
5464   fix_method_argument_names (parm, decl);
5465   /* Now, mark the artificial parameters. */
5466   DECL_FUNCTION_NAP (decl) = artificial;
5467   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5468   return decl;
5469 }
5470
5471
5472 /* Fix the constructors. This will be called right after circular
5473    references have been checked. It is necessary to fix constructors
5474    early even if no code generation will take place for that class:
5475    some generated constructor might be required by the class whose
5476    compilation triggered this one to be simply loaded.  */
5477
5478 void
5479 java_fix_constructors ()
5480 {
5481   tree current;
5482
5483   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5484     {
5485       tree class_type = TREE_TYPE (current);
5486       int saw_ctor = 0;
5487       tree decl;
5488
5489       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5490         continue;
5491
5492       current_class = class_type;
5493       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5494         {
5495           if (DECL_CONSTRUCTOR_P (decl))
5496             {
5497               fix_constructors (decl);
5498               saw_ctor = 1;
5499             }
5500         }
5501
5502       /* Anonymous class constructor can't be generated that early. */
5503       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5504         craft_constructor (current, NULL_TREE);
5505     }
5506 }
5507
5508 /* safe_layout_class just makes sure that we can load a class without
5509    disrupting the current_class, input_file, lineno, etc, information
5510    about the class processed currently.  */
5511
5512 void
5513 safe_layout_class (class)
5514      tree class;
5515 {
5516   tree save_current_class = current_class;
5517   const char *save_input_filename = input_filename;
5518   int save_lineno = lineno;
5519
5520   layout_class (class);
5521
5522   current_class = save_current_class;
5523   input_filename = save_input_filename;
5524   lineno = save_lineno;
5525 }
5526
5527 static tree
5528 jdep_resolve_class (dep)
5529      jdep *dep;
5530 {
5531   tree decl;
5532
5533   if (JDEP_RESOLVED_P (dep))
5534     decl = JDEP_RESOLVED_DECL (dep);
5535   else
5536     {
5537       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5538                             JDEP_DECL (dep), JDEP_WFL (dep));
5539       JDEP_RESOLVED (dep, decl);
5540     }
5541
5542   if (!decl)
5543     complete_class_report_errors (dep);
5544   else if (PURE_INNER_CLASS_DECL_P (decl))
5545     {
5546       tree inner = TREE_TYPE (decl);
5547       if (! CLASS_LOADED_P (inner))
5548         {
5549           safe_layout_class (inner);
5550           if (TYPE_SIZE (inner) == error_mark_node)
5551             TYPE_SIZE (inner) = NULL_TREE;
5552         }
5553       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5554     }
5555   return decl;
5556 }
5557
5558 /* Complete unsatisfied class declaration and their dependencies */
5559
5560 void
5561 java_complete_class ()
5562 {
5563   tree cclass;
5564   jdeplist *cclassd;
5565   int error_found;
5566   tree type;
5567
5568   /* Process imports */
5569   process_imports ();
5570
5571   /* Rever things so we have the right order */
5572   ctxp->class_list = nreverse (ctxp->class_list);
5573   ctxp->classd_list = reverse_jdep_list (ctxp);
5574
5575   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5576        cclass && cclassd;
5577        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5578     {
5579       jdep *dep;
5580
5581       /* We keep the compilation unit imports in the class so that
5582          they can be used later to resolve type dependencies that
5583          aren't necessary to solve now. */
5584       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5585       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5586
5587       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5588         {
5589           tree decl;
5590           if (!(decl = jdep_resolve_class (dep)))
5591             continue;
5592
5593           /* Now it's time to patch */
5594           switch (JDEP_KIND (dep))
5595             {
5596             case JDEP_SUPER:
5597               /* Simply patch super */
5598               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5599                 continue;
5600               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5601                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5602               break;
5603
5604             case JDEP_FIELD:
5605               {
5606                 /* We do part of the job done in add_field */
5607                 tree field_decl = JDEP_DECL (dep);
5608                 tree field_type = TREE_TYPE (decl);
5609                 if (TREE_CODE (field_type) == RECORD_TYPE)
5610                   field_type = promote_type (field_type);
5611                 TREE_TYPE (field_decl) = field_type;
5612                 DECL_ALIGN (field_decl) = 0;
5613                 DECL_USER_ALIGN (field_decl) = 0;
5614                 layout_decl (field_decl, 0);
5615                 SOURCE_FRONTEND_DEBUG
5616                   (("Completed field/var decl `%s' with `%s'",
5617                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5618                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5619                 break;
5620               }
5621             case JDEP_METHOD:   /* We start patching a method */
5622             case JDEP_METHOD_RETURN:
5623               error_found = 0;
5624               while (1)
5625                 {
5626                   if (decl)
5627                     {
5628                       type = TREE_TYPE(decl);
5629                       if (TREE_CODE (type) == RECORD_TYPE)
5630                         type = promote_type (type);
5631                       JDEP_APPLY_PATCH (dep, type);
5632                       SOURCE_FRONTEND_DEBUG
5633                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5634                            "Completing fct `%s' with ret type `%s'":
5635                            "Completing arg `%s' with type `%s'"),
5636                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5637                                               (JDEP_DECL_WFL (dep))),
5638                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5639                     }
5640                   else
5641                     error_found = 1;
5642                   dep = JDEP_CHAIN (dep);
5643                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5644                     break;
5645                   else
5646                     decl = jdep_resolve_class (dep);
5647                 }
5648               if (!error_found)
5649                 {
5650                   tree mdecl = JDEP_DECL (dep), signature;
5651                   /* Recompute and reset the signature, check first that
5652                      all types are now defined. If they're not,
5653                      don't build the signature. */
5654                   if (check_method_types_complete (mdecl))
5655                     {
5656                       signature = build_java_signature (TREE_TYPE (mdecl));
5657                       set_java_signature (TREE_TYPE (mdecl), signature);
5658                     }
5659                 }
5660               else
5661                 continue;
5662               break;
5663
5664             case JDEP_INTERFACE:
5665               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5666                                                 JDEP_WFL (dep)))
5667                 continue;
5668               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5669               break;
5670
5671             case JDEP_PARM:
5672             case JDEP_VARIABLE:
5673               type = TREE_TYPE(decl);
5674               if (TREE_CODE (type) == RECORD_TYPE)
5675                 type = promote_type (type);
5676               JDEP_APPLY_PATCH (dep, type);
5677               break;
5678
5679             case JDEP_TYPE:
5680               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5681               SOURCE_FRONTEND_DEBUG
5682                 (("Completing a random type dependency on a '%s' node",
5683                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5684               break;
5685
5686             case JDEP_EXCEPTION:
5687               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5688               SOURCE_FRONTEND_DEBUG
5689                 (("Completing `%s' `throws' argument node",
5690                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5691               break;
5692
5693             case JDEP_ANONYMOUS:
5694               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5695               break;
5696
5697             default:
5698               abort ();
5699             }
5700         }
5701     }
5702   return;
5703 }
5704
5705 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5706    array.  */
5707
5708 static tree
5709 resolve_class (enclosing, class_type, decl, cl)
5710      tree enclosing, class_type, decl, cl;
5711 {
5712   tree tname = TYPE_NAME (class_type);
5713   tree resolved_type = TREE_TYPE (class_type);
5714   int array_dims = 0;
5715   tree resolved_type_decl;
5716
5717   if (resolved_type != NULL_TREE)
5718     {
5719       tree resolved_type_decl = TYPE_NAME (resolved_type);
5720       if (resolved_type_decl == NULL_TREE
5721           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5722         {
5723           resolved_type_decl = build_decl (TYPE_DECL,
5724                                            TYPE_NAME (class_type),
5725                                            resolved_type);
5726         }
5727       return resolved_type_decl;
5728     }
5729
5730   /* 1- Check to see if we have an array. If true, find what we really
5731      want to resolve  */
5732   if ((array_dims = build_type_name_from_array_name (tname,
5733                                                      &TYPE_NAME (class_type))))
5734     WFL_STRIP_BRACKET (cl, cl);
5735
5736   /* 2- Resolve the bare type */
5737   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5738                                                decl, cl)))
5739     return NULL_TREE;
5740   resolved_type = TREE_TYPE (resolved_type_decl);
5741
5742   /* 3- If we have and array, reconstruct the array down to its nesting */
5743   if (array_dims)
5744     {
5745       for (; array_dims; array_dims--)
5746         resolved_type = build_java_array_type (resolved_type, -1);
5747       resolved_type_decl = TYPE_NAME (resolved_type);
5748     }
5749   TREE_TYPE (class_type) = resolved_type;
5750   return resolved_type_decl;
5751 }
5752
5753 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5754    are used to report error messages. Do not try to replace TYPE_NAME
5755    (class_type) by a variable, since it is changed by
5756    find_in_imports{_on_demand} and (but it doesn't really matter)
5757    qualify_and_find.  */
5758
5759 tree
5760 do_resolve_class (enclosing, class_type, decl, cl)
5761      tree enclosing, class_type, decl, cl;
5762 {
5763   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5764   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5765   tree decl_result;
5766   struct hash_table _ht, *circularity_hash = &_ht;
5767
5768   /* This hash table is used to register the classes we're going
5769      through when searching the current class as an inner class, in
5770      order to detect circular references. Remember to free it before
5771      returning the section 0- of this function. */
5772   hash_table_init (circularity_hash, hash_newfunc,
5773                    java_hash_hash_tree_node, java_hash_compare_tree_node);
5774
5775   /* 0- Search in the current class as an inner class.
5776      Maybe some code here should be added to load the class or
5777      something, at least if the class isn't an inner class and ended
5778      being loaded from class file. FIXME. */
5779   while (enclosing)
5780     {
5781       new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5782                                             &super, class_type);
5783       if (new_class_decl)
5784         break;
5785
5786       /* If we haven't found anything because SUPER reached Object and
5787          ENCLOSING happens to be an innerclass, try the enclosing context. */
5788       if ((!super || super == object_type_node) &&
5789           enclosing && INNER_CLASS_DECL_P (enclosing))
5790         enclosing = DECL_CONTEXT (enclosing);
5791       else
5792         enclosing = NULL_TREE;
5793     }
5794
5795   hash_table_free (circularity_hash);
5796
5797   if (new_class_decl)
5798     return new_class_decl;
5799
5800   /* 1- Check for the type in single imports. This will change
5801      TYPE_NAME() if something relevant is found */
5802   find_in_imports (saved_enclosing_type, class_type);
5803
5804   /* 2- And check for the type in the current compilation unit */
5805   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5806     {
5807       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5808           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5809         load_class (TYPE_NAME (class_type), 0);
5810       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5811     }
5812
5813   /* 3- Search according to the current package definition */
5814   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5815     {
5816       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5817                                              TYPE_NAME (class_type))))
5818         return new_class_decl;
5819     }
5820
5821   /* 4- Check the import on demands. Don't allow bar.baz to be
5822      imported from foo.* */
5823   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5824     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5825       return NULL_TREE;
5826
5827   /* If found in find_in_imports_on_demant, the type has already been
5828      loaded. */
5829   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5830     return new_class_decl;
5831
5832   /* 5- Try with a name qualified with the package name we've seen so far */
5833   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5834     {
5835       tree package;
5836
5837       /* If there is a current package (ctxp->package), it's the first
5838          element of package_list and we can skip it. */
5839       for (package = (ctxp->package ?
5840                       TREE_CHAIN (package_list) : package_list);
5841            package; package = TREE_CHAIN (package))
5842         if ((new_class_decl = qualify_and_find (class_type,
5843                                                TREE_PURPOSE (package),
5844                                                TYPE_NAME (class_type))))
5845           return new_class_decl;
5846     }
5847
5848   /* 5- Check an other compilation unit that bears the name of type */
5849   load_class (TYPE_NAME (class_type), 0);
5850
5851   if (!cl)
5852     cl = lookup_cl (decl);
5853
5854   /* If we don't have a value for CL, then we're being called recursively.
5855      We can't check package access just yet, but it will be taken care of
5856      by the caller. */
5857   if (cl)
5858     {
5859       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5860         return NULL_TREE;
5861     }
5862
5863   /* 6- Last call for a resolution */
5864   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5865
5866   /* The final lookup might have registered a.b.c into a.b$c If we
5867      failed at the first lookup, progressively change the name if
5868      applicable and use the matching DECL instead. */
5869   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5870     {
5871       tree name = TYPE_NAME (class_type);
5872       char *separator;
5873       do {
5874
5875        /* Reach the last '.', and if applicable, replace it by a `$' and
5876           see if this exists as a type. */
5877        if ((separator = strrchr (IDENTIFIER_POINTER (name), '.')))
5878          {
5879            int c = *separator;
5880            *separator = '$';
5881            name = get_identifier (IDENTIFIER_POINTER (name));
5882            *separator = c;
5883            decl_result = IDENTIFIER_CLASS_VALUE (name);
5884          }
5885       } while (!decl_result && separator);
5886     }
5887   return decl_result;
5888 }
5889
5890 static tree
5891 qualify_and_find (class_type, package, name)
5892      tree class_type, package, name;
5893 {
5894   tree new_qualified = merge_qualified_name (package, name);
5895   tree new_class_decl;
5896
5897   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5898     load_class (new_qualified, 0);
5899   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5900     {
5901       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5902           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5903         load_class (new_qualified, 0);
5904       TYPE_NAME (class_type) = new_qualified;
5905       return IDENTIFIER_CLASS_VALUE (new_qualified);
5906     }
5907   return NULL_TREE;
5908 }
5909
5910 /* Resolve NAME and lay it out (if not done and if not the current
5911    parsed class). Return a decl node. This function is meant to be
5912    called when type resolution is necessary during the walk pass.  */
5913
5914 static tree
5915 resolve_and_layout (something, cl)
5916      tree something;
5917      tree cl;
5918 {
5919   tree decl, decl_type;
5920
5921   /* Don't do that on the current class */
5922   if (something == current_class)
5923     return TYPE_NAME (current_class);
5924
5925   /* Don't do anything for void and other primitive types */
5926   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5927     return NULL_TREE;
5928
5929   /* Pointer types can be reall pointer types or fake pointers. When
5930      finding a real pointer, recheck for primitive types */
5931   if (TREE_CODE (something) == POINTER_TYPE)
5932     {
5933       if (TREE_TYPE (something))
5934         {
5935           something = TREE_TYPE (something);
5936           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5937             return NULL_TREE;
5938         }
5939       else
5940         something = TYPE_NAME (something);
5941     }
5942
5943   /* Don't do anything for arrays of primitive types */
5944   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5945       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5946     return NULL_TREE;
5947
5948   /* Something might be a WFL */
5949   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5950     something = EXPR_WFL_NODE (something);
5951
5952   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5953      TYPE_DECL or a real TYPE */
5954   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5955     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5956             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5957
5958   if (!(decl = resolve_no_layout (something, cl)))
5959     return NULL_TREE;
5960
5961   /* Resolve and layout if necessary */
5962   decl_type = TREE_TYPE (decl);
5963   layout_class_methods (decl_type);
5964   /* Check methods */
5965   if (CLASS_FROM_SOURCE_P (decl_type))
5966     java_check_methods (decl);
5967   /* Layout the type if necessary */
5968   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5969     safe_layout_class (decl_type);
5970
5971   return decl;
5972 }
5973
5974 /* Resolve a class, returns its decl but doesn't perform any
5975    layout. The current parsing context is saved and restored */
5976
5977 static tree
5978 resolve_no_layout (name, cl)
5979      tree name, cl;
5980 {
5981   tree ptr, decl;
5982   BUILD_PTR_FROM_NAME (ptr, name);
5983   java_parser_context_save_global ();
5984   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5985   java_parser_context_restore_global ();
5986
5987   return decl;
5988 }
5989
5990 /* Called when reporting errors. Skip the '[]'s in a complex array
5991    type description that failed to be resolved. purify_type_name can't
5992    use an identifier tree.  */
5993
5994 static const char *
5995 purify_type_name (name)
5996      const char *name;
5997 {
5998   int len = strlen (name);
5999   int bracket_found;
6000
6001   STRING_STRIP_BRACKETS (name, len, bracket_found);
6002   if (bracket_found)
6003     {
6004       char *stripped_name = xmemdup (name, len, len+1);
6005       stripped_name [len] = '\0';
6006       return stripped_name;
6007     }
6008   return name;
6009 }
6010
6011 /* The type CURRENT refers to can't be found. We print error messages.  */
6012
6013 static void
6014 complete_class_report_errors (dep)
6015      jdep *dep;
6016 {
6017   const char *name;
6018
6019   if (!JDEP_WFL (dep))
6020     return;
6021
6022   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6023   switch (JDEP_KIND (dep))
6024     {
6025     case JDEP_SUPER:
6026       parse_error_context
6027         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6028          purify_type_name (name),
6029          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6030       break;
6031     case JDEP_FIELD:
6032       parse_error_context
6033         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6034          purify_type_name (name),
6035          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6036       break;
6037     case JDEP_METHOD:           /* Covers arguments */
6038       parse_error_context
6039         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6040          purify_type_name (name),
6041          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6042          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6043       break;
6044     case JDEP_METHOD_RETURN:    /* Covers return type */
6045       parse_error_context
6046         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6047          purify_type_name (name),
6048          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6049       break;
6050     case JDEP_INTERFACE:
6051       parse_error_context
6052         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6053          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6054          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6055          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6056       break;
6057     case JDEP_VARIABLE:
6058       parse_error_context
6059         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6060          purify_type_name (IDENTIFIER_POINTER
6061                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6062          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6063       break;
6064     case JDEP_EXCEPTION:        /* As specified by `throws' */
6065       parse_error_context
6066           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6067          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6068       break;
6069     default:
6070       /* Fix for -Wall. Just break doing nothing. The error will be
6071          caught later */
6072       break;
6073     }
6074 }
6075
6076 /* Return a static string containing the DECL prototype string. If
6077    DECL is a constructor, use the class name instead of the form
6078    <init> */
6079
6080 static const char *
6081 get_printable_method_name (decl)
6082      tree decl;
6083 {
6084   const char *to_return;
6085   tree name = NULL_TREE;
6086
6087   if (DECL_CONSTRUCTOR_P (decl))
6088     {
6089       name = DECL_NAME (decl);
6090       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6091     }
6092
6093   to_return = lang_printable_name (decl, 0);
6094   if (DECL_CONSTRUCTOR_P (decl))
6095     DECL_NAME (decl) = name;
6096
6097   return to_return;
6098 }
6099
6100 /* Track method being redefined inside the same class. As a side
6101    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6102    function it's a FWL, so we can track errors more accurately.)  */
6103
6104 static int
6105 check_method_redefinition (class, method)
6106      tree class, method;
6107 {
6108   tree redef, sig;
6109
6110   /* There's no need to verify <clinit> and finit$ and instinit$ */
6111   if (DECL_CLINIT_P (method)
6112       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6113     return 0;
6114
6115   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6116   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6117     {
6118       if (redef == method)
6119         break;
6120       if (DECL_NAME (redef) == DECL_NAME (method)
6121           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6122           && !DECL_ARTIFICIAL (method))
6123         {
6124           parse_error_context
6125             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6126              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6127              get_printable_method_name (redef));
6128           return 1;
6129         }
6130     }
6131   return 0;
6132 }
6133
6134 /* Return 1 if check went ok, 0 otherwise.  */
6135 static int
6136 check_abstract_method_definitions (do_interface, class_decl, type)
6137      int do_interface;
6138      tree class_decl, type;
6139 {
6140   tree class = TREE_TYPE (class_decl);
6141   tree method, end_type;
6142   int ok = 1;
6143
6144   end_type = (do_interface ? object_type_node : type);
6145   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6146     {
6147       tree other_super, other_method, method_sig, method_name;
6148       int found = 0;
6149       int end_type_reached = 0;
6150
6151       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6152         continue;
6153
6154       /* Now verify that somewhere in between TYPE and CLASS,
6155          abstract method METHOD gets a non abstract definition
6156          that is inherited by CLASS.  */
6157
6158       method_sig = build_java_signature (TREE_TYPE (method));
6159       method_name = DECL_NAME (method);
6160       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6161         method_name = EXPR_WFL_NODE (method_name);
6162
6163       other_super = class;
6164       do {
6165         if (other_super == end_type)
6166           end_type_reached = 1;
6167
6168         /* Method search */
6169         for (other_method = TYPE_METHODS (other_super); other_method;
6170             other_method = TREE_CHAIN (other_method))
6171           {
6172             tree s = build_java_signature (TREE_TYPE (other_method));
6173             tree other_name = DECL_NAME (other_method);
6174
6175             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6176               other_name = EXPR_WFL_NODE (other_name);
6177             if (!DECL_CLINIT_P (other_method)
6178                 && !DECL_CONSTRUCTOR_P (other_method)
6179                 && method_name == other_name
6180                 && method_sig == s
6181                 && !METHOD_ABSTRACT (other_method))
6182              {
6183                found = 1;
6184                break;
6185              }
6186           }
6187         other_super = CLASSTYPE_SUPER (other_super);
6188       } while (!end_type_reached);
6189
6190       /* Report that abstract METHOD didn't find an implementation
6191          that CLASS can use. */
6192       if (!found)
6193         {
6194           char *t = xstrdup (lang_printable_name
6195                             (TREE_TYPE (TREE_TYPE (method)), 0));
6196           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6197
6198           parse_error_context
6199             (lookup_cl (class_decl),
6200              "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",
6201              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6202              t, lang_printable_name (method, 0),
6203              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6204               "interface" : "class"),
6205              IDENTIFIER_POINTER (ccn),
6206              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6207              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6208           ok = 0;
6209           free (t);
6210         }
6211     }
6212
6213   if (ok && do_interface)
6214     {
6215       /* Check for implemented interfaces. */
6216       int i;
6217       tree vector = TYPE_BINFO_BASETYPES (type);
6218       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6219         {
6220           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6221           ok = check_abstract_method_definitions (1, class_decl, super);
6222         }
6223     }
6224
6225   return ok;
6226 }
6227
6228 /* Check that CLASS_DECL somehow implements all inherited abstract
6229    methods.  */
6230
6231 static void
6232 java_check_abstract_method_definitions (class_decl)
6233      tree class_decl;
6234 {
6235   tree class = TREE_TYPE (class_decl);
6236   tree super, vector;
6237   int i;
6238
6239   if (CLASS_ABSTRACT (class_decl))
6240     return;
6241
6242   /* Check for inherited types */
6243   super = class;
6244   do {
6245     super = CLASSTYPE_SUPER (super);
6246     check_abstract_method_definitions (0, class_decl, super);
6247   } while (super != object_type_node);
6248
6249   /* Check for implemented interfaces. */
6250   vector = TYPE_BINFO_BASETYPES (class);
6251   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6252     {
6253       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6254       check_abstract_method_definitions (1, class_decl, super);
6255     }
6256 }
6257
6258 /* Check all the types method DECL uses and return 1 if all of them
6259    are now complete, 0 otherwise. This is used to check whether its
6260    safe to build a method signature or not.  */
6261
6262 static int
6263 check_method_types_complete (decl)
6264      tree decl;
6265 {
6266   tree type = TREE_TYPE (decl);
6267   tree args;
6268
6269   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6270     return 0;
6271
6272   args = TYPE_ARG_TYPES (type);
6273   if (TREE_CODE (type) == METHOD_TYPE)
6274     args = TREE_CHAIN (args);
6275   for (; args != end_params_node; args = TREE_CHAIN (args))
6276     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6277       return 0;
6278
6279   return 1;
6280 }
6281
6282 /* Visible interface to check methods contained in CLASS_DECL */
6283
6284 void
6285 java_check_methods (class_decl)
6286      tree class_decl;
6287 {
6288   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6289     return;
6290
6291   if (CLASS_INTERFACE (class_decl))
6292     java_check_abstract_methods (class_decl);
6293   else
6294     java_check_regular_methods (class_decl);
6295
6296   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6297 }
6298
6299 /* Check all the methods of CLASS_DECL. Methods are first completed
6300    then checked according to regular method existence rules.  If no
6301    constructor for CLASS_DECL were encountered, then build its
6302    declaration.  */
6303
6304 static void
6305 java_check_regular_methods (class_decl)
6306      tree class_decl;
6307 {
6308   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6309   tree method;
6310   tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
6311   tree found = NULL_TREE;
6312   tree mthrows;
6313
6314   /* It is not necessary to check methods defined in java.lang.Object */
6315   if (class == object_type_node)
6316     return;
6317
6318   if (!TYPE_NVIRTUALS (class))
6319     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6320
6321   /* Should take interfaces into account. FIXME */
6322   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6323     {
6324       tree sig;
6325       tree method_wfl = DECL_FUNCTION_WFL (method);
6326       int aflags;
6327
6328       /* Check for redefinitions */
6329       if (check_method_redefinition (class, method))
6330         continue;
6331
6332       /* If we see one constructor a mark so we don't generate the
6333          default one. Also skip other verifications: constructors
6334          can't be inherited hence hiden or overriden */
6335      if (DECL_CONSTRUCTOR_P (method))
6336        {
6337          saw_constructor = 1;
6338          continue;
6339        }
6340
6341       /* We verify things thrown by the method. They must inherits from
6342          java.lang.Throwable */
6343       for (mthrows = DECL_FUNCTION_THROWS (method);
6344            mthrows; mthrows = TREE_CHAIN (mthrows))
6345         {
6346           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6347             parse_error_context
6348               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6349                IDENTIFIER_POINTER
6350                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6351         }
6352
6353       sig = build_java_argument_signature (TREE_TYPE (method));
6354       found = lookup_argument_method2 (class, DECL_NAME (method), sig);
6355
6356       /* Inner class can't declare static methods */
6357       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6358         {
6359           char *t = xstrdup (lang_printable_name (class, 0));
6360           parse_error_context
6361             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6362              lang_printable_name (method, 0), t);
6363           free (t);
6364         }
6365
6366       /* Nothing overrides or it's a private method. */
6367       if (!found)
6368         continue;
6369       if (METHOD_PRIVATE (found))
6370         {
6371           found = NULL_TREE;
6372           continue;
6373         }
6374
6375       /* If `found' is declared in an interface, make sure the
6376          modifier matches. */
6377       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6378           && clinit_identifier_node != DECL_NAME (found)
6379           && !METHOD_PUBLIC (method))
6380         {
6381           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6382           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6383                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6384                                lang_printable_name (method, 0),
6385                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6386         }
6387
6388       /* Can't override a method with the same name and different return
6389          types. */
6390       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6391         {
6392           char *t = xstrdup
6393             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6394           parse_error_context
6395             (method_wfl,
6396              "Method `%s' was defined with return type `%s' in class `%s'",
6397              lang_printable_name (found, 0), t,
6398              IDENTIFIER_POINTER
6399                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6400           free (t);
6401         }
6402
6403       aflags = get_access_flags_from_decl (found);
6404
6405       /* Can't override final. Can't override static. */
6406       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6407         {
6408           /* Static *can* override static */
6409           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6410             continue;
6411           parse_error_context
6412             (method_wfl,
6413              "%s methods can't be overriden. Method `%s' is %s in class `%s'",
6414              (METHOD_FINAL (found) ? "Final" : "Static"),
6415              lang_printable_name (found, 0),
6416              (METHOD_FINAL (found) ? "final" : "static"),
6417              IDENTIFIER_POINTER
6418                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6419           continue;
6420         }
6421
6422       /* Static method can't override instance method. */
6423       if (METHOD_STATIC (method))
6424         {
6425           parse_error_context
6426             (method_wfl,
6427              "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
6428              lang_printable_name (found, 0),
6429              IDENTIFIER_POINTER
6430                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6431           continue;
6432         }
6433
6434       /* - Overriding/hiding public must be public
6435          - Overriding/hiding protected must be protected or public
6436          - If the overriden or hidden method has default (package)
6437            access, then the overriding or hiding method must not be
6438            private; otherwise, a compile-time error occurs.  If
6439            `found' belongs to an interface, things have been already
6440            taken care of.  */
6441       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6442           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6443               || (METHOD_PROTECTED (found)
6444                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6445               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6446                   && METHOD_PRIVATE (method))))
6447         {
6448           parse_error_context
6449             (method_wfl,
6450              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6451              (METHOD_PUBLIC (method) ? "public" :
6452               (METHOD_PRIVATE (method) ? "private" : "protected")),
6453              IDENTIFIER_POINTER (DECL_NAME
6454                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6455           continue;
6456         }
6457
6458       /* Overriding methods must have compatible `throws' clauses on checked
6459          exceptions, if any */
6460       check_throws_clauses (method, method_wfl, found);
6461
6462       /* Inheriting multiple methods with the same signature. FIXME */
6463     }
6464
6465   if (!TYPE_NVIRTUALS (class))
6466     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6467
6468   /* Search for inherited abstract method not yet implemented in this
6469      class.  */
6470   java_check_abstract_method_definitions (class_decl);
6471
6472   if (!saw_constructor)
6473     abort ();
6474 }
6475
6476 /* Return a non zero value if the `throws' clause of METHOD (if any)
6477    is incompatible with the `throws' clause of FOUND (if any).  */
6478
6479 static void
6480 check_throws_clauses (method, method_wfl, found)
6481      tree method, method_wfl, found;
6482 {
6483   tree mthrows, fthrows;
6484
6485   /* Can't check these things with class loaded from bytecode. FIXME */
6486   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6487     return;
6488
6489   for (mthrows = DECL_FUNCTION_THROWS (method);
6490        mthrows; mthrows = TREE_CHAIN (mthrows))
6491     {
6492       /* We don't verify unchecked expressions */
6493       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6494         continue;
6495       /* Checked expression must be compatible */
6496       for (fthrows = DECL_FUNCTION_THROWS (found);
6497            fthrows; fthrows = TREE_CHAIN (fthrows))
6498         if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6499           break;
6500       if (!fthrows)
6501         {
6502           parse_error_context
6503             (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'",
6504              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6505              lang_printable_name (found, 0),
6506              IDENTIFIER_POINTER
6507                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6508         }
6509     }
6510 }
6511
6512 /* Check abstract method of interface INTERFACE */
6513
6514 static void
6515 java_check_abstract_methods (interface_decl)
6516      tree interface_decl;
6517 {
6518   int i, n;
6519   tree method, basetype_vec, found;
6520   tree interface = TREE_TYPE (interface_decl);
6521
6522   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6523     {
6524       /* 2- Check for double definition inside the defining interface */
6525       if (check_method_redefinition (interface, method))
6526         continue;
6527
6528       /* 3- Overriding is OK as far as we preserve the return type and
6529          the thrown exceptions (FIXME) */
6530       found = lookup_java_interface_method2 (interface, method);
6531       if (found)
6532         {
6533           char *t;
6534           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6535           parse_error_context
6536             (DECL_FUNCTION_WFL (found),
6537              "Method `%s' was defined with return type `%s' in class `%s'",
6538              lang_printable_name (found, 0), t,
6539              IDENTIFIER_POINTER
6540                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6541           free (t);
6542           continue;
6543         }
6544     }
6545
6546   /* 4- Inherited methods can't differ by their returned types */
6547   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6548     return;
6549   n = TREE_VEC_LENGTH (basetype_vec);
6550   for (i = 0; i < n; i++)
6551     {
6552       tree sub_interface_method, sub_interface;
6553       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6554       if (!vec_elt)
6555         continue;
6556       sub_interface = BINFO_TYPE (vec_elt);
6557       for (sub_interface_method = TYPE_METHODS (sub_interface);
6558            sub_interface_method;
6559            sub_interface_method = TREE_CHAIN (sub_interface_method))
6560         {
6561           found = lookup_java_interface_method2 (interface,
6562                                                  sub_interface_method);
6563           if (found && (found != sub_interface_method))
6564             {
6565               parse_error_context
6566                 (lookup_cl (sub_interface_method),
6567                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6568                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6569                  lang_printable_name (found, 0),
6570                  IDENTIFIER_POINTER
6571                    (DECL_NAME (TYPE_NAME
6572                                (DECL_CONTEXT (sub_interface_method)))),
6573                  IDENTIFIER_POINTER
6574                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6575             }
6576         }
6577     }
6578 }
6579
6580 /* Lookup methods in interfaces using their name and partial
6581    signature. Return a matching method only if their types differ.  */
6582
6583 static tree
6584 lookup_java_interface_method2 (class, method_decl)
6585      tree class, method_decl;
6586 {
6587   int i, n;
6588   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6589
6590   if (!basetype_vec)
6591     return NULL_TREE;
6592
6593   n = TREE_VEC_LENGTH (basetype_vec);
6594   for (i = 0; i < n; i++)
6595     {
6596       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6597       if ((BINFO_TYPE (vec_elt) != object_type_node)
6598           && (to_return =
6599               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6600         return to_return;
6601     }
6602   for (i = 0; i < n; i++)
6603     {
6604       to_return = lookup_java_interface_method2
6605         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6606       if (to_return)
6607         return to_return;
6608     }
6609
6610   return NULL_TREE;
6611 }
6612
6613 /* Lookup method using their name and partial signature. Return a
6614    matching method only if their types differ.  */
6615
6616 static tree
6617 lookup_java_method2 (clas, method_decl, do_interface)
6618      tree clas, method_decl;
6619      int do_interface;
6620 {
6621   tree method, method_signature, method_name, method_type, name;
6622
6623   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6624   name = DECL_NAME (method_decl);
6625   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6626                  EXPR_WFL_NODE (name) : name);
6627   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6628
6629   while (clas != NULL_TREE)
6630     {
6631       for (method = TYPE_METHODS (clas);
6632            method != NULL_TREE;  method = TREE_CHAIN (method))
6633         {
6634           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6635           tree name = DECL_NAME (method);
6636           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6637                EXPR_WFL_NODE (name) : name) == method_name
6638               && method_sig == method_signature
6639               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6640             return method;
6641         }
6642       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6643     }
6644   return NULL_TREE;
6645 }
6646
6647 /* Return the line that matches DECL line number, and try its best to
6648    position the column number. Used during error reports.  */
6649
6650 static tree
6651 lookup_cl (decl)
6652      tree decl;
6653 {
6654   static tree cl = NULL_TREE;
6655   char *line, *found;
6656
6657   if (!decl)
6658     return NULL_TREE;
6659
6660   if (cl == NULL_TREE)
6661     {
6662       cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6663       ggc_add_tree_root (&cl, 1);
6664     }
6665
6666   EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
6667   EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
6668
6669   line = java_get_line_col (EXPR_WFL_FILENAME (cl),
6670                             EXPR_WFL_LINENO (cl), EXPR_WFL_COLNO (cl));
6671
6672   found = strstr ((const char *)line,
6673                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6674   if (found)
6675     EXPR_WFL_SET_LINECOL (cl, EXPR_WFL_LINENO (cl), found - line);
6676
6677   return cl;
6678 }
6679
6680 /* Look for a simple name in the single-type import list */
6681
6682 static tree
6683 find_name_in_single_imports (name)
6684      tree name;
6685 {
6686   tree node;
6687
6688   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6689     if (TREE_VALUE (node) == name)
6690       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6691
6692   return NULL_TREE;
6693 }
6694
6695 /* Process all single-type import. */
6696
6697 static int
6698 process_imports ()
6699 {
6700   tree import;
6701   int error_found;
6702
6703   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6704     {
6705       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6706       char *original_name;
6707
6708       obstack_grow0 (&temporary_obstack,
6709                      IDENTIFIER_POINTER (to_be_found),
6710                      IDENTIFIER_LENGTH (to_be_found));
6711       original_name = obstack_finish (&temporary_obstack);
6712
6713       /* Don't load twice something already defined. */
6714       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6715         continue;
6716
6717       while (1)
6718         {
6719           tree left;
6720
6721           QUALIFIED_P (to_be_found) = 1;
6722           load_class (to_be_found, 0);
6723           error_found =
6724             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6725
6726           /* We found it, we can bail out */
6727           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6728             break;
6729
6730           /* We haven't found it. Maybe we're trying to access an
6731              inner class.  The only way for us to know is to try again
6732              after having dropped a qualifier. If we can't break it further,
6733              we have an error. */
6734           if (breakdown_qualified (&left, NULL, to_be_found))
6735             break;
6736
6737           to_be_found = left;
6738         }
6739       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6740         {
6741           parse_error_context (TREE_PURPOSE (import),
6742                                "Class or interface `%s' not found in import",
6743                                original_name);
6744           error_found = 1;
6745         }
6746
6747       obstack_free (&temporary_obstack, original_name);
6748       if (error_found)
6749         return 1;
6750     }
6751   return 0;
6752 }
6753
6754 /* Possibly find and mark a class imported by a single-type import
6755    statement.  */
6756
6757 static void
6758 find_in_imports (enclosing_type, class_type)
6759      tree enclosing_type;
6760      tree class_type;
6761 {
6762   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6763                  ctxp->import_list);
6764   while (import)
6765     {
6766       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6767         {
6768           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6769           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6770           return;
6771         }
6772       import = TREE_CHAIN (import);
6773     }
6774 }
6775
6776 static int
6777 note_possible_classname (name, len)
6778      const char *name;
6779      int len;
6780 {
6781   tree node;
6782   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6783     len = len - 5;
6784   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6785     len = len - 6;
6786   else
6787     return 0;
6788   node = ident_subst (name, len, "", '/', '.', "");
6789   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6790   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6791   return 1;
6792 }
6793
6794 /* Read a import directory, gathering potential match for further type
6795    references. Indifferently reads a filesystem or a ZIP archive
6796    directory.  */
6797
6798 static void
6799 read_import_dir (wfl)
6800      tree wfl;
6801 {
6802   tree package_id = EXPR_WFL_NODE (wfl);
6803   const char *package_name = IDENTIFIER_POINTER (package_id);
6804   int package_length = IDENTIFIER_LENGTH (package_id);
6805   DIR *dirp = NULL;
6806   JCF *saved_jcf = current_jcf;
6807
6808   int found = 0;
6809   int k;
6810   void *entry;
6811   struct buffer filename[1];
6812
6813   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6814     return;
6815   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6816
6817   BUFFER_INIT (filename);
6818   buffer_grow (filename, package_length + 100);
6819
6820   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6821     {
6822       const char *entry_name = jcf_path_name (entry);
6823       int entry_length = strlen (entry_name);
6824       if (jcf_path_is_zipfile (entry))
6825         {
6826           ZipFile *zipf;
6827           buffer_grow (filename, entry_length);
6828           memcpy (filename->data, entry_name, entry_length - 1);
6829           filename->data[entry_length-1] = '\0';
6830           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6831           if (zipf == NULL)
6832             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6833           else
6834             {
6835               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6836               BUFFER_RESET (filename);
6837               for (k = 0; k < package_length; k++)
6838                 {
6839                   char ch = package_name[k];
6840                   *filename->ptr++ = ch == '.' ? '/' : ch;
6841                 }
6842               *filename->ptr++ = '/';
6843
6844               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6845                 {
6846                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6847                   int current_entry_len = zipd->filename_length;
6848
6849                   if (current_entry_len >= BUFFER_LENGTH (filename)
6850                       && strncmp (filename->data, current_entry,
6851                                   BUFFER_LENGTH (filename)) != 0)
6852                     continue;
6853                   found |= note_possible_classname (current_entry,
6854                                                     current_entry_len);
6855                 }
6856             }
6857         }
6858       else
6859         {
6860           BUFFER_RESET (filename);
6861           buffer_grow (filename, entry_length + package_length + 4);
6862           strcpy (filename->data, entry_name);
6863           filename->ptr = filename->data + entry_length;
6864           for (k = 0; k < package_length; k++)
6865             {
6866               char ch = package_name[k];
6867               *filename->ptr++ = ch == '.' ? '/' : ch;
6868             }
6869           *filename->ptr = '\0';
6870
6871           dirp = opendir (filename->data);
6872           if (dirp == NULL)
6873             continue;
6874           *filename->ptr++ = '/';
6875           for (;;)
6876             {
6877               int len;
6878               const char *d_name;
6879               struct dirent *direntp = readdir (dirp);
6880               if (!direntp)
6881                 break;
6882               d_name = direntp->d_name;
6883               len = strlen (direntp->d_name);
6884               buffer_grow (filename, len+1);
6885               strcpy (filename->ptr, d_name);
6886               found |= note_possible_classname (filename->data + entry_length,
6887                                                 package_length+len+1);
6888             }
6889           if (dirp)
6890             closedir (dirp);
6891         }
6892     }
6893
6894   free (filename->data);
6895
6896   /* Here we should have a unified way of retrieving an entry, to be
6897      indexed. */
6898   if (!found)
6899     {
6900       static int first = 1;
6901       if (first)
6902         {
6903           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6904           java_error_count++;
6905           first = 0;
6906         }
6907       else
6908         parse_error_context (wfl, "Package `%s' not found in import",
6909                              package_name);
6910       current_jcf = saved_jcf;
6911       return;
6912     }
6913   current_jcf = saved_jcf;
6914 }
6915
6916 /* Possibly find a type in the import on demands specified
6917    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6918    entire list, to detected potential double definitions.  */
6919
6920 static int
6921 find_in_imports_on_demand (enclosing_type, class_type)
6922      tree enclosing_type;
6923      tree class_type;
6924 {
6925   tree class_type_name = TYPE_NAME (class_type);
6926   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
6927                   ctxp->import_demand_list);
6928   tree cl = NULL_TREE;
6929   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
6930   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
6931   tree node;
6932
6933   for (; import; import = TREE_CHAIN (import))
6934     {
6935       int saved_lineno = lineno;
6936       int access_check;
6937       const char *id_name;
6938       tree decl, type_name_copy;
6939
6940       obstack_grow (&temporary_obstack,
6941                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6942                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6943       obstack_1grow (&temporary_obstack, '.');
6944       obstack_grow0 (&temporary_obstack,
6945                      IDENTIFIER_POINTER (class_type_name),
6946                      IDENTIFIER_LENGTH (class_type_name));
6947       id_name = obstack_finish (&temporary_obstack);
6948
6949       if (! (node = maybe_get_identifier (id_name)))
6950         continue;
6951
6952       /* Setup lineno so that it refers to the line of the import (in
6953          case we parse a class file and encounter errors */
6954       lineno = EXPR_WFL_LINENO (TREE_PURPOSE (import));
6955
6956       type_name_copy = TYPE_NAME (class_type);
6957       TYPE_NAME (class_type) = node;
6958       QUALIFIED_P (node) = 1;
6959       decl = IDENTIFIER_CLASS_VALUE (node);
6960       access_check = -1;
6961       /* If there is no DECL set for the class or if the class isn't
6962          loaded and not seen in source yet, then load */
6963       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
6964                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
6965         {
6966           load_class (node, 0);
6967           decl = IDENTIFIER_CLASS_VALUE (node);
6968         }
6969       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
6970         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
6971                                                false);
6972       else
6973         /* 6.6.1: Inner classes are subject to member access rules. */
6974         access_check = 0;
6975
6976       lineno = saved_lineno;
6977
6978       /* If the loaded class is not accessible or couldn't be loaded,
6979          we restore the original TYPE_NAME and process the next
6980          import. */
6981       if (access_check || !decl)
6982         {
6983           TYPE_NAME (class_type) = type_name_copy;
6984           continue;
6985         }
6986
6987       /* If the loaded class is accessible, we keep a tab on it to
6988          detect and report multiple inclusions. */
6989       if (IS_A_CLASSFILE_NAME (node))
6990         {
6991           if (seen_once < 0)
6992             {
6993               cl = TREE_PURPOSE (import);
6994               seen_once = 1;
6995             }
6996           else if (seen_once >= 0)
6997             {
6998               tree location = (cl ? cl : TREE_PURPOSE (import));
6999               tree package = (cl ? EXPR_WFL_NODE (cl) :
7000                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7001               seen_once++;
7002               parse_error_context
7003                 (location,
7004                  "Type `%s' also potentially defined in package `%s'",
7005                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7006                  IDENTIFIER_POINTER (package));
7007             }
7008         }
7009       to_return = access_check;
7010     }
7011
7012   if (seen_once == 1)
7013     return to_return;
7014   else
7015     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7016 }
7017
7018 /* Add package NAME to the list of package encountered so far. To
7019    speed up class lookup in do_resolve_class, we make sure a
7020    particular package is added only once.  */
7021
7022 static void
7023 register_package (name)
7024      tree name;
7025 {
7026   static struct hash_table _pht, *pht = NULL;
7027
7028   if (!pht)
7029     {
7030       hash_table_init (&_pht, hash_newfunc,
7031                        java_hash_hash_tree_node, java_hash_compare_tree_node);
7032       pht = &_pht;
7033     }
7034
7035   if (!hash_lookup (pht, (const hash_table_key) name, FALSE, NULL))
7036     {
7037       package_list = chainon (package_list, build_tree_list (name, NULL));
7038       hash_lookup (pht, (const hash_table_key) name, TRUE, NULL);
7039     }
7040 }
7041
7042 static tree
7043 resolve_package (pkg, next, type_name)
7044      tree pkg, *next, *type_name;
7045 {
7046   tree current;
7047   tree decl = NULL_TREE;
7048   *type_name = NULL_TREE;
7049
7050   /* The trick is to determine when the package name stops and were
7051      the name of something contained in the package starts. Then we
7052      return a fully qualified name of what we want to get. */
7053
7054   *next = EXPR_WFL_QUALIFICATION (pkg);
7055
7056   /* Try to progressively construct a type name */
7057   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7058     for (current = EXPR_WFL_QUALIFICATION (pkg);
7059          current; current = TREE_CHAIN (current))
7060       {
7061         /* If we don't have what we're expecting, exit now. TYPE_NAME
7062            will be null and the error caught later. */
7063         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7064           break;
7065         *type_name =
7066           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7067         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7068           {
7069             /* resolve_package should be used in a loop, hence we
7070                point at this one to naturally process the next one at
7071                the next iteration. */
7072             *next = current;
7073             break;
7074           }
7075       }
7076   return decl;
7077 }
7078
7079
7080 /* Check accessibility of inner classes according to member access rules.
7081    DECL is the inner class, ENCLOSING_DECL is the class from which the
7082    access is being attempted. */
7083
7084 static void
7085 check_inner_class_access (decl, enclosing_decl, cl)
7086      tree decl, enclosing_decl, cl;
7087 {
7088   const char *access;
7089   tree enclosing_decl_type;
7090
7091   /* We don't issue an error message when CL is null. CL can be null
7092      as a result of processing a JDEP crafted by source_start_java_method
7093      for the purpose of patching its parm decl. But the error would
7094      have been already trapped when fixing the method's signature.
7095      DECL can also be NULL in case of earlier errors. */
7096   if (!decl || !cl)
7097     return;
7098
7099   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7100
7101   if (CLASS_PRIVATE (decl))
7102     {
7103       /* Access is permitted only within the body of the top-level
7104          class in which DECL is declared. */
7105       tree top_level = decl;
7106       while (DECL_CONTEXT (top_level))
7107         top_level = DECL_CONTEXT (top_level);
7108       while (DECL_CONTEXT (enclosing_decl))
7109         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7110       if (top_level == enclosing_decl)
7111         return;
7112       access = "private";
7113     }
7114   else if (CLASS_PROTECTED (decl))
7115     {
7116       tree decl_context;
7117       /* Access is permitted from within the same package... */
7118       if (in_same_package (decl, enclosing_decl))
7119         return;
7120
7121       /* ... or from within the body of a subtype of the context in which
7122          DECL is declared. */
7123       decl_context = DECL_CONTEXT (decl);
7124       while (enclosing_decl)
7125         {
7126           if (CLASS_INTERFACE (decl))
7127             {
7128               if (interface_of_p (TREE_TYPE (decl_context),
7129                                   enclosing_decl_type))
7130                 return;
7131             }
7132           else
7133             {
7134               /* Eww. The order of the arguments is different!! */
7135               if (inherits_from_p (enclosing_decl_type,
7136                                    TREE_TYPE (decl_context)))
7137                 return;
7138             }
7139           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7140         }
7141       access = "protected";
7142     }
7143   else if (! CLASS_PUBLIC (decl))
7144     {
7145       /* Access is permitted only from within the same package as DECL. */
7146       if (in_same_package (decl, enclosing_decl))
7147         return;
7148       access = "non-public";
7149     }
7150   else
7151     /* Class is public. */
7152     return;
7153
7154   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7155                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7156                        lang_printable_name (decl, 0), access);
7157 }
7158
7159 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7160    foreign package, it must be PUBLIC. Return 0 if no access
7161    violations were found, 1 otherwise. If VERBOSE is true and an error
7162    was found, it is reported and accounted for.  */
7163
7164 static int
7165 check_pkg_class_access (class_name, cl, verbose)
7166      tree class_name;
7167      tree cl;
7168      bool verbose;
7169 {
7170   tree type;
7171
7172   if (!IDENTIFIER_CLASS_VALUE (class_name))
7173     return 0;
7174
7175   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7176     return 0;
7177
7178   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7179     {
7180       /* Access to a private class within the same package is
7181          allowed. */
7182       tree l, r;
7183       breakdown_qualified (&l, &r, class_name);
7184       if (!QUALIFIED_P (class_name) && !ctxp->package)
7185         /* Both in the empty package. */
7186         return 0;
7187       if (l == ctxp->package)
7188         /* Both in the same package. */
7189         return 0;
7190
7191       if (verbose)
7192         parse_error_context
7193           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7194            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7195            IDENTIFIER_POINTER (class_name));
7196       return 1;
7197     }
7198   return 0;
7199 }
7200
7201 /* Local variable declaration. */
7202
7203 static void
7204 declare_local_variables (modifier, type, vlist)
7205      int modifier;
7206      tree type;
7207      tree vlist;
7208 {
7209   tree decl, current, saved_type;
7210   tree type_wfl = NULL_TREE;
7211   int must_chain = 0;
7212   int final_p = 0;
7213
7214   /* Push a new block if statements were seen between the last time we
7215      pushed a block and now. Keep a count of blocks to close */
7216   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7217     {
7218       tree b = enter_block ();
7219       BLOCK_IS_IMPLICIT (b) = 1;
7220     }
7221
7222   if (modifier)
7223     {
7224       int i;
7225       for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
7226       if (modifier == ACC_FINAL)
7227         final_p = 1;
7228       else
7229         {
7230           parse_error_context
7231             (ctxp->modifier_ctx [i],
7232              "Only `final' is allowed as a local variables modifier");
7233           return;
7234         }
7235     }
7236
7237   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7238      hold the TYPE value if a new incomplete has to be created (as
7239      opposed to being found already existing and reused). */
7240   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7241
7242   /* If TYPE is fully resolved and we don't have a reference, make one */
7243   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7244
7245   /* Go through all the declared variables */
7246   for (current = vlist, saved_type = type; current;
7247        current = TREE_CHAIN (current), type = saved_type)
7248     {
7249       tree other, real_type;
7250       tree wfl  = TREE_PURPOSE (current);
7251       tree name = EXPR_WFL_NODE (wfl);
7252       tree init = TREE_VALUE (current);
7253
7254       /* Process NAME, as it may specify extra dimension(s) for it */
7255       type = build_array_from_name (type, type_wfl, name, &name);
7256
7257       /* Variable redefinition check */
7258       if ((other = lookup_name_in_blocks (name)))
7259         {
7260           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7261                                        DECL_SOURCE_LINE (other));
7262           continue;
7263         }
7264
7265       /* Type adjustment. We may have just readjusted TYPE because
7266          the variable specified more dimensions. Make sure we have
7267          a reference if we can and don't have one already. */
7268       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7269
7270       real_type = GET_REAL_TYPE (type);
7271       /* Never layout this decl. This will be done when its scope
7272          will be entered */
7273       decl = build_decl (VAR_DECL, name, real_type);
7274       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7275       DECL_FINAL (decl) = final_p;
7276       BLOCK_CHAIN_DECL (decl);
7277
7278       /* If doing xreferencing, replace the line number with the WFL
7279          compound value */
7280       if (flag_emit_xref)
7281         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7282
7283       /* Don't try to use an INIT statement when an error was found */
7284       if (init && java_error_count)
7285         init = NULL_TREE;
7286
7287       /* Add the initialization function to the current function's code */
7288       if (init)
7289         {
7290           /* Name might have been readjusted */
7291           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7292           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7293           java_method_add_stmt (current_function_decl,
7294                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7295                                                       init));
7296         }
7297
7298       /* Setup dependency the type of the decl */
7299       if (must_chain)
7300         {
7301           jdep *dep;
7302           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7303           dep = CLASSD_LAST (ctxp->classd_list);
7304           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7305         }
7306     }
7307   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7308 }
7309
7310 /* Called during parsing. Build decls from argument list.  */
7311
7312 static void
7313 source_start_java_method (fndecl)
7314      tree fndecl;
7315 {
7316   tree tem;
7317   tree parm_decl;
7318   int i;
7319
7320   if (!fndecl)
7321     return;
7322
7323   current_function_decl = fndecl;
7324
7325   /* New scope for the function */
7326   enter_block ();
7327   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7328        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7329     {
7330       tree type = TREE_VALUE (tem);
7331       tree name = TREE_PURPOSE (tem);
7332
7333       /* If type is incomplete. Create an incomplete decl and ask for
7334          the decl to be patched later */
7335       if (INCOMPLETE_TYPE_P (type))
7336         {
7337           jdep *jdep;
7338           tree real_type = GET_REAL_TYPE (type);
7339           parm_decl = build_decl (PARM_DECL, name, real_type);
7340           type = obtain_incomplete_type (type);
7341           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7342           jdep = CLASSD_LAST (ctxp->classd_list);
7343           JDEP_MISC (jdep) = name;
7344           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7345         }
7346       else
7347         parm_decl = build_decl (PARM_DECL, name, type);
7348
7349       /* Remember if a local variable was declared final (via its
7350          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7351       if (ARG_FINAL_P (tem))
7352         {
7353           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7354           DECL_FINAL (parm_decl) = 1;
7355         }
7356
7357       BLOCK_CHAIN_DECL (parm_decl);
7358     }
7359   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7360   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7361     nreverse (tem);
7362   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7363   DECL_MAX_LOCALS (current_function_decl) = i;
7364 }
7365
7366 /* Called during parsing. Creates an artificial method declaration.  */
7367
7368 static tree
7369 create_artificial_method (class, flags, type, name, args)
7370      tree class;
7371      int flags;
7372      tree type, name, args;
7373 {
7374   tree mdecl;
7375
7376   java_parser_context_save_global ();
7377   lineno = 0;
7378   mdecl = make_node (FUNCTION_TYPE);
7379   TREE_TYPE (mdecl) = type;
7380   TYPE_ARG_TYPES (mdecl) = args;
7381   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7382   java_parser_context_restore_global ();
7383   DECL_ARTIFICIAL (mdecl) = 1;
7384   return mdecl;
7385 }
7386
7387 /* Starts the body if an artificial method.  */
7388
7389 static void
7390 start_artificial_method_body (mdecl)
7391      tree mdecl;
7392 {
7393   DECL_SOURCE_LINE (mdecl) = 1;
7394   DECL_SOURCE_LINE_MERGE (mdecl, 1);
7395   source_start_java_method (mdecl);
7396   enter_block ();
7397 }
7398
7399 static void
7400 end_artificial_method_body (mdecl)
7401      tree mdecl;
7402 {
7403   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7404      It has to be evaluated first. (if mdecl is current_function_decl,
7405      we have an undefined behavior if no temporary variable is used.) */
7406   tree b = exit_block ();
7407   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7408   exit_block ();
7409 }
7410
7411 /* Dump a tree of some kind.  This is a convenience wrapper for the
7412    dump_* functions in tree-dump.c.  */
7413 static void
7414 dump_java_tree (phase, t)
7415      enum tree_dump_index phase;
7416      tree t;
7417 {
7418   FILE *stream;
7419   int flags;
7420
7421   stream = dump_begin (phase, &flags);
7422   if (stream)
7423     {
7424       dump_node (t, flags, stream);
7425       dump_end (phase, stream);
7426     }
7427 }
7428
7429 /* Terminate a function and expand its body.  */
7430
7431 static void
7432 source_end_java_method ()
7433 {
7434   tree fndecl = current_function_decl;
7435
7436   if (!fndecl)
7437     return;
7438
7439   java_parser_context_save_global ();
7440   lineno = ctxp->last_ccb_indent1;
7441
7442   /* Turn function bodies with only a NOP expr null, so they don't get
7443      generated at all and we won't get warnings when using the -W
7444      -Wall flags. */
7445   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7446     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7447
7448   /* We've generated all the trees for this function, and it has been
7449      patched.  Dump it to a file if the user requested it.  */
7450   dump_java_tree (TDI_original, fndecl);
7451
7452   /* Generate function's code */
7453   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7454       && ! flag_emit_class_files
7455       && ! flag_emit_xref)
7456     expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
7457
7458   /* pop out of its parameters */
7459   pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7460   poplevel (1, 0, 1);
7461   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7462
7463   /* Generate rtl for function exit.  */
7464   if (! flag_emit_class_files && ! flag_emit_xref)
7465     {
7466       lineno = DECL_SOURCE_LINE_LAST (fndecl);
7467       expand_function_end (input_filename, lineno, 0);
7468
7469       /* Run the optimizers and output assembler code for this function. */
7470       rest_of_compilation (fndecl);
7471     }
7472
7473   current_function_decl = NULL_TREE;
7474   java_parser_context_restore_global ();
7475 }
7476
7477 /* Record EXPR in the current function block. Complements compound
7478    expression second operand if necessary.  */
7479
7480 tree
7481 java_method_add_stmt (fndecl, expr)
7482      tree fndecl, expr;
7483 {
7484   if (!GET_CURRENT_BLOCK (fndecl))
7485     return NULL_TREE;
7486   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7487 }
7488
7489 static tree
7490 add_stmt_to_block (b, type, stmt)
7491      tree b, type, stmt;
7492 {
7493   tree body = BLOCK_EXPR_BODY (b), c;
7494
7495   if (java_error_count)
7496     return body;
7497
7498   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7499     return body;
7500
7501   BLOCK_EXPR_BODY (b) = c;
7502   TREE_SIDE_EFFECTS (c) = 1;
7503   return c;
7504 }
7505
7506 /* Add STMT to EXISTING if possible, otherwise create a new
7507    COMPOUND_EXPR and add STMT to it. */
7508
7509 static tree
7510 add_stmt_to_compound (existing, type, stmt)
7511      tree existing, type, stmt;
7512 {
7513   if (existing)
7514     return build (COMPOUND_EXPR, type, existing, stmt);
7515   else
7516     return stmt;
7517 }
7518
7519 void java_layout_seen_class_methods ()
7520 {
7521   tree previous_list = all_class_list;
7522   tree end = NULL_TREE;
7523   tree current;
7524
7525   while (1)
7526     {
7527       for (current = previous_list;
7528            current != end; current = TREE_CHAIN (current))
7529         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7530
7531       if (previous_list != all_class_list)
7532         {
7533           end = previous_list;
7534           previous_list = all_class_list;
7535         }
7536       else
7537         break;
7538     }
7539 }
7540
7541 void
7542 java_reorder_fields ()
7543 {
7544   static tree stop_reordering = NULL_TREE;
7545   static int initialized_p;
7546   tree current;
7547
7548   /* Register STOP_REORDERING with the garbage collector.  */
7549   if (!initialized_p)
7550     {
7551       ggc_add_tree_root (&stop_reordering, 1);
7552       initialized_p = 1;
7553     }
7554
7555   for (current = gclass_list; current; current = TREE_CHAIN (current))
7556     {
7557       current_class = TREE_TYPE (TREE_VALUE (current));
7558
7559       if (current_class == stop_reordering)
7560         break;
7561
7562       /* Reverse the fields, but leave the dummy field in front.
7563          Fields are already ordered for Object and Class */
7564       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7565           && current_class != class_type_node)
7566       {
7567         /* If the dummy field is there, reverse the right fields and
7568            just layout the type for proper fields offset */
7569         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7570           {
7571             tree fields = TYPE_FIELDS (current_class);
7572             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7573             TYPE_SIZE (current_class) = NULL_TREE;
7574           }
7575         /* We don't have a dummy field, we need to layout the class,
7576            after having reversed the fields */
7577         else
7578           {
7579             TYPE_FIELDS (current_class) =
7580               nreverse (TYPE_FIELDS (current_class));
7581             TYPE_SIZE (current_class) = NULL_TREE;
7582           }
7583       }
7584     }
7585   /* There are cases were gclass_list will be empty. */
7586   if (gclass_list)
7587     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7588 }
7589
7590 /* Layout the methods of all classes loaded in one way or another.
7591    Check methods of source parsed classes. Then reorder the
7592    fields and layout the classes or the type of all source parsed
7593    classes */
7594
7595 void
7596 java_layout_classes ()
7597 {
7598   tree current;
7599   int save_error_count = java_error_count;
7600
7601   /* Layout the methods of all classes seen so far */
7602   java_layout_seen_class_methods ();
7603   java_parse_abort_on_error ();
7604   all_class_list = NULL_TREE;
7605
7606   /* Then check the methods of all parsed classes */
7607   for (current = gclass_list; current; current = TREE_CHAIN (current))
7608     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7609       java_check_methods (TREE_VALUE (current));
7610   java_parse_abort_on_error ();
7611
7612   for (current = gclass_list; current; current = TREE_CHAIN (current))
7613     {
7614       current_class = TREE_TYPE (TREE_VALUE (current));
7615       layout_class (current_class);
7616
7617       /* Error reported by the caller */
7618       if (java_error_count)
7619         return;
7620     }
7621
7622   /* We might have reloaded classes durign the process of laying out
7623      classes for code generation. We must layout the methods of those
7624      late additions, as constructor checks might use them */
7625   java_layout_seen_class_methods ();
7626   java_parse_abort_on_error ();
7627 }
7628
7629 /* Expand methods in the current set of classes rememebered for
7630    generation.  */
7631
7632 static void
7633 java_complete_expand_classes ()
7634 {
7635   tree current;
7636
7637   do_not_fold = flag_emit_xref;
7638
7639   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7640     if (!INNER_CLASS_DECL_P (current))
7641       java_complete_expand_class (current);
7642 }
7643
7644 /* Expand the methods found in OUTER, starting first by OUTER's inner
7645    classes, if any.  */
7646
7647 static void
7648 java_complete_expand_class (outer)
7649      tree outer;
7650 {
7651   tree inner_list;
7652
7653   set_nested_class_simple_name_value (outer, 1); /* Set */
7654
7655   /* We need to go after all inner classes and start expanding them,
7656      starting with most nested ones. We have to do that because nested
7657      classes might add functions to outer classes */
7658
7659   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7660        inner_list; inner_list = TREE_CHAIN (inner_list))
7661     java_complete_expand_class (TREE_PURPOSE (inner_list));
7662
7663   java_complete_expand_methods (outer);
7664   set_nested_class_simple_name_value (outer, 0); /* Reset */
7665 }
7666
7667 /* Expand methods registered in CLASS_DECL. The general idea is that
7668    we expand regular methods first. This allows us get an estimate on
7669    how outer context local alias fields are really used so we can add
7670    to the constructor just enough code to initialize them properly (it
7671    also lets us generate finit$ correctly.) Then we expand the
7672    constructors and then <clinit>.  */
7673
7674 static void
7675 java_complete_expand_methods (class_decl)
7676      tree class_decl;
7677 {
7678   tree clinit, decl, first_decl;
7679
7680   current_class = TREE_TYPE (class_decl);
7681
7682   /* Initialize a new constant pool */
7683   init_outgoing_cpool ();
7684
7685   /* Pre-expand <clinit> to figure whether we really need it or
7686      not. If we do need it, we pre-expand the static fields so they're
7687      ready to be used somewhere else. <clinit> will be fully expanded
7688      after we processed the constructors. */
7689   first_decl = TYPE_METHODS (current_class);
7690   clinit = maybe_generate_pre_expand_clinit (current_class);
7691
7692   /* Then generate finit$ (if we need to) because constructors will
7693    try to use it.*/
7694   if (TYPE_FINIT_STMT_LIST (current_class))
7695     java_complete_expand_method (generate_finit (current_class));
7696
7697   /* Then generate instinit$ (if we need to) because constructors will
7698      try to use it. */
7699   if (TYPE_II_STMT_LIST (current_class))
7700     java_complete_expand_method (generate_instinit (current_class));
7701
7702   /* Now do the constructors */
7703   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7704     {
7705       int no_body;
7706
7707       if (!DECL_CONSTRUCTOR_P (decl))
7708         continue;
7709
7710       no_body = !DECL_FUNCTION_BODY (decl);
7711       /* Don't generate debug info on line zero when expanding a
7712          generated constructor. */
7713       if (no_body)
7714         restore_line_number_status (1);
7715
7716       java_complete_expand_method (decl);
7717
7718       if (no_body)
7719         restore_line_number_status (0);
7720     }
7721
7722   /* First, do the ordinary methods. */
7723   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7724     {
7725       /* Ctors aren't part of this batch. */
7726       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7727         continue;
7728
7729       /* Skip abstract or native methods -- but do handle native
7730          methods when generating JNI stubs.  */
7731       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7732         {
7733           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7734           continue;
7735         }
7736
7737       if (METHOD_NATIVE (decl))
7738         {
7739           tree body;
7740           current_function_decl = decl;
7741           body = build_jni_stub (decl);
7742           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7743         }
7744
7745       java_complete_expand_method (decl);
7746     }
7747
7748   /* If there is indeed a <clinit>, fully expand it now */
7749   if (clinit)
7750     {
7751       /* Prevent the use of `this' inside <clinit> */
7752       ctxp->explicit_constructor_p = 1;
7753       java_complete_expand_method (clinit);
7754       ctxp->explicit_constructor_p = 0;
7755     }
7756
7757   /* We might have generated a class$ that we now want to expand */
7758   if (TYPE_DOT_CLASS (current_class))
7759     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7760
7761   /* Now verify constructor circularity (stop after the first one we
7762      prove wrong.) */
7763   if (!CLASS_INTERFACE (class_decl))
7764     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7765       if (DECL_CONSTRUCTOR_P (decl)
7766           && verify_constructor_circularity (decl, decl))
7767         break;
7768
7769   /* Save the constant pool. We'll need to restore it later. */
7770   TYPE_CPOOL (current_class) = outgoing_cpool;
7771 }
7772
7773 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7774    safely used in some other methods/constructors.  */
7775
7776 static tree
7777 maybe_generate_pre_expand_clinit (class_type)
7778      tree class_type;
7779 {
7780   tree current, mdecl;
7781
7782   if (!TYPE_CLINIT_STMT_LIST (class_type))
7783     return NULL_TREE;
7784
7785   /* Go through all static fields and pre expand them */
7786   for (current = TYPE_FIELDS (class_type); current;
7787        current = TREE_CHAIN (current))
7788     if (FIELD_STATIC (current))
7789       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7790
7791   /* Then build the <clinit> method */
7792   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7793                                     clinit_identifier_node, end_params_node);
7794   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7795                        mdecl, NULL_TREE);
7796   start_artificial_method_body (mdecl);
7797
7798   /* We process the list of assignment we produced as the result of
7799      the declaration of initialized static field and add them as
7800      statement to the <clinit> method. */
7801   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7802        current = TREE_CHAIN (current))
7803     {
7804       tree stmt = current;
7805       /* We build the assignment expression that will initialize the
7806          field to its value. There are strict rules on static
7807          initializers (8.5). FIXME */
7808       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7809         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7810       java_method_add_stmt (mdecl, stmt);
7811     }
7812
7813   end_artificial_method_body (mdecl);
7814
7815   /* Now we want to place <clinit> as the last method (because we need
7816      it at least for interface so that it doesn't interfere with the
7817      dispatch table based lookup. */
7818   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7819     {
7820       current = TREE_CHAIN (TYPE_METHODS (class_type));
7821       TYPE_METHODS (class_type) = current;
7822
7823       while (TREE_CHAIN (current))
7824         current = TREE_CHAIN (current);
7825
7826       TREE_CHAIN (current) = mdecl;
7827       TREE_CHAIN (mdecl) = NULL_TREE;
7828     }
7829
7830   return mdecl;
7831 }
7832
7833 /* Analyzes a method body and look for something that isn't a
7834    MODIFY_EXPR with a constant value.  */
7835
7836 static int
7837 analyze_clinit_body (this_class, bbody)
7838      tree this_class, bbody;
7839 {
7840   while (bbody)
7841     switch (TREE_CODE (bbody))
7842       {
7843       case BLOCK:
7844         bbody = BLOCK_EXPR_BODY (bbody);
7845         break;
7846
7847       case EXPR_WITH_FILE_LOCATION:
7848         bbody = EXPR_WFL_NODE (bbody);
7849         break;
7850
7851       case COMPOUND_EXPR:
7852         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7853           return 1;
7854         bbody = TREE_OPERAND (bbody, 1);
7855         break;
7856
7857       case MODIFY_EXPR:
7858         /* If we're generating to class file and we're dealing with an
7859            array initialization, we return 1 to keep <clinit> */
7860         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7861             && flag_emit_class_files)
7862           return 1;
7863
7864         /* There are a few cases where we're required to keep
7865            <clinit>:
7866            - If this is an assignment whose operand is not constant,
7867            - If this is an assignment to a non-initialized field,
7868            - If this field is not a member of the current class.
7869         */
7870         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7871                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7872                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7873
7874       default:
7875         return 1;
7876       }
7877   return 0;
7878 }
7879
7880
7881 /* See whether we could get rid of <clinit>. Criteria are: all static
7882    final fields have constant initial values and the body of <clinit>
7883    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7884
7885 static int
7886 maybe_yank_clinit (mdecl)
7887      tree mdecl;
7888 {
7889   tree type, current;
7890   tree fbody, bbody;
7891
7892   if (!DECL_CLINIT_P (mdecl))
7893     return 0;
7894
7895   /* If the body isn't empty, then we keep <clinit>. Note that if
7896      we're emitting classfiles, this isn't enough not to rule it
7897      out. */
7898   fbody = DECL_FUNCTION_BODY (mdecl);
7899   bbody = BLOCK_EXPR_BODY (fbody);
7900   if (bbody && bbody != error_mark_node)
7901     bbody = BLOCK_EXPR_BODY (bbody);
7902   else
7903     return 0;
7904   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7905     return 0;
7906
7907   type = DECL_CONTEXT (mdecl);
7908   current = TYPE_FIELDS (type);
7909
7910   for (current = (current ? TREE_CHAIN (current) : current);
7911        current; current = TREE_CHAIN (current))
7912     {
7913       tree f_init;
7914
7915       /* We're not interested in non-static fields.  */
7916       if (!FIELD_STATIC (current))
7917         continue;
7918
7919       /* Nor in fields without initializers. */
7920       f_init = DECL_INITIAL (current);
7921       if (f_init == NULL_TREE)
7922         continue;
7923
7924       /* Anything that isn't String or a basic type is ruled out -- or
7925          if we know how to deal with it (when doing things natively) we
7926          should generated an empty <clinit> so that SUID are computed
7927          correctly. */
7928       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7929           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7930         return 0;
7931
7932       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7933         return 0;
7934     }
7935
7936   /* Now we analyze the method body and look for something that
7937      isn't a MODIFY_EXPR */
7938   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7939     return 0;
7940
7941   /* Get rid of <clinit> in the class' list of methods */
7942   if (TYPE_METHODS (type) == mdecl)
7943     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7944   else
7945     for (current = TYPE_METHODS (type); current;
7946          current = TREE_CHAIN (current))
7947       if (TREE_CHAIN (current) == mdecl)
7948         {
7949           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7950           break;
7951         }
7952
7953   return 1;
7954 }
7955
7956 /* Install the argument from MDECL. Suitable to completion and
7957    expansion of mdecl's body.  */
7958
7959 static void
7960 start_complete_expand_method (mdecl)
7961      tree mdecl;
7962 {
7963   tree tem;
7964
7965   pushlevel (1);                /* Prepare for a parameter push */
7966   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7967   DECL_ARGUMENTS (mdecl) = tem;
7968
7969   for (; tem; tem = TREE_CHAIN (tem))
7970     {
7971       /* TREE_CHAIN (tem) will change after pushdecl. */
7972       tree next = TREE_CHAIN (tem);
7973       tree type = TREE_TYPE (tem);
7974       if (PROMOTE_PROTOTYPES
7975           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7976           && INTEGRAL_TYPE_P (type))
7977         type = integer_type_node;
7978       DECL_ARG_TYPE (tem) = type;
7979       layout_decl (tem, 0);
7980       pushdecl (tem);
7981       /* Re-install the next so that the list is kept and the loop
7982          advances. */
7983       TREE_CHAIN (tem) = next;
7984     }
7985   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7986   lineno = DECL_SOURCE_LINE_FIRST (mdecl);
7987   build_result_decl (mdecl);
7988 }
7989
7990
7991 /* Complete and expand a method.  */
7992
7993 static void
7994 java_complete_expand_method (mdecl)
7995      tree mdecl;
7996 {
7997   tree fbody, block_body, exception_copy;
7998
7999   current_function_decl = mdecl;
8000   /* Fix constructors before expanding them */
8001   if (DECL_CONSTRUCTOR_P (mdecl))
8002     fix_constructors (mdecl);
8003
8004   /* Expand functions that have a body */
8005   if (!DECL_FUNCTION_BODY (mdecl))
8006     return;
8007
8008   fbody = DECL_FUNCTION_BODY (mdecl);
8009   block_body = BLOCK_EXPR_BODY (fbody);
8010   exception_copy = NULL_TREE;
8011
8012   current_function_decl = mdecl;
8013
8014   if (! quiet_flag)
8015     fprintf (stderr, " [%s.",
8016              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8017   announce_function (mdecl);
8018   if (! quiet_flag)
8019     fprintf (stderr, "]");
8020
8021   /* Prepare the function for tree completion */
8022   start_complete_expand_method (mdecl);
8023
8024   /* Install the current this */
8025   current_this = (!METHOD_STATIC (mdecl) ?
8026                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8027
8028   /* Purge the `throws' list of unchecked exceptions (we save a copy
8029      of the list and re-install it later.) */
8030   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8031   purge_unchecked_exceptions (mdecl);
8032
8033   /* Install exceptions thrown with `throws' */
8034   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8035
8036   if (block_body != NULL_TREE)
8037     {
8038       block_body = java_complete_tree (block_body);
8039
8040       /* Before we check initialization, attached all class initialization
8041          variable to the block_body */
8042       hash_traverse (&DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8043                      attach_init_test_initialization_flags, block_body);
8044
8045       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8046         {
8047           check_for_initialization (block_body, mdecl);
8048
8049           /* Go through all the flags marking the initialization of
8050              static variables and see whether they're definitively
8051              assigned, in which case the type is remembered as
8052              definitively initialized in MDECL. */
8053           if (STATIC_CLASS_INIT_OPT_P ())
8054             {
8055               /* Always register the context as properly initialized in
8056                  MDECL. This used with caution helps removing extra
8057                  initialization of self. */
8058               if (METHOD_STATIC (mdecl))
8059                 hash_lookup (&DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8060                              (hash_table_key) DECL_CONTEXT (mdecl),
8061                              TRUE, NULL);
8062             }
8063         }
8064       ctxp->explicit_constructor_p = 0;
8065     }
8066
8067   BLOCK_EXPR_BODY (fbody) = block_body;
8068
8069   /* If we saw a return but couldn't evaluate it properly, we'll have
8070      an error_mark_node here. */
8071   if (block_body != error_mark_node
8072       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8073       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8074       && !flag_emit_xref)
8075     missing_return_error (current_function_decl);
8076
8077   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8078   maybe_yank_clinit (mdecl);
8079
8080   /* Pop the current level, with special measures if we found errors. */
8081   if (java_error_count)
8082     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8083   poplevel (1, 0, 1);
8084
8085   /* Pop the exceptions and sanity check */
8086   POP_EXCEPTIONS();
8087   if (currently_caught_type_list)
8088     abort ();
8089
8090   /* Restore the copy of the list of exceptions if emitting xrefs. */
8091   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8092 }
8093
8094 /* For with each class for which there's code to generate. */
8095
8096 static void
8097 java_expand_method_bodies (class)
8098      tree class;
8099 {
8100   tree decl;
8101   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8102     {
8103       if (!DECL_FUNCTION_BODY (decl))
8104         continue;
8105
8106       current_function_decl = decl;
8107
8108       /* It's time to assign the variable flagging static class
8109          initialization based on which classes invoked static methods
8110          are definitely initializing. This should be flagged. */
8111       if (STATIC_CLASS_INIT_OPT_P ())
8112         {
8113           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8114           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8115             {
8116               /* Executed for each statement calling a static function.
8117                  LIST is a TREE_LIST whose PURPOSE is the called function
8118                  and VALUE is a compound whose second operand can be patched
8119                  with static class initialization flag assignments.  */
8120
8121               tree called_method = TREE_PURPOSE (list);
8122               tree compound = TREE_VALUE (list);
8123               tree assignment_compound_list
8124                 = build_tree_list (called_method, NULL);
8125
8126               /* For each class definitely initialized in
8127                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8128                  assignment to the class initialization flag. */
8129               hash_traverse (&DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8130                              emit_test_initialization,
8131                              assignment_compound_list);
8132
8133               if (TREE_VALUE (assignment_compound_list))
8134                 TREE_OPERAND (compound, 1)
8135                   = TREE_VALUE (assignment_compound_list);
8136             }
8137         }
8138
8139       /* Prepare the function for RTL expansion */
8140       start_complete_expand_method (decl);
8141
8142       /* Expand function start, generate initialization flag
8143          assignment, and handle synchronized methods. */
8144       complete_start_java_method (decl);
8145
8146       /* Expand the rest of the function body and terminate
8147          expansion. */
8148       source_end_java_method ();
8149     }
8150 }
8151
8152 \f
8153
8154 /* This section of the code deals with accessing enclosing context
8155    fields either directly by using the relevant access to this$<n> or
8156    by invoking an access method crafted for that purpose.  */
8157
8158 /* Build the necessary access from an inner class to an outer
8159    class. This routine could be optimized to cache previous result
8160    (decl, current_class and returned access).  When an access method
8161    needs to be generated, it always takes the form of a read. It might
8162    be later turned into a write by calling outer_field_access_fix.  */
8163
8164 static tree
8165 build_outer_field_access (id, decl)
8166      tree id, decl;
8167 {
8168   tree access = NULL_TREE;
8169   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8170   tree decl_ctx = DECL_CONTEXT (decl);
8171
8172   /* If the immediate enclosing context of the current class is the
8173      field decl's class or inherits from it; build the access as
8174      `this$<n>.<field>'. Note that we will break the `private' barrier
8175      if we're not emitting bytecodes. */
8176   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8177       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8178     {
8179       tree thisn = build_current_thisn (current_class);
8180       access = make_qualified_primary (build_wfl_node (thisn),
8181                                        id, EXPR_WFL_LINECOL (id));
8182     }
8183   /* Otherwise, generate access methods to outer this and access the
8184      field (either using an access method or by direct access.) */
8185   else
8186     {
8187       int lc = EXPR_WFL_LINECOL (id);
8188
8189       /* Now we chain the required number of calls to the access$0 to
8190          get a hold to the enclosing instance we need, and then we
8191          build the field access. */
8192       access = build_access_to_thisn (current_class, decl_ctx, lc);
8193
8194       /* If the field is private and we're generating bytecode, then
8195          we generate an access method */
8196       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8197         {
8198           tree name = build_outer_field_access_methods (decl);
8199           access = build_outer_field_access_expr (lc, decl_ctx,
8200                                                   name, access, NULL_TREE);
8201         }
8202       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8203          Once again we break the `private' access rule from a foreign
8204          class. */
8205       else
8206         access = make_qualified_primary (access, id, lc);
8207     }
8208   return resolve_expression_name (access, NULL);
8209 }
8210
8211 /* Return a non zero value if NODE describes an outer field inner
8212    access.  */
8213
8214 static int
8215 outer_field_access_p (type, decl)
8216     tree type, decl;
8217 {
8218   if (!INNER_CLASS_TYPE_P (type)
8219       || TREE_CODE (decl) != FIELD_DECL
8220       || DECL_CONTEXT (decl) == type)
8221     return 0;
8222
8223   /* If the inner class extends the declaration context of the field
8224      we're try to acces, then this isn't an outer field access */
8225   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8226     return 0;
8227
8228   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8229        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8230     {
8231       if (type == DECL_CONTEXT (decl))
8232         return 1;
8233
8234       if (!DECL_CONTEXT (TYPE_NAME (type)))
8235         {
8236           /* Before we give up, see whether the field is inherited from
8237              the enclosing context we're considering. */
8238           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8239             return 1;
8240           break;
8241         }
8242     }
8243
8244   return 0;
8245 }
8246
8247 /* Return a non zero value if NODE represents an outer field inner
8248    access that was been already expanded. As a side effect, it returns
8249    the name of the field being accessed and the argument passed to the
8250    access function, suitable for a regeneration of the access method
8251    call if necessary. */
8252
8253 static int
8254 outer_field_expanded_access_p (node, name, arg_type, arg)
8255     tree node, *name, *arg_type, *arg;
8256 {
8257   int identified = 0;
8258
8259   if (TREE_CODE (node) != CALL_EXPR)
8260     return 0;
8261
8262   /* Well, gcj generates slightly different tree nodes when compiling
8263      to native or bytecodes. It's the case for function calls. */
8264
8265   if (flag_emit_class_files
8266       && TREE_CODE (node) == CALL_EXPR
8267       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8268     identified = 1;
8269   else if (!flag_emit_class_files)
8270     {
8271       node = TREE_OPERAND (node, 0);
8272
8273       if (node && TREE_OPERAND (node, 0)
8274           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8275         {
8276           node = TREE_OPERAND (node, 0);
8277           if (TREE_OPERAND (node, 0)
8278               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8279               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8280                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8281             identified = 1;
8282         }
8283     }
8284
8285   if (identified && name && arg_type && arg)
8286     {
8287       tree argument = TREE_OPERAND (node, 1);
8288       *name = DECL_NAME (TREE_OPERAND (node, 0));
8289       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8290       *arg = TREE_VALUE (argument);
8291     }
8292   return identified;
8293 }
8294
8295 /* Detect in NODE an outer field read access from an inner class and
8296    transform it into a write with RHS as an argument. This function is
8297    called from the java_complete_lhs when an assignment to a LHS can
8298    be identified. */
8299
8300 static tree
8301 outer_field_access_fix (wfl, node, rhs)
8302     tree wfl, node, rhs;
8303 {
8304   tree name, arg_type, arg;
8305
8306   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8307     {
8308       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8309                                             arg_type, name, arg, rhs);
8310       return java_complete_tree (node);
8311     }
8312   return NULL_TREE;
8313 }
8314
8315 /* Construct the expression that calls an access method:
8316      <type>.access$<n>(<arg1> [, <arg2>]);
8317
8318    ARG2 can be NULL and will be omitted in that case. It will denote a
8319    read access.  */
8320
8321 static tree
8322 build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
8323     int lc;
8324     tree type, access_method_name, arg1, arg2;
8325 {
8326   tree args, cn, access;
8327
8328   args = arg1 ? arg1 :
8329     build_wfl_node (build_current_thisn (current_class));
8330   args = build_tree_list (NULL_TREE, args);
8331
8332   if (arg2)
8333     args = tree_cons (NULL_TREE, arg2, args);
8334
8335   access = build_method_invocation (build_wfl_node (access_method_name), args);
8336   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8337   return make_qualified_primary (cn, access, lc);
8338 }
8339
8340 static tree
8341 build_new_access_id ()
8342 {
8343   static int access_n_counter = 1;
8344   char buffer [128];
8345
8346   sprintf (buffer, "access$%d", access_n_counter++);
8347   return get_identifier (buffer);
8348 }
8349
8350 /* Create the static access functions for the outer field DECL. We define a
8351    read:
8352      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8353        return inst$.field;
8354      }
8355    and a write access:
8356      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8357                                      TREE_TYPE (<field>) value$) {
8358        return inst$.field = value$;
8359      }
8360    We should have a usage flags on the DECL so we can lazily turn the ones
8361    we're using for code generation. FIXME.
8362 */
8363
8364 static tree
8365 build_outer_field_access_methods (decl)
8366     tree decl;
8367 {
8368   tree id, args, stmt, mdecl;
8369
8370   if (FIELD_INNER_ACCESS_P (decl))
8371     return FIELD_INNER_ACCESS (decl);
8372
8373   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8374
8375   /* Create the identifier and a function named after it. */
8376   id = build_new_access_id ();
8377
8378   /* The identifier is marked as bearing the name of a generated write
8379      access function for outer field accessed from inner classes. */
8380   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8381
8382   /* Create the read access */
8383   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8384   TREE_CHAIN (args) = end_params_node;
8385   stmt = make_qualified_primary (build_wfl_node (inst_id),
8386                                  build_wfl_node (DECL_NAME (decl)), 0);
8387   stmt = build_return (0, stmt);
8388   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8389                                            TREE_TYPE (decl), id, args, stmt);
8390   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8391
8392   /* Create the write access method. No write access for final variable */
8393   if (!FIELD_FINAL (decl))
8394     {
8395       args = build_tree_list (inst_id,
8396                               build_pointer_type (DECL_CONTEXT (decl)));
8397       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8398       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8399       stmt = make_qualified_primary (build_wfl_node (inst_id),
8400                                      build_wfl_node (DECL_NAME (decl)), 0);
8401       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8402                                                 build_wfl_node (wpv_id)));
8403       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8404                                                TREE_TYPE (decl), id,
8405                                                args, stmt);
8406     }
8407   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8408
8409   /* Return the access name */
8410   return FIELD_INNER_ACCESS (decl) = id;
8411 }
8412
8413 /* Build an field access method NAME.  */
8414
8415 static tree
8416 build_outer_field_access_method (class, type, name, args, body)
8417     tree class, type, name, args, body;
8418 {
8419   tree saved_current_function_decl, mdecl;
8420
8421   /* Create the method */
8422   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8423   fix_method_argument_names (args, mdecl);
8424   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8425
8426   /* Attach the method body. */
8427   saved_current_function_decl = current_function_decl;
8428   start_artificial_method_body (mdecl);
8429   java_method_add_stmt (mdecl, body);
8430   end_artificial_method_body (mdecl);
8431   current_function_decl = saved_current_function_decl;
8432
8433   return mdecl;
8434 }
8435
8436 \f
8437 /* This section deals with building access function necessary for
8438    certain kinds of method invocation from inner classes.  */
8439
8440 static tree
8441 build_outer_method_access_method (decl)
8442     tree decl;
8443 {
8444   tree saved_current_function_decl, mdecl;
8445   tree args = NULL_TREE, call_args = NULL_TREE;
8446   tree carg, id, body, class;
8447   char buffer [80];
8448   int parm_id_count = 0;
8449
8450   /* Test this abort with an access to a private field */
8451   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8452     abort ();
8453
8454   /* Check the cache first */
8455   if (DECL_FUNCTION_INNER_ACCESS (decl))
8456     return DECL_FUNCTION_INNER_ACCESS (decl);
8457
8458   class = DECL_CONTEXT (decl);
8459
8460   /* Obtain an access identifier and mark it */
8461   id = build_new_access_id ();
8462   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8463
8464   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8465   /* Create the arguments, as much as the original */
8466   for (; carg && carg != end_params_node;
8467        carg = TREE_CHAIN (carg))
8468     {
8469       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8470       args = chainon (args, build_tree_list (get_identifier (buffer),
8471                                              TREE_VALUE (carg)));
8472     }
8473   args = chainon (args, end_params_node);
8474
8475   /* Create the method */
8476   mdecl = create_artificial_method (class, ACC_STATIC,
8477                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8478   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8479   /* There is a potential bug here. We should be able to use
8480      fix_method_argument_names, but then arg names get mixed up and
8481      eventually a constructor will have its this$0 altered and the
8482      outer context won't be assignment properly. The test case is
8483      stub.java FIXME */
8484   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8485
8486   /* Attach the method body. */
8487   saved_current_function_decl = current_function_decl;
8488   start_artificial_method_body (mdecl);
8489
8490   /* The actual method invocation uses the same args. When invoking a
8491      static methods that way, we don't want to skip the first
8492      argument. */
8493   carg = args;
8494   if (!METHOD_STATIC (decl))
8495     carg = TREE_CHAIN (carg);
8496   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8497     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8498                            call_args);
8499
8500   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8501                                   call_args);
8502   if (!METHOD_STATIC (decl))
8503     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8504                                    body, 0);
8505   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8506     body = build_return (0, body);
8507   java_method_add_stmt (mdecl,body);
8508   end_artificial_method_body (mdecl);
8509   current_function_decl = saved_current_function_decl;
8510
8511   /* Back tag the access function so it know what it accesses */
8512   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8513
8514   /* Tag the current method so it knows it has an access generated */
8515   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8516 }
8517
8518 \f
8519 /* This section of the code deals with building expressions to access
8520    the enclosing instance of an inner class. The enclosing instance is
8521    kept in a generated field called this$<n>, with <n> being the
8522    inner class nesting level (starting from 0.)  */
8523
8524 /* Build an access to a given this$<n>, always chaining access call to
8525    others. Access methods to this$<n> are build on the fly if
8526    necessary. This CAN'T be used to solely access this$<n-1> from
8527    this$<n> (which alway yield to special cases and optimization, see
8528    for example build_outer_field_access).  */
8529
8530 static tree
8531 build_access_to_thisn (from, to, lc)
8532      tree from, to;
8533      int lc;
8534 {
8535   tree access = NULL_TREE;
8536
8537   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8538     {
8539       if (!access)
8540         {
8541           access = build_current_thisn (from);
8542           access = build_wfl_node (access);
8543         }
8544       else
8545         {
8546           tree access0_wfl, cn;
8547
8548           maybe_build_thisn_access_method (from);
8549           access0_wfl = build_wfl_node (access0_identifier_node);
8550           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8551           EXPR_WFL_LINECOL (access0_wfl) = lc;
8552           access = build_tree_list (NULL_TREE, access);
8553           access = build_method_invocation (access0_wfl, access);
8554           access = make_qualified_primary (cn, access, lc);
8555         }
8556
8557       /* If FROM isn't an inner class, that's fine, we've done enough.
8558          What we're looking for can be accessed from there.  */
8559       from = DECL_CONTEXT (TYPE_NAME (from));
8560       if (!from)
8561         break;
8562       from = TREE_TYPE (from);
8563     }
8564   return access;
8565 }
8566
8567 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8568    is returned if nothing needs to be generated. Otherwise, the method
8569    generated and a method decl is returned.
8570
8571    NOTE: These generated methods should be declared in a class file
8572    attribute so that they can't be referred to directly.  */
8573
8574 static tree
8575 maybe_build_thisn_access_method (type)
8576     tree type;
8577 {
8578   tree mdecl, args, stmt, rtype;
8579   tree saved_current_function_decl;
8580
8581   /* If TYPE is a top-level class, no access method is required.
8582      If there already is such an access method, bail out. */
8583   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8584     return NULL_TREE;
8585
8586   /* We generate the method. The method looks like:
8587      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8588   */
8589   args = build_tree_list (inst_id, build_pointer_type (type));
8590   TREE_CHAIN (args) = end_params_node;
8591   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8592   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8593                                     access0_identifier_node, args);
8594   fix_method_argument_names (args, mdecl);
8595   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8596   stmt = build_current_thisn (type);
8597   stmt = make_qualified_primary (build_wfl_node (inst_id),
8598                                  build_wfl_node (stmt), 0);
8599   stmt = build_return (0, stmt);
8600
8601   saved_current_function_decl = current_function_decl;
8602   start_artificial_method_body (mdecl);
8603   java_method_add_stmt (mdecl, stmt);
8604   end_artificial_method_body (mdecl);
8605   current_function_decl = saved_current_function_decl;
8606
8607   CLASS_ACCESS0_GENERATED_P (type) = 1;
8608
8609   return mdecl;
8610 }
8611
8612 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8613    the first level of innerclassing. this$1 for the next one, etc...
8614    This function can be invoked with TYPE to NULL, available and then
8615    has to count the parser context.  */
8616
8617 static tree
8618 build_current_thisn (type)
8619     tree type;
8620 {
8621   static int saved_i = -1;
8622   static tree saved_thisn = NULL_TREE;
8623   static tree saved_type = NULL_TREE;
8624   static int saved_type_i = 0;
8625   static int initialized_p;
8626   tree decl;
8627   char buffer [24];
8628   int i = 0;
8629
8630   /* Register SAVED_THISN and SAVED_TYPE with the garbage collector.  */
8631   if (!initialized_p)
8632     {
8633       ggc_add_tree_root (&saved_thisn, 1);
8634       ggc_add_tree_root (&saved_type, 1);
8635       initialized_p = 1;
8636     }
8637
8638   if (type)
8639     {
8640       if (type == saved_type)
8641         i = saved_type_i;
8642       else
8643         {
8644           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8645                decl; decl = DECL_CONTEXT (decl), i++)
8646             ;
8647
8648           saved_type = type;
8649           saved_type_i = i;
8650         }
8651     }
8652   else
8653     i = list_length (GET_CPC_LIST ())-2;
8654
8655   if (i == saved_i)
8656     return saved_thisn;
8657
8658   sprintf (buffer, "this$%d", i);
8659   saved_i = i;
8660   saved_thisn = get_identifier (buffer);
8661   return saved_thisn;
8662 }
8663
8664 /* Return the assignement to the hidden enclosing context `this$<n>'
8665    by the second incoming parameter to the innerclass constructor. The
8666    form used is `this.this$<n> = this$<n>;'.  */
8667
8668 static tree
8669 build_thisn_assign ()
8670 {
8671   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8672     {
8673       tree thisn = build_current_thisn (current_class);
8674       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8675                                          build_wfl_node (thisn), 0);
8676       tree rhs = build_wfl_node (thisn);
8677       EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
8678       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8679     }
8680   return NULL_TREE;
8681 }
8682
8683 \f
8684 /* Building the synthetic `class$' used to implement the `.class' 1.1
8685    extension for non primitive types. This method looks like:
8686
8687     static Class class$(String type) throws NoClassDefFoundError
8688     {
8689       try {return (java.lang.Class.forName (String));}
8690       catch (ClassNotFoundException e) {
8691         throw new NoClassDefFoundError(e.getMessage());}
8692     } */
8693
8694 static tree
8695 build_dot_class_method (class)
8696      tree class;
8697 {
8698 #define BWF(S) build_wfl_node (get_identifier ((S)))
8699 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8700   tree args, tmp, saved_current_function_decl, mdecl;
8701   tree stmt, throw_stmt;
8702
8703   static tree get_message_wfl, type_parm_wfl;
8704
8705   if (!get_message_wfl)
8706     {
8707       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8708       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8709       ggc_add_tree_root (&get_message_wfl, 1);
8710       ggc_add_tree_root (&type_parm_wfl, 1);
8711     }
8712
8713   /* Build the arguments */
8714   args = build_tree_list (get_identifier ("type$"),
8715                           build_pointer_type (string_type_node));
8716   TREE_CHAIN (args) = end_params_node;
8717
8718   /* Build the qualified name java.lang.Class.forName */
8719   tmp = MQN (MQN (MQN (BWF ("java"),
8720                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8721   load_class (class_not_found_type_node, 1);
8722   load_class (no_class_def_found_type_node, 1);
8723
8724   /* Create the "class$" function */
8725   mdecl = create_artificial_method (class, ACC_STATIC,
8726                                     build_pointer_type (class_type_node),
8727                                     classdollar_identifier_node, args);
8728   DECL_FUNCTION_THROWS (mdecl) =
8729     build_tree_list (NULL_TREE, no_class_def_found_type_node);
8730
8731   /* We start by building the try block. We need to build:
8732        return (java.lang.Class.forName (type)); */
8733   stmt = build_method_invocation (tmp,
8734                                   build_tree_list (NULL_TREE, type_parm_wfl));
8735   stmt = build_return (0, stmt);
8736
8737   /* Now onto the catch block. We start by building the expression
8738      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8739   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8740                                     get_message_wfl, 0);
8741   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8742
8743   /* Build new NoClassDefFoundError (_.getMessage) */
8744   throw_stmt = build_new_invocation
8745     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8746      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8747
8748   /* Build the throw, (it's too early to use BUILD_THROW) */
8749   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8750
8751   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8752   stmt = encapsulate_with_try_catch (0, class_not_found_type_node,
8753                                      stmt, throw_stmt);
8754
8755   fix_method_argument_names (args, mdecl);
8756   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8757   saved_current_function_decl = current_function_decl;
8758   start_artificial_method_body (mdecl);
8759   java_method_add_stmt (mdecl, stmt);
8760   end_artificial_method_body (mdecl);
8761   current_function_decl = saved_current_function_decl;
8762   TYPE_DOT_CLASS (class) = mdecl;
8763
8764   return mdecl;
8765 }
8766
8767 static tree
8768 build_dot_class_method_invocation (type)
8769      tree type;
8770 {
8771   tree sig_id, s;
8772
8773   if (TYPE_ARRAY_P (type))
8774     sig_id = build_java_signature (type);
8775   else
8776     sig_id = DECL_NAME (TYPE_NAME (type));
8777
8778   /* Ensure that the proper name separator is used */
8779   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8780                                IDENTIFIER_LENGTH (sig_id));
8781
8782   s = build_string (IDENTIFIER_LENGTH (sig_id),
8783                     IDENTIFIER_POINTER (sig_id));
8784   return build_method_invocation (build_wfl_node (classdollar_identifier_node),
8785                                   build_tree_list (NULL_TREE, s));
8786 }
8787
8788 /* This section of the code deals with constructor.  */
8789
8790 /* Craft a body for default constructor. Patch existing constructor
8791    bodies with call to super() and field initialization statements if
8792    necessary.  */
8793
8794 static void
8795 fix_constructors (mdecl)
8796      tree mdecl;
8797 {
8798   tree iii;                     /* Instance Initializer Invocation */
8799   tree body = DECL_FUNCTION_BODY (mdecl);
8800   tree thisn_assign, compound = NULL_TREE;
8801   tree class_type = DECL_CONTEXT (mdecl);
8802
8803   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8804     return;
8805   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8806
8807   if (!body)
8808     {
8809       /* It is an error for the compiler to generate a default
8810          constructor if the superclass doesn't have a constructor that
8811          takes no argument, or the same args for an anonymous class */
8812       if (verify_constructor_super (mdecl))
8813         {
8814           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8815           tree save = DECL_NAME (mdecl);
8816           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8817           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8818           parse_error_context
8819             (lookup_cl (TYPE_NAME (class_type)),
8820              "No constructor matching `%s' found in class `%s'",
8821              lang_printable_name (mdecl, 0), n);
8822           DECL_NAME (mdecl) = save;
8823         }
8824
8825       /* The constructor body must be crafted by hand. It's the
8826          constructor we defined when we realize we didn't have the
8827          CLASSNAME() constructor */
8828       start_artificial_method_body (mdecl);
8829
8830       /* Insert an assignment to the this$<n> hidden field, if
8831          necessary */
8832       if ((thisn_assign = build_thisn_assign ()))
8833         java_method_add_stmt (mdecl, thisn_assign);
8834
8835       /* We don't generate a super constructor invocation if we're
8836          compiling java.lang.Object. build_super_invocation takes care
8837          of that. */
8838       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8839
8840       /* FIXME */
8841       if ((iii = build_instinit_invocation (class_type)))
8842         java_method_add_stmt (mdecl, iii);
8843
8844       end_artificial_method_body (mdecl);
8845     }
8846   /* Search for an explicit constructor invocation */
8847   else
8848     {
8849       int found = 0;
8850       int invokes_this = 0;
8851       tree found_call = NULL_TREE;
8852       tree main_block = BLOCK_EXPR_BODY (body);
8853
8854       while (body)
8855         switch (TREE_CODE (body))
8856           {
8857           case CALL_EXPR:
8858             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8859             if (CALL_THIS_CONSTRUCTOR_P (body))
8860               invokes_this = 1;
8861             body = NULL_TREE;
8862             break;
8863           case COMPOUND_EXPR:
8864           case EXPR_WITH_FILE_LOCATION:
8865             found_call = body;
8866             body = TREE_OPERAND (body, 0);
8867             break;
8868           case BLOCK:
8869             found_call = body;
8870             body = BLOCK_EXPR_BODY (body);
8871             break;
8872           default:
8873             found = 0;
8874             body = NULL_TREE;
8875           }
8876
8877       /* Generate the assignment to this$<n>, if necessary */
8878       if ((thisn_assign = build_thisn_assign ()))
8879         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8880
8881       /* The constructor is missing an invocation of super() */
8882       if (!found)
8883         compound = add_stmt_to_compound (compound, NULL_TREE,
8884                                          build_super_invocation (mdecl));
8885       /* Explicit super() invokation should take place before the
8886          instance initializer blocks. */
8887       else
8888         {
8889           compound = add_stmt_to_compound (compound, NULL_TREE,
8890                                            TREE_OPERAND (found_call, 0));
8891           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8892         }
8893
8894       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8895
8896       /* Insert the instance initializer block right after. */
8897       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8898         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8899
8900       /* Fix the constructor main block if we're adding extra stmts */
8901       if (compound)
8902         {
8903           compound = add_stmt_to_compound (compound, NULL_TREE,
8904                                            BLOCK_EXPR_BODY (main_block));
8905           BLOCK_EXPR_BODY (main_block) = compound;
8906         }
8907     }
8908 }
8909
8910 /* Browse constructors in the super class, searching for a constructor
8911    that doesn't take any argument. Return 0 if one is found, 1
8912    otherwise.  If the current class is an anonymous inner class, look
8913    for something that has the same signature. */
8914
8915 static int
8916 verify_constructor_super (mdecl)
8917      tree mdecl;
8918 {
8919   tree class = CLASSTYPE_SUPER (current_class);
8920   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8921   tree sdecl;
8922
8923   if (!class)
8924     return 0;
8925
8926   if (ANONYMOUS_CLASS_P (current_class))
8927     {
8928       tree mdecl_arg_type;
8929       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8930       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8931         if (DECL_CONSTRUCTOR_P (sdecl))
8932           {
8933             tree m_arg_type;
8934             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8935             if (super_inner)
8936               arg_type = TREE_CHAIN (arg_type);
8937             for (m_arg_type = mdecl_arg_type;
8938                  (arg_type != end_params_node
8939                   && m_arg_type != end_params_node);
8940                  arg_type = TREE_CHAIN (arg_type),
8941                    m_arg_type = TREE_CHAIN (m_arg_type))
8942               if (!valid_method_invocation_conversion_p
8943                      (TREE_VALUE (arg_type),
8944                       TREE_VALUE (m_arg_type)))
8945                 break;
8946
8947             if (arg_type == end_params_node && m_arg_type == end_params_node)
8948               return 0;
8949           }
8950     }
8951   else
8952     {
8953       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8954         {
8955           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8956           if (super_inner)
8957             arg = TREE_CHAIN (arg);
8958           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8959             return 0;
8960         }
8961     }
8962   return 1;
8963 }
8964
8965 /* Generate code for all context remembered for code generation.  */
8966
8967 void
8968 java_expand_classes ()
8969 {
8970   int save_error_count = 0;
8971   static struct parser_ctxt *cur_ctxp = NULL;
8972
8973   java_parse_abort_on_error ();
8974   if (!(ctxp = ctxp_for_generation))
8975     return;
8976   java_layout_classes ();
8977   java_parse_abort_on_error ();
8978
8979   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8980     {
8981       ctxp = cur_ctxp;
8982       input_filename = ctxp->filename;
8983       lang_init_source (2);            /* Error msgs have method prototypes */
8984       java_complete_expand_classes (); /* Complete and expand classes */
8985       java_parse_abort_on_error ();
8986     }
8987   input_filename = main_input_filename;
8988
8989
8990   /* Find anonymous classes and expand their constructor. This extra pass is
8991      neccessary because the constructor itself is only generated when the
8992      method in which it is defined is expanded. */
8993   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8994     {
8995       tree current;
8996       ctxp = cur_ctxp;
8997       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8998         {
8999           current_class = TREE_TYPE (current);
9000           if (ANONYMOUS_CLASS_P (current_class))
9001             {
9002               tree d;
9003               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9004                 {
9005                   if (DECL_CONSTRUCTOR_P (d))
9006                     {
9007                       restore_line_number_status (1);
9008                       java_complete_expand_method (d);
9009                       restore_line_number_status (0);
9010                       break;    /* There is only one constructor. */
9011                     }
9012                 }
9013             }
9014         }
9015     }
9016
9017   /* If we've found error at that stage, don't try to generate
9018      anything, unless we're emitting xrefs or checking the syntax only
9019      (but not using -fsyntax-only for the purpose of generating
9020      bytecode. */
9021   if (java_error_count && !flag_emit_xref
9022       && (!flag_syntax_only && !flag_emit_class_files))
9023     return;
9024
9025   /* Now things are stable, go for generation of the class data. */
9026
9027   /* We pessimistically marked all fields external until we knew
9028      what set of classes we were planning to compile.  Now mark
9029      those that will be generated locally as not external.  */
9030   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9031     {
9032       tree current;
9033       ctxp = cur_ctxp;
9034       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9035         {
9036           tree class = TREE_TYPE (current);
9037           tree field;
9038           for (field = TYPE_FIELDS (class); field ; field = TREE_CHAIN (field))
9039             if (FIELD_STATIC (field))
9040               DECL_EXTERNAL (field) = 0;
9041         }
9042     }
9043
9044   /* Compile the classes.  */
9045   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9046     {
9047       tree current;
9048       ctxp = cur_ctxp;
9049       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9050         {
9051           current_class = TREE_TYPE (current);
9052           outgoing_cpool = TYPE_CPOOL (current_class);
9053           if (flag_emit_class_files)
9054             write_classfile (current_class);
9055           if (flag_emit_xref)
9056             expand_xref (current_class);
9057           else if (! flag_syntax_only)
9058             {
9059               java_expand_method_bodies (current_class);
9060               finish_class ();
9061             }
9062         }
9063     }
9064 }
9065
9066 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9067    a tree list node containing RIGHT. Fore coming RIGHTs will be
9068    chained to this hook. LOCATION contains the location of the
9069    separating `.' operator.  */
9070
9071 static tree
9072 make_qualified_primary (primary, right, location)
9073      tree primary, right;
9074      int location;
9075 {
9076   tree wfl;
9077
9078   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9079     wfl = build_wfl_wrap (primary, location);
9080   else
9081     {
9082       wfl = primary;
9083       /* If wfl wasn't qualified, we build a first anchor */
9084       if (!EXPR_WFL_QUALIFICATION (wfl))
9085         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9086     }
9087
9088   /* And chain them */
9089   EXPR_WFL_LINECOL (right) = location;
9090   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9091   PRIMARY_P (wfl) =  1;
9092   return wfl;
9093 }
9094
9095 /* Simple merge of two name separated by a `.' */
9096
9097 static tree
9098 merge_qualified_name (left, right)
9099      tree left, right;
9100 {
9101   tree node;
9102   if (!left && !right)
9103     return NULL_TREE;
9104
9105   if (!left)
9106     return right;
9107
9108   if (!right)
9109     return left;
9110
9111   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9112                 IDENTIFIER_LENGTH (left));
9113   obstack_1grow (&temporary_obstack, '.');
9114   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9115                  IDENTIFIER_LENGTH (right));
9116   node =  get_identifier (obstack_base (&temporary_obstack));
9117   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9118   QUALIFIED_P (node) = 1;
9119   return node;
9120 }
9121
9122 /* Merge the two parts of a qualified name into LEFT.  Set the
9123    location information of the resulting node to LOCATION, usually
9124    inherited from the location information of the `.' operator. */
9125
9126 static tree
9127 make_qualified_name (left, right, location)
9128      tree left, right;
9129      int location;
9130 {
9131 #ifdef USE_COMPONENT_REF
9132   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9133   EXPR_WFL_LINECOL (node) = location;
9134   return node;
9135 #else
9136   tree left_id = EXPR_WFL_NODE (left);
9137   tree right_id = EXPR_WFL_NODE (right);
9138   tree wfl, merge;
9139
9140   merge = merge_qualified_name (left_id, right_id);
9141
9142   /* Left wasn't qualified and is now qualified */
9143   if (!QUALIFIED_P (left_id))
9144     {
9145       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9146       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9147       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9148     }
9149
9150   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9151   EXPR_WFL_LINECOL (wfl) = location;
9152   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9153
9154   EXPR_WFL_NODE (left) = merge;
9155   return left;
9156 #endif
9157 }
9158
9159 /* Extract the last identifier component of the qualified in WFL. The
9160    last identifier is removed from the linked list */
9161
9162 static tree
9163 cut_identifier_in_qualified (wfl)
9164      tree wfl;
9165 {
9166   tree q;
9167   tree previous = NULL_TREE;
9168   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9169     if (!TREE_CHAIN (q))
9170       {
9171         if (!previous)
9172           /* Operating on a non qualified qualified WFL.  */
9173           abort ();
9174
9175         TREE_CHAIN (previous) = NULL_TREE;
9176         return TREE_PURPOSE (q);
9177       }
9178 }
9179
9180 /* Resolve the expression name NAME. Return its decl.  */
9181
9182 static tree
9183 resolve_expression_name (id, orig)
9184      tree id;
9185      tree *orig;
9186 {
9187   tree name = EXPR_WFL_NODE (id);
9188   tree decl;
9189
9190   /* 6.5.5.1: Simple expression names */
9191   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9192     {
9193       /* 15.13.1: NAME can appear within the scope of a local variable
9194          declaration */
9195       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9196         return decl;
9197
9198       /* 15.13.1: NAME can appear within a class declaration */
9199       else
9200         {
9201           decl = lookup_field_wrapper (current_class, name);
9202           if (decl)
9203             {
9204               tree access = NULL_TREE;
9205               int fs = FIELD_STATIC (decl);
9206
9207               /* If we're accessing an outer scope local alias, make
9208                  sure we change the name of the field we're going to
9209                  build access to. */
9210               if (FIELD_LOCAL_ALIAS_USED (decl))
9211                 name = DECL_NAME (decl);
9212
9213               /* Instance variable (8.3.1.1) can't appear within
9214                  static method, static initializer or initializer for
9215                  a static variable. */
9216               if (!fs && METHOD_STATIC (current_function_decl))
9217                 {
9218                   static_ref_err (id, name, current_class);
9219                   return error_mark_node;
9220                 }
9221               /* Instance variables can't appear as an argument of
9222                  an explicit constructor invocation */
9223               if (!fs && ctxp->explicit_constructor_p
9224                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9225                 {
9226                   parse_error_context
9227                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9228                   return error_mark_node;
9229                 }
9230
9231               /* If we're processing an inner class and we're trying
9232                  to access a field belonging to an outer class, build
9233                  the access to the field */
9234               if (!fs && outer_field_access_p (current_class, decl))
9235                 {
9236                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9237                     {
9238                       static_ref_err (id, DECL_NAME (decl), current_class);
9239                       return error_mark_node;
9240                     }
9241                   access = build_outer_field_access (id, decl);
9242                   if (orig)
9243                     *orig = access;
9244                   return access;
9245                 }
9246
9247               /* Otherwise build what it takes to access the field */
9248               access = build_field_ref ((fs ? NULL_TREE : current_this),
9249                                         DECL_CONTEXT (decl), name);
9250               if (fs)
9251                 access = maybe_build_class_init_for_field (decl, access);
9252               /* We may be asked to save the real field access node */
9253               if (orig)
9254                 *orig = access;
9255               /* And we return what we got */
9256               return access;
9257             }
9258           /* Fall down to error report on undefined variable */
9259         }
9260     }
9261   /* 6.5.5.2 Qualified Expression Names */
9262   else
9263     {
9264       if (orig)
9265         *orig = NULL_TREE;
9266       qualify_ambiguous_name (id);
9267       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9268       /* 15.10.2: Accessing Superclass Members using super */
9269       return resolve_field_access (id, orig, NULL);
9270     }
9271
9272   /* We've got an error here */
9273   if (INNER_CLASS_TYPE_P (current_class))
9274     parse_error_context (id,
9275                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9276                          IDENTIFIER_POINTER (name),
9277                          IDENTIFIER_POINTER (DECL_NAME
9278                                              (TYPE_NAME (current_class))));
9279   else
9280     parse_error_context (id, "Undefined variable `%s'",
9281                          IDENTIFIER_POINTER (name));
9282
9283   return error_mark_node;
9284 }
9285
9286 static void
9287 static_ref_err (wfl, field_id, class_type)
9288     tree wfl, field_id, class_type;
9289 {
9290   parse_error_context
9291     (wfl,
9292      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9293      IDENTIFIER_POINTER (field_id),
9294      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9295 }
9296
9297 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9298    We return something suitable to generate the field access. We also
9299    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9300    recipient's address can be null. */
9301
9302 static tree
9303 resolve_field_access (qual_wfl, field_decl, field_type)
9304      tree qual_wfl;
9305      tree *field_decl, *field_type;
9306 {
9307   int is_static = 0;
9308   tree field_ref;
9309   tree decl, where_found, type_found;
9310
9311   if (resolve_qualified_expression_name (qual_wfl, &decl,
9312                                          &where_found, &type_found))
9313     return error_mark_node;
9314
9315   /* Resolve the LENGTH field of an array here */
9316   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9317       && type_found && TYPE_ARRAY_P (type_found)
9318       && ! flag_emit_class_files && ! flag_emit_xref)
9319     {
9320       tree length = build_java_array_length_access (where_found);
9321       field_ref = length;
9322
9323       /* In case we're dealing with a static array, we need to
9324          initialize its class before the array length can be fetched.
9325          It's also a good time to create a DECL_RTL for the field if
9326          none already exists, otherwise if the field was declared in a
9327          class found in an external file and hasn't been (and won't
9328          be) accessed for its value, none will be created. */
9329       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9330         {
9331           build_static_field_ref (where_found);
9332           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9333         }
9334     }
9335   /* We might have been trying to resolve field.method(). In which
9336      case, the resolution is over and decl is the answer */
9337   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9338     field_ref = decl;
9339   else if (JDECL_P (decl))
9340     {
9341       if (!type_found)
9342         type_found = DECL_CONTEXT (decl);
9343       is_static = FIELD_STATIC (decl);
9344       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9345                                     NULL_TREE : where_found),
9346                                    type_found, DECL_NAME (decl));
9347       if (field_ref == error_mark_node)
9348         return error_mark_node;
9349       if (is_static)
9350         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9351     }
9352   else
9353     field_ref = decl;
9354
9355   if (field_decl)
9356     *field_decl = decl;
9357   if (field_type)
9358     *field_type = (QUAL_DECL_TYPE (decl) ?
9359                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9360   return field_ref;
9361 }
9362
9363 /* If NODE is an access to f static field, strip out the class
9364    initialization part and return the field decl, otherwise, return
9365    NODE. */
9366
9367 static tree
9368 strip_out_static_field_access_decl (node)
9369     tree node;
9370 {
9371   if (TREE_CODE (node) == COMPOUND_EXPR)
9372     {
9373       tree op1 = TREE_OPERAND (node, 1);
9374       if (TREE_CODE (op1) == COMPOUND_EXPR)
9375          {
9376            tree call = TREE_OPERAND (op1, 0);
9377            if (TREE_CODE (call) == CALL_EXPR
9378                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9379                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9380                == soft_initclass_node)
9381              return TREE_OPERAND (op1, 1);
9382          }
9383       else if (JDECL_P (op1))
9384         return op1;
9385     }
9386   return node;
9387 }
9388
9389 /* 6.5.5.2: Qualified Expression Names */
9390
9391 static int
9392 resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
9393      tree wfl;
9394      tree *found_decl, *type_found, *where_found;
9395 {
9396   int from_type = 0;            /* Field search initiated from a type */
9397   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9398   int previous_call_static = 0;
9399   int is_static;
9400   tree decl = NULL_TREE, type = NULL_TREE, q;
9401   /* For certain for of inner class instantiation */
9402   tree saved_current, saved_this;
9403 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9404   { current_class = saved_current; current_this = saved_this;}
9405
9406   *type_found = *where_found = NULL_TREE;
9407
9408   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9409     {
9410       tree qual_wfl = QUAL_WFL (q);
9411       tree ret_decl;            /* for EH checking */
9412       int location;             /* for EH checking */
9413
9414       /* 15.10.1 Field Access Using a Primary */
9415       switch (TREE_CODE (qual_wfl))
9416         {
9417         case CALL_EXPR:
9418         case NEW_CLASS_EXPR:
9419           /* If the access to the function call is a non static field,
9420              build the code to access it. */
9421           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9422             {
9423               decl = maybe_access_field (decl, *where_found,
9424                                          DECL_CONTEXT (decl));
9425               if (decl == error_mark_node)
9426                 return 1;
9427             }
9428
9429           /* And code for the function call */
9430           if (complete_function_arguments (qual_wfl))
9431             return 1;
9432
9433           /* We might have to setup a new current class and a new this
9434              for the search of an inner class, relative to the type of
9435              a expression resolved as `decl'. The current values are
9436              saved and restored shortly after */
9437           saved_current = current_class;
9438           saved_this = current_this;
9439           if (decl
9440               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9441                   || from_qualified_this))
9442             {
9443               /* If we still have `from_qualified_this', we have the form
9444                  <T>.this.f() and we need to build <T>.this */
9445               if (from_qualified_this)
9446                 {
9447                   decl = build_access_to_thisn (current_class, type, 0);
9448                   decl = java_complete_tree (decl);
9449                   type = TREE_TYPE (TREE_TYPE (decl));
9450                 }
9451               current_class = type;
9452               current_this = decl;
9453               from_qualified_this = 0;
9454             }
9455
9456           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9457             CALL_USING_SUPER (qual_wfl) = 1;
9458           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9459                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9460           *where_found = patch_method_invocation (qual_wfl, decl, type,
9461                                                   from_super,
9462                                                   &is_static, &ret_decl);
9463           if (*where_found == error_mark_node)
9464             {
9465               RESTORE_THIS_AND_CURRENT_CLASS;
9466               return 1;
9467             }
9468           *type_found = type = QUAL_DECL_TYPE (*where_found);
9469
9470           /* If we're creating an inner class instance, check for that
9471              an enclosing instance is in scope */
9472           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9473               && INNER_ENCLOSING_SCOPE_CHECK (type))
9474             {
9475               parse_error_context
9476                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9477                  lang_printable_name (type, 0),
9478                  (!current_this ? "" :
9479                   "; an explicit one must be provided when creating this inner class"));
9480               RESTORE_THIS_AND_CURRENT_CLASS;
9481               return 1;
9482             }
9483
9484           /* In case we had to change then to resolve a inner class
9485              instantiation using a primary qualified by a `new' */
9486           RESTORE_THIS_AND_CURRENT_CLASS;
9487
9488           /* EH check. No check on access$<n> functions */
9489           if (location
9490               && !OUTER_FIELD_ACCESS_IDENTIFIER_P
9491                     (DECL_NAME (current_function_decl)))
9492             check_thrown_exceptions (location, ret_decl);
9493
9494           /* If the previous call was static and this one is too,
9495              build a compound expression to hold the two (because in
9496              that case, previous function calls aren't transported as
9497              forcoming function's argument. */
9498           if (previous_call_static && is_static)
9499             {
9500               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9501                             decl, *where_found);
9502               TREE_SIDE_EFFECTS (decl) = 1;
9503             }
9504           else
9505             {
9506               previous_call_static = is_static;
9507               decl = *where_found;
9508             }
9509           from_type = 0;
9510           continue;
9511
9512         case NEW_ARRAY_EXPR:
9513         case NEW_ANONYMOUS_ARRAY_EXPR:
9514           *where_found = decl = java_complete_tree (qual_wfl);
9515           if (decl == error_mark_node)
9516             return 1;
9517           *type_found = type = QUAL_DECL_TYPE (decl);
9518           continue;
9519
9520         case CONVERT_EXPR:
9521           *where_found = decl = java_complete_tree (qual_wfl);
9522           if (decl == error_mark_node)
9523             return 1;
9524           *type_found = type = QUAL_DECL_TYPE (decl);
9525           from_cast = 1;
9526           continue;
9527
9528         case CONDITIONAL_EXPR:
9529         case STRING_CST:
9530         case MODIFY_EXPR:
9531           *where_found = decl = java_complete_tree (qual_wfl);
9532           if (decl == error_mark_node)
9533             return 1;
9534           *type_found = type = QUAL_DECL_TYPE (decl);
9535           continue;
9536
9537         case ARRAY_REF:
9538           /* If the access to the function call is a non static field,
9539              build the code to access it. */
9540           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9541             {
9542               decl = maybe_access_field (decl, *where_found, type);
9543               if (decl == error_mark_node)
9544                 return 1;
9545             }
9546           /* And code for the array reference expression */
9547           decl = java_complete_tree (qual_wfl);
9548           if (decl == error_mark_node)
9549             return 1;
9550           type = QUAL_DECL_TYPE (decl);
9551           continue;
9552
9553         case PLUS_EXPR:
9554           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9555             return 1;
9556           if ((type = patch_string (decl)))
9557             decl = type;
9558           *where_found = QUAL_RESOLUTION (q) = decl;
9559           *type_found = type = TREE_TYPE (decl);
9560           break;
9561
9562         case CLASS_LITERAL:
9563           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9564             return 1;
9565           *where_found = QUAL_RESOLUTION (q) = decl;
9566           *type_found = type = TREE_TYPE (decl);
9567           break;
9568
9569         default:
9570           /* Fix for -Wall Just go to the next statement. Don't
9571              continue */
9572           break;
9573         }
9574
9575       /* If we fall here, we weren't processing a (static) function call. */
9576       previous_call_static = 0;
9577
9578       /* It can be the keyword THIS */
9579       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9580           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9581         {
9582           if (!current_this)
9583             {
9584               parse_error_context
9585                 (wfl, "Keyword `this' used outside allowed context");
9586               return 1;
9587             }
9588           if (ctxp->explicit_constructor_p
9589               && type == current_class)
9590             {
9591               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9592               return 1;
9593             }
9594           /* We have to generate code for intermediate access */
9595           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9596             {
9597               *where_found = decl = current_this;
9598               *type_found = type = QUAL_DECL_TYPE (decl);
9599             }
9600           /* We're trying to access the this from somewhere else. Make sure
9601              it's allowed before doing so. */
9602           else
9603             {
9604               if (!enclosing_context_p (type, current_class))
9605                 {
9606                   char *p  = xstrdup (lang_printable_name (type, 0));
9607                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9608                                        p, p,
9609                                        lang_printable_name (current_class, 0));
9610                   free (p);
9611                   return 1;
9612                 }
9613               from_qualified_this = 1;
9614               /* If there's nothing else after that, we need to
9615                  produce something now, otherwise, the section of the
9616                  code that needs to produce <T>.this will generate
9617                  what is necessary. */
9618               if (!TREE_CHAIN (q))
9619                 {
9620                   decl = build_access_to_thisn (current_class, type, 0);
9621                   *where_found = decl = java_complete_tree (decl);
9622                   *type_found = type = TREE_TYPE (decl);
9623                 }
9624             }
9625
9626           from_type = 0;
9627           continue;
9628         }
9629
9630       /* 15.10.2 Accessing Superclass Members using SUPER */
9631       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9632           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9633         {
9634           tree node;
9635           /* Check on the restricted use of SUPER */
9636           if (METHOD_STATIC (current_function_decl)
9637               || current_class == object_type_node)
9638             {
9639               parse_error_context
9640                 (wfl, "Keyword `super' used outside allowed context");
9641               return 1;
9642             }
9643           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9644           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9645                              CLASSTYPE_SUPER (current_class),
9646                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9647           *where_found = decl = java_complete_tree (node);
9648           if (decl == error_mark_node)
9649             return 1;
9650           *type_found = type = QUAL_DECL_TYPE (decl);
9651           from_super = from_type = 1;
9652           continue;
9653         }
9654
9655       /* 15.13.1: Can't search for field name in packages, so we
9656          assume a variable/class name was meant. */
9657       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9658         {
9659           tree name;
9660           if ((decl = resolve_package (wfl, &q, &name)))
9661             {
9662               tree list;
9663               *where_found = decl;
9664
9665               /* We want to be absolutely sure that the class is laid
9666                  out. We're going to search something inside it. */
9667               *type_found = type = TREE_TYPE (decl);
9668               layout_class (type);
9669               from_type = 1;
9670
9671               /* Fix them all the way down, if any are left. */
9672               if (q)
9673                 {
9674                   list = TREE_CHAIN (q);
9675                   while (list)
9676                     {
9677                       RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9678                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9679                       list = TREE_CHAIN (list);
9680                     }
9681                 }
9682             }
9683           else
9684             {
9685               if (from_super || from_cast)
9686                 parse_error_context
9687                   ((from_cast ? qual_wfl : wfl),
9688                    "No variable `%s' defined in class `%s'",
9689                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9690                    lang_printable_name (type, 0));
9691               else
9692                 parse_error_context
9693                   (qual_wfl, "Undefined variable or class name: `%s'",
9694                    IDENTIFIER_POINTER (name));
9695               return 1;
9696             }
9697         }
9698
9699       /* We have a type name. It's been already resolved when the
9700          expression was qualified. */
9701       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9702         {
9703           decl = QUAL_RESOLUTION (q);
9704
9705           /* Sneak preview. If next we see a `new', we're facing a
9706              qualification with resulted in a type being selected
9707              instead of a field.  Report the error */
9708           if(TREE_CHAIN (q)
9709              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9710             {
9711               parse_error_context (qual_wfl, "Undefined variable `%s'",
9712                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9713               return 1;
9714             }
9715
9716           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9717             {
9718               parse_error_context
9719                 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
9720                  java_accstring_lookup (get_access_flags_from_decl (decl)),
9721                  GET_TYPE_NAME (type),
9722                  IDENTIFIER_POINTER (DECL_NAME (decl)),
9723                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9724               return 1;
9725             }
9726           check_deprecation (qual_wfl, decl);
9727
9728           type = TREE_TYPE (decl);
9729           from_type = 1;
9730         }
9731       /* We resolve an expression name */
9732       else
9733         {
9734           tree field_decl = NULL_TREE;
9735
9736           /* If there exists an early resolution, use it. That occurs
9737              only once and we know that there are more things to
9738              come. Don't do that when processing something after SUPER
9739              (we need more thing to be put in place below */
9740           if (!from_super && QUAL_RESOLUTION (q))
9741             {
9742               decl = QUAL_RESOLUTION (q);
9743               if (!type)
9744                 {
9745                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9746                     {
9747                       if (current_this)
9748                         *where_found = current_this;
9749                       else
9750                         {
9751                           static_ref_err (qual_wfl, DECL_NAME (decl),
9752                                           current_class);
9753                           return 1;
9754                         }
9755                       if (outer_field_access_p (current_class, decl))
9756                         decl = build_outer_field_access (qual_wfl, decl);
9757                     }
9758                   else
9759                     {
9760                       *where_found = TREE_TYPE (decl);
9761                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9762                         *where_found = TREE_TYPE (*where_found);
9763                     }
9764                 }
9765             }
9766
9767           /* Report and error if we're using a numerical litteral as a
9768              qualifier. It can only be an INTEGER_CST. */
9769           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9770             {
9771               parse_error_context
9772                 (wfl, "Can't use type `%s' as a qualifier",
9773                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9774               return 1;
9775             }
9776
9777           /* We have to search for a field, knowing the type of its
9778              container. The flag FROM_TYPE indicates that we resolved
9779              the last member of the expression as a type name, which
9780              means that for the resolution of this field, we'll look
9781              for other errors than if it was resolved as a member of
9782              an other field. */
9783           else
9784             {
9785               int is_static;
9786               tree field_decl_type; /* For layout */
9787
9788               if (!from_type && !JREFERENCE_TYPE_P (type))
9789                 {
9790                   parse_error_context
9791                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9792                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9793                      lang_printable_name (type, 0),
9794                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9795                   return 1;
9796                 }
9797
9798               field_decl = lookup_field_wrapper (type,
9799                                                  EXPR_WFL_NODE (qual_wfl));
9800
9801               /* Maybe what we're trying to access to is an inner
9802                  class, only if decl is a TYPE_DECL. */
9803               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9804                 {
9805                   tree ptr, inner_decl;
9806
9807                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9808                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9809                   if (inner_decl)
9810                     {
9811                       check_inner_class_access (inner_decl, decl, qual_wfl);
9812                       type = TREE_TYPE (inner_decl);
9813                       decl = inner_decl;
9814                       from_type = 1;
9815                       continue;
9816                     }
9817                 }
9818
9819               if (field_decl == NULL_TREE)
9820                 {
9821                   parse_error_context
9822                     (qual_wfl, "No variable `%s' defined in type `%s'",
9823                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9824                      GET_TYPE_NAME (type));
9825                   return 1;
9826                 }
9827               if (field_decl == error_mark_node)
9828                 return 1;
9829
9830               /* Layout the type of field_decl, since we may need
9831                  it. Don't do primitive types or loaded classes. The
9832                  situation of non primitive arrays may not handled
9833                  properly here. FIXME */
9834               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9835                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9836               else
9837                 field_decl_type = TREE_TYPE (field_decl);
9838               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9839                   && !CLASS_LOADED_P (field_decl_type)
9840                   && !TYPE_ARRAY_P (field_decl_type))
9841                 resolve_and_layout (field_decl_type, NULL_TREE);
9842
9843               /* Check on accessibility here */
9844               if (not_accessible_p (current_class, field_decl,
9845                                     DECL_CONTEXT (field_decl), from_super))
9846                 {
9847                   parse_error_context
9848                     (qual_wfl,
9849                      "Can't access %s field `%s.%s' from `%s'",
9850                      java_accstring_lookup
9851                        (get_access_flags_from_decl (field_decl)),
9852                      GET_TYPE_NAME (type),
9853                      IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9854                      IDENTIFIER_POINTER
9855                        (DECL_NAME (TYPE_NAME (current_class))));
9856                   return 1;
9857                 }
9858               check_deprecation (qual_wfl, field_decl);
9859
9860               /* There are things to check when fields are accessed
9861                  from type. There are no restrictions on a static
9862                  declaration of the field when it is accessed from an
9863                  interface */
9864               is_static = FIELD_STATIC (field_decl);
9865               if (!from_super && from_type
9866                   && !TYPE_INTERFACE_P (type)
9867                   && !is_static
9868                   && (current_function_decl
9869                       && METHOD_STATIC (current_function_decl)))
9870                 {
9871                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9872                   return 1;
9873                 }
9874               from_cast = from_super = 0;
9875
9876               /* It's an access from a type but it isn't static, we
9877                  make it relative to `this'. */
9878               if (!is_static && from_type)
9879                 decl = current_this;
9880
9881               /* If we need to generate something to get a proper
9882                  handle on what this field is accessed from, do it
9883                  now. */
9884               if (!is_static)
9885                 {
9886                   decl = maybe_access_field (decl, *where_found, *type_found);
9887                   if (decl == error_mark_node)
9888                     return 1;
9889                 }
9890
9891               /* We want to keep the location were found it, and the type
9892                  we found. */
9893               *where_found = decl;
9894               *type_found = type;
9895
9896               /* Generate the correct expression for field access from
9897                  qualified this */
9898               if (from_qualified_this)
9899                 {
9900                   field_decl = build_outer_field_access (qual_wfl, field_decl);
9901                   from_qualified_this = 0;
9902                 }
9903
9904               /* This is the decl found and eventually the next one to
9905                  search from */
9906               decl = field_decl;
9907             }
9908           from_type = 0;
9909           type = QUAL_DECL_TYPE (decl);
9910
9911           /* Sneak preview. If decl is qualified by a `new', report
9912              the error here to be accurate on the peculiar construct */
9913           if (TREE_CHAIN (q)
9914               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9915               && !JREFERENCE_TYPE_P (type))
9916             {
9917               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9918                                    lang_printable_name (type, 0));
9919               return 1;
9920             }
9921         }
9922       /* `q' might have changed due to a after package resolution
9923          re-qualification */
9924       if (!q)
9925         break;
9926     }
9927   *found_decl = decl;
9928   return 0;
9929 }
9930
9931 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9932    can't be accessed from REFERENCE (a record type). If MEMBER
9933    features a protected access, we then use WHERE which, if non null,
9934    holds the type of MEMBER's access that is checked against
9935    6.6.2.1. This function should be used when decl is a field or a
9936    method.  */
9937
9938 static int
9939 not_accessible_p (reference, member, where, from_super)
9940      tree reference, member;
9941      tree where;
9942      int from_super;
9943 {
9944   int access_flag = get_access_flags_from_decl (member);
9945
9946   /* Inner classes are processed by check_inner_class_access */
9947   if (INNER_CLASS_TYPE_P (reference))
9948     return 0;
9949
9950   /* Access always granted for members declared public */
9951   if (access_flag & ACC_PUBLIC)
9952     return 0;
9953
9954   /* Check access on protected members */
9955   if (access_flag & ACC_PROTECTED)
9956     {
9957       /* Access granted if it occurs from within the package
9958          containing the class in which the protected member is
9959          declared */
9960       if (class_in_current_package (DECL_CONTEXT (member)))
9961         return 0;
9962
9963       /* If accessed with the form `super.member', then access is granted */
9964       if (from_super)
9965         return 0;
9966
9967       /* If where is active, access was made through a
9968          qualifier. Access is granted if the type of the qualifier is
9969          or is a sublass of the type the access made from (6.6.2.1.)  */
9970       if (where && !inherits_from_p (reference, where))
9971         return 1;
9972
9973       /* Otherwise, access is granted if occurring from the class where
9974          member is declared or a subclass of it. Find the right
9975          context to perform the check */
9976       if (PURE_INNER_CLASS_TYPE_P (reference))
9977         {
9978           while (INNER_CLASS_TYPE_P (reference))
9979             {
9980               if (inherits_from_p (reference, DECL_CONTEXT (member)))
9981                 return 0;
9982               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
9983             }
9984         }
9985       if (inherits_from_p (reference, DECL_CONTEXT (member)))
9986         return 0;
9987       return 1;
9988     }
9989
9990   /* Check access on private members. Access is granted only if it
9991      occurs from within the class in which it is declared -- that does
9992      it for innerclasses too. */
9993   if (access_flag & ACC_PRIVATE)
9994     {
9995       if (reference == DECL_CONTEXT (member))
9996         return 0;
9997       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
9998         return 0;
9999       return 1;
10000     }
10001
10002   /* Default access are permitted only when occurring within the
10003      package in which the type (REFERENCE) is declared. In other words,
10004      REFERENCE is defined in the current package */
10005   if (ctxp->package)
10006     return !class_in_current_package (reference);
10007
10008   /* Otherwise, access is granted */
10009   return 0;
10010 }
10011
10012 /* Test deprecated decl access.  */
10013 static void
10014 check_deprecation (wfl, decl)
10015      tree wfl, decl;
10016 {
10017   const char *file = DECL_SOURCE_FILE (decl);
10018   /* Complain if the field is deprecated and the file it was defined
10019      in isn't compiled at the same time the file which contains its
10020      use is */
10021   if (DECL_DEPRECATED (decl)
10022       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10023     {
10024       char the [20];
10025       switch (TREE_CODE (decl))
10026         {
10027         case FUNCTION_DECL:
10028           strcpy (the, "method");
10029           break;
10030         case FIELD_DECL:
10031         case VAR_DECL:
10032           strcpy (the, "field");
10033           break;
10034         case TYPE_DECL:
10035           parse_warning_context (wfl, "The class `%s' has been deprecated",
10036                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10037           return;
10038         default:
10039           abort ();
10040         }
10041       /* Don't issue a message if the context as been deprecated as a
10042          whole. */
10043       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10044         parse_warning_context
10045           (wfl, "The %s `%s' in class `%s' has been deprecated",
10046            the, lang_printable_name (decl, 0),
10047            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10048     }
10049 }
10050
10051 /* Returns 1 if class was declared in the current package, 0 otherwise */
10052
10053 static int
10054 class_in_current_package (class)
10055      tree class;
10056 {
10057   static tree cache = NULL_TREE;
10058   int qualified_flag;
10059   tree left;
10060
10061   if (cache == class)
10062     return 1;
10063
10064   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10065
10066   /* If the current package is empty and the name of CLASS is
10067      qualified, class isn't in the current package.  If there is a
10068      current package and the name of the CLASS is not qualified, class
10069      isn't in the current package */
10070   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10071     return 0;
10072
10073   /* If there is not package and the name of CLASS isn't qualified,
10074      they belong to the same unnamed package */
10075   if (!ctxp->package && !qualified_flag)
10076     return 1;
10077
10078   /* Compare the left part of the name of CLASS with the package name */
10079   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10080   if (ctxp->package == left)
10081     {
10082       static int initialized_p;
10083       /* Register CACHE with the garbage collector.  */
10084       if (!initialized_p)
10085         {
10086           ggc_add_tree_root (&cache, 1);
10087           initialized_p = 1;
10088         }
10089
10090       cache = class;
10091       return 1;
10092     }
10093   return 0;
10094 }
10095
10096 /* This function may generate code to access DECL from WHERE. This is
10097    done only if certain conditions meet.  */
10098
10099 static tree
10100 maybe_access_field (decl, where, type)
10101   tree decl, where, type;
10102 {
10103   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10104       && !FIELD_STATIC (decl))
10105     decl = build_field_ref (where ? where : current_this,
10106                             (type ? type : DECL_CONTEXT (decl)),
10107                             DECL_NAME (decl));
10108   return decl;
10109 }
10110
10111 /* Build a method invocation, by patching PATCH. If non NULL
10112    and according to the situation, PRIMARY and WHERE may be
10113    used. IS_STATIC is set to 1 if the invoked function is static. */
10114
10115 static tree
10116 patch_method_invocation (patch, primary, where, from_super,
10117                         is_static, ret_decl)
10118      tree patch, primary, where;
10119      int from_super;
10120      int *is_static;
10121      tree *ret_decl;
10122 {
10123   tree wfl = TREE_OPERAND (patch, 0);
10124   tree args = TREE_OPERAND (patch, 1);
10125   tree name = EXPR_WFL_NODE (wfl);
10126   tree list;
10127   int is_static_flag = 0;
10128   int is_super_init = 0;
10129   tree this_arg = NULL_TREE;
10130   int is_array_clone_call = 0;
10131
10132   /* Should be overriden if everything goes well. Otherwise, if
10133      something fails, it should keep this value. It stop the
10134      evaluation of a bogus assignment. See java_complete_tree,
10135      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10136      evaluating an assignment */
10137   TREE_TYPE (patch) = error_mark_node;
10138
10139   /* Since lookup functions are messing with line numbers, save the
10140      context now.  */
10141   java_parser_context_save_global ();
10142
10143   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10144
10145   /* Resolution of qualified name, excluding constructors */
10146   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10147     {
10148       tree identifier, identifier_wfl, type, resolved;
10149       /* Extract the last IDENTIFIER of the qualified
10150          expression. This is a wfl and we will use it's location
10151          data during error report. */
10152       identifier_wfl = cut_identifier_in_qualified (wfl);
10153       identifier = EXPR_WFL_NODE (identifier_wfl);
10154
10155       /* Given the context, IDENTIFIER is syntactically qualified
10156          as a MethodName. We need to qualify what's before */
10157       qualify_ambiguous_name (wfl);
10158       resolved = resolve_field_access (wfl, NULL, NULL);
10159
10160       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10161          && FIELD_FINAL (resolved)
10162          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10163          && !flag_emit_class_files && !flag_emit_xref)
10164        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10165
10166       if (resolved == error_mark_node)
10167         PATCH_METHOD_RETURN_ERROR ();
10168
10169       type = GET_SKIP_TYPE (resolved);
10170       resolve_and_layout (type, NULL_TREE);
10171
10172       if (JPRIMITIVE_TYPE_P (type))
10173         {
10174           parse_error_context
10175             (identifier_wfl,
10176              "Can't invoke a method on primitive type `%s'",
10177              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10178           PATCH_METHOD_RETURN_ERROR ();
10179         }
10180
10181       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10182       args = nreverse (args);
10183
10184       /* We're resolving a call from a type */
10185       if (TREE_CODE (resolved) == TYPE_DECL)
10186         {
10187           if (CLASS_INTERFACE (resolved))
10188             {
10189               parse_error_context
10190                 (identifier_wfl,
10191                 "Can't make static reference to method `%s' in interface `%s'",
10192                  IDENTIFIER_POINTER (identifier),
10193                  IDENTIFIER_POINTER (name));
10194               PATCH_METHOD_RETURN_ERROR ();
10195             }
10196           if (list && !METHOD_STATIC (list))
10197             {
10198               char *fct_name = xstrdup (lang_printable_name (list, 0));
10199               parse_error_context
10200                 (identifier_wfl,
10201                  "Can't make static reference to method `%s %s' in class `%s'",
10202                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10203                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10204               free (fct_name);
10205               PATCH_METHOD_RETURN_ERROR ();
10206             }
10207         }
10208       else
10209         this_arg = primary = resolved;
10210
10211       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10212         is_array_clone_call = 1;
10213
10214       /* IDENTIFIER_WFL will be used to report any problem further */
10215       wfl = identifier_wfl;
10216     }
10217   /* Resolution of simple names, names generated after a primary: or
10218      constructors */
10219   else
10220     {
10221       tree class_to_search = NULL_TREE;
10222       int lc;                   /* Looking for Constructor */
10223
10224       /* We search constructor in their target class */
10225       if (CALL_CONSTRUCTOR_P (patch))
10226         {
10227           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10228             class_to_search = EXPR_WFL_NODE (wfl);
10229           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10230                    this_identifier_node)
10231             class_to_search = NULL_TREE;
10232           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10233                    super_identifier_node)
10234             {
10235               is_super_init = 1;
10236               if (CLASSTYPE_SUPER (current_class))
10237                 class_to_search =
10238                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10239               else
10240                 {
10241                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10242                   PATCH_METHOD_RETURN_ERROR ();
10243                 }
10244             }
10245
10246           /* Class to search is NULL if we're searching the current one */
10247           if (class_to_search)
10248             {
10249               class_to_search = resolve_and_layout (class_to_search, wfl);
10250
10251               if (!class_to_search)
10252                 {
10253                   parse_error_context
10254                     (wfl, "Class `%s' not found in type declaration",
10255                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10256                   PATCH_METHOD_RETURN_ERROR ();
10257                 }
10258
10259               /* Can't instantiate an abstract class, but we can
10260                  invoke it's constructor. It's use within the `new'
10261                  context is denied here. */
10262               if (CLASS_ABSTRACT (class_to_search)
10263                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10264                 {
10265                   parse_error_context
10266                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10267                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10268                   PATCH_METHOD_RETURN_ERROR ();
10269                 }
10270
10271               class_to_search = TREE_TYPE (class_to_search);
10272             }
10273           else
10274             class_to_search = current_class;
10275           lc = 1;
10276         }
10277       /* This is a regular search in the local class, unless an
10278          alternate class is specified. */
10279       else
10280         {
10281           if (where != NULL_TREE)
10282             class_to_search = where;
10283           else if (QUALIFIED_P (name))
10284             class_to_search = current_class;
10285           else
10286             {
10287               class_to_search = current_class;
10288
10289               for (;;)
10290                 {
10291                   if (has_method (class_to_search, name))
10292                     break;
10293                   if (! INNER_CLASS_TYPE_P (class_to_search))
10294                     {
10295                       parse_error_context (wfl,
10296                                            "No method named `%s' in scope",
10297                                            IDENTIFIER_POINTER (name));
10298                       PATCH_METHOD_RETURN_ERROR ();
10299                     }
10300                   class_to_search
10301                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10302                 }
10303             }
10304           lc = 0;
10305         }
10306
10307       /* NAME is a simple identifier or comes from a primary. Search
10308          in the class whose declaration contain the method being
10309          invoked. */
10310       resolve_and_layout (class_to_search, NULL_TREE);
10311
10312       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10313       /* Don't continue if no method were found, as the next statement
10314          can't be executed then. */
10315       if (!list)
10316         PATCH_METHOD_RETURN_ERROR ();
10317
10318       if (TYPE_ARRAY_P (class_to_search)
10319           && DECL_NAME (list) == get_identifier ("clone"))
10320         is_array_clone_call = 1;
10321
10322       /* Check for static reference if non static methods */
10323       if (check_for_static_method_reference (wfl, patch, list,
10324                                              class_to_search, primary))
10325         PATCH_METHOD_RETURN_ERROR ();
10326
10327       /* Check for inner classes creation from illegal contexts */
10328       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10329                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10330           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10331           && !DECL_INIT_P (current_function_decl))
10332         {
10333           parse_error_context
10334             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10335              lang_printable_name (class_to_search, 0),
10336              (!current_this ? "" :
10337               "; an explicit one must be provided when creating this inner class"));
10338           PATCH_METHOD_RETURN_ERROR ();
10339         }
10340
10341       /* Non static methods are called with the current object extra
10342          argument. If patch a `new TYPE()', the argument is the value
10343          returned by the object allocator. If method is resolved as a
10344          primary, use the primary otherwise use the current THIS. */
10345       args = nreverse (args);
10346       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10347         {
10348           this_arg = primary ? primary : current_this;
10349
10350           /* If we're using an access method, things are different.
10351              There are two familly of cases:
10352
10353              1) We're not generating bytecodes:
10354
10355              - LIST is non static. It's invocation is transformed from
10356                x(a1,...,an) into this$<n>.x(a1,....an).
10357              - LIST is static. It's invocation is transformed from
10358                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10359
10360              2) We're generating bytecodes:
10361
10362              - LIST is non static. It's invocation is transformed from
10363                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10364              - LIST is static. It's invocation is transformed from
10365                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10366
10367              Of course, this$<n> can be abitrary complex, ranging from
10368              this$0 (the immediate outer context) to
10369              access$0(access$0(...(this$0))).
10370
10371              maybe_use_access_method returns a non zero value if the
10372              this_arg has to be moved into the (then generated) stub
10373              argument list. In the meantime, the selected function
10374              might have be replaced by a generated stub. */
10375           if (!primary &&
10376               maybe_use_access_method (is_super_init, &list, &this_arg))
10377             {
10378               args = tree_cons (NULL_TREE, this_arg, args);
10379               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10380             }
10381         }
10382     }
10383
10384   /* Merge point of all resolution schemes. If we have nothing, this
10385      is an error, already signaled */
10386   if (!list)
10387     PATCH_METHOD_RETURN_ERROR ();
10388
10389   /* Check accessibility, position the is_static flag, build and
10390      return the call */
10391   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10392                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10393                          NULL_TREE), from_super)
10394       /* Calls to clone() on array types are permitted as a special-case. */
10395       && !is_array_clone_call)
10396     {
10397       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10398       const char *const access =
10399         java_accstring_lookup (get_access_flags_from_decl (list));
10400       const char *const klass =
10401         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10402       const char *const refklass =
10403         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10404       const char *const what = (DECL_CONSTRUCTOR_P (list)
10405                                 ? "constructor" : "method");
10406       /* FIXME: WFL yields the wrong message here but I don't know
10407          what else to use.  */
10408       parse_error_context (wfl,
10409                            "Can't access %s %s `%s.%s' from `%s'",
10410                            access, what, klass, fct_name, refklass);
10411       PATCH_METHOD_RETURN_ERROR ();
10412     }
10413
10414   /* Deprecation check: check whether the method being invoked or the
10415      instance-being-created's type are deprecated. */
10416   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10417     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10418   else
10419     check_deprecation (wfl, list);
10420
10421   /* If invoking a innerclass constructor, there are hidden parameters
10422      to pass */
10423   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10424       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10425     {
10426       /* And make sure we add the accessed local variables to be saved
10427          in field aliases. */
10428       args = build_alias_initializer_parameter_list
10429         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10430
10431       /* Secretly pass the current_this/primary as a second argument */
10432       if (primary || current_this)
10433         {
10434           tree extra_arg;
10435           tree this_type = (current_this ?
10436                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10437           /* Method's (list) enclosing context */
10438           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10439           /* If we have a primary, use it. */
10440           if (primary)
10441             extra_arg = primary;
10442           /* The current `this' is an inner class but isn't a direct
10443              enclosing context for the inner class we're trying to
10444              create. Build an access to the proper enclosing context
10445              and use it. */
10446           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10447                    && this_type != TREE_TYPE (mec))
10448             {
10449
10450               extra_arg = build_access_to_thisn (current_class,
10451                                                  TREE_TYPE (mec), 0);
10452               extra_arg = java_complete_tree (extra_arg);
10453             }
10454           /* Otherwise, just use the current `this' as an enclosing
10455              context. */
10456           else
10457             extra_arg = current_this;
10458           args = tree_cons (NULL_TREE, extra_arg, args);
10459         }
10460       else
10461         args = tree_cons (NULL_TREE, integer_zero_node, args);
10462     }
10463
10464   /* This handles the situation where a constructor invocation needs
10465      to have an enclosing context passed as a second parameter (the
10466      constructor is one of an inner class. We extract it from the
10467      current function.  */
10468   if ((is_super_init ||
10469        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10470       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10471     {
10472       tree enclosing_decl = DECL_CONTEXT (TYPE_NAME (current_class));
10473       tree extra_arg;
10474
10475       if (ANONYMOUS_CLASS_P (current_class) || !DECL_CONTEXT (enclosing_decl))
10476         {
10477           extra_arg = DECL_FUNCTION_BODY (current_function_decl);
10478           extra_arg = TREE_CHAIN (BLOCK_EXPR_DECLS (extra_arg));
10479         }
10480       else
10481         {
10482           tree dest = TREE_TYPE (DECL_CONTEXT (enclosing_decl));
10483           extra_arg =
10484             build_access_to_thisn (TREE_TYPE (enclosing_decl), dest, 0);
10485           extra_arg = java_complete_tree (extra_arg);
10486         }
10487       args = tree_cons (NULL_TREE, extra_arg, args);
10488     }
10489
10490   is_static_flag = METHOD_STATIC (list);
10491   if (! is_static_flag && this_arg != NULL_TREE)
10492     args = tree_cons (NULL_TREE, this_arg, args);
10493
10494   /* In the context of an explicit constructor invocation, we can't
10495      invoke any method relying on `this'. Exceptions are: we're
10496      invoking a static function, primary exists and is not the current
10497      this, we're creating a new object. */
10498   if (ctxp->explicit_constructor_p
10499       && !is_static_flag
10500       && (!primary || primary == current_this)
10501       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10502     {
10503       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10504       PATCH_METHOD_RETURN_ERROR ();
10505     }
10506   java_parser_context_restore_global ();
10507   if (is_static)
10508     *is_static = is_static_flag;
10509   /* Sometimes, we want the decl of the selected method. Such as for
10510      EH checking */
10511   if (ret_decl)
10512     *ret_decl = list;
10513   patch = patch_invoke (patch, list, args);
10514
10515   /* Now is a good time to insert the call to finit$ */
10516   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10517     {
10518       tree finit_parms, finit_call;
10519
10520       /* Prepare to pass hidden parameters to finit$, if any. */
10521       finit_parms = build_alias_initializer_parameter_list
10522         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10523
10524       finit_call =
10525         build_method_invocation (build_wfl_node (finit_identifier_node),
10526                                  finit_parms);
10527
10528       /* Generate the code used to initialize fields declared with an
10529          initialization statement and build a compound statement along
10530          with the super constructor invocation. */
10531       CAN_COMPLETE_NORMALLY (patch) = 1;
10532       patch = build (COMPOUND_EXPR, void_type_node, patch,
10533                      java_complete_tree (finit_call));
10534     }
10535   return patch;
10536 }
10537
10538 /* Check that we're not trying to do a static reference to a method in
10539    non static method. Return 1 if it's the case, 0 otherwise. */
10540
10541 static int
10542 check_for_static_method_reference (wfl, node, method, where, primary)
10543      tree wfl, node, method, where, primary;
10544 {
10545   if (METHOD_STATIC (current_function_decl)
10546       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10547     {
10548       char *fct_name = xstrdup (lang_printable_name (method, 0));
10549       parse_error_context
10550         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10551          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10552          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10553       free (fct_name);
10554       return 1;
10555     }
10556   return 0;
10557 }
10558
10559 /* Fix the invocation of *MDECL if necessary in the case of a
10560    invocation from an inner class. *THIS_ARG might be modified
10561    appropriately and an alternative access to *MDECL might be
10562    returned.  */
10563
10564 static int
10565 maybe_use_access_method (is_super_init, mdecl, this_arg)
10566      int is_super_init;
10567      tree *mdecl, *this_arg;
10568 {
10569   tree ctx;
10570   tree md = *mdecl, ta = *this_arg;
10571   int to_return = 0;
10572   int non_static_context = !METHOD_STATIC (md);
10573
10574   if (is_super_init
10575       || DECL_CONTEXT (md) == current_class
10576       || !PURE_INNER_CLASS_TYPE_P (current_class)
10577       || DECL_FINIT_P (md)
10578       || DECL_INSTINIT_P (md))
10579     return 0;
10580
10581   /* If we're calling a method found in an enclosing class, generate
10582      what it takes to retrieve the right this. Don't do that if we're
10583      invoking a static method. Note that if MD's type is unrelated to
10584      CURRENT_CLASS, then the current this can be used. */
10585
10586   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10587     {
10588       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10589       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10590         {
10591           ta = build_current_thisn (current_class);
10592           ta = build_wfl_node (ta);
10593         }
10594       else
10595         {
10596           tree type = ctx;
10597           while (type)
10598             {
10599               maybe_build_thisn_access_method (type);
10600               if (inherits_from_p (type, DECL_CONTEXT (md)))
10601                 {
10602                   ta = build_access_to_thisn (ctx, type, 0);
10603                   break;
10604                 }
10605               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10606                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10607             }
10608         }
10609       ta = java_complete_tree (ta);
10610     }
10611
10612   /* We might have to use an access method to get to MD. We can
10613      break the method access rule as far as we're not generating
10614      bytecode */
10615   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10616     {
10617       md = build_outer_method_access_method (md);
10618       to_return = 1;
10619     }
10620
10621   *mdecl = md;
10622   *this_arg = ta;
10623
10624   /* Returnin a non zero value indicates we were doing a non static
10625      method invokation that is now a static invocation. It will have
10626      callee displace `this' to insert it in the regular argument
10627      list. */
10628   return (non_static_context && to_return);
10629 }
10630
10631 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10632    mode.  */
10633
10634 static tree
10635 patch_invoke (patch, method, args)
10636      tree patch, method, args;
10637 {
10638   tree dtable, func;
10639   tree original_call, t, ta;
10640   tree check = NULL_TREE;
10641
10642   /* Last step for args: convert build-in types. If we're dealing with
10643      a new TYPE() type call, the first argument to the constructor
10644      isn't found in the incoming argument list, but delivered by
10645      `new' */
10646   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10647   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10648     t = TREE_CHAIN (t);
10649   for (ta = args; t != end_params_node && ta;
10650        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10651     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10652         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10653       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10654
10655   /* Resolve unresolved returned type isses */
10656   t = TREE_TYPE (TREE_TYPE (method));
10657   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10658     resolve_and_layout (TREE_TYPE (t), NULL);
10659
10660   if (flag_emit_class_files || flag_emit_xref)
10661     func = method;
10662   else
10663     {
10664       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10665         {
10666         case INVOKE_VIRTUAL:
10667           dtable = invoke_build_dtable (0, args);
10668           func = build_invokevirtual (dtable, method);
10669           break;
10670
10671         case INVOKE_NONVIRTUAL:
10672           /* If the object for the method call is null, we throw an
10673              exception.  We don't do this if the object is the current
10674              method's `this'.  In other cases we just rely on an
10675              optimization pass to eliminate redundant checks.  */
10676           if (TREE_VALUE (args) != current_this)
10677             {
10678               /* We use a save_expr here to make sure we only evaluate
10679                  the new `self' expression once.  */
10680               tree save_arg = save_expr (TREE_VALUE (args));
10681               TREE_VALUE (args) = save_arg;
10682               check = java_check_reference (save_arg, 1);
10683             }
10684           /* Fall through.  */
10685
10686         case INVOKE_SUPER:
10687         case INVOKE_STATIC:
10688           {
10689             tree signature = build_java_signature (TREE_TYPE (method));
10690             func = build_known_method_ref (method, TREE_TYPE (method),
10691                                            DECL_CONTEXT (method),
10692                                            signature, args);
10693           }
10694           break;
10695
10696         case INVOKE_INTERFACE:
10697           dtable = invoke_build_dtable (1, args);
10698           func = build_invokeinterface (dtable, method);
10699           break;
10700
10701         default:
10702           abort ();
10703         }
10704
10705       /* Ensure self_type is initialized, (invokestatic). FIXME */
10706       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10707     }
10708
10709   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10710   TREE_OPERAND (patch, 0) = func;
10711   TREE_OPERAND (patch, 1) = args;
10712   patch = check_for_builtin (method, patch);
10713   original_call = patch;
10714
10715   /* We're processing a `new TYPE ()' form. New is called and its
10716      returned value is the first argument to the constructor. We build
10717      a COMPOUND_EXPR and use saved expression so that the overall NEW
10718      expression value is a pointer to a newly created and initialized
10719      class. */
10720   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10721     {
10722       tree class = DECL_CONTEXT (method);
10723       tree c1, saved_new, size, new;
10724       tree alloc_node;
10725
10726       if (flag_emit_class_files || flag_emit_xref)
10727         {
10728           TREE_TYPE (patch) = build_pointer_type (class);
10729           return patch;
10730         }
10731       if (!TYPE_SIZE (class))
10732         safe_layout_class (class);
10733       size = size_in_bytes (class);
10734       alloc_node =
10735         (class_has_finalize_method (class) ? alloc_object_node
10736                                            : alloc_no_finalizer_node);
10737       new = build (CALL_EXPR, promote_type (class),
10738                    build_address_of (alloc_node),
10739                    tree_cons (NULL_TREE, build_class_ref (class),
10740                               build_tree_list (NULL_TREE,
10741                                                size_in_bytes (class))),
10742                    NULL_TREE);
10743       saved_new = save_expr (new);
10744       c1 = build_tree_list (NULL_TREE, saved_new);
10745       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10746       TREE_OPERAND (original_call, 1) = c1;
10747       TREE_SET_CODE (original_call, CALL_EXPR);
10748       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10749     }
10750
10751   /* If CHECK is set, then we are building a check to see if the object
10752      is NULL.  */
10753   if (check != NULL_TREE)
10754     {
10755       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check, patch);
10756       TREE_SIDE_EFFECTS (patch) = 1;
10757     }
10758
10759   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10760      put it as the first expression of a COMPOUND_EXPR. The second
10761      expression being an empty statement to be later patched if
10762      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10763      the VALUE is the compound) in a hashtable and return a
10764      COMPOUND_EXPR built so that the result of the evaluation of the
10765      original PATCH node is returned. */
10766   if (STATIC_CLASS_INIT_OPT_P ()
10767       && current_function_decl && METHOD_STATIC (method))
10768     {
10769       tree list;
10770       tree fndecl = current_function_decl;
10771       tree save = save_expr (patch);
10772       tree type = TREE_TYPE (patch);
10773
10774       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10775       list = tree_cons (method, patch,
10776                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10777
10778       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10779
10780       patch = build (COMPOUND_EXPR, type, patch, save);
10781     }
10782
10783   return patch;
10784 }
10785
10786 static int
10787 invocation_mode (method, super)
10788      tree method;
10789      int super;
10790 {
10791   int access = get_access_flags_from_decl (method);
10792
10793   if (super)
10794     return INVOKE_SUPER;
10795
10796   if (access & ACC_STATIC)
10797     return INVOKE_STATIC;
10798
10799   /* We have to look for a constructor before we handle nonvirtual
10800      calls; otherwise the constructor will look nonvirtual.  */
10801   if (DECL_CONSTRUCTOR_P (method))
10802     return INVOKE_STATIC;
10803
10804   if (access & ACC_FINAL || access & ACC_PRIVATE)
10805     return INVOKE_NONVIRTUAL;
10806
10807   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10808     return INVOKE_NONVIRTUAL;
10809
10810   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10811     return INVOKE_INTERFACE;
10812
10813   return INVOKE_VIRTUAL;
10814 }
10815
10816 /* Retrieve a refined list of matching methods. It covers the step
10817    15.11.2 (Compile-Time Step 2) */
10818
10819 static tree
10820 lookup_method_invoke (lc, cl, class, name, arg_list)
10821      int lc;
10822      tree cl;
10823      tree class, name, arg_list;
10824 {
10825   tree atl = end_params_node;           /* Arg Type List */
10826   tree method, signature, list, node;
10827   const char *candidates;               /* Used for error report */
10828   char *dup;
10829
10830   /* Fix the arguments */
10831   for (node = arg_list; node; node = TREE_CHAIN (node))
10832     {
10833       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10834       /* Non primitive type may have to be resolved */
10835       if (!JPRIMITIVE_TYPE_P (current_arg))
10836         resolve_and_layout (current_arg, NULL_TREE);
10837       /* And promoted */
10838       if (TREE_CODE (current_arg) == RECORD_TYPE)
10839         current_arg = promote_type (current_arg);
10840       atl = tree_cons (NULL_TREE, current_arg, atl);
10841     }
10842
10843   /* Presto. If we're dealing with an anonymous class and a
10844      constructor call, generate the right constructor now, since we
10845      know the arguments' types. */
10846
10847   if (lc && ANONYMOUS_CLASS_P (class))
10848     {
10849       tree saved_current_class;
10850       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10851       saved_current_class = current_class;
10852       current_class = class;
10853       fix_constructors (mdecl);
10854       current_class = saved_current_class;
10855     }
10856
10857   /* Find all candidates and then refine the list, searching for the
10858      most specific method. */
10859   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10860   list = find_most_specific_methods_list (list);
10861   if (list && !TREE_CHAIN (list))
10862     return TREE_VALUE (list);
10863
10864   /* Issue an error. List candidates if any. Candidates are listed
10865      only if accessible (non accessible methods may end-up here for
10866      the sake of a better error report). */
10867   candidates = NULL;
10868   if (list)
10869     {
10870       tree current;
10871       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10872       for (current = list; current; current = TREE_CHAIN (current))
10873         {
10874           tree cm = TREE_VALUE (current);
10875           char string [4096];
10876           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10877             continue;
10878           sprintf
10879             (string, "  `%s' in `%s'%s",
10880              get_printable_method_name (cm),
10881              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10882              (TREE_CHAIN (current) ? "\n" : ""));
10883           obstack_grow (&temporary_obstack, string, strlen (string));
10884         }
10885       obstack_1grow (&temporary_obstack, '\0');
10886       candidates = obstack_finish (&temporary_obstack);
10887     }
10888   /* Issue the error message */
10889   method = make_node (FUNCTION_TYPE);
10890   TYPE_ARG_TYPES (method) = atl;
10891   signature = build_java_argument_signature (method);
10892   dup = xstrdup (lang_printable_name (class, 0));
10893   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10894                        (lc ? "constructor" : "method"),
10895                        (lc ? dup : IDENTIFIER_POINTER (name)),
10896                        IDENTIFIER_POINTER (signature), dup,
10897                        (candidates ? candidates : ""));
10898   free (dup);
10899   return NULL_TREE;
10900 }
10901
10902 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10903    when we're looking for a constructor. */
10904
10905 static tree
10906 find_applicable_accessible_methods_list (lc, class, name, arglist)
10907      int lc;
10908      tree class, name, arglist;
10909 {
10910   static struct hash_table t, *searched_classes = NULL;
10911   static int search_not_done = 0;
10912   tree list = NULL_TREE, all_list = NULL_TREE;
10913
10914   /* Check the hash table to determine if this class has been searched
10915      already. */
10916   if (searched_classes)
10917     {
10918       if (hash_lookup (searched_classes,
10919                       (const hash_table_key) class, FALSE, NULL))
10920        return NULL;
10921     }
10922   else
10923     {
10924       hash_table_init (&t, hash_newfunc, java_hash_hash_tree_node,
10925                       java_hash_compare_tree_node);
10926       searched_classes = &t;
10927     }
10928
10929   search_not_done++;
10930   hash_lookup (searched_classes,
10931                (const hash_table_key) class, TRUE, NULL);
10932
10933   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
10934     {
10935       load_class (class, 1);
10936       safe_layout_class (class);
10937     }
10938
10939   /* Search interfaces */
10940   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
10941       && CLASS_INTERFACE (TYPE_NAME (class)))
10942     {
10943       int i, n;
10944       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
10945       search_applicable_methods_list (lc, TYPE_METHODS (class),
10946                                       name, arglist, &list, &all_list);
10947       n = TREE_VEC_LENGTH (basetype_vec);
10948       for (i = 1; i < n; i++)
10949         {
10950           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10951           tree rlist;
10952
10953           rlist = find_applicable_accessible_methods_list (lc,  t, name,
10954                                                            arglist);
10955           list = chainon (rlist, list);
10956         }
10957     }
10958   /* Search classes */
10959   else
10960     {
10961       search_applicable_methods_list (lc, TYPE_METHODS (class),
10962                                       name, arglist, &list, &all_list);
10963
10964       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
10965          that we only search in class. Note that we should have found
10966          something at this point. */
10967       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
10968         {
10969           lc = 1;
10970           if (!list)
10971             abort ();
10972         }
10973
10974       /* We must search all interfaces of this class */
10975       if (!lc)
10976       {
10977         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
10978         int n = TREE_VEC_LENGTH (basetype_vec), i;
10979         for (i = 1; i < n; i++)
10980           {
10981             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10982             if (t != object_type_node)
10983               {
10984                 tree rlist
10985                   = find_applicable_accessible_methods_list (lc, t,
10986                                                              name, arglist);
10987                 list = chainon (rlist, list);
10988               }
10989           }
10990       }
10991
10992       /* Search superclass */
10993       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
10994         {
10995           tree rlist;
10996           class = CLASSTYPE_SUPER (class);
10997           rlist = find_applicable_accessible_methods_list (lc, class,
10998                                                            name, arglist);
10999           list = chainon (rlist, list);
11000         }
11001     }
11002
11003   search_not_done--;
11004
11005   /* We're done. Reset the searched classes list and finally search
11006      java.lang.Object if it wasn't searched already. */
11007   if (!search_not_done)
11008     {
11009       if (!lc
11010           && TYPE_METHODS (object_type_node)
11011           && !hash_lookup (searched_classes,
11012                            (const hash_table_key) object_type_node,
11013                            FALSE, NULL))
11014         {
11015           search_applicable_methods_list (lc,
11016                                           TYPE_METHODS (object_type_node),
11017                                           name, arglist, &list, &all_list);
11018         }
11019       hash_table_free (searched_classes);
11020       searched_classes = NULL;
11021     }
11022
11023   /* Either return the list obtained or all selected (but
11024      inaccessible) methods for better error report. */
11025   return (!list ? all_list : list);
11026 }
11027
11028 /* Effectively search for the appropriate method in method */
11029
11030 static void
11031 search_applicable_methods_list (lc, method, name, arglist, list, all_list)
11032      int lc;
11033      tree method, name, arglist;
11034      tree *list, *all_list;
11035 {
11036   for (; method; method = TREE_CHAIN (method))
11037     {
11038       /* When dealing with constructor, stop here, otherwise search
11039          other classes */
11040       if (lc && !DECL_CONSTRUCTOR_P (method))
11041         continue;
11042       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11043                        || (DECL_NAME (method) != name)))
11044         continue;
11045
11046       if (argument_types_convertible (method, arglist))
11047         {
11048           /* Retain accessible methods only */
11049           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11050                                  method, NULL_TREE, 0))
11051             *list = tree_cons (NULL_TREE, method, *list);
11052           else
11053             /* Also retain all selected method here */
11054             *all_list = tree_cons (NULL_TREE, method, *list);
11055         }
11056     }
11057 }
11058
11059 /* 15.11.2.2 Choose the Most Specific Method */
11060
11061 static tree
11062 find_most_specific_methods_list (list)
11063      tree list;
11064 {
11065   int max = 0;
11066   int abstract, candidates;
11067   tree current, new_list = NULL_TREE;
11068   for (current = list; current; current = TREE_CHAIN (current))
11069     {
11070       tree method;
11071       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11072
11073       for (method = list; method; method = TREE_CHAIN (method))
11074         {
11075           tree method_v, current_v;
11076           /* Don't test a method against itself */
11077           if (method == current)
11078             continue;
11079
11080           method_v = TREE_VALUE (method);
11081           current_v = TREE_VALUE (current);
11082
11083           /* Compare arguments and location where methods where declared */
11084           if (argument_types_convertible (method_v, current_v))
11085             {
11086               if (valid_method_invocation_conversion_p
11087                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11088                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11089                       && enclosing_context_p (DECL_CONTEXT (method_v),
11090                                               DECL_CONTEXT (current_v))))
11091                 {
11092                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11093                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11094                   max = (v > max ? v : max);
11095                 }
11096             }
11097         }
11098     }
11099
11100   /* Review the list and select the maximally specific methods */
11101   for (current = list, abstract = -1, candidates = -1;
11102        current; current = TREE_CHAIN (current))
11103     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11104       {
11105         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11106         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11107         candidates++;
11108       }
11109
11110   /* If we have several and they're all abstract, just pick the
11111      closest one. */
11112   if (candidates > 0 && (candidates == abstract))
11113     {
11114       new_list = nreverse (new_list);
11115       TREE_CHAIN (new_list) = NULL_TREE;
11116     }
11117
11118   /* We have several (we couldn't find a most specific), all but one
11119      are abstract, we pick the only non abstract one. */
11120   if (candidates > 0 && (candidates == abstract+1))
11121     {
11122       for (current = new_list; current; current = TREE_CHAIN (current))
11123         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11124           {
11125             TREE_CHAIN (current) = NULL_TREE;
11126             new_list = current;
11127           }
11128     }
11129
11130   /* If we can't find one, lower expectations and try to gather multiple
11131      maximally specific methods */
11132   while (!new_list && max)
11133     {
11134       while (--max > 0)
11135         {
11136           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11137             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11138         }
11139     }
11140
11141   return new_list;
11142 }
11143
11144 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11145    converted by method invocation conversion (5.3) to the type of the
11146    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11147    to change less often than M1. */
11148
11149 static int
11150 argument_types_convertible (m1, m2_or_arglist)
11151     tree m1, m2_or_arglist;
11152 {
11153   static tree m2_arg_value = NULL_TREE;
11154   static tree m2_arg_cache = NULL_TREE;
11155   static int initialized_p;
11156
11157   register tree m1_arg, m2_arg;
11158
11159   /* Register M2_ARG_VALUE and M2_ARG_CACHE with the garbage
11160      collector.  */
11161   if (!initialized_p)
11162     {
11163       ggc_add_tree_root (&m2_arg_value, 1);
11164       ggc_add_tree_root (&m2_arg_cache, 1);
11165       initialized_p = 1;
11166     }
11167
11168   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11169
11170   if (m2_arg_value == m2_or_arglist)
11171     m2_arg = m2_arg_cache;
11172   else
11173     {
11174       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11175          argument types */
11176       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11177         {
11178           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11179           if (!METHOD_STATIC (m2_or_arglist))
11180             m2_arg = TREE_CHAIN (m2_arg);
11181         }
11182       else
11183         m2_arg = m2_or_arglist;
11184
11185       m2_arg_value = m2_or_arglist;
11186       m2_arg_cache = m2_arg;
11187     }
11188
11189   while (m1_arg != end_params_node && m2_arg != end_params_node)
11190     {
11191       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11192       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11193                                                  TREE_VALUE (m2_arg)))
11194         break;
11195       m1_arg = TREE_CHAIN (m1_arg);
11196       m2_arg = TREE_CHAIN (m2_arg);
11197     }
11198   return m1_arg == end_params_node && m2_arg == end_params_node;
11199 }
11200
11201 /* Qualification routines */
11202
11203 static void
11204 qualify_ambiguous_name (id)
11205      tree id;
11206 {
11207   tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
11208     saved_current_class;
11209   int again, super_found = 0, this_found = 0, new_array_found = 0;
11210   int code;
11211
11212   /* We first qualify the first element, then derive qualification of
11213      others based on the first one. If the first element is qualified
11214      by a resolution (field or type), this resolution is stored in the
11215      QUAL_RESOLUTION of the qual element being examined. We need to
11216      save the current_class since the use of SUPER might change the
11217      its value. */
11218   saved_current_class = current_class;
11219   qual = EXPR_WFL_QUALIFICATION (id);
11220   do {
11221
11222     /* Simple qualified expression feature a qual_wfl that is a
11223        WFL. Expression derived from a primary feature more complicated
11224        things like a CALL_EXPR. Expression from primary need to be
11225        worked out to extract the part on which the qualification will
11226        take place. */
11227     qual_wfl = QUAL_WFL (qual);
11228     switch (TREE_CODE (qual_wfl))
11229       {
11230       case CALL_EXPR:
11231         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11232         if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11233           {
11234             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11235             qual_wfl = QUAL_WFL (qual);
11236           }
11237         break;
11238       case NEW_ARRAY_EXPR:
11239       case NEW_ANONYMOUS_ARRAY_EXPR:
11240         qual = TREE_CHAIN (qual);
11241         again = new_array_found = 1;
11242         continue;
11243       case CONVERT_EXPR:
11244         break;
11245       case NEW_CLASS_EXPR:
11246         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11247         break;
11248       case ARRAY_REF:
11249         while (TREE_CODE (qual_wfl) == ARRAY_REF)
11250           qual_wfl = TREE_OPERAND (qual_wfl, 0);
11251         break;
11252       case STRING_CST:
11253         qual = TREE_CHAIN (qual);
11254         qual_wfl = QUAL_WFL (qual);
11255         break;
11256       case CLASS_LITERAL:
11257         qual = TREE_CHAIN (qual);
11258         qual_wfl = QUAL_WFL (qual);
11259       break;
11260       default:
11261         /* Fix for -Wall. Just break doing nothing */
11262         break;
11263       }
11264
11265     ptr_type = current_class;
11266     again = 0;
11267     code = TREE_CODE (qual_wfl);
11268
11269     /* Pos evaluation: non WFL leading expression nodes */
11270     if (code == CONVERT_EXPR
11271         && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
11272       name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
11273
11274     else if (code == INTEGER_CST)
11275       name = qual_wfl;
11276
11277     else if (code == CONVERT_EXPR &&
11278              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11279       name = TREE_OPERAND (qual_wfl, 0);
11280
11281     else if (code == CONVERT_EXPR
11282              && TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == CALL_EXPR
11283              && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0))
11284                  == EXPR_WITH_FILE_LOCATION))
11285       name = TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0);
11286
11287     else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
11288              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11289       name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
11290
11291     else if (code == TREE_LIST)
11292       name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
11293
11294     else if (code == STRING_CST || code == CONDITIONAL_EXPR
11295              || code == PLUS_EXPR)
11296       {
11297         qual = TREE_CHAIN (qual);
11298         qual_wfl = QUAL_WFL (qual);
11299         again = 1;
11300       }
11301     else
11302       {
11303         name = EXPR_WFL_NODE (qual_wfl);
11304         if (!name)
11305           {
11306             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11307             again = 1;
11308           }
11309       }
11310
11311     /* If we have a THIS (from a primary), we set the context accordingly */
11312     if (name == this_identifier_node)
11313       {
11314         /* This isn't really elegant. One more added irregularity
11315            before I start using COMPONENT_REF (hopefully very soon.)  */
11316         if (TREE_CODE (TREE_PURPOSE (qual)) == ARRAY_REF
11317             && TREE_CODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11318                EXPR_WITH_FILE_LOCATION
11319             && EXPR_WFL_NODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11320                this_identifier_node)
11321             {
11322               qual = TREE_OPERAND (TREE_PURPOSE (qual), 0);
11323               qual = EXPR_WFL_QUALIFICATION (qual);
11324             }
11325         qual = TREE_CHAIN (qual);
11326         qual_wfl = QUAL_WFL (qual);
11327         if (TREE_CODE (qual_wfl) == CALL_EXPR)
11328           again = 1;
11329         else if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION)
11330           name = EXPR_WFL_NODE (qual_wfl);
11331         else if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
11332           name = TREE_OPERAND (qual_wfl, 0);
11333         this_found = 1;
11334       }
11335     /* If we have a SUPER, we set the context accordingly */
11336     if (name == super_identifier_node)
11337       {
11338         current_class = CLASSTYPE_SUPER (ptr_type);
11339         /* Check that there is such a thing as a super class. If not,
11340            return.  The error will be caught later on, during the
11341            resolution */
11342         if (!current_class)
11343           {
11344             current_class = saved_current_class;
11345             return;
11346           }
11347         qual = TREE_CHAIN (qual);
11348         /* Do one more interation to set things up */
11349         super_found = again = 1;
11350       }
11351   } while (again);
11352
11353   /* If name appears within the scope of a local variable declaration
11354      or parameter declaration, then it is an expression name. We don't
11355      carry this test out if we're in the context of the use of SUPER
11356      or THIS */
11357   if (!this_found && !super_found
11358       && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
11359       && (decl = IDENTIFIER_LOCAL_VALUE (name)))
11360     {
11361       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11362       QUAL_RESOLUTION (qual) = decl;
11363     }
11364
11365   /* If within the class/interface NAME was found to be used there
11366      exists a (possibly inherited) field named NAME, then this is an
11367      expression name. If we saw a NEW_ARRAY_EXPR before and want to
11368      address length, it is OK. */
11369   else if ((decl = lookup_field_wrapper (ptr_type, name))
11370            || name == length_identifier_node)
11371     {
11372       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11373       QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
11374     }
11375
11376   /* We reclassify NAME as yielding to a type name resolution if:
11377      - NAME is a class/interface declared within the compilation
11378        unit containing NAME,
11379      - NAME is imported via a single-type-import declaration,
11380      - NAME is declared in an another compilation unit of the package
11381        of the compilation unit containing NAME,
11382      - NAME is declared by exactly on type-import-on-demand declaration
11383      of the compilation unit containing NAME.
11384      - NAME is actually a STRING_CST.
11385      This can't happen if the expression was qualified by `this.' */
11386   else if (! this_found &&
11387            (TREE_CODE (name) == STRING_CST ||
11388             TREE_CODE (name) == INTEGER_CST ||
11389             (decl = resolve_and_layout (name, NULL_TREE))))
11390     {
11391       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11392       QUAL_RESOLUTION (qual) = decl;
11393     }
11394
11395   /* Method call, array references and cast are expression name */
11396   else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
11397            || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
11398            || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR
11399            || TREE_CODE (QUAL_WFL (qual)) == MODIFY_EXPR)
11400     RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11401
11402   /* Check here that NAME isn't declared by more than one
11403      type-import-on-demand declaration of the compilation unit
11404      containing NAME. FIXME */
11405
11406   /* Otherwise, NAME is reclassified as a package name */
11407   else
11408     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11409
11410   /* Propagate the qualification accross other components of the
11411      qualified name */
11412   for (qual = TREE_CHAIN (qual); qual;
11413        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11414     {
11415       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11416         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11417       else
11418         RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
11419     }
11420
11421   /* Store the global qualification for the ambiguous part of ID back
11422      into ID fields */
11423   if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
11424     RESOLVE_EXPRESSION_NAME_P (id) = 1;
11425   else if (RESOLVE_TYPE_NAME_P (qual_wfl))
11426     RESOLVE_TYPE_NAME_P (id) = 1;
11427   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11428     RESOLVE_PACKAGE_NAME_P (id) = 1;
11429
11430   /* Restore the current class */
11431   current_class = saved_current_class;
11432 }
11433
11434 static int
11435 breakdown_qualified (left, right, source)
11436     tree *left, *right, source;
11437 {
11438   char *p, *base;
11439   int   l = IDENTIFIER_LENGTH (source);
11440
11441   base = alloca (l + 1);
11442   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11443
11444   /* Breakdown NAME into REMAINDER . IDENTIFIER */
11445   p = base + l - 1;
11446   while (*p != '.' && p != base)
11447     p--;
11448
11449   /* We didn't find a '.'. Return an error */
11450   if (p == base)
11451     return 1;
11452
11453   *p = '\0';
11454   if (right)
11455     *right = get_identifier (p+1);
11456   *left = get_identifier (base);
11457
11458   return 0;
11459 }
11460
11461 /* Return TRUE if two classes are from the same package. */
11462
11463 static int
11464 in_same_package (name1, name2)
11465   tree name1, name2;
11466 {
11467   tree tmp;
11468   tree pkg1;
11469   tree pkg2;
11470
11471   if (TREE_CODE (name1) == TYPE_DECL)
11472     name1 = DECL_NAME (name1);
11473   if (TREE_CODE (name2) == TYPE_DECL)
11474     name2 = DECL_NAME (name2);
11475
11476   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11477     /* One in empty package. */
11478     return 0;
11479
11480   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11481     /* Both in empty package. */
11482     return 1;
11483
11484   breakdown_qualified (&pkg1, &tmp, name1);
11485   breakdown_qualified (&pkg2, &tmp, name2);
11486
11487   return (pkg1 == pkg2);
11488 }
11489
11490 /* Patch tree nodes in a function body. When a BLOCK is found, push
11491    local variable decls if present.
11492    Same as java_complete_lhs, but does resolve static finals to values. */
11493
11494 static tree
11495 java_complete_tree (node)
11496      tree node;
11497 {
11498   node = java_complete_lhs (node);
11499   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11500       && DECL_INITIAL (node) != NULL_TREE
11501       && !flag_emit_xref)
11502     {
11503       tree value = DECL_INITIAL (node);
11504       DECL_INITIAL (node) = NULL_TREE;
11505       value = fold_constant_for_init (value, node);
11506       DECL_INITIAL (node) = value;
11507       if (value != NULL_TREE)
11508         {
11509           /* fold_constant_for_init sometimes widens the original type
11510              of the constant (i.e. byte to int). It's not desirable,
11511              especially if NODE is a function argument. */
11512           if ((TREE_CODE (value) == INTEGER_CST
11513                || TREE_CODE (value) == REAL_CST)
11514               && TREE_TYPE (node) != TREE_TYPE (value))
11515             return convert (TREE_TYPE (node), value);
11516           else
11517             return value;
11518         }
11519     }
11520   return node;
11521 }
11522
11523 static tree
11524 java_stabilize_reference (node)
11525      tree node;
11526 {
11527   if (TREE_CODE (node) == COMPOUND_EXPR)
11528     {
11529       tree op0 = TREE_OPERAND (node, 0);
11530       tree op1 = TREE_OPERAND (node, 1);
11531       TREE_OPERAND (node, 0) = save_expr (op0);
11532       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11533       return node;
11534     }
11535   return stabilize_reference (node);
11536 }
11537
11538 /* Patch tree nodes in a function body. When a BLOCK is found, push
11539    local variable decls if present.
11540    Same as java_complete_tree, but does not resolve static finals to values. */
11541
11542 static tree
11543 java_complete_lhs (node)
11544      tree node;
11545 {
11546   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11547   int flag;
11548
11549   /* CONVERT_EXPR always has its type set, even though it needs to be
11550      worked out. */
11551   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11552     return node;
11553
11554   /* The switch block implements cases processing container nodes
11555      first.  Contained nodes are always written back. Leaves come
11556      next and return a value. */
11557   switch (TREE_CODE (node))
11558     {
11559     case BLOCK:
11560
11561       /* 1- Block section.
11562          Set the local values on decl names so we can identify them
11563          faster when they're referenced. At that stage, identifiers
11564          are legal so we don't check for declaration errors. */
11565       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11566         {
11567           DECL_CONTEXT (cn) = current_function_decl;
11568           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11569         }
11570       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11571           CAN_COMPLETE_NORMALLY (node) = 1;
11572       else
11573         {
11574           tree stmt = BLOCK_EXPR_BODY (node);
11575           tree *ptr;
11576           int error_seen = 0;
11577           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11578             {
11579               /* Re-order from (((A; B); C); ...; Z) to
11580                  (A; (B; (C ; (...; Z)))).
11581                  This makes it easier to scan the statements left-to-right
11582                  without using recursion (which might overflow the stack
11583                  if the block has many statements. */
11584               for (;;)
11585                 {
11586                   tree left = TREE_OPERAND (stmt, 0);
11587                   if (TREE_CODE (left) != COMPOUND_EXPR)
11588                     break;
11589                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11590                   TREE_OPERAND (left, 1) = stmt;
11591                   stmt = left;
11592                 }
11593               BLOCK_EXPR_BODY (node) = stmt;
11594             }
11595
11596           /* Now do the actual complete, without deep recursion for
11597              long blocks. */
11598           ptr = &BLOCK_EXPR_BODY (node);
11599           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11600                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11601             {
11602               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11603               tree *next = &TREE_OPERAND (*ptr, 1);
11604               TREE_OPERAND (*ptr, 0) = cur;
11605               if (cur == empty_stmt_node)
11606                 {
11607                   /* Optimization;  makes it easier to detect empty bodies.
11608                      Most useful for <clinit> with all-constant initializer. */
11609                   *ptr = *next;
11610                   continue;
11611                 }
11612               if (TREE_CODE (cur) == ERROR_MARK)
11613                 error_seen++;
11614               else if (! CAN_COMPLETE_NORMALLY (cur))
11615                 {
11616                   wfl_op2 = *next;
11617                   for (;;)
11618                     {
11619                       if (TREE_CODE (wfl_op2) == BLOCK)
11620                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11621                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11622                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11623                       else
11624                         break;
11625                     }
11626                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11627                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11628                     unreachable_stmt_error (*ptr);
11629                 }
11630               ptr = next;
11631             }
11632           *ptr = java_complete_tree (*ptr);
11633
11634           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11635             return error_mark_node;
11636           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11637         }
11638       /* Turn local bindings to null */
11639       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11640         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11641
11642       TREE_TYPE (node) = void_type_node;
11643       break;
11644
11645       /* 2- They are expressions but ultimately deal with statements */
11646
11647     case THROW_EXPR:
11648       wfl_op1 = TREE_OPERAND (node, 0);
11649       COMPLETE_CHECK_OP_0 (node);
11650       /* 14.19 A throw statement cannot complete normally. */
11651       CAN_COMPLETE_NORMALLY (node) = 0;
11652       return patch_throw_statement (node, wfl_op1);
11653
11654     case SYNCHRONIZED_EXPR:
11655       wfl_op1 = TREE_OPERAND (node, 0);
11656       return patch_synchronized_statement (node, wfl_op1);
11657
11658     case TRY_EXPR:
11659       return patch_try_statement (node);
11660
11661     case TRY_FINALLY_EXPR:
11662       COMPLETE_CHECK_OP_0 (node);
11663       COMPLETE_CHECK_OP_1 (node);
11664       if (TREE_OPERAND (node, 0) == empty_stmt_node)
11665         return TREE_OPERAND (node, 1);
11666       if (TREE_OPERAND (node, 1) == empty_stmt_node)
11667         return TREE_OPERAND (node, 0);
11668       CAN_COMPLETE_NORMALLY (node)
11669         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11670            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11671       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11672       return node;
11673
11674     case LABELED_BLOCK_EXPR:
11675       PUSH_LABELED_BLOCK (node);
11676       if (LABELED_BLOCK_BODY (node))
11677         COMPLETE_CHECK_OP_1 (node);
11678       TREE_TYPE (node) = void_type_node;
11679       POP_LABELED_BLOCK ();
11680
11681       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11682         {
11683           LABELED_BLOCK_BODY (node) = NULL_TREE;
11684           CAN_COMPLETE_NORMALLY (node) = 1;
11685         }
11686       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11687         CAN_COMPLETE_NORMALLY (node) = 1;
11688       return node;
11689
11690     case EXIT_BLOCK_EXPR:
11691       /* We don't complete operand 1, because it's the return value of
11692          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11693       return patch_bc_statement (node);
11694
11695     case CASE_EXPR:
11696       cn = java_complete_tree (TREE_OPERAND (node, 0));
11697       if (cn == error_mark_node)
11698         return cn;
11699
11700       /* First, the case expression must be constant. Values of final
11701          fields are accepted. */
11702       cn = fold (cn);
11703       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11704           && JDECL_P (TREE_OPERAND (cn, 1))
11705           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11706           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11707         {
11708           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11709                                        TREE_OPERAND (cn, 1));
11710         }
11711       /* Accept final locals too. */
11712       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11713         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11714
11715       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11716         {
11717           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11718           parse_error_context (node, "Constant expression required");
11719           return error_mark_node;
11720         }
11721
11722       nn = ctxp->current_loop;
11723
11724       /* It must be assignable to the type of the switch expression. */
11725       if (!try_builtin_assignconv (NULL_TREE,
11726                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11727         {
11728           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11729           parse_error_context
11730             (wfl_operator,
11731              "Incompatible type for case. Can't convert `%s' to `int'",
11732              lang_printable_name (TREE_TYPE (cn), 0));
11733           return error_mark_node;
11734         }
11735
11736       cn = fold (convert (int_type_node, cn));
11737       TREE_CONSTANT_OVERFLOW (cn) = 0;
11738       CAN_COMPLETE_NORMALLY (cn) = 1;
11739
11740       /* Save the label on a list so that we can later check for
11741          duplicates.  */
11742       case_label_list = tree_cons (node, cn, case_label_list);
11743
11744       /* Multiple instance of a case label bearing the same value is
11745          checked later. The case expression is all right so far. */
11746       if (TREE_CODE (cn) == VAR_DECL)
11747         cn = DECL_INITIAL (cn);
11748       TREE_OPERAND (node, 0) = cn;
11749       TREE_TYPE (node) = void_type_node;
11750       CAN_COMPLETE_NORMALLY (node) = 1;
11751       TREE_SIDE_EFFECTS (node) = 1;
11752       break;
11753
11754     case DEFAULT_EXPR:
11755       nn = ctxp->current_loop;
11756       /* Only one default label is allowed per switch statement */
11757       if (SWITCH_HAS_DEFAULT (nn))
11758         {
11759           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11760           parse_error_context (wfl_operator,
11761                                "Duplicate case label: `default'");
11762           return error_mark_node;
11763         }
11764       else
11765         SWITCH_HAS_DEFAULT (nn) = 1;
11766       TREE_TYPE (node) = void_type_node;
11767       TREE_SIDE_EFFECTS (node) = 1;
11768       CAN_COMPLETE_NORMALLY (node) = 1;
11769       break;
11770
11771     case SWITCH_EXPR:
11772     case LOOP_EXPR:
11773       PUSH_LOOP (node);
11774       /* Check whether the loop was enclosed in a labeled
11775          statement. If not, create one, insert the loop in it and
11776          return the node */
11777       nn = patch_loop_statement (node);
11778
11779       /* Anyways, walk the body of the loop */
11780       if (TREE_CODE (node) == LOOP_EXPR)
11781         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11782       /* Switch statement: walk the switch expression and the cases */
11783       else
11784         node = patch_switch_statement (node);
11785
11786       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11787         nn = error_mark_node;
11788       else
11789         {
11790           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11791           /* If we returned something different, that's because we
11792              inserted a label. Pop the label too. */
11793           if (nn != node)
11794             {
11795               if (CAN_COMPLETE_NORMALLY (node))
11796                 CAN_COMPLETE_NORMALLY (nn) = 1;
11797               POP_LABELED_BLOCK ();
11798             }
11799         }
11800       POP_LOOP ();
11801       return nn;
11802
11803     case EXIT_EXPR:
11804       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11805       return patch_exit_expr (node);
11806
11807     case COND_EXPR:
11808       /* Condition */
11809       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11810       if (TREE_OPERAND (node, 0) == error_mark_node)
11811         return error_mark_node;
11812       /* then-else branches */
11813       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11814       if (TREE_OPERAND (node, 1) == error_mark_node)
11815         return error_mark_node;
11816       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11817       if (TREE_OPERAND (node, 2) == error_mark_node)
11818         return error_mark_node;
11819       return patch_if_else_statement (node);
11820       break;
11821
11822     case CONDITIONAL_EXPR:
11823       /* Condition */
11824       wfl_op1 = TREE_OPERAND (node, 0);
11825       COMPLETE_CHECK_OP_0 (node);
11826       wfl_op2 = TREE_OPERAND (node, 1);
11827       COMPLETE_CHECK_OP_1 (node);
11828       wfl_op3 = TREE_OPERAND (node, 2);
11829       COMPLETE_CHECK_OP_2 (node);
11830       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11831
11832       /* 3- Expression section */
11833     case COMPOUND_EXPR:
11834       wfl_op2 = TREE_OPERAND (node, 1);
11835       TREE_OPERAND (node, 0) = nn =
11836         java_complete_tree (TREE_OPERAND (node, 0));
11837       if (wfl_op2 == empty_stmt_node)
11838         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11839       else
11840         {
11841           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11842             {
11843               /* An unreachable condition in a do-while statement
11844                  is *not* (technically) an unreachable statement. */
11845               nn = wfl_op2;
11846               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11847                 nn = EXPR_WFL_NODE (nn);
11848               if (TREE_CODE (nn) != EXIT_EXPR)
11849                 {
11850                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11851                   parse_error_context (wfl_operator, "Unreachable statement");
11852                 }
11853             }
11854           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11855           if (TREE_OPERAND (node, 1) == error_mark_node)
11856             return error_mark_node;
11857           /* Even though we might allow the case where the first
11858              operand doesn't return normally, we still should compute
11859              CAN_COMPLETE_NORMALLY correctly.  */
11860           CAN_COMPLETE_NORMALLY (node)
11861             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11862                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11863         }
11864       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11865       break;
11866
11867     case RETURN_EXPR:
11868       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11869       return patch_return (node);
11870
11871     case EXPR_WITH_FILE_LOCATION:
11872       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11873           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11874         {
11875           tree wfl = node;
11876           node = resolve_expression_name (node, NULL);
11877           if (node == error_mark_node)
11878             return node;
11879           /* Keep line number information somewhere were it doesn't
11880              disrupt the completion process. */
11881           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11882             {
11883               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11884               TREE_OPERAND (node, 1) = wfl;
11885             }
11886           CAN_COMPLETE_NORMALLY (node) = 1;
11887         }
11888       else
11889         {
11890           tree body;
11891           int save_lineno = lineno;
11892           lineno = EXPR_WFL_LINENO (node);
11893           body = java_complete_tree (EXPR_WFL_NODE (node));
11894           lineno = save_lineno;
11895           EXPR_WFL_NODE (node) = body;
11896           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11897           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11898           if (body == empty_stmt_node || TREE_CONSTANT (body))
11899             {
11900               /* Makes it easier to constant fold, detect empty bodies. */
11901               return body;
11902             }
11903           if (body == error_mark_node)
11904             {
11905               /* Its important for the evaluation of assignment that
11906                  this mark on the TREE_TYPE is propagated. */
11907               TREE_TYPE (node) = error_mark_node;
11908               return error_mark_node;
11909             }
11910           else
11911             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11912
11913         }
11914       break;
11915
11916     case NEW_ARRAY_EXPR:
11917       /* Patch all the dimensions */
11918       flag = 0;
11919       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11920         {
11921           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11922           tree dim = convert (int_type_node,
11923                               java_complete_tree (TREE_VALUE (cn)));
11924           if (dim == error_mark_node)
11925             {
11926               flag = 1;
11927               continue;
11928             }
11929           else
11930             {
11931               TREE_VALUE (cn) = dim;
11932               /* Setup the location of the current dimension, for
11933                  later error report. */
11934               TREE_PURPOSE (cn) =
11935                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11936               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11937             }
11938         }
11939       /* They complete the array creation expression, if no errors
11940          were found. */
11941       CAN_COMPLETE_NORMALLY (node) = 1;
11942       return (flag ? error_mark_node
11943               : force_evaluation_order (patch_newarray (node)));
11944
11945     case NEW_ANONYMOUS_ARRAY_EXPR:
11946       /* Create the array type if necessary. */
11947       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11948         {
11949           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11950           if (!(type = resolve_type_during_patch (type)))
11951             return error_mark_node;
11952           type = build_array_from_name (type, NULL_TREE,
11953                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11954           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11955         }
11956       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11957                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11958       if (node == error_mark_node)
11959         return error_mark_node;
11960       CAN_COMPLETE_NORMALLY (node) = 1;
11961       return node;
11962
11963     case NEW_CLASS_EXPR:
11964     case CALL_EXPR:
11965       /* Complete function's argument(s) first */
11966       if (complete_function_arguments (node))
11967         return error_mark_node;
11968       else
11969         {
11970           tree decl, wfl = TREE_OPERAND (node, 0);
11971           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11972           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11973                            super_identifier_node);
11974
11975           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11976                                           from_super, 0, &decl);
11977           if (node == error_mark_node)
11978             return error_mark_node;
11979
11980           check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
11981           /* If we call this(...), register signature and positions */
11982           if (in_this)
11983             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11984               tree_cons (wfl, decl,
11985                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11986           CAN_COMPLETE_NORMALLY (node) = 1;
11987           return force_evaluation_order (node);
11988         }
11989
11990     case MODIFY_EXPR:
11991       /* Save potential wfls */
11992       wfl_op1 = TREE_OPERAND (node, 0);
11993       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11994
11995       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11996           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11997           && DECL_INITIAL (nn) != NULL_TREE)
11998         {
11999           tree value;
12000
12001           value = fold_constant_for_init (nn, nn);
12002
12003           /* When we have a primitype type, or a string and we're not
12004              emitting a class file, we actually don't want to generate
12005              anything for the assignment. */
12006           if (value != NULL_TREE &&
12007               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12008                (TREE_TYPE (value) == string_ptr_type_node &&
12009                 ! flag_emit_class_files)))
12010             {
12011               /* Prepare node for patch_assignment */
12012               TREE_OPERAND (node, 1) = value;
12013               /* Call patch assignment to verify the assignment */
12014               if (patch_assignment (node, wfl_op1) == error_mark_node)
12015                 return error_mark_node;
12016               /* Set DECL_INITIAL properly (a conversion might have
12017                  been decided by patch_assignment) and return the
12018                  empty statement. */
12019               else
12020                 {
12021                   tree patched = patch_string (TREE_OPERAND (node, 1));
12022                   if (patched)
12023                     DECL_INITIAL (nn) = patched;
12024                   else
12025                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12026                   DECL_FIELD_FINAL_IUD (nn) = 1;
12027                   return empty_stmt_node;
12028                 }
12029             }
12030           if (! flag_emit_class_files)
12031             DECL_INITIAL (nn) = NULL_TREE;
12032         }
12033       wfl_op2 = TREE_OPERAND (node, 1);
12034
12035       if (TREE_OPERAND (node, 0) == error_mark_node)
12036         return error_mark_node;
12037
12038       flag = COMPOUND_ASSIGN_P (wfl_op2);
12039       if (flag)
12040         {
12041           /* This might break when accessing outer field from inner
12042              class. TESTME, FIXME */
12043           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12044
12045           /* Hand stabilize the lhs on both places */
12046           TREE_OPERAND (node, 0) = lvalue;
12047           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12048             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12049
12050           /* 15.25.2.a: Left hand is not an array access. FIXME */
12051           /* Now complete the RHS. We write it back later on. */
12052           nn = java_complete_tree (TREE_OPERAND (node, 1));
12053
12054           if ((cn = patch_string (nn)))
12055             nn = cn;
12056
12057           /* The last part of the rewrite for E1 op= E2 is to have
12058              E1 = (T)(E1 op E2), with T being the type of E1. */
12059           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12060                                                TREE_TYPE (lvalue), nn));
12061
12062           /* If the assignment is compound and has reference type,
12063              then ensure the LHS has type String and nothing else.  */
12064           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12065               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12066             parse_error_context (wfl_op2,
12067                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12068                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12069
12070           /* 15.25.2.b: Left hand is an array access. FIXME */
12071         }
12072
12073       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12074          function to complete this RHS. Note that a NEW_ARRAY_INIT
12075          might have been already fully expanded if created as a result
12076          of processing an anonymous array initializer. We avoid doing
12077          the operation twice by testing whether the node already bears
12078          a type. */
12079       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12080         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12081                                    TREE_OPERAND (node, 1));
12082       /* Otherwise we simply complete the RHS */
12083       else
12084         nn = java_complete_tree (TREE_OPERAND (node, 1));
12085
12086       if (nn == error_mark_node)
12087         return error_mark_node;
12088
12089       /* Write back the RHS as we evaluated it. */
12090       TREE_OPERAND (node, 1) = nn;
12091
12092       /* In case we're handling = with a String as a RHS, we need to
12093          produce a String out of the RHS (it might still be a
12094          STRING_CST or a StringBuffer at this stage */
12095       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12096         TREE_OPERAND (node, 1) = nn;
12097
12098       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12099                                         TREE_OPERAND (node, 1))))
12100         {
12101           /* We return error_mark_node if outer_field_access_fix
12102              detects we write into a final. */
12103           if (nn == error_mark_node)
12104             return error_mark_node;
12105           node = nn;
12106         }
12107       else
12108         {
12109           node = patch_assignment (node, wfl_op1);
12110           if (node == error_mark_node)
12111             return error_mark_node;
12112           /* Reorganize the tree if necessary. */
12113           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12114                        || JSTRING_P (TREE_TYPE (node))))
12115             node = java_refold (node);
12116         }
12117
12118       /* Seek to set DECL_INITIAL to a proper value, since it might have
12119          undergone a conversion in patch_assignment. We do that only when
12120          it's necessary to have DECL_INITIAL properly set. */
12121       nn = TREE_OPERAND (node, 0);
12122       if (TREE_CODE (nn) == VAR_DECL
12123           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12124           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12125           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12126               || TREE_TYPE (nn) == string_ptr_type_node))
12127         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12128
12129       CAN_COMPLETE_NORMALLY (node) = 1;
12130       return node;
12131
12132     case MULT_EXPR:
12133     case PLUS_EXPR:
12134     case MINUS_EXPR:
12135     case LSHIFT_EXPR:
12136     case RSHIFT_EXPR:
12137     case URSHIFT_EXPR:
12138     case BIT_AND_EXPR:
12139     case BIT_XOR_EXPR:
12140     case BIT_IOR_EXPR:
12141     case TRUNC_MOD_EXPR:
12142     case TRUNC_DIV_EXPR:
12143     case RDIV_EXPR:
12144     case TRUTH_ANDIF_EXPR:
12145     case TRUTH_ORIF_EXPR:
12146     case EQ_EXPR:
12147     case NE_EXPR:
12148     case GT_EXPR:
12149     case GE_EXPR:
12150     case LT_EXPR:
12151     case LE_EXPR:
12152       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12153          knows how to handle those cases. */
12154       wfl_op1 = TREE_OPERAND (node, 0);
12155       wfl_op2 = TREE_OPERAND (node, 1);
12156
12157       CAN_COMPLETE_NORMALLY (node) = 1;
12158       /* Don't complete string nodes if dealing with the PLUS operand. */
12159       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12160         {
12161           nn = java_complete_tree (wfl_op1);
12162           if (nn == error_mark_node)
12163             return error_mark_node;
12164
12165           TREE_OPERAND (node, 0) = nn;
12166         }
12167       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12168         {
12169           nn = java_complete_tree (wfl_op2);
12170           if (nn == error_mark_node)
12171             return error_mark_node;
12172
12173           TREE_OPERAND (node, 1) = nn;
12174         }
12175       return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
12176
12177     case INSTANCEOF_EXPR:
12178       wfl_op1 = TREE_OPERAND (node, 0);
12179       COMPLETE_CHECK_OP_0 (node);
12180       if (flag_emit_xref)
12181         {
12182           TREE_TYPE (node) = boolean_type_node;
12183           return node;
12184         }
12185       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12186
12187     case UNARY_PLUS_EXPR:
12188     case NEGATE_EXPR:
12189     case TRUTH_NOT_EXPR:
12190     case BIT_NOT_EXPR:
12191     case PREDECREMENT_EXPR:
12192     case PREINCREMENT_EXPR:
12193     case POSTDECREMENT_EXPR:
12194     case POSTINCREMENT_EXPR:
12195     case CONVERT_EXPR:
12196       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12197          how to handle those cases. */
12198       wfl_op1 = TREE_OPERAND (node, 0);
12199       CAN_COMPLETE_NORMALLY (node) = 1;
12200       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12201       if (TREE_OPERAND (node, 0) == error_mark_node)
12202         return error_mark_node;
12203       node = patch_unaryop (node, wfl_op1);
12204       CAN_COMPLETE_NORMALLY (node) = 1;
12205       break;
12206
12207     case ARRAY_REF:
12208       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12209          how to handle those cases. */
12210       wfl_op1 = TREE_OPERAND (node, 0);
12211       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12212       if (TREE_OPERAND (node, 0) == error_mark_node)
12213         return error_mark_node;
12214       if (!flag_emit_class_files && !flag_emit_xref)
12215         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12216       /* The same applies to wfl_op2 */
12217       wfl_op2 = TREE_OPERAND (node, 1);
12218       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12219       if (TREE_OPERAND (node, 1) == error_mark_node)
12220         return error_mark_node;
12221       if (!flag_emit_class_files && !flag_emit_xref)
12222         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12223       return patch_array_ref (node);
12224
12225     case RECORD_TYPE:
12226       return node;;
12227
12228     case COMPONENT_REF:
12229       /* The first step in the re-write of qualified name handling.  FIXME.
12230          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12231       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12232       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12233         {
12234           tree name = TREE_OPERAND (node, 1);
12235           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12236           if (field == NULL_TREE)
12237             {
12238               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12239               return error_mark_node;
12240             }
12241           if (! FIELD_STATIC (field))
12242             {
12243               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12244               return error_mark_node;
12245             }
12246           return field;
12247         }
12248       else
12249         abort ();
12250       break;
12251
12252     case THIS_EXPR:
12253       /* Can't use THIS in a static environment */
12254       if (!current_this)
12255         {
12256           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12257           parse_error_context (wfl_operator,
12258                                "Keyword `this' used outside allowed context");
12259           TREE_TYPE (node) = error_mark_node;
12260           return error_mark_node;
12261         }
12262       if (ctxp->explicit_constructor_p)
12263         {
12264           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12265           parse_error_context
12266             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12267           TREE_TYPE (node) = error_mark_node;
12268           return error_mark_node;
12269         }
12270       return current_this;
12271
12272     case CLASS_LITERAL:
12273       CAN_COMPLETE_NORMALLY (node) = 1;
12274       node = patch_incomplete_class_ref (node);
12275       if (node == error_mark_node)
12276         return error_mark_node;
12277       break;
12278
12279     default:
12280       CAN_COMPLETE_NORMALLY (node) = 1;
12281       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12282          and it's time to turn it into the appropriate String object */
12283       if ((nn = patch_string (node)))
12284         node = nn;
12285       else
12286         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12287     }
12288   return node;
12289 }
12290
12291 /* Complete function call's argument. Return a non zero value is an
12292    error was found.  */
12293
12294 static int
12295 complete_function_arguments (node)
12296      tree node;
12297 {
12298   int flag = 0;
12299   tree cn;
12300
12301   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12302   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12303     {
12304       tree wfl = TREE_VALUE (cn), parm, temp;
12305       parm = java_complete_tree (wfl);
12306
12307       if (parm == error_mark_node)
12308         {
12309           flag = 1;
12310           continue;
12311         }
12312       /* If have a string literal that we haven't transformed yet or a
12313          crafted string buffer, as a result of use of the the String
12314          `+' operator. Build `parm.toString()' and expand it. */
12315       if ((temp = patch_string (parm)))
12316         parm = temp;
12317
12318       TREE_VALUE (cn) = parm;
12319     }
12320   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12321   return flag;
12322 }
12323
12324 /* Sometimes (for loops and variable initialized during their
12325    declaration), we want to wrap a statement around a WFL and turn it
12326    debugable.  */
12327
12328 static tree
12329 build_debugable_stmt (location, stmt)
12330     int location;
12331     tree stmt;
12332 {
12333   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12334     {
12335       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12336       EXPR_WFL_LINECOL (stmt) = location;
12337     }
12338   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12339   return stmt;
12340 }
12341
12342 static tree
12343 build_expr_block (body, decls)
12344      tree body, decls;
12345 {
12346   tree node = make_node (BLOCK);
12347   BLOCK_EXPR_DECLS (node) = decls;
12348   BLOCK_EXPR_BODY (node) = body;
12349   if (body)
12350     TREE_TYPE (node) = TREE_TYPE (body);
12351   TREE_SIDE_EFFECTS (node) = 1;
12352   return node;
12353 }
12354
12355 /* Create a new function block and link it appropriately to current
12356    function block chain */
12357
12358 static tree
12359 enter_block ()
12360 {
12361   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12362
12363   /* Link block B supercontext to the previous block. The current
12364      function DECL is used as supercontext when enter_a_block is called
12365      for the first time for a given function. The current function body
12366      (DECL_FUNCTION_BODY) is set to be block B.  */
12367
12368   tree fndecl = current_function_decl;
12369
12370   if (!fndecl) {
12371     BLOCK_SUPERCONTEXT (b) = current_static_block;
12372     current_static_block = b;
12373   }
12374
12375   else if (!DECL_FUNCTION_BODY (fndecl))
12376     {
12377       BLOCK_SUPERCONTEXT (b) = fndecl;
12378       DECL_FUNCTION_BODY (fndecl) = b;
12379     }
12380   else
12381     {
12382       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12383       DECL_FUNCTION_BODY (fndecl) = b;
12384     }
12385   return b;
12386 }
12387
12388 /* Exit a block by changing the current function body
12389    (DECL_FUNCTION_BODY) to the current block super context, only if
12390    the block being exited isn't the method's top level one.  */
12391
12392 static tree
12393 exit_block ()
12394 {
12395   tree b;
12396   if (current_function_decl)
12397     {
12398       b = DECL_FUNCTION_BODY (current_function_decl);
12399       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12400         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12401     }
12402   else
12403     {
12404       b = current_static_block;
12405
12406       if (BLOCK_SUPERCONTEXT (b))
12407         current_static_block = BLOCK_SUPERCONTEXT (b);
12408     }
12409   return b;
12410 }
12411
12412 /* Lookup for NAME in the nested function's blocks, all the way up to
12413    the current toplevel one. It complies with Java's local variable
12414    scoping rules.  */
12415
12416 static tree
12417 lookup_name_in_blocks (name)
12418      tree name;
12419 {
12420   tree b = GET_CURRENT_BLOCK (current_function_decl);
12421
12422   while (b != current_function_decl)
12423     {
12424       tree current;
12425
12426       /* Paranoid sanity check. To be removed */
12427       if (TREE_CODE (b) != BLOCK)
12428         abort ();
12429
12430       for (current = BLOCK_EXPR_DECLS (b); current;
12431            current = TREE_CHAIN (current))
12432         if (DECL_NAME (current) == name)
12433           return current;
12434       b = BLOCK_SUPERCONTEXT (b);
12435     }
12436   return NULL_TREE;
12437 }
12438
12439 static void
12440 maybe_absorb_scoping_blocks ()
12441 {
12442   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12443     {
12444       tree b = exit_block ();
12445       java_method_add_stmt (current_function_decl, b);
12446       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
12447     }
12448 }
12449
12450 \f
12451 /* This section of the source is reserved to build_* functions that
12452    are building incomplete tree nodes and the patch_* functions that
12453    are completing them.  */
12454
12455 /* Wrap a non WFL node around a WFL.  */
12456
12457 static tree
12458 build_wfl_wrap (node, location)
12459     tree node;
12460     int location;
12461 {
12462   tree wfl, node_to_insert = node;
12463
12464   /* We want to process THIS . xxx symbolicaly, to keep it consistent
12465      with the way we're processing SUPER. A THIS from a primary as a
12466      different form than a SUPER. Turn THIS into something symbolic */
12467   if (TREE_CODE (node) == THIS_EXPR)
12468     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12469   else
12470     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12471
12472   EXPR_WFL_LINECOL (wfl) = location;
12473   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12474   return wfl;
12475 }
12476
12477 /* Build a super() constructor invocation. Returns empty_stmt_node if
12478    we're currently dealing with the class java.lang.Object. */
12479
12480 static tree
12481 build_super_invocation (mdecl)
12482      tree mdecl;
12483 {
12484   if (DECL_CONTEXT (mdecl) == object_type_node)
12485     return empty_stmt_node;
12486   else
12487     {
12488       tree super_wfl = build_wfl_node (super_identifier_node);
12489       tree a = NULL_TREE, t;
12490       /* If we're dealing with an anonymous class, pass the arguments
12491          of the crafted constructor along. */
12492       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12493         {
12494           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12495           for (; t != end_params_node; t = TREE_CHAIN (t))
12496             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12497         }
12498       return build_method_invocation (super_wfl, a);
12499     }
12500 }
12501
12502 /* Build a SUPER/THIS qualified method invocation.  */
12503
12504 static tree
12505 build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
12506      int use_this;
12507      tree name, args;
12508      int lloc, rloc;
12509 {
12510   tree invok;
12511   tree wfl =
12512     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12513   EXPR_WFL_LINECOL (wfl) = lloc;
12514   invok = build_method_invocation (name, args);
12515   return make_qualified_primary (wfl, invok, rloc);
12516 }
12517
12518 /* Build an incomplete CALL_EXPR node. */
12519
12520 static tree
12521 build_method_invocation (name, args)
12522     tree name;
12523     tree args;
12524 {
12525   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12526   TREE_SIDE_EFFECTS (call) = 1;
12527   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12528   return call;
12529 }
12530
12531 /* Build an incomplete new xxx(...) node. */
12532
12533 static tree
12534 build_new_invocation (name, args)
12535     tree name, args;
12536 {
12537   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12538   TREE_SIDE_EFFECTS (call) = 1;
12539   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12540   return call;
12541 }
12542
12543 /* Build an incomplete assignment expression. */
12544
12545 static tree
12546 build_assignment (op, op_location, lhs, rhs)
12547      int op, op_location;
12548      tree lhs, rhs;
12549 {
12550   tree assignment;
12551   /* Build the corresponding binop if we deal with a Compound
12552      Assignment operator. Mark the binop sub-tree as part of a
12553      Compound Assignment expression */
12554   if (op != ASSIGN_TK)
12555     {
12556       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12557       COMPOUND_ASSIGN_P (rhs) = 1;
12558     }
12559   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12560   TREE_SIDE_EFFECTS (assignment) = 1;
12561   EXPR_WFL_LINECOL (assignment) = op_location;
12562   return assignment;
12563 }
12564
12565 /* Print an INTEGER_CST node in a static buffer, and return the buffer. */
12566
12567 char *
12568 print_int_node (node)
12569     tree node;
12570 {
12571   static char buffer [80];
12572   if (TREE_CONSTANT_OVERFLOW (node))
12573     sprintf (buffer, "<overflow>");
12574
12575   if (TREE_INT_CST_HIGH (node) == 0)
12576     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12577              TREE_INT_CST_LOW (node));
12578   else if (TREE_INT_CST_HIGH (node) == -1
12579            && TREE_INT_CST_LOW (node) != 0)
12580     {
12581       buffer [0] = '-';
12582       sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
12583                -TREE_INT_CST_LOW (node));
12584     }
12585   else
12586     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12587              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12588
12589   return buffer;
12590 }
12591
12592 \f
12593 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12594    context.  */
12595
12596 /* 15.25 Assignment operators. */
12597
12598 static tree
12599 patch_assignment (node, wfl_op1)
12600      tree node;
12601      tree wfl_op1;
12602 {
12603   tree rhs = TREE_OPERAND (node, 1);
12604   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12605   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12606   int error_found = 0;
12607   int lvalue_from_array = 0;
12608   int is_return = 0;
12609
12610   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12611
12612   /* Lhs can be a named variable */
12613   if (JDECL_P (lvalue))
12614     {
12615       lhs_type = TREE_TYPE (lvalue);
12616     }
12617   /* Or Lhs can be an array access. */
12618   else if (TREE_CODE (lvalue) == ARRAY_REF)
12619     {
12620       lhs_type = TREE_TYPE (lvalue);
12621       lvalue_from_array = 1;
12622     }
12623   /* Or a field access */
12624   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12625     lhs_type = TREE_TYPE (lvalue);
12626   /* Or a function return slot */
12627   else if (TREE_CODE (lvalue) == RESULT_DECL)
12628     {
12629       /* If the return type is an integral type, then we create the
12630          RESULT_DECL with a promoted type, but we need to do these
12631          checks against the unpromoted type to ensure type safety.  So
12632          here we look at the real type, not the type of the decl we
12633          are modifying.  */
12634       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12635       is_return = 1;
12636     }
12637   /* Otherwise, we might want to try to write into an optimized static
12638      final, this is an of a different nature, reported further on. */
12639   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12640            && resolve_expression_name (wfl_op1, &llvalue))
12641     {
12642       lhs_type = TREE_TYPE (lvalue);
12643     }
12644   else
12645     {
12646       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12647       error_found = 1;
12648     }
12649
12650   rhs_type = TREE_TYPE (rhs);
12651
12652   /* 5.1 Try the assignment conversion for builtin type. */
12653   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12654
12655   /* 5.2 If it failed, try a reference conversion */
12656   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
12657     lhs_type = promote_type (rhs_type);
12658
12659   /* 15.25.2 If we have a compound assignment, convert RHS into the
12660      type of the LHS */
12661   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12662     new_rhs = convert (lhs_type, rhs);
12663
12664   /* Explicit cast required. This is an error */
12665   if (!new_rhs)
12666     {
12667       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12668       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12669       tree wfl;
12670       char operation [32];      /* Max size known */
12671
12672       /* If the assignment is part of a declaration, we use the WFL of
12673          the declared variable to point out the error and call it a
12674          declaration problem. If the assignment is a genuine =
12675          operator, we call is a operator `=' problem, otherwise we
12676          call it an assignment problem. In both of these last cases,
12677          we use the WFL of the operator to indicate the error. */
12678
12679       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12680         {
12681           wfl = wfl_op1;
12682           strcpy (operation, "declaration");
12683         }
12684       else
12685         {
12686           wfl = wfl_operator;
12687           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12688             strcpy (operation, "assignment");
12689           else if (is_return)
12690             strcpy (operation, "`return'");
12691           else
12692             strcpy (operation, "`='");
12693         }
12694
12695       if (!valid_cast_to_p (rhs_type, lhs_type))
12696         parse_error_context
12697           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12698            operation, t1, t2);
12699       else
12700         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12701                              operation, t1, t2);
12702       free (t1); free (t2);
12703       error_found = 1;
12704     }
12705
12706   if (error_found)
12707     return error_mark_node;
12708
12709   /* If we're processing a `return' statement, promote the actual type
12710      to the promoted type.  */
12711   if (is_return)
12712     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12713
12714   /* 10.10: Array Store Exception runtime check */
12715   if (!flag_emit_class_files
12716       && !flag_emit_xref
12717       && lvalue_from_array
12718       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12719     {
12720       tree array, store_check, base, index_expr;
12721
12722       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12723       new_rhs = save_expr (new_rhs);
12724
12725       /* Get the INDIRECT_REF. */
12726       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12727       /* Get the array pointer expr. */
12728       array = TREE_OPERAND (array, 0);
12729       store_check = build_java_arraystore_check (array, new_rhs);
12730
12731       index_expr = TREE_OPERAND (lvalue, 1);
12732
12733       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12734         {
12735           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12736              happen before the store check, so prepare to insert the store
12737              check within the second operand of the existing COMPOUND_EXPR. */
12738           base = index_expr;
12739         }
12740       else
12741         base = lvalue;
12742
12743       index_expr = TREE_OPERAND (base, 1);
12744       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12745                                       store_check, index_expr);
12746     }
12747
12748   /* Final locals can be used as case values in switch
12749      statement. Prepare them for this eventuality. */
12750   if (TREE_CODE (lvalue) == VAR_DECL
12751       && DECL_FINAL (lvalue)
12752       && TREE_CONSTANT (new_rhs)
12753       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12754       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12755       )
12756     {
12757       TREE_CONSTANT (lvalue) = 1;
12758       DECL_INITIAL (lvalue) = new_rhs;
12759     }
12760
12761   TREE_OPERAND (node, 0) = lvalue;
12762   TREE_OPERAND (node, 1) = new_rhs;
12763   TREE_TYPE (node) = lhs_type;
12764   return node;
12765 }
12766
12767 /* Check that type SOURCE can be cast into type DEST. If the cast
12768    can't occur at all, return NULL; otherwise, return a possibly
12769    modified rhs.  */
12770
12771 static tree
12772 try_reference_assignconv (lhs_type, rhs)
12773      tree lhs_type, rhs;
12774 {
12775   tree new_rhs = NULL_TREE;
12776   tree rhs_type = TREE_TYPE (rhs);
12777
12778   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12779     {
12780       /* `null' may be assigned to any reference type */
12781       if (rhs == null_pointer_node)
12782         new_rhs = null_pointer_node;
12783       /* Try the reference assignment conversion */
12784       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12785         new_rhs = rhs;
12786       /* This is a magic assignment that we process differently */
12787       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12788         new_rhs = rhs;
12789     }
12790   return new_rhs;
12791 }
12792
12793 /* Check that RHS can be converted into LHS_TYPE by the assignment
12794    conversion (5.2), for the cases of RHS being a builtin type. Return
12795    NULL_TREE if the conversion fails or if because RHS isn't of a
12796    builtin type. Return a converted RHS if the conversion is possible.  */
12797
12798 static tree
12799 try_builtin_assignconv (wfl_op1, lhs_type, rhs)
12800      tree wfl_op1, lhs_type, rhs;
12801 {
12802   tree new_rhs = NULL_TREE;
12803   tree rhs_type = TREE_TYPE (rhs);
12804
12805   /* Handle boolean specially.  */
12806   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12807       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12808     {
12809       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12810           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12811         new_rhs = rhs;
12812     }
12813
12814   /* 5.1.1 Try Identity Conversion,
12815      5.1.2 Try Widening Primitive Conversion */
12816   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12817     new_rhs = convert (lhs_type, rhs);
12818
12819   /* Try a narrowing primitive conversion (5.1.3):
12820        - expression is a constant expression of type int AND
12821        - variable is byte, short or char AND
12822        - The value of the expression is representable in the type of the
12823          variable */
12824   else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
12825            && (lhs_type == byte_type_node || lhs_type == char_type_node
12826                || lhs_type == short_type_node))
12827     {
12828       if (int_fits_type_p (rhs, lhs_type))
12829         new_rhs = convert (lhs_type, rhs);
12830       else if (wfl_op1)         /* Might be called with a NULL */
12831         parse_warning_context
12832           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12833            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12834       /* Reported a warning that will turn into an error further
12835          down, so we don't return */
12836     }
12837
12838   return new_rhs;
12839 }
12840
12841 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12842    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12843    0 is the conversion test fails.  This implements parts the method
12844    invocation convertion (5.3).  */
12845
12846 static int
12847 valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
12848      tree lhs_type, rhs_type;
12849 {
12850   /* 5.1.1: This is the identity conversion part. */
12851   if (lhs_type == rhs_type)
12852     return 1;
12853
12854   /* Reject non primitive types and boolean conversions.  */
12855   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12856     return 0;
12857
12858   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12859      than a char can't be converted into a char. Short can't too, but
12860      the < test below takes care of that */
12861   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12862     return 0;
12863
12864   /* Accept all promoted type here. Note, we can't use <= in the test
12865      below, because we still need to bounce out assignments of short
12866      to char and the likes */
12867   if (lhs_type == int_type_node
12868       && (rhs_type == promoted_byte_type_node
12869           || rhs_type == promoted_short_type_node
12870           || rhs_type == promoted_char_type_node
12871           || rhs_type == promoted_boolean_type_node))
12872     return 1;
12873
12874   /* From here, an integral is widened if its precision is smaller
12875      than the precision of the LHS or if the LHS is a floating point
12876      type, or the RHS is a float and the RHS a double. */
12877   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12878        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12879       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12880       || (rhs_type == float_type_node && lhs_type == double_type_node))
12881     return 1;
12882
12883   return 0;
12884 }
12885
12886 /* Check that something of SOURCE type can be assigned or cast to
12887    something of DEST type at runtime. Return 1 if the operation is
12888    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12889    were SOURCE is cast into DEST, which borrows a lot of the
12890    assignment check. */
12891
12892 static int
12893 valid_ref_assignconv_cast_p (source, dest, cast)
12894      tree source;
12895      tree dest;
12896      int cast;
12897 {
12898   /* SOURCE or DEST might be null if not from a declared entity. */
12899   if (!source || !dest)
12900     return 0;
12901   if (JNULLP_TYPE_P (source))
12902     return 1;
12903   if (TREE_CODE (source) == POINTER_TYPE)
12904     source = TREE_TYPE (source);
12905   if (TREE_CODE (dest) == POINTER_TYPE)
12906     dest = TREE_TYPE (dest);
12907
12908   /* If source and dest are being compiled from bytecode, they may need to
12909      be loaded. */
12910   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12911     {
12912       load_class (source, 1);
12913       safe_layout_class (source);
12914     }
12915   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12916     {
12917       load_class (dest, 1);
12918       safe_layout_class (dest);
12919     }
12920
12921   /* Case where SOURCE is a class type */
12922   if (TYPE_CLASS_P (source))
12923     {
12924       if (TYPE_CLASS_P (dest))
12925         return  (source == dest
12926                  || inherits_from_p (source, dest)
12927                  || (cast && inherits_from_p (dest, source)));
12928       if (TYPE_INTERFACE_P (dest))
12929         {
12930           /* If doing a cast and SOURCE is final, the operation is
12931              always correct a compile time (because even if SOURCE
12932              does not implement DEST, a subclass of SOURCE might). */
12933           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12934             return 1;
12935           /* Otherwise, SOURCE must implement DEST */
12936           return interface_of_p (dest, source);
12937         }
12938       /* DEST is an array, cast permited if SOURCE is of Object type */
12939       return (cast && source == object_type_node ? 1 : 0);
12940     }
12941   if (TYPE_INTERFACE_P (source))
12942     {
12943       if (TYPE_CLASS_P (dest))
12944         {
12945           /* If not casting, DEST must be the Object type */
12946           if (!cast)
12947             return dest == object_type_node;
12948           /* We're doing a cast. The cast is always valid is class
12949              DEST is not final, otherwise, DEST must implement SOURCE */
12950           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12951             return 1;
12952           else
12953             return interface_of_p (source, dest);
12954         }
12955       if (TYPE_INTERFACE_P (dest))
12956         {
12957           /* If doing a cast, then if SOURCE and DEST contain method
12958              with the same signature but different return type, then
12959              this is a (compile time) error */
12960           if (cast)
12961             {
12962               tree method_source, method_dest;
12963               tree source_type;
12964               tree source_sig;
12965               tree source_name;
12966               for (method_source = TYPE_METHODS (source); method_source;
12967                    method_source = TREE_CHAIN (method_source))
12968                 {
12969                   source_sig =
12970                     build_java_argument_signature (TREE_TYPE (method_source));
12971                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12972                   source_name = DECL_NAME (method_source);
12973                   for (method_dest = TYPE_METHODS (dest);
12974                        method_dest; method_dest = TREE_CHAIN (method_dest))
12975                     if (source_sig ==
12976                         build_java_argument_signature (TREE_TYPE (method_dest))
12977                         && source_name == DECL_NAME (method_dest)
12978                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12979                       return 0;
12980                 }
12981               return 1;
12982             }
12983           else
12984             return source == dest || interface_of_p (dest, source);
12985         }
12986       else
12987         {
12988           /* Array */
12989           return (cast
12990                   && (DECL_NAME (TYPE_NAME (source)) == java_lang_cloneable
12991                       || (DECL_NAME (TYPE_NAME (source))
12992                           == java_io_serializable)));
12993         }
12994     }
12995   if (TYPE_ARRAY_P (source))
12996     {
12997       if (TYPE_CLASS_P (dest))
12998         return dest == object_type_node;
12999       /* Can't cast an array to an interface unless the interface is
13000          java.lang.Cloneable or java.io.Serializable.  */
13001       if (TYPE_INTERFACE_P (dest))
13002         return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable
13003                 || DECL_NAME (TYPE_NAME (dest)) == java_io_serializable);
13004       else                      /* Arrays */
13005         {
13006           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13007           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13008
13009           /* In case of severe errors, they turn out null */
13010           if (!dest_element_type || !source_element_type)
13011             return 0;
13012           if (source_element_type == dest_element_type)
13013             return 1;
13014           return valid_ref_assignconv_cast_p (source_element_type,
13015                                               dest_element_type, cast);
13016         }
13017       return 0;
13018     }
13019   return 0;
13020 }
13021
13022 static int
13023 valid_cast_to_p (source, dest)
13024      tree source;
13025      tree dest;
13026 {
13027   if (TREE_CODE (source) == POINTER_TYPE)
13028     source = TREE_TYPE (source);
13029   if (TREE_CODE (dest) == POINTER_TYPE)
13030     dest = TREE_TYPE (dest);
13031
13032   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13033     return valid_ref_assignconv_cast_p (source, dest, 1);
13034
13035   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13036     return 1;
13037
13038   else if (TREE_CODE (source) == BOOLEAN_TYPE
13039            && TREE_CODE (dest) == BOOLEAN_TYPE)
13040     return 1;
13041
13042   return 0;
13043 }
13044
13045 static tree
13046 do_unary_numeric_promotion (arg)
13047      tree arg;
13048 {
13049   tree type = TREE_TYPE (arg);
13050   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13051       || TREE_CODE (type) == CHAR_TYPE)
13052     arg = convert (int_type_node, arg);
13053   return arg;
13054 }
13055
13056 /* Return a non zero value if SOURCE can be converted into DEST using
13057    the method invocation conversion rule (5.3).  */
13058 static int
13059 valid_method_invocation_conversion_p (dest, source)
13060      tree dest, source;
13061 {
13062   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13063            && valid_builtin_assignconv_identity_widening_p (dest, source))
13064           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13065               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13066               && valid_ref_assignconv_cast_p (source, dest, 0)));
13067 }
13068
13069 /* Build an incomplete binop expression. */
13070
13071 static tree
13072 build_binop (op, op_location, op1, op2)
13073      enum tree_code op;
13074      int op_location;
13075      tree op1, op2;
13076 {
13077   tree binop = build (op, NULL_TREE, op1, op2);
13078   TREE_SIDE_EFFECTS (binop) = 1;
13079   /* Store the location of the operator, for better error report. The
13080      string of the operator will be rebuild based on the OP value. */
13081   EXPR_WFL_LINECOL (binop) = op_location;
13082   return binop;
13083 }
13084
13085 /* Build the string of the operator retained by NODE. If NODE is part
13086    of a compound expression, add an '=' at the end of the string. This
13087    function is called when an error needs to be reported on an
13088    operator. The string is returned as a pointer to a static character
13089    buffer. */
13090
13091 static char *
13092 operator_string (node)
13093      tree node;
13094 {
13095 #define BUILD_OPERATOR_STRING(S)                                        \
13096   {                                                                     \
13097     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13098     return buffer;                                                      \
13099   }
13100
13101   static char buffer [10];
13102   switch (TREE_CODE (node))
13103     {
13104     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13105     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13106     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13107     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13108     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13109     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13110     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13111     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13112     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13113     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13114     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13115     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13116     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13117     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13118     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13119     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13120     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13121     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13122     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13123     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13124     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13125     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13126     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13127     case PREINCREMENT_EXPR:     /* Fall through */
13128     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13129     case PREDECREMENT_EXPR:     /* Fall through */
13130     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13131     default:
13132       internal_error ("unregistered operator %s",
13133                       tree_code_name [TREE_CODE (node)]);
13134     }
13135   return NULL;
13136 #undef BUILD_OPERATOR_STRING
13137 }
13138
13139 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13140
13141 static int
13142 java_decl_equiv (var_acc1, var_acc2)
13143      tree var_acc1, var_acc2;
13144 {
13145   if (JDECL_P (var_acc1))
13146     return (var_acc1 == var_acc2);
13147
13148   return (TREE_CODE (var_acc1) == COMPONENT_REF
13149           && TREE_CODE (var_acc2) == COMPONENT_REF
13150           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13151              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13152           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13153 }
13154
13155 /* Return a non zero value if CODE is one of the operators that can be
13156    used in conjunction with the `=' operator in a compound assignment.  */
13157
13158 static int
13159 binop_compound_p (code)
13160     enum tree_code code;
13161 {
13162   int i;
13163   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13164     if (binop_lookup [i] == code)
13165       break;
13166
13167   return i < BINOP_COMPOUND_CANDIDATES;
13168 }
13169
13170 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13171
13172 static tree
13173 java_refold (t)
13174      tree t;
13175 {
13176   tree c, b, ns, decl;
13177
13178   if (TREE_CODE (t) != MODIFY_EXPR)
13179     return t;
13180
13181   c = TREE_OPERAND (t, 1);
13182   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13183          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13184          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13185     return t;
13186
13187   /* Now the left branch of the binary operator. */
13188   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13189   if (! (b && TREE_CODE (b) == NOP_EXPR
13190          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13191     return t;
13192
13193   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13194   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13195          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13196     return t;
13197
13198   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13199   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13200       /* It's got to be the an equivalent decl */
13201       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13202     {
13203       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13204       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13205       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13206       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13207       /* Change the right part of the BINOP_EXPR */
13208       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13209     }
13210
13211   return t;
13212 }
13213
13214 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13215    errors but we modify NODE so that it contains the type computed
13216    according to the expression, when it's fixed. Otherwise, we write
13217    error_mark_node as the type. It allows us to further the analysis
13218    of remaining nodes and detects more errors in certain cases.  */
13219
13220 static tree
13221 patch_binop (node, wfl_op1, wfl_op2)
13222      tree node;
13223      tree wfl_op1;
13224      tree wfl_op2;
13225 {
13226   tree op1 = TREE_OPERAND (node, 0);
13227   tree op2 = TREE_OPERAND (node, 1);
13228   tree op1_type = TREE_TYPE (op1);
13229   tree op2_type = TREE_TYPE (op2);
13230   tree prom_type = NULL_TREE, cn;
13231   enum tree_code code = TREE_CODE (node);
13232
13233   /* If 1, tell the routine that we have to return error_mark_node
13234      after checking for the initialization of the RHS */
13235   int error_found = 0;
13236
13237   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13238
13239   /* If either op<n>_type are NULL, this might be early signs of an
13240      error situation, unless it's too early to tell (in case we're
13241      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13242      correctly so the error can be later on reported accurately. */
13243   if (! (code == PLUS_EXPR || code == NE_EXPR
13244          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13245     {
13246       tree n;
13247       if (! op1_type)
13248         {
13249           n = java_complete_tree (op1);
13250           op1_type = TREE_TYPE (n);
13251         }
13252       if (! op2_type)
13253         {
13254           n = java_complete_tree (op2);
13255           op2_type = TREE_TYPE (n);
13256         }
13257     }
13258
13259   switch (code)
13260     {
13261     /* 15.16 Multiplicative operators */
13262     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13263     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13264     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13265     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13266       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13267         {
13268           if (!JNUMERIC_TYPE_P (op1_type))
13269             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13270           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13271             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13272           TREE_TYPE (node) = error_mark_node;
13273           error_found = 1;
13274           break;
13275         }
13276       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13277
13278       /* Detect integral division by zero */
13279       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13280           && TREE_CODE (prom_type) == INTEGER_TYPE
13281           && (op2 == integer_zero_node || op2 == long_zero_node ||
13282               (TREE_CODE (op2) == INTEGER_CST &&
13283                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13284         {
13285           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13286           TREE_CONSTANT (node) = 0;
13287         }
13288
13289       /* Change the division operator if necessary */
13290       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13291         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13292
13293       /* Before divisions as is disapear, try to simplify and bail if
13294          applicable, otherwise we won't perform even simple
13295          simplifications like (1-1)/3. We can't do that with floating
13296          point number, folds can't handle them at this stage. */
13297       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13298           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13299         {
13300           TREE_TYPE (node) = prom_type;
13301           node = fold (node);
13302           if (TREE_CODE (node) != code)
13303             return node;
13304         }
13305
13306       if (TREE_CODE (prom_type) == INTEGER_TYPE
13307           && flag_use_divide_subroutine
13308           && ! flag_emit_class_files
13309           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13310         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13311
13312       /* This one is more complicated. FLOATs are processed by a
13313          function call to soft_fmod. Duplicate the value of the
13314          COMPOUND_ASSIGN_P flag. */
13315       if (code == TRUNC_MOD_EXPR)
13316         {
13317           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13318           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13319           TREE_SIDE_EFFECTS (mod)
13320             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13321           return mod;
13322         }
13323       break;
13324
13325     /* 15.17 Additive Operators */
13326     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13327
13328       /* Operation is valid if either one argument is a string
13329          constant, a String object or a StringBuffer crafted for the
13330          purpose of the a previous usage of the String concatenation
13331          operator */
13332
13333       if (TREE_CODE (op1) == STRING_CST
13334           || TREE_CODE (op2) == STRING_CST
13335           || JSTRING_TYPE_P (op1_type)
13336           || JSTRING_TYPE_P (op2_type)
13337           || IS_CRAFTED_STRING_BUFFER_P (op1)
13338           || IS_CRAFTED_STRING_BUFFER_P (op2))
13339         return build_string_concatenation (op1, op2);
13340
13341     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13342                                    Numeric Types */
13343       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13344         {
13345           if (!JNUMERIC_TYPE_P (op1_type))
13346             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13347           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13348             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13349           TREE_TYPE (node) = error_mark_node;
13350           error_found = 1;
13351           break;
13352         }
13353       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13354       break;
13355
13356     /* 15.18 Shift Operators */
13357     case LSHIFT_EXPR:
13358     case RSHIFT_EXPR:
13359     case URSHIFT_EXPR:
13360       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13361         {
13362           if (!JINTEGRAL_TYPE_P (op1_type))
13363             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13364           else
13365             {
13366               if (JNUMERIC_TYPE_P (op2_type))
13367                 parse_error_context (wfl_operator,
13368                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13369                                      operator_string (node),
13370                                      lang_printable_name (op2_type, 0));
13371               else
13372                 parse_error_context (wfl_operator,
13373                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13374                                      operator_string (node),
13375                                      lang_printable_name (op2_type, 0));
13376             }
13377           TREE_TYPE (node) = error_mark_node;
13378           error_found = 1;
13379           break;
13380         }
13381
13382       /* Unary numeric promotion (5.6.1) is performed on each operand
13383          separately */
13384       op1 = do_unary_numeric_promotion (op1);
13385       op2 = do_unary_numeric_promotion (op2);
13386
13387       /* The type of the shift expression is the type of the promoted
13388          type of the left-hand operand */
13389       prom_type = TREE_TYPE (op1);
13390
13391       /* Shift int only up to 0x1f and long up to 0x3f */
13392       if (prom_type == int_type_node)
13393         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13394                            build_int_2 (0x1f, 0)));
13395       else
13396         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13397                            build_int_2 (0x3f, 0)));
13398
13399       /* The >>> operator is a >> operating on unsigned quantities */
13400       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13401         {
13402           tree to_return;
13403           tree utype = unsigned_type (prom_type);
13404           op1 = convert (utype, op1);
13405           TREE_SET_CODE (node, RSHIFT_EXPR);
13406           TREE_OPERAND (node, 0) = op1;
13407           TREE_OPERAND (node, 1) = op2;
13408           TREE_TYPE (node) = utype;
13409           to_return = convert (prom_type, node);
13410           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13411           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13412           TREE_SIDE_EFFECTS (to_return)
13413             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13414           return to_return;
13415         }
13416       break;
13417
13418       /* 15.19.1 Type Comparison Operator instaceof */
13419     case INSTANCEOF_EXPR:
13420
13421       TREE_TYPE (node) = boolean_type_node;
13422
13423       if (!(op2_type = resolve_type_during_patch (op2)))
13424         return error_mark_node;
13425
13426       /* The first operand must be a reference type or the null type */
13427       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13428         error_found = 1;        /* Error reported further below */
13429
13430       /* The second operand must be a reference type */
13431       if (!JREFERENCE_TYPE_P (op2_type))
13432         {
13433           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13434           parse_error_context
13435             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13436              lang_printable_name (op2_type, 0));
13437           error_found = 1;
13438         }
13439
13440       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13441         {
13442           /* If the first operand is null, the result is always false */
13443           if (op1 == null_pointer_node)
13444             return boolean_false_node;
13445           else if (flag_emit_class_files)
13446             {
13447               TREE_OPERAND (node, 1) = op2_type;
13448               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13449               return node;
13450             }
13451           /* Otherwise we have to invoke instance of to figure it out */
13452           else
13453             return build_instanceof (op1, op2_type);
13454         }
13455       /* There is no way the expression operand can be an instance of
13456          the type operand. This is a compile time error. */
13457       else
13458         {
13459           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13460           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13461           parse_error_context
13462             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13463              t1, lang_printable_name (op2_type, 0));
13464           free (t1);
13465           error_found = 1;
13466         }
13467
13468       break;
13469
13470       /* 15.21 Bitwise and Logical Operators */
13471     case BIT_AND_EXPR:
13472     case BIT_XOR_EXPR:
13473     case BIT_IOR_EXPR:
13474       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13475         /* Binary numeric promotion is performed on both operand and the
13476            expression retain that type */
13477         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13478
13479       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13480                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13481         /* The type of the bitwise operator expression is BOOLEAN */
13482         prom_type = boolean_type_node;
13483       else
13484         {
13485           if (!JINTEGRAL_TYPE_P (op1_type))
13486             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13487           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13488             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13489           TREE_TYPE (node) = error_mark_node;
13490           error_found = 1;
13491           /* Insert a break here if adding thing before the switch's
13492              break for this case */
13493         }
13494       break;
13495
13496       /* 15.22 Conditional-And Operator */
13497     case TRUTH_ANDIF_EXPR:
13498       /* 15.23 Conditional-Or Operator */
13499     case TRUTH_ORIF_EXPR:
13500       /* Operands must be of BOOLEAN type */
13501       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13502           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13503         {
13504           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13505             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13506           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13507             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13508           TREE_TYPE (node) = boolean_type_node;
13509           error_found = 1;
13510           break;
13511         }
13512       else if (integer_zerop (op1))
13513         {
13514           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13515         }
13516       else if (integer_onep (op1))
13517         {
13518           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13519         }
13520       /* The type of the conditional operators is BOOLEAN */
13521       prom_type = boolean_type_node;
13522       break;
13523
13524       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13525     case LT_EXPR:
13526     case GT_EXPR:
13527     case LE_EXPR:
13528     case GE_EXPR:
13529       /* The type of each of the operands must be a primitive numeric
13530          type */
13531       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13532         {
13533           if (!JNUMERIC_TYPE_P (op1_type))
13534             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13535           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13536             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13537           TREE_TYPE (node) = boolean_type_node;
13538           error_found = 1;
13539           break;
13540         }
13541       /* Binary numeric promotion is performed on the operands */
13542       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13543       /* The type of the relation expression is always BOOLEAN */
13544       prom_type = boolean_type_node;
13545       break;
13546
13547       /* 15.20 Equality Operator */
13548     case EQ_EXPR:
13549     case NE_EXPR:
13550       /* It's time for us to patch the strings. */
13551       if ((cn = patch_string (op1)))
13552        {
13553          op1 = cn;
13554          op1_type = TREE_TYPE (op1);
13555        }
13556       if ((cn = patch_string (op2)))
13557        {
13558          op2 = cn;
13559          op2_type = TREE_TYPE (op2);
13560        }
13561
13562       /* 15.20.1 Numerical Equality Operators == and != */
13563       /* Binary numeric promotion is performed on the operands */
13564       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13565         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13566
13567       /* 15.20.2 Boolean Equality Operators == and != */
13568       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13569           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13570         ;                       /* Nothing to do here */
13571
13572       /* 15.20.3 Reference Equality Operators == and != */
13573       /* Types have to be either references or the null type. If
13574          they're references, it must be possible to convert either
13575          type to the other by casting conversion. */
13576       else if (op1 == null_pointer_node || op2 == null_pointer_node
13577                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13578                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13579                        || valid_ref_assignconv_cast_p (op2_type,
13580                                                        op1_type, 1))))
13581         ;                       /* Nothing to do here */
13582
13583       /* Else we have an error figure what can't be converted into
13584          what and report the error */
13585       else
13586         {
13587           char *t1;
13588           t1 = xstrdup (lang_printable_name (op1_type, 0));
13589           parse_error_context
13590             (wfl_operator,
13591              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13592              operator_string (node), t1,
13593              lang_printable_name (op2_type, 0));
13594           free (t1);
13595           TREE_TYPE (node) = boolean_type_node;
13596           error_found = 1;
13597           break;
13598         }
13599       prom_type = boolean_type_node;
13600       break;
13601     default:
13602       abort ();
13603     }
13604
13605   if (error_found)
13606     return error_mark_node;
13607
13608   TREE_OPERAND (node, 0) = op1;
13609   TREE_OPERAND (node, 1) = op2;
13610   TREE_TYPE (node) = prom_type;
13611   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13612
13613   if (flag_emit_xref)
13614     return node;
13615
13616   /* fold does not respect side-effect order as required for Java but not C.
13617    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13618    * bytecode.
13619    */
13620   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13621       : ! TREE_SIDE_EFFECTS (node))
13622     node = fold (node);
13623   return node;
13624 }
13625
13626 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13627    zero value, the value of CSTE comes after the valude of STRING */
13628
13629 static tree
13630 do_merge_string_cste (cste, string, string_len, after)
13631      tree cste;
13632      const char *string;
13633      int string_len, after;
13634 {
13635   const char *old = TREE_STRING_POINTER (cste);
13636   int old_len = TREE_STRING_LENGTH (cste);
13637   int len = old_len + string_len;
13638   char *new = alloca (len+1);
13639
13640   if (after)
13641     {
13642       memcpy (new, string, string_len);
13643       memcpy (&new [string_len], old, old_len);
13644     }
13645   else
13646     {
13647       memcpy (new, old, old_len);
13648       memcpy (&new [old_len], string, string_len);
13649     }
13650   new [len] = '\0';
13651   return build_string (len, new);
13652 }
13653
13654 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13655    new STRING_CST on success, NULL_TREE on failure */
13656
13657 static tree
13658 merge_string_cste (op1, op2, after)
13659      tree op1, op2;
13660      int after;
13661 {
13662   /* Handle two string constants right away */
13663   if (TREE_CODE (op2) == STRING_CST)
13664     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13665                                  TREE_STRING_LENGTH (op2), after);
13666
13667   /* Reasonable integer constant can be treated right away */
13668   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13669     {
13670       static const char *const boolean_true = "true";
13671       static const char *const boolean_false = "false";
13672       static const char *const null_pointer = "null";
13673       char ch[3];
13674       const char *string;
13675
13676       if (op2 == boolean_true_node)
13677         string = boolean_true;
13678       else if (op2 == boolean_false_node)
13679         string = boolean_false;
13680       else if (op2 == null_pointer_node)
13681         string = null_pointer;
13682       else if (TREE_TYPE (op2) == char_type_node)
13683         {
13684           ch[0] = (char )TREE_INT_CST_LOW (op2);
13685           ch[1] = '\0';
13686           string = ch;
13687         }
13688       else
13689           string = print_int_node (op2);
13690
13691       return do_merge_string_cste (op1, string, strlen (string), after);
13692     }
13693   return NULL_TREE;
13694 }
13695
13696 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13697    has to be a STRING_CST and the other part must be a STRING_CST or a
13698    INTEGRAL constant. Return a new STRING_CST if the operation
13699    succeed, NULL_TREE otherwise.
13700
13701    If the case we want to optimize for space, we might want to return
13702    NULL_TREE for each invocation of this routine. FIXME */
13703
13704 static tree
13705 string_constant_concatenation (op1, op2)
13706      tree op1, op2;
13707 {
13708   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13709     {
13710       tree string, rest;
13711       int invert;
13712
13713       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13714       rest   = (string == op1 ? op2 : op1);
13715       invert = (string == op1 ? 0 : 1 );
13716
13717       /* Walk REST, only if it looks reasonable */
13718       if (TREE_CODE (rest) != STRING_CST
13719           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13720           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13721           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13722         {
13723           rest = java_complete_tree (rest);
13724           if (rest == error_mark_node)
13725             return error_mark_node;
13726           rest = fold (rest);
13727         }
13728       return merge_string_cste (string, rest, invert);
13729     }
13730   return NULL_TREE;
13731 }
13732
13733 /* Implement the `+' operator. Does static optimization if possible,
13734    otherwise create (if necessary) and append elements to a
13735    StringBuffer. The StringBuffer will be carried around until it is
13736    used for a function call or an assignment. Then toString() will be
13737    called on it to turn it into a String object. */
13738
13739 static tree
13740 build_string_concatenation (op1, op2)
13741      tree op1, op2;
13742 {
13743   tree result;
13744   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13745
13746   if (flag_emit_xref)
13747     return build (PLUS_EXPR, string_type_node, op1, op2);
13748
13749   /* Try to do some static optimization */
13750   if ((result = string_constant_concatenation (op1, op2)))
13751     return result;
13752
13753   /* Discard empty strings on either side of the expression */
13754   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13755     {
13756       op1 = op2;
13757       op2 = NULL_TREE;
13758     }
13759   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13760     op2 = NULL_TREE;
13761
13762   /* If operands are string constant, turn then into object references */
13763   if (TREE_CODE (op1) == STRING_CST)
13764     op1 = patch_string_cst (op1);
13765   if (op2 && TREE_CODE (op2) == STRING_CST)
13766     op2 = patch_string_cst (op2);
13767
13768   /* If either one of the constant is null and the other non null
13769      operand is a String object, return it. */
13770   if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
13771     return op1;
13772
13773   /* If OP1 isn't already a StringBuffer, create and
13774      initialize a new one */
13775   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13776     {
13777       /* Two solutions here:
13778          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13779          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13780       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13781         op1 = BUILD_STRING_BUFFER (op1);
13782       else
13783         {
13784           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13785           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13786         }
13787     }
13788
13789   if (op2)
13790     {
13791       /* OP1 is no longer the last node holding a crafted StringBuffer */
13792       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13793       /* Create a node for `{new...,xxx}.append (op2)' */
13794       if (op2)
13795         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13796     }
13797
13798   /* Mark the last node holding a crafted StringBuffer */
13799   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13800
13801   TREE_SIDE_EFFECTS (op1) = side_effects;
13802   return op1;
13803 }
13804
13805 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13806    StringBuffer. If no string were found to be patched, return
13807    NULL. */
13808
13809 static tree
13810 patch_string (node)
13811     tree node;
13812 {
13813   if (node == error_mark_node)
13814     return error_mark_node;
13815   if (TREE_CODE (node) == STRING_CST)
13816     return patch_string_cst (node);
13817   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13818     {
13819       int saved = ctxp->explicit_constructor_p;
13820       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13821       tree ret;
13822       /* Temporary disable forbid the use of `this'. */
13823       ctxp->explicit_constructor_p = 0;
13824       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13825       /* String concatenation arguments must be evaluated in order too. */
13826       ret = force_evaluation_order (ret);
13827       /* Restore it at its previous value */
13828       ctxp->explicit_constructor_p = saved;
13829       return ret;
13830     }
13831   return NULL_TREE;
13832 }
13833
13834 /* Build the internal representation of a string constant.  */
13835
13836 static tree
13837 patch_string_cst (node)
13838      tree node;
13839 {
13840   int location;
13841   if (! flag_emit_class_files)
13842     {
13843       node = get_identifier (TREE_STRING_POINTER (node));
13844       location = alloc_name_constant (CONSTANT_String, node);
13845       node = build_ref_from_constant_pool (location);
13846     }
13847   TREE_TYPE (node) = string_ptr_type_node;
13848   TREE_CONSTANT (node) = 1;
13849   return node;
13850 }
13851
13852 /* Build an incomplete unary operator expression. */
13853
13854 static tree
13855 build_unaryop (op_token, op_location, op1)
13856      int op_token, op_location;
13857      tree op1;
13858 {
13859   enum tree_code op;
13860   tree unaryop;
13861   switch (op_token)
13862     {
13863     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13864     case MINUS_TK: op = NEGATE_EXPR; break;
13865     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13866     case NOT_TK: op = BIT_NOT_EXPR; break;
13867     default: abort ();
13868     }
13869
13870   unaryop = build1 (op, NULL_TREE, op1);
13871   TREE_SIDE_EFFECTS (unaryop) = 1;
13872   /* Store the location of the operator, for better error report. The
13873      string of the operator will be rebuild based on the OP value. */
13874   EXPR_WFL_LINECOL (unaryop) = op_location;
13875   return unaryop;
13876 }
13877
13878 /* Special case for the ++/-- operators, since they require an extra
13879    argument to build, which is set to NULL and patched
13880    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13881
13882 static tree
13883 build_incdec (op_token, op_location, op1, is_post_p)
13884      int op_token, op_location;
13885      tree op1;
13886      int is_post_p;
13887 {
13888   static const enum tree_code lookup [2][2] =
13889     {
13890       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13891       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13892     };
13893   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13894                      NULL_TREE, op1, NULL_TREE);
13895   TREE_SIDE_EFFECTS (node) = 1;
13896   /* Store the location of the operator, for better error report. The
13897      string of the operator will be rebuild based on the OP value. */
13898   EXPR_WFL_LINECOL (node) = op_location;
13899   return node;
13900 }
13901
13902 /* Build an incomplete cast operator, based on the use of the
13903    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13904    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13905    though its type is already set.  */
13906
13907 static tree
13908 build_cast (location, type, exp)
13909      int location;
13910      tree type, exp;
13911 {
13912   tree node = build1 (CONVERT_EXPR, type, exp);
13913   EXPR_WFL_LINECOL (node) = location;
13914   return node;
13915 }
13916
13917 /* Build an incomplete class reference operator.  */
13918 static tree
13919 build_incomplete_class_ref (location, class_name)
13920     int location;
13921     tree class_name;
13922 {
13923   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13924   EXPR_WFL_LINECOL (node) = location;
13925   return node;
13926 }
13927
13928 /* Complete an incomplete class reference operator.  */
13929 static tree
13930 patch_incomplete_class_ref (node)
13931     tree node;
13932 {
13933   tree type = TREE_OPERAND (node, 0);
13934   tree ref_type;
13935
13936   if (!(ref_type = resolve_type_during_patch (type)))
13937     return error_mark_node;
13938
13939   if (!flag_emit_class_files || JPRIMITIVE_TYPE_P (ref_type))
13940     {
13941       tree dot = build_class_ref (ref_type);
13942       /* A class referenced by `foo.class' is initialized.  */
13943       if (!flag_emit_class_files)
13944        dot = build_class_init (ref_type, dot);
13945       return java_complete_tree (dot);
13946     }
13947
13948   /* If we're emitting class files and we have to deal with non
13949      primitive types, we invoke (and consider generating) the
13950      synthetic static method `class$'. */
13951   if (!TYPE_DOT_CLASS (current_class))
13952       build_dot_class_method (current_class);
13953   ref_type = build_dot_class_method_invocation (ref_type);
13954   return java_complete_tree (ref_type);
13955 }
13956
13957 /* 15.14 Unary operators. We return error_mark_node in case of error,
13958    but preserve the type of NODE if the type is fixed.  */
13959
13960 static tree
13961 patch_unaryop (node, wfl_op)
13962      tree node;
13963      tree wfl_op;
13964 {
13965   tree op = TREE_OPERAND (node, 0);
13966   tree op_type = TREE_TYPE (op);
13967   tree prom_type = NULL_TREE, value, decl;
13968   int outer_field_flag = 0;
13969   int code = TREE_CODE (node);
13970   int error_found = 0;
13971
13972   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13973
13974   switch (code)
13975     {
13976       /* 15.13.2 Postfix Increment Operator ++ */
13977     case POSTINCREMENT_EXPR:
13978       /* 15.13.3 Postfix Increment Operator -- */
13979     case POSTDECREMENT_EXPR:
13980       /* 15.14.1 Prefix Increment Operator ++ */
13981     case PREINCREMENT_EXPR:
13982       /* 15.14.2 Prefix Decrement Operator -- */
13983     case PREDECREMENT_EXPR:
13984       op = decl = strip_out_static_field_access_decl (op);
13985       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
13986       /* We might be trying to change an outer field accessed using
13987          access method. */
13988       if (outer_field_flag)
13989         {
13990           /* Retrieve the decl of the field we're trying to access. We
13991              do that by first retrieving the function we would call to
13992              access the field. It has been already verified that this
13993              field isn't final */
13994           if (flag_emit_class_files)
13995             decl = TREE_OPERAND (op, 0);
13996           else
13997             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
13998           decl = DECL_FUNCTION_ACCESS_DECL (decl);
13999         }
14000       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14001       else if (!JDECL_P (decl)
14002           && TREE_CODE (decl) != COMPONENT_REF
14003           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14004           && TREE_CODE (decl) != INDIRECT_REF
14005           && !(TREE_CODE (decl) == COMPOUND_EXPR
14006                && TREE_OPERAND (decl, 1)
14007                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14008         {
14009           TREE_TYPE (node) = error_mark_node;
14010           error_found = 1;
14011         }
14012
14013       /* From now on, we know that op if a variable and that it has a
14014          valid wfl. We use wfl_op to locate errors related to the
14015          ++/-- operand. */
14016       if (!JNUMERIC_TYPE_P (op_type))
14017         {
14018           parse_error_context
14019             (wfl_op, "Invalid argument type `%s' to `%s'",
14020              lang_printable_name (op_type, 0), operator_string (node));
14021           TREE_TYPE (node) = error_mark_node;
14022           error_found = 1;
14023         }
14024       else
14025         {
14026           /* Before the addition, binary numeric promotion is performed on
14027              both operands, if really necessary */
14028           if (JINTEGRAL_TYPE_P (op_type))
14029             {
14030               value = build_int_2 (1, 0);
14031               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14032             }
14033           else
14034             {
14035               value = build_int_2 (1, 0);
14036               TREE_TYPE (node) =
14037                 binary_numeric_promotion (op_type,
14038                                           TREE_TYPE (value), &op, &value);
14039             }
14040
14041           /* We remember we might be accessing an outer field */
14042           if (outer_field_flag)
14043             {
14044               /* We re-generate an access to the field */
14045               value = build (PLUS_EXPR, TREE_TYPE (op),
14046                              build_outer_field_access (wfl_op, decl), value);
14047
14048               /* And we patch the original access$() into a write
14049                  with plus_op as a rhs */
14050               return outer_field_access_fix (node, op, value);
14051             }
14052
14053           /* And write back into the node. */
14054           TREE_OPERAND (node, 0) = op;
14055           TREE_OPERAND (node, 1) = value;
14056           /* Convert the overall back into its original type, if
14057              necessary, and return */
14058           if (JINTEGRAL_TYPE_P (op_type))
14059             return fold (node);
14060           else
14061             return fold (convert (op_type, node));
14062         }
14063       break;
14064
14065       /* 15.14.3 Unary Plus Operator + */
14066     case UNARY_PLUS_EXPR:
14067       /* 15.14.4 Unary Minus Operator - */
14068     case NEGATE_EXPR:
14069       if (!JNUMERIC_TYPE_P (op_type))
14070         {
14071           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14072           TREE_TYPE (node) = error_mark_node;
14073           error_found = 1;
14074         }
14075       /* Unary numeric promotion is performed on operand */
14076       else
14077         {
14078           op = do_unary_numeric_promotion (op);
14079           prom_type = TREE_TYPE (op);
14080           if (code == UNARY_PLUS_EXPR)
14081             return fold (op);
14082         }
14083       break;
14084
14085       /* 15.14.5 Bitwise Complement Operator ~ */
14086     case BIT_NOT_EXPR:
14087       if (!JINTEGRAL_TYPE_P (op_type))
14088         {
14089           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14090           TREE_TYPE (node) = error_mark_node;
14091           error_found = 1;
14092         }
14093       else
14094         {
14095           op = do_unary_numeric_promotion (op);
14096           prom_type = TREE_TYPE (op);
14097         }
14098       break;
14099
14100       /* 15.14.6 Logical Complement Operator ! */
14101     case TRUTH_NOT_EXPR:
14102       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14103         {
14104           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14105           /* But the type is known. We will report an error if further
14106              attempt of a assignment is made with this rhs */
14107           TREE_TYPE (node) = boolean_type_node;
14108           error_found = 1;
14109         }
14110       else
14111         prom_type = boolean_type_node;
14112       break;
14113
14114       /* 15.15 Cast Expression */
14115     case CONVERT_EXPR:
14116       value = patch_cast (node, wfl_operator);
14117       if (value == error_mark_node)
14118         {
14119           /* If this cast is part of an assignment, we tell the code
14120              that deals with it not to complain about a mismatch,
14121              because things have been cast, anyways */
14122           TREE_TYPE (node) = error_mark_node;
14123           error_found = 1;
14124         }
14125       else
14126         {
14127           value = fold (value);
14128           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14129           return value;
14130         }
14131       break;
14132     }
14133
14134   if (error_found)
14135     return error_mark_node;
14136
14137   /* There are cases where node has been replaced by something else
14138      and we don't end up returning here: UNARY_PLUS_EXPR,
14139      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14140   TREE_OPERAND (node, 0) = fold (op);
14141   TREE_TYPE (node) = prom_type;
14142   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14143   return fold (node);
14144 }
14145
14146 /* Generic type resolution that sometimes takes place during node
14147    patching. Returned the resolved type or generate an error
14148    message. Return the resolved type or NULL_TREE.  */
14149
14150 static tree
14151 resolve_type_during_patch (type)
14152      tree type;
14153 {
14154   if (unresolved_type_p (type, NULL))
14155     {
14156       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14157       if (!type_decl)
14158         {
14159           parse_error_context (type,
14160                                "Class `%s' not found in type declaration",
14161                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14162           return NULL_TREE;
14163         }
14164       return TREE_TYPE (type_decl);
14165     }
14166   return type;
14167 }
14168 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14169    found. Otherwise NODE or something meant to replace it is returned.  */
14170
14171 static tree
14172 patch_cast (node, wfl_op)
14173      tree node;
14174      tree wfl_op;
14175 {
14176   tree op = TREE_OPERAND (node, 0);
14177   tree cast_type = TREE_TYPE (node);
14178   tree patched, op_type;
14179   char *t1;
14180
14181   /* Some string patching might be necessary at this stage */
14182   if ((patched = patch_string (op)))
14183     TREE_OPERAND (node, 0) = op = patched;
14184   op_type = TREE_TYPE (op);
14185
14186   /* First resolve OP_TYPE if unresolved */
14187   if (!(cast_type = resolve_type_during_patch (cast_type)))
14188     return error_mark_node;
14189
14190   /* Check on cast that are proven correct at compile time */
14191   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14192     {
14193       /* Same type */
14194       if (cast_type == op_type)
14195         return node;
14196
14197       /* float and double type are converted to the original type main
14198          variant and then to the target type. */
14199       if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
14200         op = convert (integer_type_node, op);
14201
14202       /* Try widening/narowwing convertion. Potentially, things need
14203          to be worked out in gcc so we implement the extreme cases
14204          correctly. fold_convert() needs to be fixed. */
14205       return convert (cast_type, op);
14206     }
14207
14208   /* It's also valid to cast a boolean into a boolean */
14209   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14210     return node;
14211
14212   /* null can be casted to references */
14213   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14214     return build_null_of_type (cast_type);
14215
14216   /* The remaining legal casts involve conversion between reference
14217      types. Check for their compile time correctness. */
14218   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14219       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14220     {
14221       TREE_TYPE (node) = promote_type (cast_type);
14222       /* Now, the case can be determined correct at compile time if
14223          OP_TYPE can be converted into CAST_TYPE by assignment
14224          conversion (5.2) */
14225
14226       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14227         {
14228           TREE_SET_CODE (node, NOP_EXPR);
14229           return node;
14230         }
14231
14232       if (flag_emit_class_files)
14233         {
14234           TREE_SET_CODE (node, CONVERT_EXPR);
14235           return node;
14236         }
14237
14238       /* The cast requires a run-time check */
14239       return build (CALL_EXPR, promote_type (cast_type),
14240                     build_address_of (soft_checkcast_node),
14241                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14242                                build_tree_list (NULL_TREE, op)),
14243                     NULL_TREE);
14244     }
14245
14246   /* Any other casts are proven incorrect at compile time */
14247   t1 = xstrdup (lang_printable_name (op_type, 0));
14248   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14249                        t1, lang_printable_name (cast_type, 0));
14250   free (t1);
14251   return error_mark_node;
14252 }
14253
14254 /* Build a null constant and give it the type TYPE.  */
14255
14256 static tree
14257 build_null_of_type (type)
14258      tree type;
14259 {
14260   tree node = build_int_2 (0, 0);
14261   TREE_TYPE (node) = promote_type (type);
14262   return node;
14263 }
14264
14265 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14266    a list of indices. */
14267 static tree
14268 build_array_ref (location, array, index)
14269      int location;
14270      tree array, index;
14271 {
14272   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14273   EXPR_WFL_LINECOL (node) = location;
14274   return node;
14275 }
14276
14277 /* 15.12 Array Access Expression */
14278
14279 static tree
14280 patch_array_ref (node)
14281      tree node;
14282 {
14283   tree array = TREE_OPERAND (node, 0);
14284   tree array_type  = TREE_TYPE (array);
14285   tree index = TREE_OPERAND (node, 1);
14286   tree index_type = TREE_TYPE (index);
14287   int error_found = 0;
14288
14289   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14290
14291   if (TREE_CODE (array_type) == POINTER_TYPE)
14292     array_type = TREE_TYPE (array_type);
14293
14294   /* The array reference must be an array */
14295   if (!TYPE_ARRAY_P (array_type))
14296     {
14297       parse_error_context
14298         (wfl_operator,
14299          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14300          lang_printable_name (array_type, 0));
14301       TREE_TYPE (node) = error_mark_node;
14302       error_found = 1;
14303     }
14304
14305   /* The array index undergoes unary numeric promotion. The promoted
14306      type must be int */
14307   index = do_unary_numeric_promotion (index);
14308   if (TREE_TYPE (index) != int_type_node)
14309     {
14310       if (valid_cast_to_p (index_type, int_type_node))
14311         parse_error_context (wfl_operator,
14312    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14313                              lang_printable_name (index_type, 0));
14314       else
14315         parse_error_context (wfl_operator,
14316           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14317                              lang_printable_name (index_type, 0));
14318       TREE_TYPE (node) = error_mark_node;
14319       error_found = 1;
14320     }
14321
14322   if (error_found)
14323     return error_mark_node;
14324
14325   array_type = TYPE_ARRAY_ELEMENT (array_type);
14326
14327   if (flag_emit_class_files || flag_emit_xref)
14328     {
14329       TREE_OPERAND (node, 0) = array;
14330       TREE_OPERAND (node, 1) = index;
14331     }
14332   else
14333     node = build_java_arrayaccess (array, array_type, index);
14334   TREE_TYPE (node) = array_type;
14335   return node;
14336 }
14337
14338 /* 15.9 Array Creation Expressions */
14339
14340 static tree
14341 build_newarray_node (type, dims, extra_dims)
14342      tree type;
14343      tree dims;
14344      int extra_dims;
14345 {
14346   tree node =
14347     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14348            build_int_2 (extra_dims, 0));
14349   return node;
14350 }
14351
14352 static tree
14353 patch_newarray (node)
14354      tree node;
14355 {
14356   tree type = TREE_OPERAND (node, 0);
14357   tree dims = TREE_OPERAND (node, 1);
14358   tree cdim, array_type;
14359   int error_found = 0;
14360   int ndims = 0;
14361   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14362
14363   /* Dimension types are verified. It's better for the types to be
14364      verified in order. */
14365   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14366     {
14367       int dim_error = 0;
14368       tree dim = TREE_VALUE (cdim);
14369
14370       /* Dim might have been saved during its evaluation */
14371       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14372
14373       /* The type of each specified dimension must be an integral type. */
14374       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14375         dim_error = 1;
14376
14377       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14378          promoted type must be int. */
14379       else
14380         {
14381           dim = do_unary_numeric_promotion (dim);
14382           if (TREE_TYPE (dim) != int_type_node)
14383             dim_error = 1;
14384         }
14385
14386       /* Report errors on types here */
14387       if (dim_error)
14388         {
14389           parse_error_context
14390             (TREE_PURPOSE (cdim),
14391              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14392              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14393               "Explicit cast needed to" : "Can't"),
14394              lang_printable_name (TREE_TYPE (dim), 0));
14395           error_found = 1;
14396         }
14397
14398       TREE_PURPOSE (cdim) = NULL_TREE;
14399     }
14400
14401   /* Resolve array base type if unresolved */
14402   if (!(type = resolve_type_during_patch (type)))
14403     error_found = 1;
14404
14405   if (error_found)
14406     {
14407       /* We don't want further evaluation of this bogus array creation
14408          operation */
14409       TREE_TYPE (node) = error_mark_node;
14410       return error_mark_node;
14411     }
14412
14413   /* Set array_type to the actual (promoted) array type of the result. */
14414   if (TREE_CODE (type) == RECORD_TYPE)
14415     type = build_pointer_type (type);
14416   while (--xdims >= 0)
14417     {
14418       type = promote_type (build_java_array_type (type, -1));
14419     }
14420   dims = nreverse (dims);
14421   array_type = type;
14422   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14423     {
14424       type = array_type;
14425       array_type
14426         = build_java_array_type (type,
14427                                  TREE_CODE (cdim) == INTEGER_CST
14428                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14429                                  : -1);
14430       array_type = promote_type (array_type);
14431     }
14432   dims = nreverse (dims);
14433
14434   /* The node is transformed into a function call. Things are done
14435      differently according to the number of dimensions. If the number
14436      of dimension is equal to 1, then the nature of the base type
14437      (primitive or not) matters. */
14438   if (ndims == 1)
14439     return build_new_array (type, TREE_VALUE (dims));
14440
14441   /* Can't reuse what's already written in expr.c because it uses the
14442      JVM stack representation. Provide a build_multianewarray. FIXME */
14443   return build (CALL_EXPR, array_type,
14444                 build_address_of (soft_multianewarray_node),
14445                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14446                            tree_cons (NULL_TREE,
14447                                       build_int_2 (ndims, 0), dims )),
14448                 NULL_TREE);
14449 }
14450
14451 /* 10.6 Array initializer.  */
14452
14453 /* Build a wfl for array element that don't have one, so we can
14454    pin-point errors.  */
14455
14456 static tree
14457 maybe_build_array_element_wfl (node)
14458      tree node;
14459 {
14460   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14461     return build_expr_wfl (NULL_TREE, ctxp->filename,
14462                            ctxp->elc.line, ctxp->elc.prev_col);
14463   else
14464     return NULL_TREE;
14465 }
14466
14467 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14468    identification of initialized arrays easier to detect during walk
14469    and expansion.  */
14470
14471 static tree
14472 build_new_array_init (location, values)
14473      int location;
14474      tree values;
14475 {
14476   tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
14477   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14478   EXPR_WFL_LINECOL (to_return) = location;
14479   return to_return;
14480 }
14481
14482 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14483    occurred.  Otherwise return NODE after having set its type
14484    appropriately.  */
14485
14486 static tree
14487 patch_new_array_init (type, node)
14488      tree type, node;
14489 {
14490   int error_seen = 0;
14491   tree current, element_type;
14492   HOST_WIDE_INT length;
14493   int all_constant = 1;
14494   tree init = TREE_OPERAND (node, 0);
14495
14496   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14497     {
14498       parse_error_context (node,
14499                            "Invalid array initializer for non-array type `%s'",
14500                            lang_printable_name (type, 1));
14501       return error_mark_node;
14502     }
14503   type = TREE_TYPE (type);
14504   element_type = TYPE_ARRAY_ELEMENT (type);
14505
14506   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14507
14508   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14509        current;  length++, current = TREE_CHAIN (current))
14510     {
14511       tree elt = TREE_VALUE (current);
14512       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14513         {
14514           error_seen |= array_constructor_check_entry (element_type, current);
14515           elt = TREE_VALUE (current);
14516           /* When compiling to native code, STRING_CST is converted to
14517              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14518           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14519             all_constant = 0;
14520         }
14521       else
14522         {
14523           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14524           TREE_PURPOSE (current) = NULL_TREE;
14525           all_constant = 0;
14526         }
14527       if (elt && TREE_CODE (elt) == TREE_LIST
14528           && TREE_VALUE (elt) == error_mark_node)
14529         error_seen = 1;
14530     }
14531
14532   if (error_seen)
14533     return error_mark_node;
14534
14535   /* Create a new type. We can't reuse the one we have here by
14536      patching its dimension because it originally is of dimension -1
14537      hence reused by gcc. This would prevent triangular arrays. */
14538   type = build_java_array_type (element_type, length);
14539   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14540   TREE_TYPE (node) = promote_type (type);
14541   TREE_CONSTANT (init) = all_constant;
14542   TREE_CONSTANT (node) = all_constant;
14543   return node;
14544 }
14545
14546 /* Verify that one entry of the initializer element list can be
14547    assigned to the array base type. Report 1 if an error occurred, 0
14548    otherwise.  */
14549
14550 static int
14551 array_constructor_check_entry (type, entry)
14552      tree type, entry;
14553 {
14554   char *array_type_string = NULL;       /* For error reports */
14555   tree value, type_value, new_value, wfl_value, patched;
14556   int error_seen = 0;
14557
14558   new_value = NULL_TREE;
14559   wfl_value = TREE_VALUE (entry);
14560
14561   value = java_complete_tree (TREE_VALUE (entry));
14562   /* patch_string return error_mark_node if arg is error_mark_node */
14563   if ((patched = patch_string (value)))
14564     value = patched;
14565   if (value == error_mark_node)
14566     return 1;
14567
14568   type_value = TREE_TYPE (value);
14569
14570   /* At anytime, try_builtin_assignconv can report a warning on
14571      constant overflow during narrowing. */
14572   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14573   new_value = try_builtin_assignconv (wfl_operator, type, value);
14574   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14575     type_value = promote_type (type);
14576
14577   /* Check and report errors */
14578   if (!new_value)
14579     {
14580       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14581                    "Can't" : "Explicit cast needed to");
14582       if (!array_type_string)
14583         array_type_string = xstrdup (lang_printable_name (type, 1));
14584       parse_error_context
14585         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14586          msg, lang_printable_name (type_value, 1), array_type_string);
14587       error_seen = 1;
14588     }
14589
14590   if (new_value)
14591     TREE_VALUE (entry) = new_value;
14592
14593   if (array_type_string)
14594     free (array_type_string);
14595
14596   TREE_PURPOSE (entry) = NULL_TREE;
14597   return error_seen;
14598 }
14599
14600 static tree
14601 build_this (location)
14602      int location;
14603 {
14604   tree node = build_wfl_node (this_identifier_node);
14605   TREE_SET_CODE (node, THIS_EXPR);
14606   EXPR_WFL_LINECOL (node) = location;
14607   return node;
14608 }
14609
14610 /* 14.15 The return statement. It builds a modify expression that
14611    assigns the returned value to the RESULT_DECL that hold the value
14612    to be returned. */
14613
14614 static tree
14615 build_return (location, op)
14616      int location;
14617      tree op;
14618 {
14619   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14620   EXPR_WFL_LINECOL (node) = location;
14621   node = build_debugable_stmt (location, node);
14622   return node;
14623 }
14624
14625 static tree
14626 patch_return (node)
14627      tree node;
14628 {
14629   tree return_exp = TREE_OPERAND (node, 0);
14630   tree meth = current_function_decl;
14631   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14632   int error_found = 0;
14633
14634   TREE_TYPE (node) = error_mark_node;
14635   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14636
14637   /* It's invalid to have a return value within a function that is
14638      declared with the keyword void or that is a constructor */
14639   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14640     error_found = 1;
14641
14642   /* It's invalid to use a return statement in a static block */
14643   if (DECL_CLINIT_P (current_function_decl))
14644     error_found = 1;
14645
14646   /* It's invalid to have a no return value within a function that
14647      isn't declared with the keyword `void' */
14648   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14649     error_found = 2;
14650
14651   if (DECL_INSTINIT_P (current_function_decl))
14652     error_found = 1;
14653
14654   if (error_found)
14655     {
14656       if (DECL_INSTINIT_P (current_function_decl))
14657         parse_error_context (wfl_operator,
14658                              "`return' inside instance initializer");
14659
14660       else if (DECL_CLINIT_P (current_function_decl))
14661         parse_error_context (wfl_operator,
14662                              "`return' inside static initializer");
14663
14664       else if (!DECL_CONSTRUCTOR_P (meth))
14665         {
14666           char *t = xstrdup (lang_printable_name (mtype, 0));
14667           parse_error_context (wfl_operator,
14668                                "`return' with%s value from `%s %s'",
14669                                (error_found == 1 ? "" : "out"),
14670                                t, lang_printable_name (meth, 0));
14671           free (t);
14672         }
14673       else
14674         parse_error_context (wfl_operator,
14675                              "`return' with value from constructor `%s'",
14676                              lang_printable_name (meth, 0));
14677       return error_mark_node;
14678     }
14679
14680   /* If we have a return_exp, build a modify expression and expand
14681      it. Note: at that point, the assignment is declared valid, but we
14682      may want to carry some more hacks */
14683   if (return_exp)
14684     {
14685       tree exp = java_complete_tree (return_exp);
14686       tree modify, patched;
14687
14688       if ((patched = patch_string (exp)))
14689         exp = patched;
14690
14691       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14692       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14693       modify = java_complete_tree (modify);
14694
14695       if (modify != error_mark_node)
14696         {
14697           TREE_SIDE_EFFECTS (modify) = 1;
14698           TREE_OPERAND (node, 0) = modify;
14699         }
14700       else
14701         return error_mark_node;
14702     }
14703   TREE_TYPE (node) = void_type_node;
14704   TREE_SIDE_EFFECTS (node) = 1;
14705   return node;
14706 }
14707
14708 /* 14.8 The if Statement */
14709
14710 static tree
14711 build_if_else_statement (location, expression, if_body, else_body)
14712      int location;
14713      tree expression, if_body, else_body;
14714 {
14715   tree node;
14716   if (!else_body)
14717     else_body = empty_stmt_node;
14718   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14719   EXPR_WFL_LINECOL (node) = location;
14720   node = build_debugable_stmt (location, node);
14721   return node;
14722 }
14723
14724 static tree
14725 patch_if_else_statement (node)
14726      tree node;
14727 {
14728   tree expression = TREE_OPERAND (node, 0);
14729   int can_complete_normally
14730     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14731        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14732
14733   TREE_TYPE (node) = error_mark_node;
14734   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14735
14736   /* The type of expression must be boolean */
14737   if (TREE_TYPE (expression) != boolean_type_node
14738       && TREE_TYPE (expression) != promoted_boolean_type_node)
14739     {
14740       parse_error_context
14741         (wfl_operator,
14742          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14743          lang_printable_name (TREE_TYPE (expression), 0));
14744       return error_mark_node;
14745     }
14746
14747   if (TREE_CODE (expression) == INTEGER_CST)
14748     {
14749       if (integer_zerop (expression))
14750         node = TREE_OPERAND (node, 2);
14751       else
14752         node = TREE_OPERAND (node, 1);
14753       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14754         {
14755           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14756           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14757         }
14758       return node;
14759     }
14760   TREE_TYPE (node) = void_type_node;
14761   TREE_SIDE_EFFECTS (node) = 1;
14762   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14763   return node;
14764 }
14765
14766 /* 14.6 Labeled Statements */
14767
14768 /* Action taken when a lableled statement is parsed. a new
14769    LABELED_BLOCK_EXPR is created. No statement is attached to the
14770    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14771
14772 static tree
14773 build_labeled_block (location, label)
14774      int location;
14775      tree label;
14776 {
14777   tree label_name ;
14778   tree label_decl, node;
14779   if (label == NULL_TREE || label == continue_identifier_node)
14780     label_name = label;
14781   else
14782     {
14783       label_name = merge_qualified_name (label_id, label);
14784       /* Issue an error if we try to reuse a label that was previously
14785          declared */
14786       if (IDENTIFIER_LOCAL_VALUE (label_name))
14787         {
14788           EXPR_WFL_LINECOL (wfl_operator) = location;
14789           parse_error_context (wfl_operator,
14790             "Declaration of `%s' shadows a previous label declaration",
14791                                IDENTIFIER_POINTER (label));
14792           EXPR_WFL_LINECOL (wfl_operator) =
14793             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14794           parse_error_context (wfl_operator,
14795             "This is the location of the previous declaration of label `%s'",
14796                                IDENTIFIER_POINTER (label));
14797           java_error_count--;
14798         }
14799     }
14800
14801   label_decl = create_label_decl (label_name);
14802   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14803   EXPR_WFL_LINECOL (node) = location;
14804   TREE_SIDE_EFFECTS (node) = 1;
14805   return node;
14806 }
14807
14808 /* A labeled statement LBE is attached a statement.  */
14809
14810 static tree
14811 finish_labeled_statement (lbe, statement)
14812      tree lbe;                  /* Labeled block expr */
14813      tree statement;
14814 {
14815   /* In anyways, tie the loop to its statement */
14816   LABELED_BLOCK_BODY (lbe) = statement;
14817   pop_labeled_block ();
14818   POP_LABELED_BLOCK ();
14819   return lbe;
14820 }
14821
14822 /* 14.10, 14.11, 14.12 Loop Statements */
14823
14824 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14825    list. */
14826
14827 static tree
14828 build_new_loop (loop_body)
14829      tree loop_body;
14830 {
14831   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14832   TREE_SIDE_EFFECTS (loop) = 1;
14833   PUSH_LOOP (loop);
14834   return loop;
14835 }
14836
14837 /* Create a loop body according to the following structure:
14838      COMPOUND_EXPR
14839        COMPOUND_EXPR            (loop main body)
14840          EXIT_EXPR              (this order is for while/for loops.
14841          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14842            LABEL_DECL           (a continue occurring here branches at the
14843            BODY                  end of this labeled block)
14844        INCREMENT                (if any)
14845
14846   REVERSED, if non zero, tells that the loop condition expr comes
14847   after the body, like in the do-while loop.
14848
14849   To obtain a loop, the loop body structure described above is
14850   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14851
14852    LABELED_BLOCK_EXPR
14853      LABEL_DECL                   (use this label to exit the loop)
14854      LOOP_EXPR
14855        <structure described above> */
14856
14857 static tree
14858 build_loop_body (location, condition, reversed)
14859      int location;
14860      tree condition;
14861      int reversed;
14862 {
14863   tree first, second, body;
14864
14865   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14866   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14867   condition = build_debugable_stmt (location, condition);
14868   TREE_SIDE_EFFECTS (condition) = 1;
14869
14870   body = build_labeled_block (0, continue_identifier_node);
14871   first = (reversed ? body : condition);
14872   second = (reversed ? condition : body);
14873   return
14874     build (COMPOUND_EXPR, NULL_TREE,
14875            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14876 }
14877
14878 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14879    their order) on the current loop. Unlink the current loop from the
14880    loop list.  */
14881
14882 static tree
14883 finish_loop_body (location, condition, body, reversed)
14884      int location;
14885      tree condition, body;
14886      int reversed;
14887 {
14888   tree to_return = ctxp->current_loop;
14889   tree loop_body = LOOP_EXPR_BODY (to_return);
14890   if (condition)
14891     {
14892       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14893       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14894          The real EXIT_EXPR is one operand further. */
14895       EXPR_WFL_LINECOL (cnode) = location;
14896       /* This one is for accurate error reports */
14897       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14898       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14899     }
14900   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14901   POP_LOOP ();
14902   return to_return;
14903 }
14904
14905 /* Tailored version of finish_loop_body for FOR loops, when FOR
14906    loops feature the condition part */
14907
14908 static tree
14909 finish_for_loop (location, condition, update, body)
14910     int location;
14911     tree condition, update, body;
14912 {
14913   /* Put the condition and the loop body in place */
14914   tree loop = finish_loop_body (location, condition, body, 0);
14915   /* LOOP is the current loop which has been now popped of the loop
14916      stack. Install the update block */
14917   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14918   return loop;
14919 }
14920
14921 /* Try to find the loop a block might be related to. This comprises
14922    the case where the LOOP_EXPR is found as the second operand of a
14923    COMPOUND_EXPR, because the loop happens to have an initialization
14924    part, then expressed as the first operand of the COMPOUND_EXPR. If
14925    the search finds something, 1 is returned. Otherwise, 0 is
14926    returned. The search is assumed to start from a
14927    LABELED_BLOCK_EXPR's block.  */
14928
14929 static tree
14930 search_loop (statement)
14931     tree statement;
14932 {
14933   if (TREE_CODE (statement) == LOOP_EXPR)
14934     return statement;
14935
14936   if (TREE_CODE (statement) == BLOCK)
14937     statement = BLOCK_SUBBLOCKS (statement);
14938   else
14939     return NULL_TREE;
14940
14941   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14942     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14943       statement = TREE_OPERAND (statement, 1);
14944
14945   return (TREE_CODE (statement) == LOOP_EXPR
14946           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14947 }
14948
14949 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14950    returned otherwise.  */
14951
14952 static int
14953 labeled_block_contains_loop_p (block, loop)
14954     tree block, loop;
14955 {
14956   if (!block)
14957     return 0;
14958
14959   if (LABELED_BLOCK_BODY (block) == loop)
14960     return 1;
14961
14962   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14963     return 1;
14964
14965   return 0;
14966 }
14967
14968 /* If the loop isn't surrounded by a labeled statement, create one and
14969    insert LOOP as its body.  */
14970
14971 static tree
14972 patch_loop_statement (loop)
14973      tree loop;
14974 {
14975   tree loop_label;
14976
14977   TREE_TYPE (loop) = void_type_node;
14978   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14979     return loop;
14980
14981   loop_label = build_labeled_block (0, NULL_TREE);
14982   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14983      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14984   LABELED_BLOCK_BODY (loop_label) = loop;
14985   PUSH_LABELED_BLOCK (loop_label);
14986   return loop_label;
14987 }
14988
14989 /* 14.13, 14.14: break and continue Statements */
14990
14991 /* Build a break or a continue statement. a null NAME indicates an
14992    unlabeled break/continue statement.  */
14993
14994 static tree
14995 build_bc_statement (location, is_break, name)
14996      int location, is_break;
14997      tree name;
14998 {
14999   tree break_continue, label_block_expr = NULL_TREE;
15000
15001   if (name)
15002     {
15003       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15004             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15005         /* Null means that we don't have a target for this named
15006            break/continue. In this case, we make the target to be the
15007            label name, so that the error can be reported accuratly in
15008            patch_bc_statement. */
15009         label_block_expr = EXPR_WFL_NODE (name);
15010     }
15011   /* Unlabeled break/continue will be handled during the
15012      break/continue patch operation */
15013   break_continue
15014     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15015
15016   IS_BREAK_STMT_P (break_continue) = is_break;
15017   TREE_SIDE_EFFECTS (break_continue) = 1;
15018   EXPR_WFL_LINECOL (break_continue) = location;
15019   break_continue = build_debugable_stmt (location, break_continue);
15020   return break_continue;
15021 }
15022
15023 /* Verification of a break/continue statement. */
15024
15025 static tree
15026 patch_bc_statement (node)
15027      tree node;
15028 {
15029   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15030   tree labeled_block = ctxp->current_labeled_block;
15031   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15032
15033   /* Having an identifier here means that the target is unknown. */
15034   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15035     {
15036       parse_error_context (wfl_operator, "No label definition found for `%s'",
15037                            IDENTIFIER_POINTER (bc_label));
15038       return error_mark_node;
15039     }
15040   if (! IS_BREAK_STMT_P (node))
15041     {
15042       /* It's a continue statement. */
15043       for (;; labeled_block = TREE_CHAIN (labeled_block))
15044         {
15045           if (labeled_block == NULL_TREE)
15046             {
15047               if (bc_label == NULL_TREE)
15048                 parse_error_context (wfl_operator,
15049                                      "`continue' must be in loop");
15050               else
15051                 parse_error_context
15052                   (wfl_operator, "continue label `%s' does not name a loop",
15053                    IDENTIFIER_POINTER (bc_label));
15054               return error_mark_node;
15055             }
15056           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15057                == continue_identifier_node)
15058               && (bc_label == NULL_TREE
15059                   || TREE_CHAIN (labeled_block) == bc_label))
15060             {
15061               bc_label = labeled_block;
15062               break;
15063             }
15064         }
15065     }
15066   else if (!bc_label)
15067     {
15068       for (;; labeled_block = TREE_CHAIN (labeled_block))
15069         {
15070           if (labeled_block == NULL_TREE)
15071             {
15072               parse_error_context (wfl_operator,
15073                                      "`break' must be in loop or switch");
15074               return error_mark_node;
15075             }
15076           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15077           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15078               || search_loop (target_stmt))
15079             {
15080               bc_label = labeled_block;
15081               break;
15082             }
15083         }
15084     }
15085
15086   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15087   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15088
15089   /* Our break/continue don't return values. */
15090   TREE_TYPE (node) = void_type_node;
15091   /* Encapsulate the break within a compound statement so that it's
15092      expanded all the times by expand_expr (and not clobbered
15093      sometimes, like after a if statement) */
15094   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15095   TREE_SIDE_EFFECTS (node) = 1;
15096   return node;
15097 }
15098
15099 /* Process the exit expression belonging to a loop. Its type must be
15100    boolean.  */
15101
15102 static tree
15103 patch_exit_expr (node)
15104      tree node;
15105 {
15106   tree expression = TREE_OPERAND (node, 0);
15107   TREE_TYPE (node) = error_mark_node;
15108   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15109
15110   /* The type of expression must be boolean */
15111   if (TREE_TYPE (expression) != boolean_type_node)
15112     {
15113       parse_error_context
15114         (wfl_operator,
15115     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15116          lang_printable_name (TREE_TYPE (expression), 0));
15117       return error_mark_node;
15118     }
15119   /* Now we know things are allright, invert the condition, fold and
15120      return */
15121   TREE_OPERAND (node, 0) =
15122     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15123
15124   if (! integer_zerop (TREE_OPERAND (node, 0))
15125       && ctxp->current_loop != NULL_TREE
15126       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15127     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15128   if (! integer_onep (TREE_OPERAND (node, 0)))
15129     CAN_COMPLETE_NORMALLY (node) = 1;
15130
15131
15132   TREE_TYPE (node) = void_type_node;
15133   return node;
15134 }
15135
15136 /* 14.9 Switch statement */
15137
15138 static tree
15139 patch_switch_statement (node)
15140      tree node;
15141 {
15142   tree se = TREE_OPERAND (node, 0), se_type;
15143   tree save, iter;
15144
15145   /* Complete the switch expression */
15146   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15147   se_type = TREE_TYPE (se);
15148   /* The type of the switch expression must be char, byte, short or
15149      int */
15150   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15151     {
15152       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15153       parse_error_context (wfl_operator,
15154           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15155                            lang_printable_name (se_type, 0));
15156       /* This is what java_complete_tree will check */
15157       TREE_OPERAND (node, 0) = error_mark_node;
15158       return error_mark_node;
15159     }
15160
15161   /* Save and restore the outer case label list.  */
15162   save = case_label_list;
15163   case_label_list = NULL_TREE;
15164
15165   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15166
15167   /* See if we've found a duplicate label.  We can't leave this until
15168      code generation, because in `--syntax-only' and `-C' modes we
15169      don't do ordinary code generation.  */
15170   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15171     {
15172       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15173       tree subiter;
15174       for (subiter = TREE_CHAIN (iter);
15175            subiter != NULL_TREE;
15176            subiter = TREE_CHAIN (subiter))
15177         {
15178           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15179           if (val == subval)
15180             {
15181               EXPR_WFL_LINECOL (wfl_operator)
15182                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15183               /* The case_label_list is in reverse order, so print the
15184                  outer label first.  */
15185               parse_error_context (wfl_operator, "duplicate case label: `"
15186                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15187               EXPR_WFL_LINECOL (wfl_operator)
15188                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15189               parse_error_context (wfl_operator, "original label is here");
15190
15191               break;
15192             }
15193         }
15194     }
15195
15196   case_label_list = save;
15197
15198   /* Ready to return */
15199   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15200     {
15201       TREE_TYPE (node) = error_mark_node;
15202       return error_mark_node;
15203     }
15204   TREE_TYPE (node) = void_type_node;
15205   TREE_SIDE_EFFECTS (node) = 1;
15206   CAN_COMPLETE_NORMALLY (node)
15207     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15208       || ! SWITCH_HAS_DEFAULT (node);
15209   return node;
15210 }
15211
15212 /* 14.18 The try/catch statements */
15213
15214 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15215    catches TYPE and executes CATCH_STMTS.  */
15216
15217 static tree
15218 encapsulate_with_try_catch (location, type, try_stmts, catch_stmts)
15219      int location;
15220      tree type, try_stmts, catch_stmts;
15221 {
15222   tree try_block, catch_clause_param, catch_block, catch;
15223
15224   /* First build a try block */
15225   try_block = build_expr_block (try_stmts, NULL_TREE);
15226
15227   /* Build a catch block: we need a catch clause parameter */
15228   catch_clause_param = build_decl (VAR_DECL,
15229                                    wpv_id, build_pointer_type (type));
15230   /* And a block */
15231   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15232
15233   /* Initialize the variable and store in the block */
15234   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15235                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15236   add_stmt_to_block (catch_block, NULL_TREE, catch);
15237
15238   /* Add the catch statements */
15239   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15240
15241   /* Now we can build a CATCH_EXPR */
15242   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15243
15244   return build_try_statement (location, try_block, catch_block);
15245 }
15246
15247 static tree
15248 build_try_statement (location, try_block, catches)
15249      int location;
15250      tree try_block, catches;
15251 {
15252   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15253   EXPR_WFL_LINECOL (node) = location;
15254   return node;
15255 }
15256
15257 static tree
15258 build_try_finally_statement (location, try_block, finally)
15259      int location;
15260      tree try_block, finally;
15261 {
15262   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15263   EXPR_WFL_LINECOL (node) = location;
15264   return node;
15265 }
15266
15267 static tree
15268 patch_try_statement (node)
15269      tree node;
15270 {
15271   int error_found = 0;
15272   tree try = TREE_OPERAND (node, 0);
15273   /* Exception handlers are considered in left to right order */
15274   tree catch = nreverse (TREE_OPERAND (node, 1));
15275   tree current, caught_type_list = NULL_TREE;
15276
15277   /* Check catch clauses, if any. Every time we find an error, we try
15278      to process the next catch clause. We process the catch clause before
15279      the try block so that when processing the try block we can check thrown
15280      exceptions againts the caught type list. */
15281   for (current = catch; current; current = TREE_CHAIN (current))
15282     {
15283       tree carg_decl, carg_type;
15284       tree sub_current, catch_block, catch_clause;
15285       int unreachable;
15286
15287       /* At this point, the structure of the catch clause is
15288            CATCH_EXPR           (catch node)
15289              BLOCK              (with the decl of the parameter)
15290                COMPOUND_EXPR
15291                  MODIFY_EXPR   (assignment of the catch parameter)
15292                  BLOCK          (catch clause block)
15293        */
15294       catch_clause = TREE_OPERAND (current, 0);
15295       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15296       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15297
15298       /* Catch clauses can't have more than one parameter declared,
15299          but it's already enforced by the grammar. Make sure that the
15300          only parameter of the clause statement in of class Throwable
15301          or a subclass of Throwable, but that was done earlier. The
15302          catch clause parameter type has also been resolved. */
15303
15304       /* Just make sure that the catch clause parameter type inherits
15305          from java.lang.Throwable */
15306       if (!inherits_from_p (carg_type, throwable_type_node))
15307         {
15308           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15309           parse_error_context (wfl_operator,
15310                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15311                                lang_printable_name (carg_type, 0));
15312           error_found = 1;
15313           continue;
15314         }
15315
15316       /* Partial check for unreachable catch statement: The catch
15317          clause is reachable iff is no earlier catch block A in
15318          the try statement such that the type of the catch
15319          clause's parameter is the same as or a subclass of the
15320          type of A's parameter */
15321       unreachable = 0;
15322       for (sub_current = catch;
15323            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15324         {
15325           tree sub_catch_clause, decl;
15326           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15327           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15328
15329           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15330             {
15331               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15332               parse_error_context
15333                 (wfl_operator,
15334                  "`catch' not reached because of the catch clause at line %d",
15335                  EXPR_WFL_LINENO (sub_current));
15336               unreachable = error_found = 1;
15337               break;
15338             }
15339         }
15340       /* Complete the catch clause block */
15341       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15342       if (catch_block == error_mark_node)
15343         {
15344           error_found = 1;
15345           continue;
15346         }
15347       if (CAN_COMPLETE_NORMALLY (catch_block))
15348         CAN_COMPLETE_NORMALLY (node) = 1;
15349       TREE_OPERAND (current, 0) = catch_block;
15350
15351       if (unreachable)
15352         continue;
15353
15354       /* Things to do here: the exception must be thrown */
15355
15356       /* Link this type to the caught type list */
15357       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15358     }
15359
15360   PUSH_EXCEPTIONS (caught_type_list);
15361   if ((try = java_complete_tree (try)) == error_mark_node)
15362     error_found = 1;
15363   if (CAN_COMPLETE_NORMALLY (try))
15364     CAN_COMPLETE_NORMALLY (node) = 1;
15365   POP_EXCEPTIONS ();
15366
15367   /* Verification ends here */
15368   if (error_found)
15369     return error_mark_node;
15370
15371   TREE_OPERAND (node, 0) = try;
15372   TREE_OPERAND (node, 1) = catch;
15373   TREE_TYPE (node) = void_type_node;
15374   return node;
15375 }
15376
15377 /* 14.17 The synchronized Statement */
15378
15379 static tree
15380 patch_synchronized_statement (node, wfl_op1)
15381     tree node, wfl_op1;
15382 {
15383   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15384   tree block = TREE_OPERAND (node, 1);
15385
15386   tree tmp, enter, exit, expr_decl, assignment;
15387
15388   if (expr == error_mark_node)
15389     {
15390       block = java_complete_tree (block);
15391       return expr;
15392     }
15393
15394   /* We might be trying to synchronize on a STRING_CST */
15395   if ((tmp = patch_string (expr)))
15396     expr = tmp;
15397
15398   /* The TYPE of expr must be a reference type */
15399   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15400     {
15401       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15402       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15403                            lang_printable_name (TREE_TYPE (expr), 0));
15404       return error_mark_node;
15405     }
15406
15407   if (flag_emit_xref)
15408     {
15409       TREE_OPERAND (node, 0) = expr;
15410       TREE_OPERAND (node, 1) = java_complete_tree (block);
15411       CAN_COMPLETE_NORMALLY (node) = 1;
15412       return node;
15413     }
15414
15415   /* Generate a try-finally for the synchronized statement, except
15416      that the handler that catches all throw exception calls
15417      _Jv_MonitorExit and then rethrow the exception.
15418      The synchronized statement is then implemented as:
15419      TRY
15420        {
15421          _Jv_MonitorEnter (expression)
15422          synchronized_block
15423          _Jv_MonitorExit (expression)
15424        }
15425      CATCH_ALL
15426        {
15427          e = _Jv_exception_info ();
15428          _Jv_MonitorExit (expression)
15429          Throw (e);
15430        } */
15431
15432   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15433   BUILD_MONITOR_ENTER (enter, expr_decl);
15434   BUILD_MONITOR_EXIT (exit, expr_decl);
15435   CAN_COMPLETE_NORMALLY (enter) = 1;
15436   CAN_COMPLETE_NORMALLY (exit) = 1;
15437   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15438   TREE_SIDE_EFFECTS (assignment) = 1;
15439   node = build (COMPOUND_EXPR, NULL_TREE,
15440                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15441                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15442   node = build_expr_block (node, expr_decl);
15443
15444   return java_complete_tree (node);
15445 }
15446
15447 /* 14.16 The throw Statement */
15448
15449 static tree
15450 patch_throw_statement (node, wfl_op1)
15451     tree node, wfl_op1;
15452 {
15453   tree expr = TREE_OPERAND (node, 0);
15454   tree type = TREE_TYPE (expr);
15455   int unchecked_ok = 0, tryblock_throws_ok = 0;
15456
15457   /* Thrown expression must be assignable to java.lang.Throwable */
15458   if (!try_reference_assignconv (throwable_type_node, expr))
15459     {
15460       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15461       parse_error_context (wfl_operator,
15462     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15463                            lang_printable_name (type, 0));
15464       /* If the thrown expression was a reference, we further the
15465          compile-time check. */
15466       if (!JREFERENCE_TYPE_P (type))
15467         return error_mark_node;
15468     }
15469
15470   /* At least one of the following must be true */
15471
15472   /* The type of the throw expression is a not checked exception,
15473      i.e. is a unchecked expression. */
15474   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15475
15476   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15477   /* An instance can't throw a checked exception unless that exception
15478      is explicitly declared in the `throws' clause of each
15479      constructor. This doesn't apply to anonymous classes, since they
15480      don't have declared constructors. */
15481   if (!unchecked_ok
15482       && DECL_INSTINIT_P (current_function_decl)
15483       && !ANONYMOUS_CLASS_P (current_class))
15484     {
15485       tree current;
15486       for (current = TYPE_METHODS (current_class); current;
15487            current = TREE_CHAIN (current))
15488         if (DECL_CONSTRUCTOR_P (current)
15489             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15490           {
15491             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)",
15492                                  lang_printable_name (TREE_TYPE (expr), 0));
15493             return error_mark_node;
15494           }
15495     }
15496
15497   /* Throw is contained in a try statement and at least one catch
15498      clause can receive the thrown expression or the current method is
15499      declared to throw such an exception. Or, the throw statement is
15500      contained in a method or constructor declaration and the type of
15501      the Expression is assignable to at least one type listed in the
15502      throws clause the declaration. */
15503   if (!unchecked_ok)
15504     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15505   if (!(unchecked_ok || tryblock_throws_ok))
15506     {
15507       /* If there is a surrounding try block that has no matching
15508          clatch clause, report it first. A surrounding try block exits
15509          only if there is something after the list of checked
15510          exception thrown by the current function (if any). */
15511       if (IN_TRY_BLOCK_P ())
15512         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15513                              lang_printable_name (type, 0));
15514       /* If we have no surrounding try statement and the method doesn't have
15515          any throws, report it now. FIXME */
15516
15517       /* We report that the exception can't be throw from a try block
15518          in all circumstances but when the `throw' is inside a static
15519          block. */
15520       else if (!EXCEPTIONS_P (currently_caught_type_list)
15521                && !tryblock_throws_ok)
15522         {
15523           if (DECL_CLINIT_P (current_function_decl))
15524             parse_error_context (wfl_operator,
15525                    "Checked exception `%s' can't be thrown in initializer",
15526                                  lang_printable_name (type, 0));
15527           else
15528             parse_error_context (wfl_operator,
15529                    "Checked exception `%s' isn't thrown from a `try' block",
15530                                  lang_printable_name (type, 0));
15531         }
15532       /* Otherwise, the current method doesn't have the appropriate
15533          throws declaration */
15534       else
15535         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15536                              lang_printable_name (type, 0));
15537       return error_mark_node;
15538     }
15539
15540   if (! flag_emit_class_files && ! flag_emit_xref)
15541     BUILD_THROW (node, expr);
15542
15543   /* If doing xrefs, keep the location where the `throw' was seen. */
15544   if (flag_emit_xref)
15545     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15546   return node;
15547 }
15548
15549 /* Check that exception said to be thrown by method DECL can be
15550    effectively caught from where DECL is invoked.  */
15551
15552 static void
15553 check_thrown_exceptions (location, decl)
15554      int location;
15555      tree decl;
15556 {
15557   tree throws;
15558   /* For all the unchecked exceptions thrown by DECL */
15559   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15560        throws = TREE_CHAIN (throws))
15561     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15562       {
15563 #if 1
15564         /* Temporary hack to suppresses errors about cloning arrays. FIXME */
15565         if (DECL_NAME (decl) == get_identifier ("clone"))
15566           continue;
15567 #endif
15568         EXPR_WFL_LINECOL (wfl_operator) = location;
15569         if (DECL_FINIT_P (current_function_decl))
15570           parse_error_context
15571             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15572              lang_printable_name (TREE_VALUE (throws), 0));
15573         else
15574           {
15575             parse_error_context
15576               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15577                lang_printable_name (TREE_VALUE (throws), 0),
15578                (DECL_INIT_P (current_function_decl) ?
15579                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15580                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15581           }
15582       }
15583 }
15584
15585 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15586    try-catch blocks, OR is listed in the `throws' clause of the
15587    current method.  */
15588
15589 static int
15590 check_thrown_exceptions_do (exception)
15591      tree exception;
15592 {
15593   tree list = currently_caught_type_list;
15594   resolve_and_layout (exception, NULL_TREE);
15595   /* First, all the nested try-catch-finally at that stage. The
15596      last element contains `throws' clause exceptions, if any. */
15597   if (IS_UNCHECKED_EXCEPTION_P (exception))
15598     return 1;
15599   while (list)
15600     {
15601       tree caught;
15602       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15603         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15604           return 1;
15605       list = TREE_CHAIN (list);
15606     }
15607   return 0;
15608 }
15609
15610 static void
15611 purge_unchecked_exceptions (mdecl)
15612      tree mdecl;
15613 {
15614   tree throws = DECL_FUNCTION_THROWS (mdecl);
15615   tree new = NULL_TREE;
15616
15617   while (throws)
15618     {
15619       tree next = TREE_CHAIN (throws);
15620       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15621         {
15622           TREE_CHAIN (throws) = new;
15623           new = throws;
15624         }
15625       throws = next;
15626     }
15627   /* List is inverted here, but it doesn't matter */
15628   DECL_FUNCTION_THROWS (mdecl) = new;
15629 }
15630
15631 /* This function goes over all of CLASS_TYPE ctors and checks whether
15632    each of them features at least one unchecked exception in its
15633    `throws' clause. If it's the case, it returns `true', `false'
15634    otherwise.  */
15635
15636 static bool
15637 ctors_unchecked_throws_clause_p (class_type)
15638      tree class_type;
15639 {
15640   tree current;
15641
15642   for (current = TYPE_METHODS (class_type); current;
15643        current = TREE_CHAIN (current))
15644     {
15645       bool ctu = false; /* Ctor Throws Unchecked */
15646       if (DECL_CONSTRUCTOR_P (current))
15647         {
15648           tree throws;
15649           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15650                throws = TREE_CHAIN (throws))
15651             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15652               ctu = true;
15653         }
15654       /* We return false as we found one ctor that is unfit. */
15655       if (!ctu && DECL_CONSTRUCTOR_P (current))
15656         return false;
15657     }
15658   /* All ctors feature at least one unchecked exception in their
15659      `throws' clause. */
15660   return true;
15661 }
15662
15663 /* 15.24 Conditional Operator ?: */
15664
15665 static tree
15666 patch_conditional_expr (node, wfl_cond, wfl_op1)
15667      tree node, wfl_cond, wfl_op1;
15668 {
15669   tree cond = TREE_OPERAND (node, 0);
15670   tree op1 = TREE_OPERAND (node, 1);
15671   tree op2 = TREE_OPERAND (node, 2);
15672   tree resulting_type = NULL_TREE;
15673   tree t1, t2, patched;
15674   int error_found = 0;
15675
15676   /* Operands of ?: might be StringBuffers crafted as a result of a
15677      string concatenation. Obtain a descent operand here.  */
15678   if ((patched = patch_string (op1)))
15679     TREE_OPERAND (node, 1) = op1 = patched;
15680   if ((patched = patch_string (op2)))
15681     TREE_OPERAND (node, 2) = op2 = patched;
15682
15683   t1 = TREE_TYPE (op1);
15684   t2 = TREE_TYPE (op2);
15685
15686   /* The first expression must be a boolean */
15687   if (TREE_TYPE (cond) != boolean_type_node)
15688     {
15689       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15690       parse_error_context (wfl_operator,
15691                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15692                            lang_printable_name (TREE_TYPE (cond), 0));
15693       error_found = 1;
15694     }
15695
15696   /* Second and third can be numeric, boolean (i.e. primitive),
15697      references or null. Anything else results in an error */
15698   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15699         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15700             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15701         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15702     error_found = 1;
15703
15704   /* Determine the type of the conditional expression. Same types are
15705      easy to deal with */
15706   else if (t1 == t2)
15707     resulting_type = t1;
15708
15709   /* There are different rules for numeric types */
15710   else if (JNUMERIC_TYPE_P (t1))
15711     {
15712       /* if byte/short found, the resulting type is short */
15713       if ((t1 == byte_type_node && t2 == short_type_node)
15714           || (t1 == short_type_node && t2 == byte_type_node))
15715         resulting_type = short_type_node;
15716
15717       /* If t1 is a constant int and t2 is of type byte, short or char
15718          and t1's value fits in t2, then the resulting type is t2 */
15719       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15720           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15721         resulting_type = t2;
15722
15723       /* If t2 is a constant int and t1 is of type byte, short or char
15724          and t2's value fits in t1, then the resulting type is t1 */
15725       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15726           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15727         resulting_type = t1;
15728
15729       /* Otherwise, binary numeric promotion is applied and the
15730          resulting type is the promoted type of operand 1 and 2 */
15731       else
15732         resulting_type = binary_numeric_promotion (t1, t2,
15733                                                    &TREE_OPERAND (node, 1),
15734                                                    &TREE_OPERAND (node, 2));
15735     }
15736
15737   /* Cases of a reference and a null type */
15738   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15739     resulting_type = t1;
15740
15741   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15742     resulting_type = t2;
15743
15744   /* Last case: different reference types. If a type can be converted
15745      into the other one by assignment conversion, the latter
15746      determines the type of the expression */
15747   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15748     resulting_type = promote_type (t1);
15749
15750   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15751     resulting_type = promote_type (t2);
15752
15753   /* If we don't have any resulting type, we're in trouble */
15754   if (!resulting_type)
15755     {
15756       char *t = xstrdup (lang_printable_name (t1, 0));
15757       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15758       parse_error_context (wfl_operator,
15759                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15760                            t, lang_printable_name (t2, 0));
15761       free (t);
15762       error_found = 1;
15763     }
15764
15765   if (error_found)
15766     {
15767       TREE_TYPE (node) = error_mark_node;
15768       return error_mark_node;
15769     }
15770
15771   TREE_TYPE (node) = resulting_type;
15772   TREE_SET_CODE (node, COND_EXPR);
15773   CAN_COMPLETE_NORMALLY (node) = 1;
15774   return node;
15775 }
15776
15777 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15778
15779 static tree
15780 maybe_build_class_init_for_field (decl, expr)
15781     tree decl, expr;
15782 {
15783   tree clas = DECL_CONTEXT (decl);
15784   if (flag_emit_class_files || flag_emit_xref)
15785     return expr;
15786
15787   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15788       && FIELD_FINAL (decl))
15789     {
15790       tree init = DECL_INITIAL (decl);
15791       if (init != NULL_TREE)
15792         init = fold_constant_for_init (init, decl);
15793       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15794         return expr;
15795     }
15796
15797   return build_class_init (clas, expr);
15798 }
15799
15800 /* Try to constant fold NODE.
15801    If NODE is not a constant expression, return NULL_EXPR.
15802    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15803
15804 static tree
15805 fold_constant_for_init (node, context)
15806      tree node;
15807      tree context;
15808 {
15809   tree op0, op1, val;
15810   enum tree_code code = TREE_CODE (node);
15811
15812   switch (code)
15813     {
15814     case STRING_CST:
15815     case INTEGER_CST:
15816     case REAL_CST:
15817       return node;
15818
15819     case PLUS_EXPR:
15820     case MINUS_EXPR:
15821     case MULT_EXPR:
15822     case TRUNC_MOD_EXPR:
15823     case RDIV_EXPR:
15824     case LSHIFT_EXPR:
15825     case RSHIFT_EXPR:
15826     case URSHIFT_EXPR:
15827     case BIT_AND_EXPR:
15828     case BIT_XOR_EXPR:
15829     case BIT_IOR_EXPR:
15830     case TRUTH_ANDIF_EXPR:
15831     case TRUTH_ORIF_EXPR:
15832     case EQ_EXPR:
15833     case NE_EXPR:
15834     case GT_EXPR:
15835     case GE_EXPR:
15836     case LT_EXPR:
15837     case LE_EXPR:
15838       op0 = TREE_OPERAND (node, 0);
15839       op1 = TREE_OPERAND (node, 1);
15840       val = fold_constant_for_init (op0, context);
15841       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15842         return NULL_TREE;
15843       TREE_OPERAND (node, 0) = val;
15844       val = fold_constant_for_init (op1, context);
15845       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15846         return NULL_TREE;
15847       TREE_OPERAND (node, 1) = val;
15848       return patch_binop (node, op0, op1);
15849
15850     case UNARY_PLUS_EXPR:
15851     case NEGATE_EXPR:
15852     case TRUTH_NOT_EXPR:
15853     case BIT_NOT_EXPR:
15854     case CONVERT_EXPR:
15855       op0 = TREE_OPERAND (node, 0);
15856       val = fold_constant_for_init (op0, context);
15857       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15858         return NULL_TREE;
15859       TREE_OPERAND (node, 0) = val;
15860       return patch_unaryop (node, op0);
15861       break;
15862
15863     case COND_EXPR:
15864       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
15865       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15866         return NULL_TREE;
15867       TREE_OPERAND (node, 0) = val;
15868       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
15869       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15870         return NULL_TREE;
15871       TREE_OPERAND (node, 1) = val;
15872       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
15873       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15874         return NULL_TREE;
15875       TREE_OPERAND (node, 2) = val;
15876       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
15877         : TREE_OPERAND (node, 2);
15878
15879     case VAR_DECL:
15880     case FIELD_DECL:
15881       if (! FIELD_FINAL (node)
15882           || DECL_INITIAL (node) == NULL_TREE)
15883         return NULL_TREE;
15884       val = DECL_INITIAL (node);
15885       /* Guard against infinite recursion. */
15886       DECL_INITIAL (node) = NULL_TREE;
15887       val = fold_constant_for_init (val, node);
15888       DECL_INITIAL (node) = val;
15889       return val;
15890
15891     case EXPR_WITH_FILE_LOCATION:
15892       /* Compare java_complete_tree and resolve_expression_name. */
15893       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15894           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15895         {
15896           tree name = EXPR_WFL_NODE (node);
15897           tree decl;
15898           if (PRIMARY_P (node))
15899             return NULL_TREE;
15900           else if (! QUALIFIED_P (name))
15901             {
15902               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
15903               if (decl == NULL_TREE
15904                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
15905                 return NULL_TREE;
15906               return fold_constant_for_init (decl, decl);
15907             }
15908           else
15909             {
15910               /* Install the proper context for the field resolution.
15911                  The prior context is restored once the name is
15912                  properly qualified. */
15913               tree saved_current_class = current_class;
15914               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
15915               current_class = DECL_CONTEXT (context);
15916               qualify_ambiguous_name (node);
15917               current_class = saved_current_class;
15918               if (resolve_field_access (node, &decl, NULL)
15919                   && decl != NULL_TREE)
15920                 return fold_constant_for_init (decl, decl);
15921               return NULL_TREE;
15922             }
15923         }
15924       else
15925         {
15926           op0 = TREE_OPERAND (node, 0);
15927           val = fold_constant_for_init (op0, context);
15928           if (val == NULL_TREE || ! TREE_CONSTANT (val))
15929             return NULL_TREE;
15930           TREE_OPERAND (node, 0) = val;
15931           return val;
15932         }
15933
15934 #ifdef USE_COMPONENT_REF
15935     case IDENTIFIER:
15936     case COMPONENT_REF:
15937       ?;
15938 #endif
15939
15940     default:
15941       return NULL_TREE;
15942     }
15943 }
15944
15945 #ifdef USE_COMPONENT_REF
15946 /* Context is 'T' for TypeName, 'P' for PackageName,
15947    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
15948
15949 tree
15950 resolve_simple_name (name, context)
15951      tree name;
15952      int context;
15953 {
15954 }
15955
15956 tree
15957 resolve_qualified_name (name, context)
15958      tree name;
15959      int context;
15960 {
15961 }
15962 #endif
15963
15964 /* Mark P, which is really a `struct parser_ctxt **' for GC.  */
15965
15966 static void
15967 mark_parser_ctxt (p)
15968      void *p;
15969 {
15970   struct parser_ctxt *pc = *((struct parser_ctxt **) p);
15971   int i;
15972
15973   if (!pc)
15974     return;
15975
15976 #ifndef JC1_LITE
15977   for (i = 0; i < 11; ++i)
15978     ggc_mark_tree (pc->modifier_ctx[i]);
15979   ggc_mark_tree (pc->class_type);
15980   ggc_mark_tree (pc->function_decl);
15981   ggc_mark_tree (pc->package);
15982   ggc_mark_tree (pc->class_list);
15983   ggc_mark_tree (pc->current_parsed_class);
15984   ggc_mark_tree (pc->current_parsed_class_un);
15985   ggc_mark_tree (pc->non_static_initialized);
15986   ggc_mark_tree (pc->static_initialized);
15987   ggc_mark_tree (pc->instance_initializers);
15988   ggc_mark_tree (pc->import_list);
15989   ggc_mark_tree (pc->import_demand_list);
15990   ggc_mark_tree (pc->current_loop);
15991   ggc_mark_tree (pc->current_labeled_block);
15992 #endif /* JC1_LITE */
15993
15994   if (pc->next)
15995     mark_parser_ctxt (&pc->next);
15996 }
15997
15998 void
15999 init_src_parse ()
16000 {
16001   /* Register roots with the garbage collector.  */
16002   ggc_add_tree_root (src_parse_roots, ARRAY_SIZE (src_parse_roots));
16003
16004   /* Sanity check; we've been bit by this before.  */
16005   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16006     abort ();
16007 }
16008
16009 \f
16010
16011 /* This section deals with the functions that are called when tables
16012    recording class initialization information are traversed.  */
16013
16014 /* Attach to PTR (a block) the declaration found in ENTRY. */
16015
16016 static bool
16017 attach_init_test_initialization_flags (entry, ptr)
16018      struct hash_entry *entry;
16019      PTR ptr;
16020 {
16021   tree block = (tree)ptr;
16022   struct init_test_hash_entry *ite = (struct init_test_hash_entry *) entry;
16023
16024   TREE_CHAIN (ite->init_test_decl) = BLOCK_EXPR_DECLS (block);
16025   BLOCK_EXPR_DECLS (block) = ite->init_test_decl;
16026   return true;
16027 }
16028
16029 /* This function is called for each classes that is known definitely
16030    assigned when a given static method was called. This function
16031    augments a compound expression (INFO) storing all assignment to
16032    initialized static class flags if a flag already existed, otherwise
16033    a new one is created.  */
16034
16035 static bool
16036 emit_test_initialization (entry, info)
16037      struct hash_entry *entry;
16038      PTR info;
16039 {
16040   tree l = (tree) info;
16041   tree decl, init;
16042
16043   struct init_test_hash_entry *ite = (struct init_test_hash_entry *)
16044     hash_lookup (&DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl),
16045                  entry->key,
16046                  current_function_decl != TREE_PURPOSE (l), NULL);
16047
16048   /* If we haven't found a flag and we're dealing with self registered
16049      with current_function_decl, then don't do anything. Self is
16050      always added as definitely initialized but this information is
16051      valid only if used outside the current function. */
16052   if (! ite)
16053     return true;
16054
16055   /* If we don't have a variable, create one and install it. */
16056   if (! ite->init_test_decl)
16057     {
16058       tree block;
16059
16060       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16061       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16062       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16063       DECL_CONTEXT (decl) = current_function_decl;
16064       DECL_INITIAL (decl) = boolean_true_node;
16065
16066       /* The trick is to find the right context for it. */
16067       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16068       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16069       BLOCK_EXPR_DECLS (block) = decl;
16070       ite->init_test_decl = decl;
16071     }
16072   else
16073     decl = ite->init_test_decl;
16074
16075   /* Now simply augment the compound that holds all the assignments
16076      pertaining to this method invocation. */
16077   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16078   TREE_SIDE_EFFECTS (init) = 1;
16079   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16080   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16081
16082   return true;
16083 }