gcc/java/parse.y

   1 /* Source code parsing and tree node generation for the GNU compiler
   2    for the Java(TM) language.
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
   4    Free Software Foundation, Inc.
   5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.
  23
  24 Java and all Java-based marks are trademarks or registered trademarks
  25 of Sun Microsystems, Inc. in the United States and other countries.
  26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  27
  28 /* This file parses java source code and issues a tree node image
  29 suitable for code generation (byte code and targeted CPU assembly
  30 language).
  31
  32 The grammar conforms to the Java grammar described in "The Java(TM)
  33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  34 1996, ISBN 0-201-63451-1"
  35
  36 The following modifications were brought to the original grammar:
  37
  38 method_body: added the rule '| block SC_TK'
  39 static_initializer: added the rule 'static block SC_TK'.
  40
  41 Note: All the extra rules described above should go away when the
  42       empty_statement rule will work.
  43
  44 statement_nsi: 'nsi' should be read no_short_if.
  45
  46 Some rules have been modified to support JDK1.1 inner classes
  47 definitions and other extensions.  */
  48
  49 %{
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include <dirent.h>
  55 #include "tree.h"
  56 #include "rtl.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "flags.h"
  61 #include "java-tree.h"
  62 #include "jcf.h"
  63 #include "lex.h"
  64 #include "parse.h"
  65 #include "zipfile.h"
  66 #include "convert.h"
  67 #include "buffer.h"
  68 #include "xref.h"
  69 #include "function.h"
  70 #include "except.h"
  71 #include "ggc.h"
  72 #include "debug.h"
  73 #include "tree-inline.h"
  74
  75 /* Local function prototypes */
  76 static char *java_accstring_lookup (int);
  77 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  78 static void  variable_redefinition_error (tree, tree, tree, int);
  79 static tree  create_class (int, tree, tree, tree);
  80 static tree  create_interface (int, tree, tree);
  81 static void  end_class_declaration (int);
  82 static tree  find_field (tree, tree);
  83 static tree lookup_field_wrapper (tree, tree);
  84 static int   duplicate_declaration_error_p (tree, tree, tree);
  85 static void  register_fields (int, tree, tree);
  86 static tree parser_qualified_classname (tree);
  87 static int  parser_check_super (tree, tree, tree);
  88 static int  parser_check_super_interface (tree, tree, tree);
  89 static void check_modifiers_consistency (int);
  90 static tree lookup_cl (tree);
  91 static tree lookup_java_method2 (tree, tree, int);
  92 static tree method_header (int, tree, tree, tree);
  93 static void fix_method_argument_names (tree ,tree);
  94 static tree method_declarator (tree, tree);
  95 static void parse_warning_context (tree cl, const char *msg, ...)
  96   ATTRIBUTE_PRINTF_2;
  97 static void issue_warning_error_from_context (tree, const char *msg, va_list)
  98   ATTRIBUTE_PRINTF (2, 0);
  99 static void parse_ctor_invocation_error (void);
 100 static tree parse_jdk1_1_error (const char *);
 101 static void complete_class_report_errors (jdep *);
 102 static int process_imports (void);
 103 static void read_import_dir (tree);
 104 static int find_in_imports_on_demand (tree, tree);
 105 static void find_in_imports (tree, tree);
 106 static void check_inner_class_access (tree, tree, tree);
 107 static int check_pkg_class_access (tree, tree, bool);
 108 static void register_package (tree);
 109 static tree resolve_package (tree, tree *, tree *);
 110 static tree resolve_class (tree, tree, tree, tree);
 111 static void declare_local_variables (int, tree, tree);
 112 static void dump_java_tree (enum tree_dump_index, tree);
 113 static void source_start_java_method (tree);
 114 static void source_end_java_method (void);
 115 static tree find_name_in_single_imports (tree);
 116 static void check_abstract_method_header (tree);
 117 static tree lookup_java_interface_method2 (tree, tree);
 118 static tree resolve_expression_name (tree, tree *);
 119 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 120 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 121 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 122 static int breakdown_qualified (tree *, tree *, tree);
 123 static int in_same_package (tree, tree);
 124 static tree resolve_and_layout (tree, tree);
 125 static tree qualify_and_find (tree, tree, tree);
 126 static tree resolve_no_layout (tree, tree);
 127 static int invocation_mode (tree, int);
 128 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 129 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 130 static tree find_most_specific_methods_list (tree);
 131 static int argument_types_convertible (tree, tree);
 132 static tree patch_invoke (tree, tree, tree);
 133 static int maybe_use_access_method (int, tree *, tree *);
 134 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 135 static tree register_incomplete_type (int, tree, tree, tree);
 136 static tree check_inner_circular_reference (tree, tree);
 137 static tree check_circular_reference (tree);
 138 static tree obtain_incomplete_type (tree);
 139 static tree java_complete_lhs (tree);
 140 static tree java_complete_tree (tree);
 141 static tree maybe_generate_pre_expand_clinit (tree);
 142 static int analyze_clinit_body (tree, tree);
 143 static int maybe_yank_clinit (tree);
 144 static void start_complete_expand_method (tree);
 145 static void java_complete_expand_method (tree);
 146 static void java_expand_method_bodies (tree);
 147 static int  unresolved_type_p (tree, tree *);
 148 static void create_jdep_list (struct parser_ctxt *);
 149 static tree build_expr_block (tree, tree);
 150 static tree enter_block (void);
 151 static tree exit_block (void);
 152 static tree lookup_name_in_blocks (tree);
 153 static void maybe_absorb_scoping_blocks (void);
 154 static tree build_method_invocation (tree, tree);
 155 static tree build_new_invocation (tree, tree);
 156 static tree build_assignment (int, int, tree, tree);
 157 static tree build_binop (enum tree_code, int, tree, tree);
 158 static tree patch_assignment (tree, tree);
 159 static tree patch_binop (tree, tree, tree);
 160 static tree build_unaryop (int, int, tree);
 161 static tree build_incdec (int, int, tree, int);
 162 static tree patch_unaryop (tree, tree);
 163 static tree build_cast (int, tree, tree);
 164 static tree build_null_of_type (tree);
 165 static tree patch_cast (tree, tree);
 166 static int valid_ref_assignconv_cast_p (tree, tree, int);
 167 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 168 static int valid_cast_to_p (tree, tree);
 169 static int valid_method_invocation_conversion_p (tree, tree);
 170 static tree try_builtin_assignconv (tree, tree, tree);
 171 static tree try_reference_assignconv (tree, tree);
 172 static tree build_unresolved_array_type (tree);
 173 static int build_type_name_from_array_name (tree, tree *);
 174 static tree build_array_from_name (tree, tree, tree, tree *);
 175 static tree build_array_ref (int, tree, tree);
 176 static tree patch_array_ref (tree);
 177 static tree make_qualified_name (tree, tree, int);
 178 static tree merge_qualified_name (tree, tree);
 179 static tree make_qualified_primary (tree, tree, int);
 180 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 181 static void qualify_ambiguous_name (tree);
 182 static tree resolve_field_access (tree, tree *, tree *);
 183 static tree build_newarray_node (tree, tree, int);
 184 static tree patch_newarray (tree);
 185 static tree resolve_type_during_patch (tree);
 186 static tree build_this (int);
 187 static tree build_wfl_wrap (tree, int);
 188 static tree build_return (int, tree);
 189 static tree patch_return (tree);
 190 static tree maybe_access_field (tree, tree, tree);
 191 static int complete_function_arguments (tree);
 192 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 193 static int not_accessible_p (tree, tree, tree, int);
 194 static void check_deprecation (tree, tree);
 195 static int class_in_current_package (tree);
 196 static tree build_if_else_statement (int, tree, tree, tree);
 197 static tree patch_if_else_statement (tree);
 198 static tree add_stmt_to_compound (tree, tree, tree);
 199 static tree add_stmt_to_block (tree, tree, tree);
 200 static tree patch_exit_expr (tree);
 201 static tree build_labeled_block (int, tree);
 202 static tree finish_labeled_statement (tree, tree);
 203 static tree build_bc_statement (int, int, tree);
 204 static tree patch_bc_statement (tree);
 205 static tree patch_loop_statement (tree);
 206 static tree build_new_loop (tree);
 207 static tree build_loop_body (int, tree, int);
 208 static tree finish_loop_body (int, tree, tree, int);
 209 static tree build_debugable_stmt (int, tree);
 210 static tree finish_for_loop (int, tree, tree, tree);
 211 static tree patch_switch_statement (tree);
 212 static tree string_constant_concatenation (tree, tree);
 213 static tree build_string_concatenation (tree, tree);
 214 static tree patch_string_cst (tree);
 215 static tree patch_string (tree);
 216 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 217 static tree build_assertion (int, tree, tree);
 218 static tree build_try_statement (int, tree, tree);
 219 static tree build_try_finally_statement (int, tree, tree);
 220 static tree patch_try_statement (tree);
 221 static tree patch_synchronized_statement (tree, tree);
 222 static tree patch_throw_statement (tree, tree);
 223 static void check_thrown_exceptions (int, tree);
 224 static int check_thrown_exceptions_do (tree);
 225 static void purge_unchecked_exceptions (tree);
 226 static bool ctors_unchecked_throws_clause_p (tree);
 227 static void check_throws_clauses (tree, tree, tree);
 228 static void finish_method_declaration (tree);
 229 static tree build_super_invocation (tree);
 230 static int verify_constructor_circularity (tree, tree);
 231 static char *constructor_circularity_msg (tree, tree);
 232 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 233 static const char *get_printable_method_name (tree);
 234 static tree patch_conditional_expr (tree, tree, tree);
 235 static tree generate_finit (tree);
 236 static tree generate_instinit (tree);
 237 static tree build_instinit_invocation (tree);
 238 static void fix_constructors (tree);
 239 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 240 static tree craft_constructor (tree, tree);
 241 static int verify_constructor_super (tree);
 242 static tree create_artificial_method (tree, int, tree, tree, tree);
 243 static void start_artificial_method_body (tree);
 244 static void end_artificial_method_body (tree);
 245 static int check_method_redefinition (tree, tree);
 246 static int check_method_types_complete (tree);
 247 static void java_check_regular_methods (tree);
 248 static void java_check_abstract_methods (tree);
 249 static void unreachable_stmt_error (tree);
 250 static tree find_expr_with_wfl (tree);
 251 static void missing_return_error (tree);
 252 static tree build_new_array_init (int, tree);
 253 static tree patch_new_array_init (tree, tree);
 254 static tree maybe_build_array_element_wfl (tree);
 255 static int array_constructor_check_entry (tree, tree);
 256 static const char *purify_type_name (const char *);
 257 static tree fold_constant_for_init (tree, tree);
 258 static tree strip_out_static_field_access_decl (tree);
 259 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 260 static void static_ref_err (tree, tree, tree);
 261 static void parser_add_interface (tree, tree, tree);
 262 static void add_superinterfaces (tree, tree);
 263 static tree jdep_resolve_class (jdep *);
 264 static int note_possible_classname (const char *, int);
 265 static void java_complete_expand_classes (void);
 266 static void java_complete_expand_class (tree);
 267 static void java_complete_expand_methods (tree);
 268 static tree cut_identifier_in_qualified (tree);
 269 static tree java_stabilize_reference (tree);
 270 static tree do_unary_numeric_promotion (tree);
 271 static char * operator_string (tree);
 272 static tree do_merge_string_cste (tree, const char *, int, int);
 273 static tree merge_string_cste (tree, tree, int);
 274 static tree java_refold (tree);
 275 static int java_decl_equiv (tree, tree);
 276 static int binop_compound_p (enum tree_code);
 277 static tree search_loop (tree);
 278 static int labeled_block_contains_loop_p (tree, tree);
 279 static int check_abstract_method_definitions (int, tree, tree);
 280 static void java_check_abstract_method_definitions (tree);
 281 static void java_debug_context_do (int);
 282 static void java_parser_context_push_initialized_field (void);
 283 static void java_parser_context_pop_initialized_field (void);
 284 static tree reorder_static_initialized (tree);
 285 static void java_parser_context_suspend (void);
 286 static void java_parser_context_resume (void);
 287 static int pop_current_osb (struct parser_ctxt *);
 288
 289 /* JDK 1.1 work. FIXME */
 290
 291 static tree maybe_make_nested_class_name (tree);
 292 static int make_nested_class_name (tree);
 293 static void set_nested_class_simple_name_value (tree, int);
 294 static void link_nested_class_to_enclosing (void);
 295 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 296 static tree find_as_inner_class (tree, tree, tree);
 297 static tree find_as_inner_class_do (tree, tree);
 298 static int check_inner_class_redefinition (tree, tree);
 299
 300 static tree build_thisn_assign (void);
 301 static tree build_current_thisn (tree);
 302 static tree build_access_to_thisn (tree, tree, int);
 303 static tree maybe_build_thisn_access_method (tree);
 304
 305 static tree build_outer_field_access (tree, tree);
 306 static tree build_outer_field_access_methods (tree);
 307 static tree build_outer_field_access_expr (int, tree, tree,
 308                                                   tree, tree);
 309 static tree build_outer_method_access_method (tree);
 310 static tree build_new_access_id (void);
 311 static tree build_outer_field_access_method (tree, tree, tree,
 312                                                     tree, tree);
 313
 314 static int outer_field_access_p (tree, tree);
 315 static int outer_field_expanded_access_p (tree, tree *,
 316                                                  tree *, tree *);
 317 static tree outer_field_access_fix (tree, tree, tree);
 318 static tree build_incomplete_class_ref (int, tree);
 319 static tree patch_incomplete_class_ref (tree);
 320 static tree create_anonymous_class (int, tree);
 321 static void patch_anonymous_class (tree, tree, tree);
 322 static void add_inner_class_fields (tree, tree);
 323
 324 static tree build_dot_class_method (tree);
 325 static tree build_dot_class_method_invocation (tree);
 326 static void create_new_parser_context (int);
 327 static tree maybe_build_class_init_for_field (tree, tree);
 328
 329 static int attach_init_test_initialization_flags (void **, void *);
 330 static int emit_test_initialization (void **, void *);
 331
 332 static char *string_convert_int_cst (tree);
 333
 334 /* Number of error found so far. */
 335 int java_error_count;
 336 /* Number of warning found so far. */
 337 int java_warning_count;
 338 /* Tell when not to fold, when doing xrefs */
 339 int do_not_fold;
 340 /* Cyclic inheritance report, as it can be set by layout_class */
 341 const char *cyclic_inheritance_report;
 342
 343 /* The current parser context */
 344 struct parser_ctxt *ctxp;
 345
 346 /* List of things that were analyzed for which code will be generated */
 347 struct parser_ctxt *ctxp_for_generation = NULL;
 348
 349 /* binop_lookup maps token to tree_code. It is used where binary
 350    operations are involved and required by the parser. RDIV_EXPR
 351    covers both integral/floating point division. The code is changed
 352    once the type of both operator is worked out.  */
 353
 354 static const enum tree_code binop_lookup[19] =
 355   {
 356     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 357     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 358     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 359     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 360     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 361    };
 362 #define BINOP_LOOKUP(VALUE)                                             \
 363   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 364
 365 /* This is the end index for binary operators that can also be used
 366    in compound assignements. */
 367 #define BINOP_COMPOUND_CANDIDATES 11
 368
 369 /* The "$L" identifier we use to create labels.  */
 370 static GTY(()) tree label_id;
 371
 372 /* The "StringBuffer" identifier used for the String `+' operator. */
 373 static GTY(()) tree wfl_string_buffer;
 374
 375 /* The "append" identifier used for String `+' operator.  */
 376 static GTY(()) tree wfl_append;
 377
 378 /* The "toString" identifier used for String `+' operator. */
 379 static GTY(()) tree wfl_to_string;
 380
 381 /* The "java.lang" import qualified name.  */
 382 static GTY(()) tree java_lang_id;
 383
 384 /* The generated `inst$' identifier used for generated enclosing
 385    instance/field access functions.  */
 386 static GTY(()) tree inst_id;
 387
 388 /* Context and flag for static blocks */
 389 static GTY(()) tree current_static_block;
 390
 391 /* The generated `write_parm_value$' identifier.  */
 392 static GTY(()) tree wpv_id;
 393
 394 /* The list of all packages we've seen so far */
 395 static GTY(()) tree package_list;
 396
 397 /* Hold THIS for the scope of the current method decl.  */
 398 static GTY(()) tree current_this;
 399
 400 /* Hold a list of catch clauses list. The first element of this list is
 401    the list of the catch clauses of the currently analysed try block. */
 402 static GTY(()) tree currently_caught_type_list;
 403
 404 /* This holds a linked list of all the case labels for the current
 405    switch statement.  It is only used when checking to see if there
 406    are duplicate labels.  FIXME: probably this should just be attached
 407    to the switch itself; then it could be referenced via
 408    `ctxp->current_loop'.  */
 409 static GTY(()) tree case_label_list;
 410
 411 /* Anonymous class counter. Will be reset to 1 every time a non
 412    anonymous class gets created. */
 413 static int anonymous_class_counter = 1;
 414
 415 static GTY(()) tree src_parse_roots[1];
 416
 417 /* All classes seen from source code */
 418 #define gclass_list src_parse_roots[0]
 419
 420 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 421    line and point it out.  */
 422 /* Should point out the one that don't fit. ASCII/unicode, going
 423    backward. FIXME */
 424
 425 #define check_modifiers(__message, __value, __mask) do {        \
 426   if ((__value) & ~(__mask))                                    \
 427     {                                                           \
 428       size_t i, remainder = (__value) & ~(__mask);              \
 429       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 430         if ((1 << i) & remainder)                               \
 431           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 432                                java_accstring_lookup (1 << i)); \
 433     }                                                           \
 434 } while (0)
 435
 436 %}
 437
 438 %union {
 439   tree node;
 440   int sub_token;
 441   struct {
 442     int token;
 443     int location;
 444   } operator;
 445   int value;
 446 }
 447
 448 %{
 449 #include "lex.c"
 450 %}
 451
 452 %pure_parser
 453
 454 /* Things defined here have to match the order of what's in the
 455    binop_lookup table.  */
 456
 457 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 458 %token   LS_TK           SRS_TK          ZRS_TK
 459 %token   AND_TK          XOR_TK          OR_TK
 460 %token   BOOL_AND_TK BOOL_OR_TK
 461 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 462
 463 /* This maps to the same binop_lookup entry than the token above */
 464
 465 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 466 %token   REM_ASSIGN_TK
 467 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 468 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 469
 470
 471 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 472
 473 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 474 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 475 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 476 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 477 %token   MODIFIER_TK
 478
 479 /* Keep those two in order, too */
 480 %token   DECR_TK INCR_TK
 481
 482 /* From now one, things can be in any order */
 483
 484 %token   DEFAULT_TK      IF_TK              THROW_TK
 485 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 486 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 487 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 488 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 489 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 490 %token   SUPER_TK        WHILE_TK           CLASS_TK
 491 %token   SWITCH_TK       CONST_TK           TRY_TK
 492 %token   FOR_TK          NEW_TK             CONTINUE_TK
 493 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 494 %token   ASSERT_TK
 495
 496 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 497 %token   CHAR_TK         INTEGRAL_TK
 498
 499 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 500
 501 %token   ID_TK
 502
 503 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 504
 505 %token   ASSIGN_ANY_TK   ASSIGN_TK
 506 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 507
 508 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 509 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 510
 511 %type    <value>        modifiers MODIFIER_TK final synchronized
 512
 513 %type    <node>         super ID_TK identifier
 514 %type    <node>         name simple_name qualified_name
 515 %type    <node>         type_declaration compilation_unit
 516                         field_declaration method_declaration extends_interfaces
 517                         interfaces interface_type_list
 518                         import_declarations package_declaration
 519                         type_declarations interface_body
 520                         interface_member_declaration constant_declaration
 521                         interface_member_declarations interface_type
 522                         abstract_method_declaration
 523 %type    <node>         class_body_declaration class_member_declaration
 524                         static_initializer constructor_declaration block
 525 %type    <node>         class_body_declarations constructor_header
 526 %type    <node>         class_or_interface_type class_type class_type_list
 527                         constructor_declarator explicit_constructor_invocation
 528 %type    <node>         dim_expr dim_exprs this_or_super throws
 529
 530 %type    <node>         variable_declarator_id variable_declarator
 531                         variable_declarators variable_initializer
 532                         variable_initializers constructor_body
 533                         array_initializer
 534
 535 %type    <node>         class_body block_end constructor_block_end
 536 %type    <node>         statement statement_without_trailing_substatement
 537                         labeled_statement if_then_statement label_decl
 538                         if_then_else_statement while_statement for_statement
 539                         statement_nsi labeled_statement_nsi do_statement
 540                         if_then_else_statement_nsi while_statement_nsi
 541                         for_statement_nsi statement_expression_list for_init
 542                         for_update statement_expression expression_statement
 543                         primary_no_new_array expression primary
 544                         array_creation_expression array_type
 545                         class_instance_creation_expression field_access
 546                         method_invocation array_access something_dot_new
 547                         argument_list postfix_expression while_expression
 548                         post_increment_expression post_decrement_expression
 549                         unary_expression_not_plus_minus unary_expression
 550                         pre_increment_expression pre_decrement_expression
 551                         cast_expression
 552                         multiplicative_expression additive_expression
 553                         shift_expression relational_expression
 554                         equality_expression and_expression
 555                         exclusive_or_expression inclusive_or_expression
 556                         conditional_and_expression conditional_or_expression
 557                         conditional_expression assignment_expression
 558                         left_hand_side assignment for_header for_begin
 559                         constant_expression do_statement_begin empty_statement
 560                         switch_statement synchronized_statement throw_statement
 561                         try_statement assert_statement
 562                         switch_expression switch_block
 563                         catches catch_clause catch_clause_parameter finally
 564                         anonymous_class_creation trap_overflow_corner_case
 565 %type    <node>         return_statement break_statement continue_statement
 566
 567 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 568 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 569 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 570 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 571 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 572 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 573 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 574 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 575 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 576 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 577 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 578 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 579 %type    <operator>     NEW_TK ASSERT_TK
 580
 581 %type    <node>         method_body
 582
 583 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 584                         STRING_LIT_TK NULL_TK VOID_TK
 585
 586 %type    <node>         IF_TK WHILE_TK FOR_TK
 587
 588 %type    <node>         formal_parameter_list formal_parameter
 589                         method_declarator method_header
 590
 591 %type    <node>         primitive_type reference_type type
 592                         BOOLEAN_TK INTEGRAL_TK FP_TK
 593
 594 /* Added or modified JDK 1.1 rule types  */
 595 %type    <node>         type_literals
 596
 597 %%
 598 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 599 goal:  compilation_unit
 600                 {}
 601 ;
 602
 603 /* 19.3 Productions from 3: Lexical structure  */
 604 literal:
 605         INT_LIT_TK
 606 |       FP_LIT_TK
 607 |       BOOL_LIT_TK
 608 |       CHAR_LIT_TK
 609 |       STRING_LIT_TK
 610 |       NULL_TK
 611 ;
 612
 613 /* 19.4 Productions from 4: Types, Values and Variables  */
 614 type:
 615         primitive_type
 616 |       reference_type
 617 ;
 618
 619 primitive_type:
 620         INTEGRAL_TK
 621 |       FP_TK
 622 |       BOOLEAN_TK
 623 ;
 624
 625 reference_type:
 626         class_or_interface_type
 627 |       array_type
 628 ;
 629
 630 class_or_interface_type:
 631         name
 632 ;
 633
 634 class_type:
 635         class_or_interface_type /* Default rule */
 636 ;
 637
 638 interface_type:
 639          class_or_interface_type
 640 ;
 641
 642 array_type:
 643         primitive_type dims
 644                 {
 645                   int osb = pop_current_osb (ctxp);
 646                   tree t = build_java_array_type (($1), -1);
 647                   while (--osb)
 648                     t = build_unresolved_array_type (t);
 649                   $$ = t;
 650                 }
 651 |       name dims
 652                 {
 653                   int osb = pop_current_osb (ctxp);
 654                   tree t = $1;
 655                   while (osb--)
 656                     t = build_unresolved_array_type (t);
 657                   $$ = t;
 658                 }
 659 ;
 660
 661 /* 19.5 Productions from 6: Names  */
 662 name:
 663         simple_name             /* Default rule */
 664 |       qualified_name          /* Default rule */
 665 ;
 666
 667 simple_name:
 668         identifier              /* Default rule */
 669 ;
 670
 671 qualified_name:
 672         name DOT_TK identifier
 673                 { $$ = make_qualified_name ($1, $3, $2.location); }
 674 ;
 675
 676 identifier:
 677         ID_TK
 678 ;
 679
 680 /* 19.6: Production from 7: Packages  */
 681 compilation_unit:
 682                 {$$ = NULL;}
 683 |       package_declaration
 684 |       import_declarations
 685 |       type_declarations
 686 |       package_declaration import_declarations
 687 |       package_declaration type_declarations
 688 |       import_declarations type_declarations
 689 |       package_declaration import_declarations type_declarations
 690 ;
 691
 692 import_declarations:
 693         import_declaration
 694                 {
 695                   $$ = NULL;
 696                 }
 697 |       import_declarations import_declaration
 698                 {
 699                   $$ = NULL;
 700                 }
 701 ;
 702
 703 type_declarations:
 704         type_declaration
 705 |       type_declarations type_declaration
 706 ;
 707
 708 package_declaration:
 709         PACKAGE_TK name SC_TK
 710                 {
 711                   ctxp->package = EXPR_WFL_NODE ($2);
 712                   register_package (ctxp->package);
 713                 }
 714 |       PACKAGE_TK error
 715                 {yyerror ("Missing name"); RECOVER;}
 716 |       PACKAGE_TK name error
 717                 {yyerror ("';' expected"); RECOVER;}
 718 ;
 719
 720 import_declaration:
 721         single_type_import_declaration
 722 |       type_import_on_demand_declaration
 723 ;
 724
 725 single_type_import_declaration:
 726         IMPORT_TK name SC_TK
 727                 {
 728                   tree name = EXPR_WFL_NODE ($2), last_name;
 729                   int   i = IDENTIFIER_LENGTH (name)-1;
 730                   const char *last = &IDENTIFIER_POINTER (name)[i];
 731                   while (last != IDENTIFIER_POINTER (name))
 732                     {
 733                       if (last [0] == '.')
 734                         break;
 735                       last--;
 736                     }
 737                   last_name = get_identifier (++last);
 738                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 739                     {
 740                       tree err = find_name_in_single_imports (last_name);
 741                       if (err && err != name)
 742                         parse_error_context
 743                           ($2, "Ambiguous class: `%s' and `%s'",
 744                            IDENTIFIER_POINTER (name),
 745                            IDENTIFIER_POINTER (err));
 746                       else
 747                         REGISTER_IMPORT ($2, last_name);
 748                     }
 749                   else
 750                     REGISTER_IMPORT ($2, last_name);
 751                 }
 752 |       IMPORT_TK error
 753                 {yyerror ("Missing name"); RECOVER;}
 754 |       IMPORT_TK name error
 755                 {yyerror ("';' expected"); RECOVER;}
 756 ;
 757
 758 type_import_on_demand_declaration:
 759         IMPORT_TK name DOT_TK MULT_TK SC_TK
 760                 {
 761                   tree name = EXPR_WFL_NODE ($2);
 762                   tree it;
 763                   /* Search for duplicates. */
 764                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 765                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 766                       break;
 767                   /* Don't import the same thing more than once, just ignore
 768                      duplicates (7.5.2) */
 769                   if (! it)
 770                     {
 771                       read_import_dir ($2);
 772                       ctxp->import_demand_list =
 773                         chainon (ctxp->import_demand_list,
 774                                  build_tree_list ($2, NULL_TREE));
 775                     }
 776                 }
 777 |       IMPORT_TK name DOT_TK error
 778                 {yyerror ("'*' expected"); RECOVER;}
 779 |       IMPORT_TK name DOT_TK MULT_TK error
 780                 {yyerror ("';' expected"); RECOVER;}
 781 ;
 782
 783 type_declaration:
 784         class_declaration
 785                 { end_class_declaration (0); }
 786 |       interface_declaration
 787                 { end_class_declaration (0); }
 788 |       empty_statement
 789 |       error
 790                 {
 791                   YYERROR_NOW;
 792                   yyerror ("Class or interface declaration expected");
 793                 }
 794 ;
 795
 796 /* 19.7 Shortened from the original:
 797    modifiers: modifier | modifiers modifier
 798    modifier: any of public...  */
 799 modifiers:
 800         MODIFIER_TK
 801                 {
 802                   $$ = (1 << $1);
 803                 }
 804 |       modifiers MODIFIER_TK
 805                 {
 806                   int acc = (1 << $2);
 807                   if ($$ & acc)
 808                     parse_error_context
 809                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 810                        java_accstring_lookup (acc));
 811                   else
 812                     {
 813                       $$ |= acc;
 814                     }
 815                 }
 816 ;
 817
 818 /* 19.8.1 Production from $8.1: Class Declaration */
 819 class_declaration:
 820         modifiers CLASS_TK identifier super interfaces
 821                 { create_class ($1, $3, $4, $5); }
 822         class_body
 823                 {;}
 824 |       CLASS_TK identifier super interfaces
 825                 { create_class (0, $2, $3, $4); }
 826         class_body
 827                 {;}
 828 |       modifiers CLASS_TK error
 829                 { yyerror ("Missing class name"); RECOVER; }
 830 |       CLASS_TK error
 831                 { yyerror ("Missing class name"); RECOVER; }
 832 |       CLASS_TK identifier error
 833                 {
 834                   if (!ctxp->class_err) yyerror ("'{' expected");
 835                   DRECOVER(class1);
 836                 }
 837 |       modifiers CLASS_TK identifier error
 838                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 839 ;
 840
 841 super:
 842                 { $$ = NULL; }
 843 |       EXTENDS_TK class_type
 844                 { $$ = $2; }
 845 |       EXTENDS_TK class_type error
 846                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 847 |       EXTENDS_TK error
 848                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 849 ;
 850
 851 interfaces:
 852                 { $$ = NULL_TREE; }
 853 |       IMPLEMENTS_TK interface_type_list
 854                 { $$ = $2; }
 855 |       IMPLEMENTS_TK error
 856                 {
 857                   ctxp->class_err=1;
 858                   yyerror ("Missing interface name");
 859                 }
 860 ;
 861
 862 interface_type_list:
 863         interface_type
 864                 {
 865                   ctxp->interface_number = 1;
 866                   $$ = build_tree_list ($1, NULL_TREE);
 867                 }
 868 |       interface_type_list C_TK interface_type
 869                 {
 870                   ctxp->interface_number++;
 871                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 872                 }
 873 |       interface_type_list C_TK error
 874                 {yyerror ("Missing interface name"); RECOVER;}
 875 ;
 876
 877 class_body:
 878         OCB_TK CCB_TK
 879                 {
 880                   /* Store the location of the `}' when doing xrefs */
 881                   if (flag_emit_xref)
 882                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 883                       EXPR_WFL_ADD_COL ($2.location, 1);
 884                   $$ = GET_CPC ();
 885                 }
 886 |       OCB_TK class_body_declarations CCB_TK
 887                 {
 888                   /* Store the location of the `}' when doing xrefs */
 889                   if (flag_emit_xref)
 890                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 891                       EXPR_WFL_ADD_COL ($3.location, 1);
 892                   $$ = GET_CPC ();
 893                 }
 894 ;
 895
 896 class_body_declarations:
 897         class_body_declaration
 898 |       class_body_declarations class_body_declaration
 899 ;
 900
 901 class_body_declaration:
 902         class_member_declaration
 903 |       static_initializer
 904 |       constructor_declaration
 905 |       block                   /* Added, JDK1.1, instance initializer */
 906                 {
 907                   if ($1 != empty_stmt_node)
 908                     {
 909                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 910                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 911                     }
 912                 }
 913 ;
 914
 915 class_member_declaration:
 916         field_declaration
 917 |       method_declaration
 918 |       class_declaration       /* Added, JDK1.1 inner classes */
 919                 { end_class_declaration (1); }
 920 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 921                 { end_class_declaration (1); }
 922 |       empty_statement
 923 ;
 924
 925 /* 19.8.2 Productions from 8.3: Field Declarations  */
 926 field_declaration:
 927         type variable_declarators SC_TK
 928                 { register_fields (0, $1, $2); }
 929 |       modifiers type variable_declarators SC_TK
 930                 {
 931                   check_modifiers
 932                     ("Illegal modifier `%s' for field declaration",
 933                      $1, FIELD_MODIFIERS);
 934                   check_modifiers_consistency ($1);
 935                   register_fields ($1, $2, $3);
 936                 }
 937 ;
 938
 939 variable_declarators:
 940         /* Should we use build_decl_list () instead ? FIXME */
 941         variable_declarator     /* Default rule */
 942 |       variable_declarators C_TK variable_declarator
 943                 { $$ = chainon ($1, $3); }
 944 |       variable_declarators C_TK error
 945                 {yyerror ("Missing term"); RECOVER;}
 946 ;
 947
 948 variable_declarator:
 949         variable_declarator_id
 950                 { $$ = build_tree_list ($1, NULL_TREE); }
 951 |       variable_declarator_id ASSIGN_TK variable_initializer
 952                 {
 953                   if (java_error_count)
 954                     $3 = NULL_TREE;
 955                   $$ = build_tree_list
 956                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 957                 }
 958 |       variable_declarator_id ASSIGN_TK error
 959                 {
 960                   yyerror ("Missing variable initializer");
 961                   $$ = build_tree_list ($1, NULL_TREE);
 962                   RECOVER;
 963                 }
 964 |       variable_declarator_id ASSIGN_TK variable_initializer error
 965                 {
 966                   yyerror ("';' expected");
 967                   $$ = build_tree_list ($1, NULL_TREE);
 968                   RECOVER;
 969                 }
 970 ;
 971
 972 variable_declarator_id:
 973         identifier
 974 |       variable_declarator_id OSB_TK CSB_TK
 975                 { $$ = build_unresolved_array_type ($1); }
 976 |       identifier error
 977                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 978 |       variable_declarator_id OSB_TK error
 979                 {
 980                   yyerror ("']' expected");
 981                   DRECOVER(vdi);
 982                 }
 983 |       variable_declarator_id CSB_TK error
 984                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 985 ;
 986
 987 variable_initializer:
 988         expression
 989 |       array_initializer
 990 ;
 991
 992 /* 19.8.3 Productions from 8.4: Method Declarations  */
 993 method_declaration:
 994         method_header
 995                 {
 996                   current_function_decl = $1;
 997                   if (current_function_decl
 998                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
 999                     source_start_java_method (current_function_decl);
1000                   else
1001                     current_function_decl = NULL_TREE;
1002                 }
1003         method_body
1004                 { finish_method_declaration ($3); }
1005 |       method_header error
1006                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1007 ;
1008
1009 method_header:
1010         type method_declarator throws
1011                 { $$ = method_header (0, $1, $2, $3); }
1012 |       VOID_TK method_declarator throws
1013                 { $$ = method_header (0, void_type_node, $2, $3); }
1014 |       modifiers type method_declarator throws
1015                 { $$ = method_header ($1, $2, $3, $4); }
1016 |       modifiers VOID_TK method_declarator throws
1017                 { $$ = method_header ($1, void_type_node, $3, $4); }
1018 |       type error
1019                 {
1020                   yyerror ("Invalid method declaration, method name required");
1021                   RECOVER;
1022                 }
1023 |       modifiers type error
1024                 {
1025                   yyerror ("Identifier expected");
1026                   RECOVER;
1027                 }
1028 |       VOID_TK error
1029                 {
1030                   yyerror ("Identifier expected");
1031                   RECOVER;
1032                 }
1033 |       modifiers VOID_TK error
1034                 {
1035                   yyerror ("Identifier expected");
1036                   RECOVER;
1037                 }
1038 |       modifiers error
1039                 {
1040                   yyerror ("Invalid method declaration, return type required");
1041                   RECOVER;
1042                 }
1043 ;
1044
1045 method_declarator:
1046         identifier OP_TK CP_TK
1047                 {
1048                   ctxp->formal_parameter_number = 0;
1049                   $$ = method_declarator ($1, NULL_TREE);
1050                 }
1051 |       identifier OP_TK formal_parameter_list CP_TK
1052                 { $$ = method_declarator ($1, $3); }
1053 |       method_declarator OSB_TK CSB_TK
1054                 {
1055                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1056                   TREE_PURPOSE ($1) =
1057                     build_unresolved_array_type (TREE_PURPOSE ($1));
1058                   parse_warning_context
1059                     (wfl_operator,
1060                      "Discouraged form of returned type specification");
1061                 }
1062 |       identifier OP_TK error
1063                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1064 |       method_declarator OSB_TK error
1065                 {yyerror ("']' expected"); RECOVER;}
1066 ;
1067
1068 formal_parameter_list:
1069         formal_parameter
1070                 {
1071                   ctxp->formal_parameter_number = 1;
1072                 }
1073 |       formal_parameter_list C_TK formal_parameter
1074                 {
1075                   ctxp->formal_parameter_number += 1;
1076                   $$ = chainon ($1, $3);
1077                 }
1078 |       formal_parameter_list C_TK error
1079                 { yyerror ("Missing formal parameter term"); RECOVER; }
1080 ;
1081
1082 formal_parameter:
1083         type variable_declarator_id
1084                 {
1085                   $$ = build_tree_list ($2, $1);
1086                 }
1087 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1088                 {
1089                   $$ = build_tree_list ($3, $2);
1090                   ARG_FINAL_P ($$) = 1;
1091                 }
1092 |       type error
1093                 {
1094                   yyerror ("Missing identifier"); RECOVER;
1095                   $$ = NULL_TREE;
1096                 }
1097 |       final type error
1098                 {
1099                   yyerror ("Missing identifier"); RECOVER;
1100                   $$ = NULL_TREE;
1101                 }
1102 ;
1103
1104 final:
1105         modifiers
1106                 {
1107                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1108                                    $1, ACC_FINAL);
1109                   if ($1 != ACC_FINAL)
1110                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1111                 }
1112 ;
1113
1114 throws:
1115                 { $$ = NULL_TREE; }
1116 |       THROWS_TK class_type_list
1117                 { $$ = $2; }
1118 |       THROWS_TK error
1119                 {yyerror ("Missing class type term"); RECOVER;}
1120 ;
1121
1122 class_type_list:
1123         class_type
1124                 { $$ = build_tree_list ($1, $1); }
1125 |       class_type_list C_TK class_type
1126                 { $$ = tree_cons ($3, $3, $1); }
1127 |       class_type_list C_TK error
1128                 {yyerror ("Missing class type term"); RECOVER;}
1129 ;
1130
1131 method_body:
1132         block
1133 |       SC_TK { $$ = NULL_TREE; }
1134 ;
1135
1136 /* 19.8.4 Productions from 8.5: Static Initializers  */
1137 static_initializer:
1138         static block
1139                 {
1140                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1141                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1142                   current_static_block = NULL_TREE;
1143                 }
1144 ;
1145
1146 static:                         /* Test lval.sub_token here */
1147         modifiers
1148                 {
1149                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1150                   /* Can't have a static initializer in an innerclass */
1151                   if ($1 | ACC_STATIC &&
1152                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1153                     parse_error_context
1154                       (MODIFIER_WFL (STATIC_TK),
1155                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1156                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1157                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1158                 }
1159 ;
1160
1161 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1162 constructor_declaration:
1163         constructor_header
1164                 {
1165                   current_function_decl = $1;
1166                   source_start_java_method (current_function_decl);
1167                 }
1168         constructor_body
1169                 { finish_method_declaration ($3); }
1170 ;
1171
1172 constructor_header:
1173         constructor_declarator throws
1174                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1175 |       modifiers constructor_declarator throws
1176                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1177 ;
1178
1179 constructor_declarator:
1180         simple_name OP_TK CP_TK
1181                 {
1182                   ctxp->formal_parameter_number = 0;
1183                   $$ = method_declarator ($1, NULL_TREE);
1184                 }
1185 |       simple_name OP_TK formal_parameter_list CP_TK
1186                 { $$ = method_declarator ($1, $3); }
1187 ;
1188
1189 constructor_body:
1190         /* Unlike regular method, we always need a complete (empty)
1191            body so we can safely perform all the required code
1192            addition (super invocation and field initialization) */
1193         block_begin constructor_block_end
1194                 {
1195                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1196                   $$ = $2;
1197                 }
1198 |       block_begin explicit_constructor_invocation constructor_block_end
1199                 { $$ = $3; }
1200 |       block_begin block_statements constructor_block_end
1201                 { $$ = $3; }
1202 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1203                 { $$ = $4; }
1204 ;
1205
1206 constructor_block_end:
1207         block_end
1208 ;
1209
1210 /* Error recovery for that rule moved down expression_statement: rule.  */
1211 explicit_constructor_invocation:
1212         this_or_super OP_TK CP_TK SC_TK
1213                 {
1214                   $$ = build_method_invocation ($1, NULL_TREE);
1215                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1216                   $$ = java_method_add_stmt (current_function_decl, $$);
1217                 }
1218 |       this_or_super OP_TK argument_list CP_TK SC_TK
1219                 {
1220                   $$ = build_method_invocation ($1, $3);
1221                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1222                   $$ = java_method_add_stmt (current_function_decl, $$);
1223                 }
1224         /* Added, JDK1.1 inner classes. Modified because the rule
1225            'primary' couldn't work.  */
1226 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1227                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1228 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1229                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1230 ;
1231
1232 this_or_super:                  /* Added, simplifies error diagnostics */
1233         THIS_TK
1234                 {
1235                   tree wfl = build_wfl_node (this_identifier_node);
1236                   EXPR_WFL_LINECOL (wfl) = $1.location;
1237                   $$ = wfl;
1238                 }
1239 |       SUPER_TK
1240                 {
1241                   tree wfl = build_wfl_node (super_identifier_node);
1242                   EXPR_WFL_LINECOL (wfl) = $1.location;
1243                   $$ = wfl;
1244                 }
1245 ;
1246
1247 /* 19.9 Productions from 9: Interfaces  */
1248 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1249 interface_declaration:
1250         INTERFACE_TK identifier
1251                 { create_interface (0, $2, NULL_TREE); }
1252         interface_body
1253                 { ; }
1254 |       modifiers INTERFACE_TK identifier
1255                 { create_interface ($1, $3, NULL_TREE); }
1256         interface_body
1257                 { ; }
1258 |       INTERFACE_TK identifier extends_interfaces
1259                 { create_interface (0, $2, $3); }
1260         interface_body
1261                 { ; }
1262 |       modifiers INTERFACE_TK identifier extends_interfaces
1263                 { create_interface ($1, $3, $4); }
1264         interface_body
1265                 { ; }
1266 |       INTERFACE_TK identifier error
1267                 { yyerror ("'{' expected"); RECOVER; }
1268 |       modifiers INTERFACE_TK identifier error
1269                 { yyerror ("'{' expected"); RECOVER; }
1270 ;
1271
1272 extends_interfaces:
1273         EXTENDS_TK interface_type
1274                 {
1275                   ctxp->interface_number = 1;
1276                   $$ = build_tree_list ($2, NULL_TREE);
1277                 }
1278 |       extends_interfaces C_TK interface_type
1279                 {
1280                   ctxp->interface_number++;
1281                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1282                 }
1283 |       EXTENDS_TK error
1284                 {yyerror ("Invalid interface type"); RECOVER;}
1285 |       extends_interfaces C_TK error
1286                 {yyerror ("Missing term"); RECOVER;}
1287 ;
1288
1289 interface_body:
1290         OCB_TK CCB_TK
1291                 { $$ = NULL_TREE; }
1292 |       OCB_TK interface_member_declarations CCB_TK
1293                 { $$ = NULL_TREE; }
1294 ;
1295
1296 interface_member_declarations:
1297         interface_member_declaration
1298 |       interface_member_declarations interface_member_declaration
1299 ;
1300
1301 interface_member_declaration:
1302         constant_declaration
1303 |       abstract_method_declaration
1304 |       class_declaration       /* Added, JDK1.1 inner classes */
1305                 { end_class_declaration (1); }
1306 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1307                 { end_class_declaration (1); }
1308 ;
1309
1310 constant_declaration:
1311         field_declaration
1312 ;
1313
1314 abstract_method_declaration:
1315         method_header SC_TK
1316                 {
1317                   check_abstract_method_header ($1);
1318                   current_function_decl = NULL_TREE; /* FIXME ? */
1319                 }
1320 |       method_header error
1321                 {yyerror ("';' expected"); RECOVER;}
1322 ;
1323
1324 /* 19.10 Productions from 10: Arrays  */
1325 array_initializer:
1326         OCB_TK CCB_TK
1327                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1328 |       OCB_TK C_TK CCB_TK
1329                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1330 |       OCB_TK variable_initializers CCB_TK
1331                 { $$ = build_new_array_init ($1.location, $2); }
1332 |       OCB_TK variable_initializers C_TK CCB_TK
1333                 { $$ = build_new_array_init ($1.location, $2); }
1334 ;
1335
1336 variable_initializers:
1337         variable_initializer
1338                 {
1339                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1340                                   $1, NULL_TREE);
1341                 }
1342 |       variable_initializers C_TK variable_initializer
1343                 {
1344                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1345                 }
1346 |       variable_initializers C_TK error
1347                 {yyerror ("Missing term"); RECOVER;}
1348 ;
1349
1350 /* 19.11 Production from 14: Blocks and Statements  */
1351 block:
1352         OCB_TK CCB_TK
1353                 {
1354                   /* Store the location of the `}' when doing xrefs */
1355                   if (current_function_decl && flag_emit_xref)
1356                     DECL_END_SOURCE_LINE (current_function_decl) =
1357                       EXPR_WFL_ADD_COL ($2.location, 1);
1358                   $$ = empty_stmt_node;
1359                 }
1360 |       block_begin block_statements block_end
1361                 { $$ = $3; }
1362 ;
1363
1364 block_begin:
1365         OCB_TK
1366                 { enter_block (); }
1367 ;
1368
1369 block_end:
1370         CCB_TK
1371                 {
1372                   maybe_absorb_scoping_blocks ();
1373                   /* Store the location of the `}' when doing xrefs */
1374                   if (current_function_decl && flag_emit_xref)
1375                     DECL_END_SOURCE_LINE (current_function_decl) =
1376                       EXPR_WFL_ADD_COL ($1.location, 1);
1377                   $$ = exit_block ();
1378                   if (!BLOCK_SUBBLOCKS ($$))
1379                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1380                 }
1381 ;
1382
1383 block_statements:
1384         block_statement
1385 |       block_statements block_statement
1386 ;
1387
1388 block_statement:
1389         local_variable_declaration_statement
1390 |       statement
1391                 { java_method_add_stmt (current_function_decl, $1); }
1392 |       class_declaration       /* Added, JDK1.1 local classes */
1393                 {
1394                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1395                   end_class_declaration (1);
1396                 }
1397 ;
1398
1399 local_variable_declaration_statement:
1400         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1401 ;
1402
1403 local_variable_declaration:
1404         type variable_declarators
1405                 { declare_local_variables (0, $1, $2); }
1406 |       final type variable_declarators /* Added, JDK1.1 final locals */
1407                 { declare_local_variables ($1, $2, $3); }
1408 ;
1409
1410 statement:
1411         statement_without_trailing_substatement
1412 |       labeled_statement
1413 |       if_then_statement
1414 |       if_then_else_statement
1415 |       while_statement
1416 |       for_statement
1417                 { $$ = exit_block (); }
1418 ;
1419
1420 statement_nsi:
1421         statement_without_trailing_substatement
1422 |       labeled_statement_nsi
1423 |       if_then_else_statement_nsi
1424 |       while_statement_nsi
1425 |       for_statement_nsi
1426                 { $$ = exit_block (); }
1427 ;
1428
1429 statement_without_trailing_substatement:
1430         block
1431 |       empty_statement
1432 |       expression_statement
1433 |       switch_statement
1434 |       do_statement
1435 |       break_statement
1436 |       continue_statement
1437 |       return_statement
1438 |       synchronized_statement
1439 |       throw_statement
1440 |       try_statement
1441 |       assert_statement
1442 ;
1443
1444 empty_statement:
1445         SC_TK
1446                 {
1447                   if (flag_extraneous_semicolon
1448                       && ! current_static_block
1449                       && (! current_function_decl ||
1450                           /* Verify we're not in a inner class declaration */
1451                           (GET_CPC () != TYPE_NAME
1452                            (DECL_CONTEXT (current_function_decl)))))
1453
1454                     {
1455                       EXPR_WFL_SET_LINECOL (wfl_operator, lineno, -1);
1456                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1457                     }
1458                   $$ = empty_stmt_node;
1459                 }
1460 ;
1461
1462 label_decl:
1463         identifier REL_CL_TK
1464                 {
1465                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1466                                             EXPR_WFL_NODE ($1));
1467                   pushlevel (2);
1468                   push_labeled_block ($$);
1469                   PUSH_LABELED_BLOCK ($$);
1470                 }
1471 ;
1472
1473 labeled_statement:
1474         label_decl statement
1475                 { $$ = finish_labeled_statement ($1, $2); }
1476 |       identifier error
1477                 {yyerror ("':' expected"); RECOVER;}
1478 ;
1479
1480 labeled_statement_nsi:
1481         label_decl statement_nsi
1482                 { $$ = finish_labeled_statement ($1, $2); }
1483 ;
1484
1485 /* We concentrate here a bunch of error handling rules that we couldn't write
1486    earlier, because expression_statement catches a missing ';'.  */
1487 expression_statement:
1488         statement_expression SC_TK
1489                 {
1490                   /* We have a statement. Generate a WFL around it so
1491                      we can debug it */
1492                   $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1493                   /* We know we have a statement, so set the debug
1494                      info to be eventually generate here. */
1495                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1496                 }
1497 |       error SC_TK
1498                 {
1499                   YYNOT_TWICE yyerror ("Invalid expression statement");
1500                   DRECOVER (expr_stmt);
1501                 }
1502 |       error OCB_TK
1503                 {
1504                   YYNOT_TWICE yyerror ("Invalid expression statement");
1505                   DRECOVER (expr_stmt);
1506                 }
1507 |       error CCB_TK
1508                 {
1509                   YYNOT_TWICE yyerror ("Invalid expression statement");
1510                   DRECOVER (expr_stmt);
1511                 }
1512 |       this_or_super OP_TK error
1513                 {yyerror ("')' expected"); RECOVER;}
1514 |       this_or_super OP_TK CP_TK error
1515                 {
1516                   parse_ctor_invocation_error ();
1517                   RECOVER;
1518                 }
1519 |       this_or_super OP_TK argument_list error
1520                 {yyerror ("')' expected"); RECOVER;}
1521 |       this_or_super OP_TK argument_list CP_TK error
1522                 {
1523                   parse_ctor_invocation_error ();
1524                   RECOVER;
1525                 }
1526 |       name DOT_TK SUPER_TK error
1527                 {yyerror ("'(' expected"); RECOVER;}
1528 |       name DOT_TK SUPER_TK OP_TK error
1529                 {yyerror ("')' expected"); RECOVER;}
1530 |       name DOT_TK SUPER_TK OP_TK argument_list error
1531                 {yyerror ("')' expected"); RECOVER;}
1532 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1533                 {yyerror ("';' expected"); RECOVER;}
1534 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1535                 {yyerror ("';' expected"); RECOVER;}
1536 ;
1537
1538 statement_expression:
1539         assignment
1540 |       pre_increment_expression
1541 |       pre_decrement_expression
1542 |       post_increment_expression
1543 |       post_decrement_expression
1544 |       method_invocation
1545 |       class_instance_creation_expression
1546 ;
1547
1548 if_then_statement:
1549         IF_TK OP_TK expression CP_TK statement
1550                 {
1551                   $$ = build_if_else_statement ($2.location, $3,
1552                                                 $5, NULL_TREE);
1553                 }
1554 |       IF_TK error
1555                 {yyerror ("'(' expected"); RECOVER;}
1556 |       IF_TK OP_TK error
1557                 {yyerror ("Missing term"); RECOVER;}
1558 |       IF_TK OP_TK expression error
1559                 {yyerror ("')' expected"); RECOVER;}
1560 ;
1561
1562 if_then_else_statement:
1563         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1564                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1565 ;
1566
1567 if_then_else_statement_nsi:
1568         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1569                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1570 ;
1571
1572 switch_statement:
1573         switch_expression
1574                 {
1575                   enter_block ();
1576                 }
1577         switch_block
1578                 {
1579                   /* Make into "proper list" of COMPOUND_EXPRs.
1580                      I.e. make the last statement also have its own
1581                      COMPOUND_EXPR. */
1582                   maybe_absorb_scoping_blocks ();
1583                   TREE_OPERAND ($1, 1) = exit_block ();
1584                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1585                 }
1586 ;
1587
1588 switch_expression:
1589         SWITCH_TK OP_TK expression CP_TK
1590                 {
1591                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1592                   EXPR_WFL_LINECOL ($$) = $2.location;
1593                 }
1594 |       SWITCH_TK error
1595                 {yyerror ("'(' expected"); RECOVER;}
1596 |       SWITCH_TK OP_TK error
1597                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1598 |       SWITCH_TK OP_TK expression CP_TK error
1599                 {yyerror ("'{' expected"); RECOVER;}
1600 ;
1601
1602 /* Default assignment is there to avoid type node on switch_block
1603    node. */
1604
1605 switch_block:
1606         OCB_TK CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_labels CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups CCB_TK
1611                 { $$ = NULL_TREE; }
1612 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1613                 { $$ = NULL_TREE; }
1614 ;
1615
1616 switch_block_statement_groups:
1617         switch_block_statement_group
1618 |       switch_block_statement_groups switch_block_statement_group
1619 ;
1620
1621 switch_block_statement_group:
1622         switch_labels block_statements
1623 ;
1624
1625 switch_labels:
1626         switch_label
1627 |       switch_labels switch_label
1628 ;
1629
1630 switch_label:
1631         CASE_TK constant_expression REL_CL_TK
1632                 {
1633                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1634                   EXPR_WFL_LINECOL (lab) = $1.location;
1635                   java_method_add_stmt (current_function_decl, lab);
1636                 }
1637 |       DEFAULT_TK REL_CL_TK
1638                 {
1639                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1640                   EXPR_WFL_LINECOL (lab) = $1.location;
1641                   java_method_add_stmt (current_function_decl, lab);
1642                 }
1643 |       CASE_TK error
1644                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1645 |       CASE_TK constant_expression error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 |       DEFAULT_TK error
1648                 {yyerror ("':' expected"); RECOVER;}
1649 ;
1650
1651 while_expression:
1652         WHILE_TK OP_TK expression CP_TK
1653                 {
1654                   tree body = build_loop_body ($2.location, $3, 0);
1655                   $$ = build_new_loop (body);
1656                 }
1657 ;
1658
1659 while_statement:
1660         while_expression statement
1661                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1662 |       WHILE_TK error
1663                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK error
1665                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1666 |       WHILE_TK OP_TK expression error
1667                 {yyerror ("')' expected"); RECOVER;}
1668 ;
1669
1670 while_statement_nsi:
1671         while_expression statement_nsi
1672                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1673 ;
1674
1675 do_statement_begin:
1676         DO_TK
1677                 {
1678                   tree body = build_loop_body (0, NULL_TREE, 1);
1679                   $$ = build_new_loop (body);
1680                 }
1681         /* Need error handing here. FIXME */
1682 ;
1683
1684 do_statement:
1685         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1686                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1687 ;
1688
1689 for_statement:
1690         for_begin SC_TK expression SC_TK for_update CP_TK statement
1691                 {
1692                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1693                     $3 = build_wfl_node ($3);
1694                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1695                 }
1696 |       for_begin SC_TK SC_TK for_update CP_TK statement
1697                 {
1698                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1699                   /* We have not condition, so we get rid of the EXIT_EXPR */
1700                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1701                     empty_stmt_node;
1702                 }
1703 |       for_begin SC_TK error
1704                 {yyerror ("Invalid control expression"); RECOVER;}
1705 |       for_begin SC_TK expression SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 |       for_begin SC_TK SC_TK error
1708                 {yyerror ("Invalid update expression"); RECOVER;}
1709 ;
1710
1711 for_statement_nsi:
1712         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1713                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1714 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1715                 {
1716                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1717                   /* We have not condition, so we get rid of the EXIT_EXPR */
1718                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1719                     empty_stmt_node;
1720                 }
1721 ;
1722
1723 for_header:
1724         FOR_TK OP_TK
1725                 {
1726                   /* This scope defined for local variable that may be
1727                      defined within the scope of the for loop */
1728                   enter_block ();
1729                 }
1730 |       FOR_TK error
1731                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1732 |       FOR_TK OP_TK error
1733                 {yyerror ("Invalid init statement"); RECOVER;}
1734 ;
1735
1736 for_begin:
1737         for_header for_init
1738                 {
1739                   /* We now declare the loop body. The loop is
1740                      declared as a for loop. */
1741                   tree body = build_loop_body (0, NULL_TREE, 0);
1742                   $$ =  build_new_loop (body);
1743                   FOR_LOOP_P ($$) = 1;
1744                   /* The loop is added to the current block the for
1745                      statement is defined within */
1746                   java_method_add_stmt (current_function_decl, $$);
1747                 }
1748 ;
1749 for_init:                       /* Can be empty */
1750                 { $$ = empty_stmt_node; }
1751 |       statement_expression_list
1752                 {
1753                   /* Init statement recorded within the previously
1754                      defined block scope */
1755                   $$ = java_method_add_stmt (current_function_decl, $1);
1756                 }
1757 |       local_variable_declaration
1758                 {
1759                   /* Local variable are recorded within the previously
1760                      defined block scope */
1761                   $$ = NULL_TREE;
1762                 }
1763 |       statement_expression_list error
1764                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1765 ;
1766
1767 for_update:                     /* Can be empty */
1768                 {$$ = empty_stmt_node;}
1769 |       statement_expression_list
1770                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1771 ;
1772
1773 statement_expression_list:
1774         statement_expression
1775                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1776 |       statement_expression_list C_TK statement_expression
1777                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1778 |       statement_expression_list C_TK error
1779                 {yyerror ("Missing term"); RECOVER;}
1780 ;
1781
1782 break_statement:
1783         BREAK_TK SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1785 |       BREAK_TK identifier SC_TK
1786                 { $$ = build_bc_statement ($1.location, 1, $2); }
1787 |       BREAK_TK error
1788                 {yyerror ("Missing term"); RECOVER;}
1789 |       BREAK_TK identifier error
1790                 {yyerror ("';' expected"); RECOVER;}
1791 ;
1792
1793 continue_statement:
1794         CONTINUE_TK SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1796 |       CONTINUE_TK identifier SC_TK
1797                 { $$ = build_bc_statement ($1.location, 0, $2); }
1798 |       CONTINUE_TK error
1799                 {yyerror ("Missing term"); RECOVER;}
1800 |       CONTINUE_TK identifier error
1801                 {yyerror ("';' expected"); RECOVER;}
1802 ;
1803
1804 return_statement:
1805         RETURN_TK SC_TK
1806                 { $$ = build_return ($1.location, NULL_TREE); }
1807 |       RETURN_TK expression SC_TK
1808                 { $$ = build_return ($1.location, $2); }
1809 |       RETURN_TK error
1810                 {yyerror ("Missing term"); RECOVER;}
1811 |       RETURN_TK expression error
1812                 {yyerror ("';' expected"); RECOVER;}
1813 ;
1814
1815 throw_statement:
1816         THROW_TK expression SC_TK
1817                 {
1818                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1819                   EXPR_WFL_LINECOL ($$) = $1.location;
1820                 }
1821 |       THROW_TK error
1822                 {yyerror ("Missing term"); RECOVER;}
1823 |       THROW_TK expression error
1824                 {yyerror ("';' expected"); RECOVER;}
1825 ;
1826
1827 assert_statement:
1828         ASSERT_TK expression REL_CL_TK expression SC_TK
1829                 {
1830                   $$ = build_assertion ($1.location, $2, $4);
1831                 }
1832 |       ASSERT_TK expression SC_TK
1833                 {
1834                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1835                 }
1836 |       ASSERT_TK error
1837                 {yyerror ("Missing term"); RECOVER;}
1838 |       ASSERT_TK expression error
1839                 {yyerror ("';' expected"); RECOVER;}
1840 ;
1841
1842 synchronized_statement:
1843         synchronized OP_TK expression CP_TK block
1844                 {
1845                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1846                   EXPR_WFL_LINECOL ($$) =
1847                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1848                 }
1849 |       synchronized OP_TK expression CP_TK error
1850                 {yyerror ("'{' expected"); RECOVER;}
1851 |       synchronized error
1852                 {yyerror ("'(' expected"); RECOVER;}
1853 |       synchronized OP_TK error CP_TK
1854                 {yyerror ("Missing term"); RECOVER;}
1855 |       synchronized OP_TK error
1856                 {yyerror ("Missing term"); RECOVER;}
1857 ;
1858
1859 synchronized:
1860         modifiers
1861                 {
1862                   check_modifiers (
1863              "Illegal modifier `%s'. Only `synchronized' was expected here",
1864                                    $1, ACC_SYNCHRONIZED);
1865                   if ($1 != ACC_SYNCHRONIZED)
1866                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1867                       build_wfl_node (NULL_TREE);
1868                 }
1869 ;
1870
1871 try_statement:
1872         TRY_TK block catches
1873                 { $$ = build_try_statement ($1.location, $2, $3); }
1874 |       TRY_TK block finally
1875                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1876 |       TRY_TK block catches finally
1877                 { $$ = build_try_finally_statement
1878                     ($1.location, build_try_statement ($1.location,
1879                                                        $2, $3), $4);
1880                 }
1881 |       TRY_TK error
1882                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1883 ;
1884
1885 catches:
1886         catch_clause
1887 |       catches catch_clause
1888                 {
1889                   TREE_CHAIN ($2) = $1;
1890                   $$ = $2;
1891                 }
1892 ;
1893
1894 catch_clause:
1895         catch_clause_parameter block
1896                 {
1897                   java_method_add_stmt (current_function_decl, $2);
1898                   exit_block ();
1899                   $$ = $1;
1900                 }
1901 ;
1902
1903 catch_clause_parameter:
1904         CATCH_TK OP_TK formal_parameter CP_TK
1905                 {
1906                   /* We add a block to define a scope for
1907                      formal_parameter (CCBP). The formal parameter is
1908                      declared initialized by the appropriate function
1909                      call */
1910                   tree ccpb = enter_block ();
1911                   tree init = build_assignment
1912                     (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1913                      build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1914                   declare_local_variables (0, TREE_VALUE ($3),
1915                                            build_tree_list (TREE_PURPOSE ($3),
1916                                                             init));
1917                   $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1918                   EXPR_WFL_LINECOL ($$) = $1.location;
1919                 }
1920 |       CATCH_TK error
1921                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1922 |       CATCH_TK OP_TK error
1923                 {
1924                   yyerror ("Missing term or ')' expected");
1925                   RECOVER; $$ = NULL_TREE;
1926                 }
1927 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1928                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1929 ;
1930
1931 finally:
1932         FINALLY_TK block
1933                 { $$ = $2; }
1934 |       FINALLY_TK error
1935                 {yyerror ("'{' expected"); RECOVER; }
1936 ;
1937
1938 /* 19.12 Production from 15: Expressions  */
1939 primary:
1940         primary_no_new_array
1941 |       array_creation_expression
1942 ;
1943
1944 primary_no_new_array:
1945         literal
1946 |       THIS_TK
1947                 { $$ = build_this ($1.location); }
1948 |       OP_TK expression CP_TK
1949                 {$$ = $2;}
1950 |       class_instance_creation_expression
1951 |       field_access
1952 |       method_invocation
1953 |       array_access
1954 |       type_literals
1955         /* Added, JDK1.1 inner classes. Documentation is wrong
1956            refering to a 'ClassName' (class_name) rule that doesn't
1957            exist. Used name: instead.  */
1958 |       name DOT_TK THIS_TK
1959                 {
1960                   tree wfl = build_wfl_node (this_identifier_node);
1961                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1962                 }
1963 |       OP_TK expression error
1964                 {yyerror ("')' expected"); RECOVER;}
1965 |       name DOT_TK error
1966                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1967 |       primitive_type DOT_TK error
1968                 {yyerror ("'class' expected" ); RECOVER;}
1969 |       VOID_TK DOT_TK error
1970                 {yyerror ("'class' expected" ); RECOVER;}
1971 ;
1972
1973 type_literals:
1974         name DOT_TK CLASS_TK
1975                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1976 |       array_type DOT_TK CLASS_TK
1977                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1978 |       primitive_type DOT_TK CLASS_TK
1979                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1980 |       VOID_TK DOT_TK CLASS_TK
1981                 {
1982                    $$ = build_incomplete_class_ref ($2.location,
1983                                                    void_type_node);
1984                 }
1985 ;
1986
1987 class_instance_creation_expression:
1988         NEW_TK class_type OP_TK argument_list CP_TK
1989                 { $$ = build_new_invocation ($2, $4); }
1990 |       NEW_TK class_type OP_TK CP_TK
1991                 { $$ = build_new_invocation ($2, NULL_TREE); }
1992 |       anonymous_class_creation
1993         /* Added, JDK1.1 inner classes, modified to use name or
1994            primary instead of primary solely which couldn't work in
1995            all situations.  */
1996 |       something_dot_new identifier OP_TK CP_TK
1997                 {
1998                   tree ctor = build_new_invocation ($2, NULL_TREE);
1999                   $$ = make_qualified_primary ($1, ctor,
2000                                                EXPR_WFL_LINECOL ($1));
2001                 }
2002 |       something_dot_new identifier OP_TK CP_TK class_body
2003 |       something_dot_new identifier OP_TK argument_list CP_TK
2004                 {
2005                   tree ctor = build_new_invocation ($2, $4);
2006                   $$ = make_qualified_primary ($1, ctor,
2007                                                EXPR_WFL_LINECOL ($1));
2008                 }
2009 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2010 |       NEW_TK error SC_TK
2011                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2012 |       NEW_TK class_type error
2013                 {yyerror ("'(' expected"); RECOVER;}
2014 |       NEW_TK class_type OP_TK error
2015                 {yyerror ("')' or term expected"); RECOVER;}
2016 |       NEW_TK class_type OP_TK argument_list error
2017                 {yyerror ("')' expected"); RECOVER;}
2018 |       something_dot_new error
2019                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2020 |       something_dot_new identifier error
2021                 {yyerror ("'(' expected"); RECOVER;}
2022 ;
2023
2024 /* Created after JDK1.1 rules originally added to
2025    class_instance_creation_expression, but modified to use
2026    'class_type' instead of 'TypeName' (type_name) which is mentionned
2027    in the documentation but doesn't exist. */
2028
2029 anonymous_class_creation:
2030         NEW_TK class_type OP_TK argument_list CP_TK
2031                 { create_anonymous_class ($1.location, $2); }
2032         class_body
2033                 {
2034                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2035                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2036
2037                   end_class_declaration (1);
2038
2039                   /* Now we can craft the new expression */
2040                   $$ = build_new_invocation (id, $4);
2041
2042                   /* Note that we can't possibly be here if
2043                      `class_type' is an interface (in which case the
2044                      anonymous class extends Object and implements
2045                      `class_type', hence its constructor can't have
2046                      arguments.) */
2047
2048                   /* Otherwise, the innerclass must feature a
2049                      constructor matching `argument_list'. Anonymous
2050                      classes are a bit special: it's impossible to
2051                      define constructor for them, hence constructors
2052                      must be generated following the hints provided by
2053                      the `new' expression. Whether a super constructor
2054                      of that nature exists or not is to be verified
2055                      later on in verify_constructor_super.
2056
2057                      It's during the expansion of a `new' statement
2058                      refering to an anonymous class that a ctor will
2059                      be generated for the anonymous class, with the
2060                      right arguments. */
2061
2062                 }
2063 |       NEW_TK class_type OP_TK CP_TK
2064                 { create_anonymous_class ($1.location, $2); }
2065         class_body
2066                 {
2067                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2068                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2069
2070                   end_class_declaration (1);
2071
2072                   /* Now we can craft the new expression. The
2073                      statement doesn't need to be remember so that a
2074                      constructor can be generated, since its signature
2075                      is already known. */
2076                   $$ = build_new_invocation (id, NULL_TREE);
2077                 }
2078 ;
2079
2080 something_dot_new:              /* Added, not part of the specs. */
2081         name DOT_TK NEW_TK
2082                 { $$ = $1; }
2083 |       primary DOT_TK NEW_TK
2084                 { $$ = $1; }
2085 ;
2086
2087 argument_list:
2088         expression
2089                 {
2090                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2091                   ctxp->formal_parameter_number = 1;
2092                 }
2093 |       argument_list C_TK expression
2094                 {
2095                   ctxp->formal_parameter_number += 1;
2096                   $$ = tree_cons (NULL_TREE, $3, $1);
2097                 }
2098 |       argument_list C_TK error
2099                 {yyerror ("Missing term"); RECOVER;}
2100 ;
2101
2102 array_creation_expression:
2103         NEW_TK primitive_type dim_exprs
2104                 { $$ = build_newarray_node ($2, $3, 0); }
2105 |       NEW_TK class_or_interface_type dim_exprs
2106                 { $$ = build_newarray_node ($2, $3, 0); }
2107 |       NEW_TK primitive_type dim_exprs dims
2108                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2109 |       NEW_TK class_or_interface_type dim_exprs dims
2110                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2111         /* Added, JDK1.1 anonymous array. Initial documentation rule
2112            modified */
2113 |       NEW_TK class_or_interface_type dims array_initializer
2114                 {
2115                   char *sig;
2116                   int osb = pop_current_osb (ctxp);
2117                   while (osb--)
2118                     obstack_grow (&temporary_obstack, "[]", 2);
2119                   obstack_1grow (&temporary_obstack, '\0');
2120                   sig = obstack_finish (&temporary_obstack);
2121                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2122                               $2, get_identifier (sig), $4);
2123                 }
2124 |       NEW_TK primitive_type dims array_initializer
2125                 {
2126                   int osb = pop_current_osb (ctxp);
2127                   tree type = $2;
2128                   while (osb--)
2129                     type = build_java_array_type (type, -1);
2130                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2131                               build_pointer_type (type), NULL_TREE, $4);
2132                 }
2133 |       NEW_TK error CSB_TK
2134                 {yyerror ("'[' expected"); DRECOVER ("]");}
2135 |       NEW_TK error OSB_TK
2136                 {yyerror ("']' expected"); RECOVER;}
2137 ;
2138
2139 dim_exprs:
2140         dim_expr
2141                 { $$ = build_tree_list (NULL_TREE, $1); }
2142 |       dim_exprs dim_expr
2143                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2144 ;
2145
2146 dim_expr:
2147         OSB_TK expression CSB_TK
2148                 {
2149                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2150                     {
2151                       $2 = build_wfl_node ($2);
2152                       TREE_TYPE ($2) = NULL_TREE;
2153                     }
2154                   EXPR_WFL_LINECOL ($2) = $1.location;
2155                   $$ = $2;
2156                 }
2157 |       OSB_TK expression error
2158                 {yyerror ("']' expected"); RECOVER;}
2159 |       OSB_TK error
2160                 {
2161                   yyerror ("Missing term");
2162                   yyerror ("']' expected");
2163                   RECOVER;
2164                 }
2165 ;
2166
2167 dims:
2168         OSB_TK CSB_TK
2169                 {
2170                   int allocate = 0;
2171                   /* If not initialized, allocate memory for the osb
2172                      numbers stack */
2173                   if (!ctxp->osb_limit)
2174                     {
2175                       allocate = ctxp->osb_limit = 32;
2176                       ctxp->osb_depth = -1;
2177                     }
2178                   /* If capacity overflown, reallocate a bigger chunk */
2179                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2180                     allocate = ctxp->osb_limit << 1;
2181
2182                   if (allocate)
2183                     {
2184                       allocate *= sizeof (int);
2185                       if (ctxp->osb_number)
2186                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2187                                                      allocate);
2188                       else
2189                         ctxp->osb_number = xmalloc (allocate);
2190                     }
2191                   ctxp->osb_depth++;
2192                   CURRENT_OSB (ctxp) = 1;
2193                 }
2194 |       dims OSB_TK CSB_TK
2195                 { CURRENT_OSB (ctxp)++; }
2196 |       dims OSB_TK error
2197                 { yyerror ("']' expected"); RECOVER;}
2198 ;
2199
2200 field_access:
2201         primary DOT_TK identifier
2202                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2203                 /*  FIXME - REWRITE TO:
2204                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2205 |       SUPER_TK DOT_TK identifier
2206                 {
2207                   tree super_wfl = build_wfl_node (super_identifier_node);
2208                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2209                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2210                 }
2211 |       SUPER_TK error
2212                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2213 ;
2214
2215 method_invocation:
2216         name OP_TK CP_TK
2217                 { $$ = build_method_invocation ($1, NULL_TREE); }
2218 |       name OP_TK argument_list CP_TK
2219                 { $$ = build_method_invocation ($1, $3); }
2220 |       primary DOT_TK identifier OP_TK CP_TK
2221                 {
2222                   if (TREE_CODE ($1) == THIS_EXPR)
2223                     $$ = build_this_super_qualified_invocation
2224                       (1, $3, NULL_TREE, 0, $2.location);
2225                   else
2226                     {
2227                       tree invok = build_method_invocation ($3, NULL_TREE);
2228                       $$ = make_qualified_primary ($1, invok, $2.location);
2229                     }
2230                 }
2231 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2232                 {
2233                   if (TREE_CODE ($1) == THIS_EXPR)
2234                     $$ = build_this_super_qualified_invocation
2235                       (1, $3, $5, 0, $2.location);
2236                   else
2237                     {
2238                       tree invok = build_method_invocation ($3, $5);
2239                       $$ = make_qualified_primary ($1, invok, $2.location);
2240                     }
2241                 }
2242 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2243                 {
2244                   $$ = build_this_super_qualified_invocation
2245                     (0, $3, NULL_TREE, $1.location, $2.location);
2246                 }
2247 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2248                 {
2249                   $$ = build_this_super_qualified_invocation
2250                     (0, $3, $5, $1.location, $2.location);
2251                 }
2252         /* Screws up thing. I let it here until I'm convinced it can
2253            be removed. FIXME
2254 |       primary DOT_TK error
2255                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2256 |       SUPER_TK DOT_TK error CP_TK
2257                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2258 |       SUPER_TK DOT_TK error DOT_TK
2259                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2260 ;
2261
2262 array_access:
2263         name OSB_TK expression CSB_TK
2264                 { $$ = build_array_ref ($2.location, $1, $3); }
2265 |       primary_no_new_array OSB_TK expression CSB_TK
2266                 { $$ = build_array_ref ($2.location, $1, $3); }
2267 |       name OSB_TK error
2268                 {
2269                   yyerror ("Missing term and ']' expected");
2270                   DRECOVER(array_access);
2271                 }
2272 |       name OSB_TK expression error
2273                 {
2274                   yyerror ("']' expected");
2275                   DRECOVER(array_access);
2276                 }
2277 |       primary_no_new_array OSB_TK error
2278                 {
2279                   yyerror ("Missing term and ']' expected");
2280                   DRECOVER(array_access);
2281                 }
2282 |       primary_no_new_array OSB_TK expression error
2283                 {
2284                   yyerror ("']' expected");
2285                   DRECOVER(array_access);
2286                 }
2287 ;
2288
2289 postfix_expression:
2290         primary
2291 |       name
2292 |       post_increment_expression
2293 |       post_decrement_expression
2294 ;
2295
2296 post_increment_expression:
2297         postfix_expression INCR_TK
2298                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2299 ;
2300
2301 post_decrement_expression:
2302         postfix_expression DECR_TK
2303                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2304 ;
2305
2306 trap_overflow_corner_case:
2307         pre_increment_expression
2308 |       pre_decrement_expression
2309 |       PLUS_TK unary_expression
2310                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2311 |       unary_expression_not_plus_minus
2312 |       PLUS_TK error
2313                 {yyerror ("Missing term"); RECOVER}
2314 ;
2315
2316 unary_expression:
2317         trap_overflow_corner_case
2318                 {
2319                   error_if_numeric_overflow ($1);
2320                   $$ = $1;
2321                 }
2322 |       MINUS_TK trap_overflow_corner_case
2323                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2324 |       MINUS_TK error
2325                 {yyerror ("Missing term"); RECOVER}
2326 ;
2327
2328 pre_increment_expression:
2329         INCR_TK unary_expression
2330                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2331 |       INCR_TK error
2332                 {yyerror ("Missing term"); RECOVER}
2333 ;
2334
2335 pre_decrement_expression:
2336         DECR_TK unary_expression
2337                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2338 |       DECR_TK error
2339                 {yyerror ("Missing term"); RECOVER}
2340 ;
2341
2342 unary_expression_not_plus_minus:
2343         postfix_expression
2344 |       NOT_TK unary_expression
2345                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2346 |       NEG_TK unary_expression
2347                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2348 |       cast_expression
2349 |       NOT_TK error
2350                 {yyerror ("Missing term"); RECOVER}
2351 |       NEG_TK error
2352                 {yyerror ("Missing term"); RECOVER}
2353 ;
2354
2355 cast_expression:                /* Error handling here is potentially weak */
2356         OP_TK primitive_type dims CP_TK unary_expression
2357                 {
2358                   tree type = $2;
2359                   int osb = pop_current_osb (ctxp);
2360                   while (osb--)
2361                     type = build_java_array_type (type, -1);
2362                   $$ = build_cast ($1.location, type, $5);
2363                 }
2364 |       OP_TK primitive_type CP_TK unary_expression
2365                 { $$ = build_cast ($1.location, $2, $4); }
2366 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2367                 { $$ = build_cast ($1.location, $2, $4); }
2368 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2369                 {
2370                   const char *ptr;
2371                   int osb = pop_current_osb (ctxp);
2372                   obstack_grow (&temporary_obstack,
2373                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2374                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2375                   while (osb--)
2376                     obstack_grow (&temporary_obstack, "[]", 2);
2377                   obstack_1grow (&temporary_obstack, '\0');
2378                   ptr = obstack_finish (&temporary_obstack);
2379                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2380                   $$ = build_cast ($1.location, $2, $5);
2381                 }
2382 |       OP_TK primitive_type OSB_TK error
2383                 {yyerror ("']' expected, invalid type expression");}
2384 |       OP_TK error
2385                 {
2386                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2387                   RECOVER;
2388                 }
2389 |       OP_TK primitive_type dims CP_TK error
2390                 {yyerror ("Missing term"); RECOVER;}
2391 |       OP_TK primitive_type CP_TK error
2392                 {yyerror ("Missing term"); RECOVER;}
2393 |       OP_TK name dims CP_TK error
2394                 {yyerror ("Missing term"); RECOVER;}
2395 ;
2396
2397 multiplicative_expression:
2398         unary_expression
2399 |       multiplicative_expression MULT_TK unary_expression
2400                 {
2401                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2402                                     $2.location, $1, $3);
2403                 }
2404 |       multiplicative_expression DIV_TK unary_expression
2405                 {
2406                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2407                                     $1, $3);
2408                 }
2409 |       multiplicative_expression REM_TK unary_expression
2410                 {
2411                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2412                                     $1, $3);
2413                 }
2414 |       multiplicative_expression MULT_TK error
2415                 {yyerror ("Missing term"); RECOVER;}
2416 |       multiplicative_expression DIV_TK error
2417                 {yyerror ("Missing term"); RECOVER;}
2418 |       multiplicative_expression REM_TK error
2419                 {yyerror ("Missing term"); RECOVER;}
2420 ;
2421
2422 additive_expression:
2423         multiplicative_expression
2424 |       additive_expression PLUS_TK multiplicative_expression
2425                 {
2426                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2427                                     $1, $3);
2428                 }
2429 |       additive_expression MINUS_TK multiplicative_expression
2430                 {
2431                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2432                                     $1, $3);
2433                 }
2434 |       additive_expression PLUS_TK error
2435                 {yyerror ("Missing term"); RECOVER;}
2436 |       additive_expression MINUS_TK error
2437                 {yyerror ("Missing term"); RECOVER;}
2438 ;
2439
2440 shift_expression:
2441         additive_expression
2442 |       shift_expression LS_TK additive_expression
2443                 {
2444                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2445                                     $1, $3);
2446                 }
2447 |       shift_expression SRS_TK additive_expression
2448                 {
2449                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2450                                     $1, $3);
2451                 }
2452 |       shift_expression ZRS_TK additive_expression
2453                 {
2454                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2455                                     $1, $3);
2456                 }
2457 |       shift_expression LS_TK error
2458                 {yyerror ("Missing term"); RECOVER;}
2459 |       shift_expression SRS_TK error
2460                 {yyerror ("Missing term"); RECOVER;}
2461 |       shift_expression ZRS_TK error
2462                 {yyerror ("Missing term"); RECOVER;}
2463 ;
2464
2465 relational_expression:
2466         shift_expression
2467 |       relational_expression LT_TK shift_expression
2468                 {
2469                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2470                                     $1, $3);
2471                 }
2472 |       relational_expression GT_TK shift_expression
2473                 {
2474                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2475                                     $1, $3);
2476                 }
2477 |       relational_expression LTE_TK shift_expression
2478                 {
2479                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2480                                     $1, $3);
2481                 }
2482 |       relational_expression GTE_TK shift_expression
2483                 {
2484                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2485                                     $1, $3);
2486                 }
2487 |       relational_expression INSTANCEOF_TK reference_type
2488                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2489 |       relational_expression LT_TK error
2490                 {yyerror ("Missing term"); RECOVER;}
2491 |       relational_expression GT_TK error
2492                 {yyerror ("Missing term"); RECOVER;}
2493 |       relational_expression LTE_TK error
2494                 {yyerror ("Missing term"); RECOVER;}
2495 |       relational_expression GTE_TK error
2496                 {yyerror ("Missing term"); RECOVER;}
2497 |       relational_expression INSTANCEOF_TK error
2498                 {yyerror ("Invalid reference type"); RECOVER;}
2499 ;
2500
2501 equality_expression:
2502         relational_expression
2503 |       equality_expression EQ_TK relational_expression
2504                 {
2505                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2506                                     $1, $3);
2507                 }
2508 |       equality_expression NEQ_TK relational_expression
2509                 {
2510                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2511                                     $1, $3);
2512                 }
2513 |       equality_expression EQ_TK error
2514                 {yyerror ("Missing term"); RECOVER;}
2515 |       equality_expression NEQ_TK error
2516                 {yyerror ("Missing term"); RECOVER;}
2517 ;
2518
2519 and_expression:
2520         equality_expression
2521 |       and_expression AND_TK equality_expression
2522                 {
2523                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2524                                     $1, $3);
2525                 }
2526 |       and_expression AND_TK error
2527                 {yyerror ("Missing term"); RECOVER;}
2528 ;
2529
2530 exclusive_or_expression:
2531         and_expression
2532 |       exclusive_or_expression XOR_TK and_expression
2533                 {
2534                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2535                                     $1, $3);
2536                 }
2537 |       exclusive_or_expression XOR_TK error
2538                 {yyerror ("Missing term"); RECOVER;}
2539 ;
2540
2541 inclusive_or_expression:
2542         exclusive_or_expression
2543 |       inclusive_or_expression OR_TK exclusive_or_expression
2544                 {
2545                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2546                                     $1, $3);
2547                 }
2548 |       inclusive_or_expression OR_TK error
2549                 {yyerror ("Missing term"); RECOVER;}
2550 ;
2551
2552 conditional_and_expression:
2553         inclusive_or_expression
2554 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2555                 {
2556                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2557                                     $1, $3);
2558                 }
2559 |       conditional_and_expression BOOL_AND_TK error
2560                 {yyerror ("Missing term"); RECOVER;}
2561 ;
2562
2563 conditional_or_expression:
2564         conditional_and_expression
2565 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2566                 {
2567                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2568                                     $1, $3);
2569                 }
2570 |       conditional_or_expression BOOL_OR_TK error
2571                 {yyerror ("Missing term"); RECOVER;}
2572 ;
2573
2574 conditional_expression:         /* Error handling here is weak */
2575         conditional_or_expression
2576 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2577                 {
2578                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2579                   EXPR_WFL_LINECOL ($$) = $2.location;
2580                 }
2581 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2582                 {
2583                   YYERROR_NOW;
2584                   yyerror ("Missing term");
2585                   DRECOVER (1);
2586                 }
2587 |       conditional_or_expression REL_QM_TK error
2588                 {yyerror ("Missing term"); DRECOVER (2);}
2589 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2590                 {yyerror ("Missing term"); DRECOVER (3);}
2591 ;
2592
2593 assignment_expression:
2594         conditional_expression
2595 |       assignment
2596 ;
2597
2598 assignment:
2599         left_hand_side assignment_operator assignment_expression
2600                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2601 |       left_hand_side assignment_operator error
2602                 {
2603                   YYNOT_TWICE yyerror ("Missing term");
2604                   DRECOVER (assign);
2605                 }
2606 ;
2607
2608 left_hand_side:
2609         name
2610 |       field_access
2611 |       array_access
2612 ;
2613
2614 assignment_operator:
2615         ASSIGN_ANY_TK
2616 |       ASSIGN_TK
2617 ;
2618
2619 expression:
2620         assignment_expression
2621 ;
2622
2623 constant_expression:
2624         expression
2625 ;
2626
2627 %%
2628
2629 /* Helper function to retrieve an OSB count. Should be used when the
2630    `dims:' rule is being used.  */
2631
2632 static int
2633 pop_current_osb (struct parser_ctxt *ctxp)
2634 {
2635   int to_return;
2636
2637   if (ctxp->osb_depth < 0)
2638     abort ();
2639
2640   to_return = CURRENT_OSB (ctxp);
2641   ctxp->osb_depth--;
2642
2643   return to_return;
2644 }
2645
2646 \f
2647
2648 /* This section of the code deal with save/restoring parser contexts.
2649    Add mode documentation here. FIXME */
2650
2651 /* Helper function. Create a new parser context. With
2652    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2653    context is copied, otherwise, the new context is zeroed. The newly
2654    created context becomes the current one.  */
2655
2656 static void
2657 create_new_parser_context (int copy_from_previous)
2658 {
2659   struct parser_ctxt *new;
2660
2661   new = ggc_alloc (sizeof (struct parser_ctxt));
2662   if (copy_from_previous)
2663     {
2664       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2665       new->saved_data_ctx = 1;
2666     }
2667   else
2668     memset (new, 0, sizeof (struct parser_ctxt));
2669
2670   new->next = ctxp;
2671   ctxp = new;
2672 }
2673
2674 /* Create a new parser context and make it the current one. */
2675
2676 void
2677 java_push_parser_context (void)
2678 {
2679   create_new_parser_context (0);
2680 }
2681
2682 void
2683 java_pop_parser_context (int generate)
2684 {
2685   tree current;
2686   struct parser_ctxt *toFree, *next;
2687
2688   if (!ctxp)
2689     return;
2690
2691   toFree = ctxp;
2692   next = ctxp->next;
2693   if (next)
2694     {
2695       lineno = ctxp->lineno;
2696       current_class = ctxp->class_type;
2697     }
2698
2699   /* If the old and new lexers differ, then free the old one.  */
2700   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2701     java_destroy_lexer (ctxp->lexer);
2702
2703   /* Set the single import class file flag to 0 for the current list
2704      of imported things */
2705   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2706     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2707
2708   /* And restore those of the previous context */
2709   if ((ctxp = next))            /* Assignment is really meant here */
2710     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2711       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2712
2713   /* If we pushed a context to parse a class intended to be generated,
2714      we keep it so we can remember the class. What we could actually
2715      do is to just update a list of class names.  */
2716   if (generate)
2717     {
2718       toFree->next = ctxp_for_generation;
2719       ctxp_for_generation = toFree;
2720     }
2721 }
2722
2723 /* Create a parser context for the use of saving some global
2724    variables.  */
2725
2726 void
2727 java_parser_context_save_global (void)
2728 {
2729   if (!ctxp)
2730     {
2731       java_push_parser_context ();
2732       ctxp->saved_data_ctx = 1;
2733     }
2734
2735   /* If this context already stores data, create a new one suitable
2736      for data storage. */
2737   else if (ctxp->saved_data)
2738     create_new_parser_context (1);
2739
2740   ctxp->lineno = lineno;
2741   ctxp->class_type = current_class;
2742   ctxp->filename = input_filename;
2743   ctxp->function_decl = current_function_decl;
2744   ctxp->saved_data = 1;
2745 }
2746
2747 /* Restore some global variables from the previous context. Make the
2748    previous context the current one.  */
2749
2750 void
2751 java_parser_context_restore_global (void)
2752 {
2753   lineno = ctxp->lineno;
2754   current_class = ctxp->class_type;
2755   input_filename = ctxp->filename;
2756   if (wfl_operator)
2757     {
2758       tree s;
2759       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2760       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2761     }
2762   current_function_decl = ctxp->function_decl;
2763   ctxp->saved_data = 0;
2764   if (ctxp->saved_data_ctx)
2765     java_pop_parser_context (0);
2766 }
2767
2768 /* Suspend vital data for the current class/function being parsed so
2769    that an other class can be parsed. Used to let local/anonymous
2770    classes be parsed.  */
2771
2772 static void
2773 java_parser_context_suspend (void)
2774 {
2775   /* This makes debugging through java_debug_context easier */
2776   static const char *const name = "<inner buffer context>";
2777
2778   /* Duplicate the previous context, use it to save the globals we're
2779      interested in */
2780   create_new_parser_context (1);
2781   ctxp->function_decl = current_function_decl;
2782   ctxp->class_type = current_class;
2783
2784   /* Then create a new context which inherits all data from the
2785      previous one. This will be the new current context  */
2786   create_new_parser_context (1);
2787
2788   /* Help debugging */
2789   ctxp->next->filename = name;
2790 }
2791
2792 /* Resume vital data for the current class/function being parsed so
2793    that an other class can be parsed. Used to let local/anonymous
2794    classes be parsed.  The trick is the data storing file position
2795    informations must be restored to their current value, so parsing
2796    can resume as if no context was ever saved. */
2797
2798 static void
2799 java_parser_context_resume (void)
2800 {
2801   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2802   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2803   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2804
2805   /* We need to inherit the list of classes to complete/generate */
2806   restored->classd_list = old->classd_list;
2807   restored->class_list = old->class_list;
2808
2809   /* Restore the current class and function from the saver */
2810   current_class = saver->class_type;
2811   current_function_decl = saver->function_decl;
2812
2813   /* Retrive the restored context */
2814   ctxp = restored;
2815
2816   /* Re-installed the data for the parsing to carry on */
2817   memcpy (&ctxp->marker_begining, &old->marker_begining,
2818           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2819 }
2820
2821 /* Add a new anchor node to which all statement(s) initializing static
2822    and non static initialized upon declaration field(s) will be
2823    linked.  */
2824
2825 static void
2826 java_parser_context_push_initialized_field (void)
2827 {
2828   tree node;
2829
2830   node = build_tree_list (NULL_TREE, NULL_TREE);
2831   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2832   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2833
2834   node = build_tree_list (NULL_TREE, NULL_TREE);
2835   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2836   CPC_INITIALIZER_LIST (ctxp) = node;
2837
2838   node = build_tree_list (NULL_TREE, NULL_TREE);
2839   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2840   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2841 }
2842
2843 /* Pop the lists of initialized field. If this lists aren't empty,
2844    remember them so we can use it to create and populate the finit$
2845    or <clinit> functions. */
2846
2847 static void
2848 java_parser_context_pop_initialized_field (void)
2849 {
2850   tree stmts;
2851   tree class_type = TREE_TYPE (GET_CPC ());
2852
2853   if (CPC_INITIALIZER_LIST (ctxp))
2854     {
2855       stmts = CPC_INITIALIZER_STMT (ctxp);
2856       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2857       if (stmts && !java_error_count)
2858         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2859     }
2860
2861   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2862     {
2863       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2864       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2865         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2866       /* Keep initialization in order to enforce 8.5 */
2867       if (stmts && !java_error_count)
2868         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2869     }
2870
2871   /* JDK 1.1 instance initializers */
2872   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2873     {
2874       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2875       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2876         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2877       if (stmts && !java_error_count)
2878         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2879     }
2880 }
2881
2882 static tree
2883 reorder_static_initialized (tree list)
2884 {
2885   /* We have to keep things in order. The alias initializer have to
2886      come first, then the initialized regular field, in reverse to
2887      keep them in lexical order. */
2888   tree marker, previous = NULL_TREE;
2889   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2890     if (TREE_CODE (marker) == TREE_LIST
2891         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2892       break;
2893
2894   /* No static initialized, the list is fine as is */
2895   if (!previous)
2896     list = TREE_CHAIN (marker);
2897
2898   /* No marker? reverse the whole list */
2899   else if (!marker)
2900     list = nreverse (list);
2901
2902   /* Otherwise, reverse what's after the marker and the new reordered
2903      sublist will replace the marker. */
2904   else
2905     {
2906       TREE_CHAIN (previous) = NULL_TREE;
2907       list = nreverse (list);
2908       list = chainon (TREE_CHAIN (marker), list);
2909     }
2910   return list;
2911 }
2912
2913 /* Helper functions to dump the parser context stack.  */
2914
2915 #define TAB_CONTEXT(C) \
2916   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2917
2918 static void
2919 java_debug_context_do (int tab)
2920 {
2921   struct parser_ctxt *copy = ctxp;
2922   while (copy)
2923     {
2924       TAB_CONTEXT (tab);
2925       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2926       TAB_CONTEXT (tab);
2927       fprintf (stderr, "filename: %s\n", copy->filename);
2928       TAB_CONTEXT (tab);
2929       fprintf (stderr, "lineno: %d\n", copy->lineno);
2930       TAB_CONTEXT (tab);
2931       fprintf (stderr, "package: %s\n",
2932                (copy->package ?
2933                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2934       TAB_CONTEXT (tab);
2935       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2936       TAB_CONTEXT (tab);
2937       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2938       copy = copy->next;
2939       tab += 2;
2940     }
2941 }
2942
2943 /* Dump the stacked up parser contexts. Intended to be called from a
2944    debugger.  */
2945
2946 void
2947 java_debug_context (void)
2948 {
2949   java_debug_context_do (0);
2950 }
2951
2952 \f
2953
2954 /* Flag for the error report routine to issue the error the first time
2955    it's called (overriding the default behavior which is to drop the
2956    first invocation and honor the second one, taking advantage of a
2957    richer context.  */
2958 static int force_error = 0;
2959
2960 /* Reporting an constructor invocation error.  */
2961 static void
2962 parse_ctor_invocation_error (void)
2963 {
2964   if (DECL_CONSTRUCTOR_P (current_function_decl))
2965     yyerror ("Constructor invocation must be first thing in a constructor");
2966   else
2967     yyerror ("Only constructors can invoke constructors");
2968 }
2969
2970 /* Reporting JDK1.1 features not implemented.  */
2971
2972 static tree
2973 parse_jdk1_1_error (const char *msg)
2974 {
2975   sorry (": `%s' JDK1.1(TM) feature", msg);
2976   java_error_count++;
2977   return empty_stmt_node;
2978 }
2979
2980 static int do_warning = 0;
2981
2982 void
2983 yyerror (const char *msg)
2984 {
2985   static java_lc elc;
2986   static int  prev_lineno;
2987   static const char *prev_msg;
2988
2989   int save_lineno;
2990   char *remainder, *code_from_source;
2991
2992   if (!force_error && prev_lineno == lineno)
2993     return;
2994
2995   /* Save current error location but report latter, when the context is
2996      richer.  */
2997   if (ctxp->java_error_flag == 0)
2998     {
2999       ctxp->java_error_flag = 1;
3000       elc = ctxp->elc;
3001       /* Do something to use the previous line if we're reaching the
3002          end of the file... */
3003 #ifdef VERBOSE_SKELETON
3004       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3005 #endif
3006       return;
3007     }
3008
3009   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3010   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3011     return;
3012
3013   ctxp->java_error_flag = 0;
3014   if (do_warning)
3015     java_warning_count++;
3016   else
3017     java_error_count++;
3018
3019   if (elc.col == 0 && msg && msg[1] == ';')
3020     {
3021       elc.col  = ctxp->p_line->char_col-1;
3022       elc.line = ctxp->p_line->lineno;
3023     }
3024
3025   save_lineno = lineno;
3026   prev_lineno = lineno = elc.line;
3027   prev_msg = msg;
3028
3029   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3030   obstack_grow0 (&temporary_obstack,
3031                  code_from_source, strlen (code_from_source));
3032   remainder = obstack_finish (&temporary_obstack);
3033   if (do_warning)
3034     warning ("%s.\n%s", msg, remainder);
3035   else
3036     error ("%s.\n%s", msg, remainder);
3037
3038   /* This allow us to cheaply avoid an extra 'Invalid expression
3039      statement' error report when errors have been already reported on
3040      the same line. This occurs when we report an error but don't have
3041      a synchronization point other than ';', which
3042      expression_statement is the only one to take care of.  */
3043   ctxp->prevent_ese = lineno = save_lineno;
3044 }
3045
3046 static void
3047 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3048 {
3049   const char *saved, *saved_input_filename;
3050   char buffer [4096];
3051   vsprintf (buffer, msg, ap);
3052   force_error = 1;
3053
3054   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3055   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3056                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3057
3058   /* We have a CL, that's a good reason for using it if it contains data */
3059   saved = ctxp->filename;
3060   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3061     ctxp->filename = EXPR_WFL_FILENAME (cl);
3062   saved_input_filename = input_filename;
3063   input_filename = ctxp->filename;
3064   java_error (NULL);
3065   java_error (buffer);
3066   ctxp->filename = saved;
3067   input_filename = saved_input_filename;
3068   force_error = 0;
3069 }
3070
3071 /* Issue an error message at a current source line CL */
3072
3073 void
3074 parse_error_context (tree cl, const char *msg, ...)
3075 {
3076   va_list ap;
3077   va_start (ap, msg);
3078   issue_warning_error_from_context (cl, msg, ap);
3079   va_end (ap);
3080 }
3081
3082 /* Issue a warning at a current source line CL */
3083
3084 static void
3085 parse_warning_context (tree cl, const char *msg, ...)
3086 {
3087   va_list ap;
3088   va_start (ap, msg);
3089
3090   force_error = do_warning = 1;
3091   issue_warning_error_from_context (cl, msg, ap);
3092   do_warning = force_error = 0;
3093   va_end (ap);
3094 }
3095
3096 static tree
3097 find_expr_with_wfl (tree node)
3098 {
3099   while (node)
3100     {
3101       char code;
3102       tree to_return;
3103
3104       switch (TREE_CODE (node))
3105         {
3106         case BLOCK:
3107           node = BLOCK_EXPR_BODY (node);
3108           continue;
3109
3110         case COMPOUND_EXPR:
3111           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3112           if (to_return)
3113             return to_return;
3114           node = TREE_OPERAND (node, 1);
3115           continue;
3116
3117         case LOOP_EXPR:
3118           node = TREE_OPERAND (node, 0);
3119           continue;
3120
3121         case LABELED_BLOCK_EXPR:
3122           node = TREE_OPERAND (node, 1);
3123           continue;
3124
3125         default:
3126           code = TREE_CODE_CLASS (TREE_CODE (node));
3127           if (((code == '1') || (code == '2') || (code == 'e'))
3128               && EXPR_WFL_LINECOL (node))
3129             return node;
3130           return NULL_TREE;
3131         }
3132     }
3133   return NULL_TREE;
3134 }
3135
3136 /* Issue a missing return statement error. Uses METHOD to figure the
3137    last line of the method the error occurs in.  */
3138
3139 static void
3140 missing_return_error (tree method)
3141 {
3142   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
3143   parse_error_context (wfl_operator, "Missing return statement");
3144 }
3145
3146 /* Issue an unreachable statement error. From NODE, find the next
3147    statement to report appropriately.  */
3148 static void
3149 unreachable_stmt_error (tree node)
3150 {
3151   /* Browse node to find the next expression node that has a WFL. Use
3152      the location to report the error */
3153   if (TREE_CODE (node) == COMPOUND_EXPR)
3154     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3155   else
3156     node = find_expr_with_wfl (node);
3157
3158   if (node)
3159     {
3160       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3161       parse_error_context (wfl_operator, "Unreachable statement");
3162     }
3163   else
3164     abort ();
3165 }
3166
3167 int
3168 java_report_errors (void)
3169 {
3170   if (java_error_count)
3171     fprintf (stderr, "%d error%s",
3172              java_error_count, (java_error_count == 1 ? "" : "s"));
3173   if (java_warning_count)
3174     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3175              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3176   if (java_error_count || java_warning_count)
3177     putc ('\n', stderr);
3178   return java_error_count;
3179 }
3180
3181 static char *
3182 java_accstring_lookup (int flags)
3183 {
3184   static char buffer [80];
3185 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3186
3187   /* Access modifier looked-up first for easier report on forbidden
3188      access. */
3189   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3190   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3191   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3192   if (flags & ACC_STATIC) COPY_RETURN ("static");
3193   if (flags & ACC_FINAL) COPY_RETURN ("final");
3194   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3195   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3196   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3197   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3198   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3199   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3200
3201   buffer [0] = '\0';
3202   return buffer;
3203 #undef COPY_RETURN
3204 }
3205
3206 /* Issuing error messages upon redefinition of classes, interfaces or
3207    variables. */
3208
3209 static void
3210 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3211 {
3212   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3213                        context, IDENTIFIER_POINTER (id),
3214                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3215   /* Here we should point out where its redefined. It's a unicode. FIXME */
3216 }
3217
3218 static void
3219 variable_redefinition_error (tree context, tree name, tree type, int line)
3220 {
3221   const char *type_name;
3222
3223   /* Figure a proper name for type. We might haven't resolved it */
3224   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3225     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3226   else
3227     type_name = lang_printable_name (type, 0);
3228
3229   parse_error_context (context,
3230                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3231                        IDENTIFIER_POINTER (name),
3232                        type_name, IDENTIFIER_POINTER (name), line);
3233 }
3234
3235 /* If ANAME is terminated with `[]', it indicates an array. This
3236    function returns the number of `[]' found and if this number is
3237    greater than zero, it extracts the array type name and places it in
3238    the node pointed to by TRIMMED unless TRIMMED is null.  */
3239
3240 static int
3241 build_type_name_from_array_name (tree aname, tree *trimmed)
3242 {
3243   const char *name = IDENTIFIER_POINTER (aname);
3244   int len = IDENTIFIER_LENGTH (aname);
3245   int array_dims;
3246
3247   STRING_STRIP_BRACKETS (name, len, array_dims);
3248
3249   if (array_dims && trimmed)
3250     *trimmed = get_identifier_with_length (name, len);
3251
3252   return array_dims;
3253 }
3254
3255 static tree
3256 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3257 {
3258   int more_dims = 0;
3259
3260   /* Eventually get more dims */
3261   more_dims = build_type_name_from_array_name (name, &name);
3262
3263   /* If we have, then craft a new type for this variable */
3264   if (more_dims)
3265     {
3266       tree save = type;
3267
3268       /* If we have a pointer, use its type */
3269       if (TREE_CODE (type) == POINTER_TYPE)
3270         type = TREE_TYPE (type);
3271
3272       /* Building the first dimension of a primitive type uses this
3273          function */
3274       if (JPRIMITIVE_TYPE_P (type))
3275         {
3276           type = build_java_array_type (type, -1);
3277           more_dims--;
3278         }
3279       /* Otherwise, if we have a WFL for this type, use it (the type
3280          is already an array on an unresolved type, and we just keep
3281          on adding dimensions) */
3282       else if (type_wfl)
3283         {
3284           type = type_wfl;
3285           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3286                                                         NULL);
3287         }
3288
3289       /* Add all the dimensions */
3290       while (more_dims--)
3291         type = build_unresolved_array_type (type);
3292
3293       /* The type may have been incomplete in the first place */
3294       if (type_wfl)
3295         type = obtain_incomplete_type (type);
3296     }
3297
3298   if (ret_name)
3299     *ret_name = name;
3300   return type;
3301 }
3302
3303 /* Build something that the type identifier resolver will identify as
3304    being an array to an unresolved type. TYPE_WFL is a WFL on a
3305    identifier. */
3306
3307 static tree
3308 build_unresolved_array_type (tree type_or_wfl)
3309 {
3310   const char *ptr;
3311   tree wfl;
3312
3313   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3314      just create a array type */
3315   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3316     return build_java_array_type (type_or_wfl, -1);
3317
3318   obstack_grow (&temporary_obstack,
3319                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3320                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3321   obstack_grow0 (&temporary_obstack, "[]", 2);
3322   ptr = obstack_finish (&temporary_obstack);
3323   wfl = build_expr_wfl (get_identifier (ptr),
3324                         EXPR_WFL_FILENAME (type_or_wfl),
3325                         EXPR_WFL_LINENO (type_or_wfl),
3326                         EXPR_WFL_COLNO (type_or_wfl));
3327   /* Re-install the existing qualifications so that the type can be
3328      resolved properly. */
3329   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3330   return wfl;
3331 }
3332
3333 static void
3334 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3335 {
3336   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3337     parse_error_context (wfl, "Interface `%s' repeated",
3338                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3339 }
3340
3341 /* Bulk of common class/interface checks. Return 1 if an error was
3342    encountered. TAG is 0 for a class, 1 for an interface.  */
3343
3344 static int
3345 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3346                                 tree qualified_name, tree decl, tree cl)
3347 {
3348   tree node;
3349   int sca = 0;                  /* Static class allowed */
3350   int icaf = 0;                 /* Inner class allowed flags */
3351   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3352
3353   if (!quiet_flag)
3354     fprintf (stderr, " %s%s %s",
3355              (CPC_INNER_P () ? "inner" : ""),
3356              (is_interface ? "interface" : "class"),
3357              IDENTIFIER_POINTER (qualified_name));
3358
3359   /* Scope of an interface/class type name:
3360        - Can't be imported by a single type import
3361        - Can't already exists in the package */
3362   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3363       && (node = find_name_in_single_imports (raw_name))
3364       && !CPC_INNER_P ())
3365     {
3366       parse_error_context
3367         (cl, "%s name `%s' clashes with imported type `%s'",
3368          (is_interface ? "Interface" : "Class"),
3369          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3370       return 1;
3371     }
3372   if (decl && CLASS_COMPLETE_P (decl))
3373     {
3374       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3375                                    qualified_name, decl, cl);
3376       return 1;
3377     }
3378
3379   if (check_inner_class_redefinition (raw_name, cl))
3380     return 1;
3381
3382   /* If public, file name should match class/interface name, except
3383      when dealing with an inner class */
3384   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3385     {
3386       const char *f;
3387
3388       for (f = &input_filename [strlen (input_filename)];
3389            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3390            f--)
3391         ;
3392       if (IS_DIR_SEPARATOR (f[0]))
3393         f++;
3394       if (strncmp (IDENTIFIER_POINTER (raw_name),
3395                    f , IDENTIFIER_LENGTH (raw_name)) ||
3396           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3397         parse_error_context
3398           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3399                              (is_interface ? "interface" : "class"),
3400                              IDENTIFIER_POINTER (qualified_name),
3401                              IDENTIFIER_POINTER (raw_name));
3402     }
3403
3404   /* Static classes can be declared only in top level classes. Note:
3405      once static, a inner class is a top level class. */
3406   if (flags & ACC_STATIC)
3407     {
3408       /* Catch the specific error of declaring an class inner class
3409          with no toplevel enclosing class. Prevent check_modifiers from
3410          complaining a second time */
3411       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3412         {
3413           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3414                                IDENTIFIER_POINTER (qualified_name));
3415           sca = ACC_STATIC;
3416         }
3417       /* Else, in the context of a top-level class declaration, let
3418          `check_modifiers' do its job, otherwise, give it a go */
3419       else
3420         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3421     }
3422
3423   /* Inner classes can be declared private or protected
3424      within their enclosing classes. */
3425   if (CPC_INNER_P ())
3426     {
3427       /* A class which is local to a block can't be public, private,
3428          protected or static. But it is created final, so allow this
3429          one. */
3430       if (current_function_decl)
3431         icaf = sca = uaaf = ACC_FINAL;
3432       else
3433         {
3434           check_modifiers_consistency (flags);
3435           icaf = ACC_PROTECTED;
3436           if (! CLASS_INTERFACE (GET_CPC ()))
3437             icaf |= ACC_PRIVATE;
3438         }
3439     }
3440
3441   if (is_interface)
3442     {
3443       if (CPC_INNER_P ())
3444         uaaf = INTERFACE_INNER_MODIFIERS;
3445       else
3446         uaaf = INTERFACE_MODIFIERS;
3447
3448       check_modifiers ("Illegal modifier `%s' for interface declaration",
3449                        flags, uaaf);
3450     }
3451   else
3452     check_modifiers ((current_function_decl ?
3453                       "Illegal modifier `%s' for local class declaration" :
3454                       "Illegal modifier `%s' for class declaration"),
3455                      flags, uaaf|sca|icaf);
3456   return 0;
3457 }
3458
3459 /* Construct a nested class name.  If the final component starts with
3460    a digit, return true.  Otherwise return false.  */
3461 static int
3462 make_nested_class_name (tree cpc_list)
3463 {
3464   tree name;
3465
3466   if (!cpc_list)
3467     return 0;
3468
3469   make_nested_class_name (TREE_CHAIN (cpc_list));
3470
3471   /* Pick the qualified name when dealing with the first upmost
3472      enclosing class */
3473   name = (TREE_CHAIN (cpc_list)
3474           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3475   obstack_grow (&temporary_obstack,
3476                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3477   obstack_1grow (&temporary_obstack, '$');
3478
3479   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3480 }
3481
3482 /* Can't redefine a class already defined in an earlier scope. */
3483
3484 static int
3485 check_inner_class_redefinition (tree raw_name, tree cl)
3486 {
3487   tree scope_list;
3488
3489   for (scope_list = GET_CPC_LIST (); scope_list;
3490        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3491     if (raw_name == GET_CPC_UN_NODE (scope_list))
3492       {
3493         parse_error_context
3494           (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",
3495            IDENTIFIER_POINTER (raw_name));
3496         return 1;
3497       }
3498   return 0;
3499 }
3500
3501 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3502    we remember ENCLOSING and SUPER.  */
3503
3504 static tree
3505 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3506                      tree *super, tree class_type)
3507 {
3508   tree local_enclosing = *enclosing;
3509   tree local_super = NULL_TREE;
3510
3511   while (local_enclosing)
3512     {
3513       tree intermediate, decl;
3514
3515       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3516         local_enclosing;
3517
3518       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3519         return decl;
3520
3521       intermediate = local_enclosing;
3522       /* Explore enclosing contexts. */
3523       while (INNER_CLASS_DECL_P (intermediate))
3524         {
3525           intermediate = DECL_CONTEXT (intermediate);
3526           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3527             return decl;
3528         }
3529
3530       /* Now go to the upper classes, bail out if necessary. We will
3531          analyze the returned SUPER and act accordingly (see
3532          do_resolve_class.) */
3533       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3534       if (!local_super || local_super == object_type_node)
3535         break;
3536
3537       if (TREE_CODE (local_super) == POINTER_TYPE)
3538         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3539       else
3540         local_super = TYPE_NAME (local_super);
3541
3542       /* We may not have checked for circular inheritance yet, so do so
3543          here to prevent an infinite loop. */
3544       if (htab_find (circularity_hash, local_super) != NULL)
3545         {
3546           if (!cl)
3547             cl = lookup_cl (local_enclosing);
3548
3549           parse_error_context
3550             (cl, "Cyclic inheritance involving %s",
3551              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3552           local_enclosing = NULL_TREE;
3553         }
3554       else
3555         local_enclosing = local_super;
3556     }
3557
3558   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3559   *super = local_super;
3560   *enclosing = local_enclosing;
3561
3562   return NULL_TREE;
3563 }
3564
3565 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3566    qualified. */
3567
3568 static tree
3569 find_as_inner_class (tree enclosing, tree name, tree cl)
3570 {
3571   tree qual, to_return;
3572   if (!enclosing)
3573     return NULL_TREE;
3574
3575   name = TYPE_NAME (name);
3576
3577   /* First search: within the scope of `enclosing', search for name */
3578   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3579     qual = EXPR_WFL_QUALIFICATION (cl);
3580   else if (cl)
3581     qual = build_tree_list (cl, NULL_TREE);
3582   else
3583     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3584
3585   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3586     return to_return;
3587
3588   /* We're dealing with a qualified name. Try to resolve thing until
3589      we get something that is an enclosing class. */
3590   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3591     {
3592       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3593
3594       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3595            qual = TREE_CHAIN (qual))
3596         {
3597           acc = merge_qualified_name (acc,
3598                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3599           BUILD_PTR_FROM_NAME (ptr, acc);
3600           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3601         }
3602
3603       /* A NULL qual and a decl means that the search ended
3604          successfully?!? We have to do something then. FIXME */
3605
3606       if (decl)
3607         enclosing = decl;
3608       else
3609         qual = EXPR_WFL_QUALIFICATION (cl);
3610     }
3611   /* Otherwise, create a qual for the other part of the resolution. */
3612   else
3613     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3614
3615   return find_as_inner_class_do (qual, enclosing);
3616 }
3617
3618 /* We go inside the list of sub classes and try to find a way
3619    through. */
3620
3621 static tree
3622 find_as_inner_class_do (tree qual, tree enclosing)
3623 {
3624   if (!qual)
3625     return NULL_TREE;
3626
3627   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3628     {
3629       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3630       tree next_enclosing = NULL_TREE;
3631       tree inner_list;
3632
3633       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3634            inner_list; inner_list = TREE_CHAIN (inner_list))
3635         {
3636           if (TREE_VALUE (inner_list) == name_to_match)
3637             {
3638               next_enclosing = TREE_PURPOSE (inner_list);
3639               break;
3640             }
3641         }
3642       enclosing = next_enclosing;
3643     }
3644
3645   return (!qual && enclosing ? enclosing : NULL_TREE);
3646 }
3647
3648 /* Reach all inner classes and tie their unqualified name to a
3649    DECL. */
3650
3651 static void
3652 set_nested_class_simple_name_value (tree outer, int set)
3653 {
3654   tree l;
3655
3656   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3657     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3658                                                 TREE_PURPOSE (l) : NULL_TREE);
3659 }
3660
3661 static void
3662 link_nested_class_to_enclosing (void)
3663 {
3664   if (GET_ENCLOSING_CPC ())
3665     {
3666       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3667       DECL_INNER_CLASS_LIST (enclosing) =
3668         tree_cons (GET_CPC (), GET_CPC_UN (),
3669                    DECL_INNER_CLASS_LIST (enclosing));
3670     }
3671 }
3672
3673 static tree
3674 maybe_make_nested_class_name (tree name)
3675 {
3676   tree id = NULL_TREE;
3677
3678   if (CPC_INNER_P ())
3679     {
3680       /* If we're in a function, we must append a number to create the
3681          nested class name.  However, we don't do this if the class we
3682          are constructing is anonymous, because in that case we'll
3683          already have a number as the class name.  */
3684       if (! make_nested_class_name (GET_CPC_LIST ())
3685           && current_function_decl != NULL_TREE
3686           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3687         {
3688           char buf[10];
3689           sprintf (buf, "%d", anonymous_class_counter);
3690           ++anonymous_class_counter;
3691           obstack_grow (&temporary_obstack, buf, strlen (buf));
3692           obstack_1grow (&temporary_obstack, '$');
3693         }
3694       obstack_grow0 (&temporary_obstack,
3695                      IDENTIFIER_POINTER (name),
3696                      IDENTIFIER_LENGTH (name));
3697       id = get_identifier (obstack_finish (&temporary_obstack));
3698       if (ctxp->package)
3699         QUALIFIED_P (id) = 1;
3700     }
3701   return id;
3702 }
3703
3704 /* If DECL is NULL, create and push a new DECL, record the current
3705    line CL and do other maintenance things.  */
3706
3707 static tree
3708 maybe_create_class_interface_decl (tree decl, tree raw_name,
3709                                    tree qualified_name, tree cl)
3710 {
3711   if (!decl)
3712     decl = push_class (make_class (), qualified_name);
3713
3714   /* Take care of the file and line business */
3715   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3716   /* If we're emiting xrefs, store the line/col number information */
3717   if (flag_emit_xref)
3718     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3719   else
3720     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3721   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3722   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3723   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3724     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3725
3726   PUSH_CPC (decl, raw_name);
3727   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3728
3729   /* Link the declaration to the already seen ones */
3730   TREE_CHAIN (decl) = ctxp->class_list;
3731   ctxp->class_list = decl;
3732
3733   /* Create a new nodes in the global lists */
3734   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3735   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3736
3737   /* Install a new dependency list element */
3738   create_jdep_list (ctxp);
3739
3740   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3741                           IDENTIFIER_POINTER (qualified_name)));
3742   return decl;
3743 }
3744
3745 static void
3746 add_superinterfaces (tree decl, tree interface_list)
3747 {
3748   tree node;
3749   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3750      takes care of ensuring that:
3751        - This is an accessible interface type,
3752        - Circularity detection.
3753    parser_add_interface is then called. If present but not defined,
3754    the check operation is delayed until the super interface gets
3755    defined.  */
3756   for (node = interface_list; node; node = TREE_CHAIN (node))
3757     {
3758       tree current = TREE_PURPOSE (node);
3759       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3760       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3761         {
3762           if (!parser_check_super_interface (idecl, decl, current))
3763             parser_add_interface (decl, idecl, current);
3764         }
3765       else
3766         register_incomplete_type (JDEP_INTERFACE,
3767                                   current, decl, NULL_TREE);
3768     }
3769 }
3770
3771 /* Create an interface in pass1 and return its decl. Return the
3772    interface's decl in pass 2.  */
3773
3774 static tree
3775 create_interface (int flags, tree id, tree super)
3776 {
3777   tree raw_name = EXPR_WFL_NODE (id);
3778   tree q_name = parser_qualified_classname (raw_name);
3779   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3780
3781   /* Certain syntax errors are making SUPER be like ID. Avoid this
3782      case. */
3783   if (ctxp->class_err && id == super)
3784     super = NULL;
3785
3786   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3787
3788   /* Basic checks: scope, redefinition, modifiers */
3789   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3790     {
3791       PUSH_ERROR ();
3792       return NULL_TREE;
3793     }
3794
3795   /* Suspend the current parsing context if we're parsing an inner
3796      interface */
3797   if (CPC_INNER_P ())
3798     {
3799       java_parser_context_suspend ();
3800       /* Interface members are public. */
3801       if (CLASS_INTERFACE (GET_CPC ()))
3802         flags |= ACC_PUBLIC;
3803     }
3804
3805   /* Push a new context for (static) initialized upon declaration fields */
3806   java_parser_context_push_initialized_field ();
3807
3808   /* Interface modifiers check
3809        - public/abstract allowed (already done at that point)
3810        - abstract is obsolete (comes first, it's a warning, or should be)
3811        - Can't use twice the same (checked in the modifier rule) */
3812   if ((flags & ACC_ABSTRACT) && flag_redundant)
3813     parse_warning_context
3814       (MODIFIER_WFL (ABSTRACT_TK),
3815        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3816
3817   /* Create a new decl if DECL is NULL, otherwise fix it */
3818   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3819
3820   /* Set super info and mark the class a complete */
3821   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3822                   object_type_node, ctxp->interface_number);
3823   ctxp->interface_number = 0;
3824   CLASS_COMPLETE_P (decl) = 1;
3825   add_superinterfaces (decl, super);
3826
3827   return decl;
3828 }
3829
3830 /* Patch anonymous class CLASS, by either extending or implementing
3831    DEP.  */
3832
3833 static void
3834 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3835 {
3836   tree class = TREE_TYPE (class_decl);
3837   tree type =  TREE_TYPE (type_decl);
3838   tree binfo = TYPE_BINFO (class);
3839
3840   /* If it's an interface, implement it */
3841   if (CLASS_INTERFACE (type_decl))
3842     {
3843       tree s_binfo;
3844       int length;
3845
3846       if (parser_check_super_interface (type_decl, class_decl, wfl))
3847         return;
3848
3849       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3850       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3851       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3852       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3853       /* And add the interface */
3854       parser_add_interface (class_decl, type_decl, wfl);
3855     }
3856   /* Otherwise, it's a type we want to extend */
3857   else
3858     {
3859       if (parser_check_super (type_decl, class_decl, wfl))
3860         return;
3861       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3862     }
3863 }
3864
3865 static tree
3866 create_anonymous_class (int location, tree type_name)
3867 {
3868   char buffer [80];
3869   tree super = NULL_TREE, itf = NULL_TREE;
3870   tree id, type_decl, class;
3871
3872   /* The unqualified name of the anonymous class. It's just a number. */
3873   sprintf (buffer, "%d", anonymous_class_counter++);
3874   id = build_wfl_node (get_identifier (buffer));
3875   EXPR_WFL_LINECOL (id) = location;
3876
3877   /* We know about the type to extend/implement. We go ahead */
3878   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3879     {
3880       /* Create a class which either implements on extends the designated
3881          class. The class bears an innacessible name. */
3882       if (CLASS_INTERFACE (type_decl))
3883         {
3884           /* It's OK to modify it here. It's been already used and
3885              shouldn't be reused */
3886           ctxp->interface_number = 1;
3887           /* Interfaces should presented as a list of WFLs */
3888           itf = build_tree_list (type_name, NULL_TREE);
3889         }
3890       else
3891         super = type_name;
3892     }
3893
3894   class = create_class (ACC_FINAL, id, super, itf);
3895
3896   /* We didn't know anything about the stuff. We register a dependence. */
3897   if (!type_decl)
3898     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3899
3900   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3901   return class;
3902 }
3903
3904 /* Create a class in pass1 and return its decl. Return class
3905    interface's decl in pass 2.  */
3906
3907 static tree
3908 create_class (int flags, tree id, tree super, tree interfaces)
3909 {
3910   tree raw_name = EXPR_WFL_NODE (id);
3911   tree class_id, decl;
3912   tree super_decl_type;
3913
3914   /* Certain syntax errors are making SUPER be like ID. Avoid this
3915      case. */
3916   if (ctxp->class_err && id == super)
3917     super = NULL;
3918
3919   class_id = parser_qualified_classname (raw_name);
3920   decl = IDENTIFIER_CLASS_VALUE (class_id);
3921   EXPR_WFL_NODE (id) = class_id;
3922
3923   /* Basic check: scope, redefinition, modifiers */
3924   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3925     {
3926       PUSH_ERROR ();
3927       return NULL_TREE;
3928     }
3929
3930   /* Suspend the current parsing context if we're parsing an inner
3931      class or an anonymous class. */
3932   if (CPC_INNER_P ())
3933     {
3934       java_parser_context_suspend ();
3935       /* Interface members are public. */
3936       if (CLASS_INTERFACE (GET_CPC ()))
3937         flags |= ACC_PUBLIC;
3938     }
3939
3940   /* Push a new context for (static) initialized upon declaration fields */
3941   java_parser_context_push_initialized_field ();
3942
3943   /* Class modifier check:
3944        - Allowed modifier (already done at that point)
3945        - abstract AND final forbidden
3946        - Public classes defined in the correct file */
3947   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3948     parse_error_context
3949       (id, "Class `%s' can't be declared both abstract and final",
3950        IDENTIFIER_POINTER (raw_name));
3951
3952   /* Create a new decl if DECL is NULL, otherwise fix it */
3953   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3954
3955   /* If SUPER exists, use it, otherwise use Object */
3956   if (super)
3957     {
3958       /* Can't extend java.lang.Object */
3959       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3960         {
3961           parse_error_context (id, "Can't extend `java.lang.Object'");
3962           return NULL_TREE;
3963         }
3964
3965       super_decl_type =
3966         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
3967     }
3968   else if (TREE_TYPE (decl) != object_type_node)
3969     super_decl_type = object_type_node;
3970   /* We're defining java.lang.Object */
3971   else
3972     super_decl_type = NULL_TREE;
3973
3974   /* A class nested in an interface is implicitly static. */
3975   if (INNER_CLASS_DECL_P (decl)
3976       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
3977     {
3978       flags |= ACC_STATIC;
3979     }
3980
3981   /* Set super info and mark the class as complete. */
3982   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
3983                   ctxp->interface_number);
3984   ctxp->interface_number = 0;
3985   CLASS_COMPLETE_P (decl) = 1;
3986   add_superinterfaces (decl, interfaces);
3987
3988   /* Add the private this$<n> field, Replicate final locals still in
3989      scope as private final fields mangled like val$<local_name>.
3990      This doesn't not occur for top level (static) inner classes. */
3991   if (PURE_INNER_CLASS_DECL_P (decl))
3992     add_inner_class_fields (decl, current_function_decl);
3993
3994   /* If doing xref, store the location at which the inherited class
3995      (if any) was seen. */
3996   if (flag_emit_xref && super)
3997     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
3998
3999   /* Eventually sets the @deprecated tag flag */
4000   CHECK_DEPRECATED (decl);
4001
4002   /* Reset the anonymous class counter when declaring non inner classes */
4003   if (!INNER_CLASS_DECL_P (decl))
4004     anonymous_class_counter = 1;
4005
4006   return decl;
4007 }
4008
4009 /* End a class declaration: register the statements used to create
4010    finit$ and <clinit>, pop the current class and resume the prior
4011    parser context if necessary.  */
4012
4013 static void
4014 end_class_declaration (int resume)
4015 {
4016   /* If an error occurred, context weren't pushed and won't need to be
4017      popped by a resume. */
4018   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4019
4020   if (GET_CPC () != error_mark_node)
4021     dump_java_tree (TDI_class, GET_CPC ());
4022
4023   java_parser_context_pop_initialized_field ();
4024   POP_CPC ();
4025   if (resume && no_error_occurred)
4026     java_parser_context_resume ();
4027
4028   /* We're ending a class declaration, this is a good time to reset
4029      the interface cout. Note that might have been already done in
4030      create_interface, but if at that time an inner class was being
4031      dealt with, the interface count was reset in a context created
4032      for the sake of handling inner classes declaration. */
4033   ctxp->interface_number = 0;
4034 }
4035
4036 static void
4037 add_inner_class_fields (tree class_decl, tree fct_decl)
4038 {
4039   tree block, marker, f;
4040
4041   f = add_field (TREE_TYPE (class_decl),
4042                  build_current_thisn (TREE_TYPE (class_decl)),
4043                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4044                  ACC_PRIVATE);
4045   FIELD_THISN (f) = 1;
4046
4047   if (!fct_decl)
4048     return;
4049
4050   for (block = GET_CURRENT_BLOCK (fct_decl);
4051        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4052     {
4053       tree decl;
4054       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4055         {
4056           tree name, pname;
4057           tree wfl, init, list;
4058
4059           /* Avoid non final arguments. */
4060           if (!LOCAL_FINAL_P (decl))
4061             continue;
4062
4063           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4064           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4065           wfl = build_wfl_node (name);
4066           init = build_wfl_node (pname);
4067           /* Build an initialization for the field: it will be
4068              initialized by a parameter added to finit$, bearing a
4069              mangled name of the field itself (param$<n>.) The
4070              parameter is provided to finit$ by the constructor
4071              invoking it (hence the constructor will also feature a
4072              hidden parameter, set to the value of the outer context
4073              local at the time the inner class is created.)
4074
4075              Note: we take into account all possible locals that can
4076              be accessed by the inner class. It's actually not trivial
4077              to minimize these aliases down to the ones really
4078              used. One way to do that would be to expand all regular
4079              methods first, then finit$ to get a picture of what's
4080              used.  It works with the exception that we would have to
4081              go back on all constructor invoked in regular methods to
4082              have their invokation reworked (to include the right amount
4083              of alias initializer parameters.)
4084
4085              The only real way around, I think, is a first pass to
4086              identify locals really used in the inner class. We leave
4087              the flag FIELD_LOCAL_ALIAS_USED around for that future
4088              use.
4089
4090              On the other hand, it only affect local inner classes,
4091              whose constructors (and finit$ call) will be featuring
4092              unecessary arguments. It's easy for a developper to keep
4093              this number of parameter down by using the `final'
4094              keyword only when necessary. For the time being, we can
4095              issue a warning on unecessary finals. FIXME */
4096           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4097                                    wfl, init);
4098
4099           /* Register the field. The TREE_LIST holding the part
4100              initialized/initializer will be marked ARG_FINAL_P so
4101              that the created field can be marked
4102              FIELD_LOCAL_ALIAS. */
4103           list = build_tree_list (wfl, init);
4104           ARG_FINAL_P (list) = 1;
4105           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4106         }
4107     }
4108
4109   if (!CPC_INITIALIZER_STMT (ctxp))
4110     return;
4111
4112   /* If we ever registered an alias field, insert and marker to
4113      remeber where the list ends. The second part of the list (the one
4114      featuring initialized fields) so it can be later reversed to
4115      enforce 8.5. The marker will be removed during that operation. */
4116   marker = build_tree_list (NULL_TREE, NULL_TREE);
4117   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4118   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4119 }
4120
4121 /* Can't use lookup_field () since we don't want to load the class and
4122    can't set the CLASS_LOADED_P flag */
4123
4124 static tree
4125 find_field (tree class, tree name)
4126 {
4127   tree decl;
4128   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4129     {
4130       if (DECL_NAME (decl) == name)
4131         return decl;
4132     }
4133   return NULL_TREE;
4134 }
4135
4136 /* Wrap around lookup_field that doesn't potentially upset the value
4137    of CLASS */
4138
4139 static tree
4140 lookup_field_wrapper (tree class, tree name)
4141 {
4142   tree type = class;
4143   tree decl = NULL_TREE;
4144   java_parser_context_save_global ();
4145
4146   /* Last chance: if we're within the context of an inner class, we
4147      might be trying to access a local variable defined in an outer
4148      context. We try to look for it now. */
4149   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4150     {
4151       tree new_name;
4152       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4153       decl = lookup_field (&type, new_name);
4154       if (decl && decl != error_mark_node)
4155         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4156     }
4157   if (!decl || decl == error_mark_node)
4158     {
4159       type = class;
4160       decl = lookup_field (&type, name);
4161     }
4162
4163   /* If the field still hasn't been found, try the next enclosing context. */
4164   if (!decl && INNER_CLASS_TYPE_P (class))
4165     {
4166       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4167       decl = lookup_field_wrapper (outer_type, name);
4168     }
4169
4170   java_parser_context_restore_global ();
4171   return decl == error_mark_node ? NULL : decl;
4172 }
4173
4174 /* Find duplicate field within the same class declarations and report
4175    the error. Returns 1 if a duplicated field was found, 0
4176    otherwise.  */
4177
4178 static int
4179 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4180 {
4181   /* This might be modified to work with method decl as well */
4182   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4183   if (decl)
4184     {
4185       char *t1 = xstrdup (purify_type_name
4186                          ((TREE_CODE (new_type) == POINTER_TYPE
4187                            && TREE_TYPE (new_type) == NULL_TREE) ?
4188                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4189                           lang_printable_name (new_type, 1)));
4190       /* The type may not have been completed by the time we report
4191          the error */
4192       char *t2 = xstrdup (purify_type_name
4193                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4194                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4195                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4196                           lang_printable_name (TREE_TYPE (decl), 1)));
4197       parse_error_context
4198         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4199          t1, IDENTIFIER_POINTER (new_field_name),
4200          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4201          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4202       free (t1);
4203       free (t2);
4204       return 1;
4205     }
4206   return 0;
4207 }
4208
4209 /* Field registration routine. If TYPE doesn't exist, field
4210    declarations are linked to the undefined TYPE dependency list, to
4211    be later resolved in java_complete_class () */
4212
4213 static void
4214 register_fields (int flags, tree type, tree variable_list)
4215 {
4216   tree current, saved_type;
4217   tree class_type = NULL_TREE;
4218   int saved_lineno = lineno;
4219   int must_chain = 0;
4220   tree wfl = NULL_TREE;
4221
4222   if (GET_CPC ())
4223     class_type = TREE_TYPE (GET_CPC ());
4224
4225   if (!class_type || class_type == error_mark_node)
4226     return;
4227
4228   /* If we're adding fields to interfaces, those fields are public,
4229      static, final */
4230   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4231     {
4232       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4233                                  flags, ACC_PUBLIC, "interface field(s)");
4234       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4235                                  flags, ACC_STATIC, "interface field(s)");
4236       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4237                                  flags, ACC_FINAL, "interface field(s)");
4238       check_modifiers ("Illegal interface member modifier `%s'", flags,
4239                        INTERFACE_FIELD_MODIFIERS);
4240       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4241     }
4242
4243   /* Obtain a suitable type for resolution, if necessary */
4244   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4245
4246   /* If TYPE is fully resolved and we don't have a reference, make one */
4247   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4248
4249   for (current = variable_list, saved_type = type; current;
4250        current = TREE_CHAIN (current), type = saved_type)
4251     {
4252       tree real_type;
4253       tree field_decl;
4254       tree cl = TREE_PURPOSE (current);
4255       tree init = TREE_VALUE (current);
4256       tree current_name = EXPR_WFL_NODE (cl);
4257
4258       /* Can't declare non-final static fields in inner classes */
4259       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4260           && !(flags & ACC_FINAL))
4261         parse_error_context
4262           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4263            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4264            lang_printable_name (class_type, 0));
4265
4266       /* Process NAME, as it may specify extra dimension(s) for it */
4267       type = build_array_from_name (type, wfl, current_name, &current_name);
4268
4269       /* Type adjustment. We may have just readjusted TYPE because
4270          the variable specified more dimensions. Make sure we have
4271          a reference if we can and don't have one already. Also
4272          change the name if we have an init. */
4273       if (type != saved_type)
4274         {
4275           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4276           if (init)
4277             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4278         }
4279
4280       real_type = GET_REAL_TYPE (type);
4281       /* Check for redeclarations */
4282       if (duplicate_declaration_error_p (current_name, real_type, cl))
4283         continue;
4284
4285       /* Set lineno to the line the field was found and create a
4286          declaration for it. Eventually sets the @deprecated tag flag. */
4287       if (flag_emit_xref)
4288         lineno = EXPR_WFL_LINECOL (cl);
4289       else
4290         lineno = EXPR_WFL_LINENO (cl);
4291       field_decl = add_field (class_type, current_name, real_type, flags);
4292       CHECK_DEPRECATED (field_decl);
4293
4294       /* If the field denotes a final instance variable, then we
4295          allocate a LANG_DECL_SPECIFIC part to keep track of its
4296          initialization. We also mark whether the field was
4297          initialized upon its declaration. We don't do that if the
4298          created field is an alias to a final local. */
4299       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4300         {
4301           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4302           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4303         }
4304
4305       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4306          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4307          hide parameters to this inner class finit$ and
4308          constructors. It also means that the field isn't final per
4309          say. */
4310       if (ARG_FINAL_P (current))
4311         {
4312           FIELD_LOCAL_ALIAS (field_decl) = 1;
4313           FIELD_FINAL (field_decl) = 0;
4314         }
4315
4316       /* Check if we must chain. */
4317       if (must_chain)
4318         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4319
4320       /* If we have an initialization value tied to the field */
4321       if (init)
4322         {
4323           /* The field is declared static */
4324           if (flags & ACC_STATIC)
4325             {
4326               /* We include the field and its initialization part into
4327                  a list used to generate <clinit>. After <clinit> is
4328                  walked, field initializations will be processed and
4329                  fields initialized with known constants will be taken
4330                  out of <clinit> and have their DECL_INITIAL set
4331                  appropriately. */
4332               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4333               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4334               if (TREE_OPERAND (init, 1)
4335                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4336                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4337             }
4338           /* A non-static field declared with an immediate initialization is
4339              to be initialized in <init>, if any.  This field is remembered
4340              to be processed at the time of the generation of <init>. */
4341           else
4342             {
4343               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4344               SET_CPC_INITIALIZER_STMT (ctxp, init);
4345             }
4346           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4347           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4348         }
4349     }
4350   lineno = saved_lineno;
4351 }
4352
4353 /* Generate finit$, using the list of initialized fields to populate
4354    its body. finit$'s parameter(s) list is adjusted to include the
4355    one(s) used to initialized the field(s) caching outer context
4356    local(s).  */
4357
4358 static tree
4359 generate_finit (tree class_type)
4360 {
4361   int count = 0;
4362   tree list = TYPE_FINIT_STMT_LIST (class_type);
4363   tree mdecl, current, parms;
4364
4365   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4366                                                   class_type, NULL_TREE,
4367                                                   &count);
4368   CRAFTED_PARAM_LIST_FIXUP (parms);
4369   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4370                                     finit_identifier_node, parms);
4371   fix_method_argument_names (parms, mdecl);
4372   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4373                        mdecl, NULL_TREE);
4374   DECL_FUNCTION_NAP (mdecl) = count;
4375   start_artificial_method_body (mdecl);
4376
4377   for (current = list; current; current = TREE_CHAIN (current))
4378     java_method_add_stmt (mdecl,
4379                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4380                                                 current));
4381   end_artificial_method_body (mdecl);
4382   return mdecl;
4383 }
4384
4385 /* Generate a function to run the instance initialization code. The
4386    private method is called `instinit$'. Unless we're dealing with an
4387    anonymous class, we determine whether all ctors of CLASS_TYPE
4388    declare a checked exception in their `throws' clause in order to
4389    see whether it's necessary to encapsulate the instance initializer
4390    statements in a try/catch/rethrow sequence.  */
4391
4392 static tree
4393 generate_instinit (tree class_type)
4394 {
4395   tree current;
4396   tree compound = NULL_TREE;
4397   tree parms = tree_cons (this_identifier_node,
4398                           build_pointer_type (class_type), end_params_node);
4399   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4400                                          void_type_node,
4401                                          instinit_identifier_node, parms);
4402
4403   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4404                        mdecl, NULL_TREE);
4405
4406   /* Gather all the statements in a compound */
4407   for (current = TYPE_II_STMT_LIST (class_type);
4408        current; current = TREE_CHAIN (current))
4409     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4410
4411   /* We need to encapsulate COMPOUND by a try/catch statement to
4412      rethrow exceptions that might occur in the instance initializer.
4413      We do that only if all ctors of CLASS_TYPE are set to catch a
4414      checked exception. This doesn't apply to anonymous classes (since
4415      they don't have declared ctors.) */
4416   if (!ANONYMOUS_CLASS_P (class_type) &&
4417       ctors_unchecked_throws_clause_p (class_type))
4418     {
4419       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4420                                              build1 (THROW_EXPR, NULL_TREE,
4421                                                      build_wfl_node (wpv_id)));
4422       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4423                                                       exception_type_node);
4424     }
4425
4426   start_artificial_method_body (mdecl);
4427   java_method_add_stmt (mdecl, compound);
4428   end_artificial_method_body (mdecl);
4429
4430   return mdecl;
4431 }
4432
4433 /* FIXME */
4434 static tree
4435 build_instinit_invocation (tree class_type)
4436 {
4437   tree to_return = NULL_TREE;
4438
4439   if (TYPE_II_STMT_LIST (class_type))
4440     {
4441       tree parm = build_tree_list (NULL_TREE,
4442                                    build_wfl_node (this_identifier_node));
4443       to_return =
4444         build_method_invocation (build_wfl_node (instinit_identifier_node),
4445                                  parm);
4446     }
4447   return to_return;
4448 }
4449
4450 /* Shared accros method_declarator and method_header to remember the
4451    patch stage that was reached during the declaration of the method.
4452    A method DECL is built differently is there is no patch
4453    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4454    pending on the currently defined method.  */
4455
4456 static int patch_stage;
4457
4458 /* Check the method declaration and add the method to its current
4459    class.  If the argument list is known to contain incomplete types,
4460    the method is partially added and the registration will be resume
4461    once the method arguments resolved. If TYPE is NULL, we're dealing
4462    with a constructor.  */
4463
4464 static tree
4465 method_header (int flags, tree type, tree mdecl, tree throws)
4466 {
4467   tree type_wfl = NULL_TREE;
4468   tree meth_name = NULL_TREE;
4469   tree current, orig_arg, this_class = NULL;
4470   tree id, meth;
4471   int saved_lineno;
4472   int constructor_ok = 0, must_chain;
4473   int count;
4474
4475   if (mdecl == error_mark_node)
4476     return error_mark_node;
4477   meth = TREE_VALUE (mdecl);
4478   id = TREE_PURPOSE (mdecl);
4479
4480   check_modifiers_consistency (flags);
4481
4482   if (GET_CPC ())
4483     this_class = TREE_TYPE (GET_CPC ());
4484
4485   if (!this_class || this_class == error_mark_node)
4486     return NULL_TREE;
4487
4488   /* There are some forbidden modifiers for an abstract method and its
4489      class must be abstract as well.  */
4490   if (type && (flags & ACC_ABSTRACT))
4491     {
4492       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4493       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4494       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4495       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4496       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4497       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4498       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4499           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4500         parse_error_context
4501           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4502            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4503            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4504     }
4505
4506   /* A native method can't be strictfp.  */
4507   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4508     parse_error_context (id, "native method `%s' can't be strictfp",
4509                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4510   /* No such thing as a transient or volatile method.  */
4511   if ((flags & ACC_TRANSIENT))
4512     parse_error_context (id, "method `%s' can't be transient",
4513                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4514   if ((flags & ACC_VOLATILE))
4515     parse_error_context (id, "method `%s' can't be volatile",
4516                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4517
4518   /* Things to be checked when declaring a constructor */
4519   if (!type)
4520     {
4521       int ec = java_error_count;
4522       /* 8.6: Constructor declarations: we might be trying to define a
4523          method without specifying a return type. */
4524       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4525         parse_error_context
4526           (id, "Invalid method declaration, return type required");
4527       /* 8.6.3: Constructor modifiers */
4528       else
4529         {
4530           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4531           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4532           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4533           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4534           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4535           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4536         }
4537       /* If we found error here, we don't consider it's OK to tread
4538          the method definition as a constructor, for the rest of this
4539          function */
4540       if (ec == java_error_count)
4541         constructor_ok = 1;
4542     }
4543
4544   /* Method declared within the scope of an interface are implicitly
4545      abstract and public. Conflicts with other erroneously provided
4546      modifiers are checked right after. */
4547
4548   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4549     {
4550       /* If FLAGS isn't set because of a modifier, turn the
4551          corresponding modifier WFL to NULL so we issue a warning on
4552          the obsolete use of the modifier */
4553       if (!(flags & ACC_PUBLIC))
4554         MODIFIER_WFL (PUBLIC_TK) = NULL;
4555       if (!(flags & ACC_ABSTRACT))
4556         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4557       flags |= ACC_PUBLIC;
4558       flags |= ACC_ABSTRACT;
4559     }
4560
4561   /* Inner class can't declare static methods */
4562   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4563     {
4564       parse_error_context
4565         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4566          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4567          lang_printable_name (this_class, 0));
4568     }
4569
4570   /* Modifiers context reset moved up, so abstract method declaration
4571      modifiers can be later checked.  */
4572
4573   /* Set constructor returned type to void and method name to <init>,
4574      unless we found an error identifier the constructor (in which
4575      case we retain the original name) */
4576   if (!type)
4577     {
4578       type = void_type_node;
4579       if (constructor_ok)
4580         meth_name = init_identifier_node;
4581     }
4582   else
4583     meth_name = EXPR_WFL_NODE (id);
4584
4585   /* Do the returned type resolution and registration if necessary */
4586   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4587
4588   if (meth_name)
4589     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4590   EXPR_WFL_NODE (id) = meth_name;
4591   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4592
4593   if (must_chain)
4594     {
4595       patch_stage = JDEP_METHOD_RETURN;
4596       register_incomplete_type (patch_stage, type_wfl, id, type);
4597       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4598     }
4599   else
4600     TREE_TYPE (meth) = type;
4601
4602   saved_lineno = lineno;
4603   /* When defining an abstract or interface method, the curly
4604      bracket at level 1 doesn't exist because there is no function
4605      body */
4606   lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4607             EXPR_WFL_LINENO (id));
4608
4609   /* Remember the original argument list */
4610   orig_arg = TYPE_ARG_TYPES (meth);
4611
4612   if (patch_stage)              /* includes ret type and/or all args */
4613     {
4614       jdep *jdep;
4615       meth = add_method_1 (this_class, flags, meth_name, meth);
4616       /* Patch for the return type */
4617       if (patch_stage == JDEP_METHOD_RETURN)
4618         {
4619           jdep = CLASSD_LAST (ctxp->classd_list);
4620           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4621         }
4622       /* This is the stop JDEP. METH allows the function's signature
4623          to be computed. */
4624       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4625     }
4626   else
4627     meth = add_method (this_class, flags, meth_name,
4628                        build_java_signature (meth));
4629
4630   /* Remember final parameters */
4631   MARK_FINAL_PARMS (meth, orig_arg);
4632
4633   /* Fix the method argument list so we have the argument name
4634      information */
4635   fix_method_argument_names (orig_arg, meth);
4636
4637   /* Register the parameter number and re-install the current line
4638      number */
4639   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4640   lineno = saved_lineno;
4641
4642   /* Register exception specified by the `throws' keyword for
4643      resolution and set the method decl appropriate field to the list.
4644      Note: the grammar ensures that what we get here are class
4645      types. */
4646   if (throws)
4647     {
4648       throws = nreverse (throws);
4649       for (current = throws; current; current = TREE_CHAIN (current))
4650         {
4651           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4652                                     NULL_TREE, NULL_TREE);
4653           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4654             &TREE_VALUE (current);
4655         }
4656       DECL_FUNCTION_THROWS (meth) = throws;
4657     }
4658
4659   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4660     DECL_FUNCTION_WFL (meth) = id;
4661
4662   /* Set the flag if we correctly processed a constructor */
4663   if (constructor_ok)
4664     {
4665       DECL_CONSTRUCTOR_P (meth) = 1;
4666       /* Compute and store the number of artificial parameters declared
4667          for this constructor */
4668       for (count = 0, current = TYPE_FIELDS (this_class); current;
4669            current = TREE_CHAIN (current))
4670         if (FIELD_LOCAL_ALIAS (current))
4671           count++;
4672       DECL_FUNCTION_NAP (meth) = count;
4673     }
4674
4675   /* Eventually set the @deprecated tag flag */
4676   CHECK_DEPRECATED (meth);
4677
4678   /* If doing xref, store column and line number information instead
4679      of the line number only. */
4680   if (flag_emit_xref)
4681     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4682
4683   return meth;
4684 }
4685
4686 static void
4687 fix_method_argument_names (tree orig_arg, tree meth)
4688 {
4689   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4690   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4691     {
4692       TREE_PURPOSE (arg) = this_identifier_node;
4693       arg = TREE_CHAIN (arg);
4694     }
4695   while (orig_arg != end_params_node)
4696     {
4697       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4698       orig_arg = TREE_CHAIN (orig_arg);
4699       arg = TREE_CHAIN (arg);
4700     }
4701 }
4702
4703 /* Complete the method declaration with METHOD_BODY.  */
4704
4705 static void
4706 finish_method_declaration (tree method_body)
4707 {
4708   int flags;
4709
4710   if (!current_function_decl)
4711     return;
4712
4713   flags = get_access_flags_from_decl (current_function_decl);
4714
4715   /* 8.4.5 Method Body */
4716   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4717     {
4718       tree name = DECL_NAME (current_function_decl);
4719       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4720                            "%s method `%s' can't have a body defined",
4721                            (METHOD_NATIVE (current_function_decl) ?
4722                             "Native" : "Abstract"),
4723                            IDENTIFIER_POINTER (name));
4724       method_body = NULL_TREE;
4725     }
4726   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4727     {
4728       tree name = DECL_NAME (current_function_decl);
4729       parse_error_context
4730         (DECL_FUNCTION_WFL (current_function_decl),
4731          "Non native and non abstract method `%s' must have a body defined",
4732          IDENTIFIER_POINTER (name));
4733       method_body = NULL_TREE;
4734     }
4735
4736   if (flag_emit_class_files && method_body
4737       && TREE_CODE (method_body) == NOP_EXPR
4738       && TREE_TYPE (current_function_decl)
4739       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4740     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4741
4742   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4743   maybe_absorb_scoping_blocks ();
4744   /* Exit function's body */
4745   exit_block ();
4746   /* Merge last line of the function with first line, directly in the
4747      function decl. It will be used to emit correct debug info. */
4748   if (!flag_emit_xref)
4749     DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
4750
4751   /* Since function's argument's list are shared, reset the
4752      ARG_FINAL_P parameter that might have been set on some of this
4753      function parameters. */
4754   UNMARK_FINAL_PARMS (current_function_decl);
4755
4756   /* So we don't have an irrelevant function declaration context for
4757      the next static block we'll see. */
4758   current_function_decl = NULL_TREE;
4759 }
4760
4761 /* Build a an error message for constructor circularity errors.  */
4762
4763 static char *
4764 constructor_circularity_msg (tree from, tree to)
4765 {
4766   static char string [4096];
4767   char *t = xstrdup (lang_printable_name (from, 0));
4768   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4769   free (t);
4770   return string;
4771 }
4772
4773 /* Verify a circular call to METH. Return 1 if an error is found, 0
4774    otherwise.  */
4775
4776 static GTY(()) tree vcc_list;
4777 static int
4778 verify_constructor_circularity (tree meth, tree current)
4779 {
4780   tree c;
4781
4782   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4783     {
4784       if (TREE_VALUE (c) == meth)
4785         {
4786           char *t;
4787           if (vcc_list)
4788             {
4789               tree liste;
4790               vcc_list = nreverse (vcc_list);
4791               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4792                 {
4793                   parse_error_context
4794                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4795                      constructor_circularity_msg
4796                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4797                   java_error_count--;
4798                 }
4799             }
4800           t = xstrdup (lang_printable_name (meth, 0));
4801           parse_error_context (TREE_PURPOSE (c),
4802                                "%s: recursive invocation of constructor `%s'",
4803                                constructor_circularity_msg (current, meth), t);
4804           free (t);
4805           vcc_list = NULL_TREE;
4806           return 1;
4807         }
4808     }
4809   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4810     {
4811       vcc_list = tree_cons (c, current, vcc_list);
4812       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4813         return 1;
4814       vcc_list = TREE_CHAIN (vcc_list);
4815     }
4816   return 0;
4817 }
4818
4819 /* Check modifiers that can be declared but exclusively */
4820
4821 static void
4822 check_modifiers_consistency (int flags)
4823 {
4824   int acc_count = 0;
4825   tree cl = NULL_TREE;
4826
4827   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4828   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4829   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4830   if (acc_count > 1)
4831     parse_error_context
4832       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4833
4834   acc_count = 0;
4835   cl = NULL_TREE;
4836   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4837   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4838   if (acc_count > 1)
4839     parse_error_context (cl,
4840                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4841 }
4842
4843 /* Check the methode header METH for abstract specifics features */
4844
4845 static void
4846 check_abstract_method_header (tree meth)
4847 {
4848   int flags = get_access_flags_from_decl (meth);
4849
4850   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4851                               ACC_ABSTRACT, "abstract method",
4852                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4853   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4854                               ACC_PUBLIC, "abstract method",
4855                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4856
4857   check_modifiers ("Illegal modifier `%s' for interface method",
4858                   flags, INTERFACE_METHOD_MODIFIERS);
4859 }
4860
4861 /* Create a FUNCTION_TYPE node and start augmenting it with the
4862    declared function arguments. Arguments type that can't be resolved
4863    are left as they are, but the returned node is marked as containing
4864    incomplete types.  */
4865
4866 static tree
4867 method_declarator (tree id, tree list)
4868 {
4869   tree arg_types = NULL_TREE, current, node;
4870   tree meth = make_node (FUNCTION_TYPE);
4871   jdep *jdep;
4872
4873   patch_stage = JDEP_NO_PATCH;
4874
4875   if (GET_CPC () == error_mark_node)
4876     return error_mark_node;
4877
4878   /* If we're dealing with an inner class constructor, we hide the
4879      this$<n> decl in the name field of its parameter declaration.  We
4880      also might have to hide the outer context local alias
4881      initializers. Not done when the class is a toplevel class. */
4882   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4883       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4884     {
4885       tree aliases_list, type, thisn;
4886       /* First the aliases, linked to the regular parameters */
4887       aliases_list =
4888         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4889                                                 TREE_TYPE (GET_CPC ()),
4890                                                 NULL_TREE, NULL);
4891       list = chainon (nreverse (aliases_list), list);
4892
4893       /* Then this$<n> */
4894       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4895       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4896       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4897                         list);
4898     }
4899
4900   for (current = list; current; current = TREE_CHAIN (current))
4901     {
4902       int must_chain = 0;
4903       tree wfl_name = TREE_PURPOSE (current);
4904       tree type = TREE_VALUE (current);
4905       tree name = EXPR_WFL_NODE (wfl_name);
4906       tree already, arg_node;
4907       tree type_wfl = NULL_TREE;
4908       tree real_type;
4909
4910       /* Obtain a suitable type for resolution, if necessary */
4911       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4912
4913       /* Process NAME, as it may specify extra dimension(s) for it */
4914       type = build_array_from_name (type, type_wfl, name, &name);
4915       EXPR_WFL_NODE (wfl_name) = name;
4916
4917       real_type = GET_REAL_TYPE (type);
4918       if (TREE_CODE (real_type) == RECORD_TYPE)
4919         {
4920           real_type = promote_type (real_type);
4921           if (TREE_CODE (type) == TREE_LIST)
4922             TREE_PURPOSE (type) = real_type;
4923         }
4924
4925       /* Check redefinition */
4926       for (already = arg_types; already; already = TREE_CHAIN (already))
4927         if (TREE_PURPOSE (already) == name)
4928           {
4929             parse_error_context
4930               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4931                IDENTIFIER_POINTER (name),
4932                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4933             break;
4934           }
4935
4936       /* If we've an incomplete argument type, we know there is a location
4937          to patch when the type get resolved, later.  */
4938       jdep = NULL;
4939       if (must_chain)
4940         {
4941           patch_stage = JDEP_METHOD;
4942           type = register_incomplete_type (patch_stage,
4943                                            type_wfl, wfl_name, type);
4944           jdep = CLASSD_LAST (ctxp->classd_list);
4945           JDEP_MISC (jdep) = id;
4946         }
4947
4948       /* The argument node: a name and a (possibly) incomplete type.  */
4949       arg_node = build_tree_list (name, real_type);
4950       /* Remeber arguments declared final. */
4951       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4952
4953       if (jdep)
4954         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4955       TREE_CHAIN (arg_node) = arg_types;
4956       arg_types = arg_node;
4957     }
4958   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4959   node = build_tree_list (id, meth);
4960   return node;
4961 }
4962
4963 static int
4964 unresolved_type_p (tree wfl, tree *returned)
4965
4966 {
4967   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
4968     {
4969       if (returned)
4970         {
4971           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
4972           if (decl && current_class && (decl == TYPE_NAME (current_class)))
4973             *returned = TREE_TYPE (decl);
4974           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
4975             *returned = TREE_TYPE (GET_CPC ());
4976           else
4977             *returned = NULL_TREE;
4978         }
4979       return 1;
4980     }
4981   if (returned)
4982     *returned = wfl;
4983   return 0;
4984 }
4985
4986 /* From NAME, build a qualified identifier node using the
4987    qualification from the current package definition. */
4988
4989 static tree
4990 parser_qualified_classname (tree name)
4991 {
4992   tree nested_class_name;
4993
4994   if ((nested_class_name = maybe_make_nested_class_name (name)))
4995     return nested_class_name;
4996
4997   if (ctxp->package)
4998     return merge_qualified_name (ctxp->package, name);
4999   else
5000     return name;
5001 }
5002
5003 /* Called once the type a interface extends is resolved. Returns 0 if
5004    everything is OK.  */
5005
5006 static int
5007 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5008 {
5009   tree super_type = TREE_TYPE (super_decl);
5010
5011   /* Has to be an interface */
5012   if (!CLASS_INTERFACE (super_decl))
5013     {
5014       parse_error_context
5015         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5016          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5017           "Interface" : "Class"),
5018          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5019          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5020          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5021       return 1;
5022     }
5023
5024   /* Check top-level interface access. Inner classes are subject to member
5025      access rules (6.6.1). */
5026   if (! INNER_CLASS_P (super_type)
5027       && check_pkg_class_access (DECL_NAME (super_decl),
5028                                  lookup_cl (this_decl), true))
5029     return 1;
5030
5031   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5032                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5033                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5034   return 0;
5035 }
5036
5037 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5038    0 if everthing is OK.  */
5039
5040 static int
5041 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5042 {
5043   tree super_type = TREE_TYPE (super_decl);
5044
5045   /* SUPER should be a CLASS (neither an array nor an interface) */
5046   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5047     {
5048       parse_error_context
5049         (wfl, "Class `%s' can't subclass %s `%s'",
5050          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5051          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5052          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5053       return 1;
5054     }
5055
5056   if (CLASS_FINAL (TYPE_NAME (super_type)))
5057     {
5058       parse_error_context (wfl, "Can't subclass final classes: %s",
5059                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5060       return 1;
5061     }
5062
5063   /* Check top-level class scope. Inner classes are subject to member access
5064      rules (6.6.1). */
5065   if (! INNER_CLASS_P (super_type)
5066       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5067     return 1;
5068
5069   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5070                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5071                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5072   return 0;
5073 }
5074
5075 /* Create a new dependency list and link it (in a LIFO manner) to the
5076    CTXP list of type dependency list.  */
5077
5078 static void
5079 create_jdep_list (struct parser_ctxt *ctxp)
5080 {
5081   jdeplist *new = xmalloc (sizeof (jdeplist));
5082   new->first = new->last = NULL;
5083   new->next = ctxp->classd_list;
5084   ctxp->classd_list = new;
5085 }
5086
5087 static jdeplist *
5088 reverse_jdep_list (struct parser_ctxt *ctxp)
5089 {
5090   register jdeplist *prev = NULL, *current, *next;
5091   for (current = ctxp->classd_list; current; current = next)
5092     {
5093       next = current->next;
5094       current->next = prev;
5095       prev = current;
5096     }
5097   return prev;
5098 }
5099
5100 /* Create a fake pointer based on the ID stored in
5101    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5102    registered again. */
5103
5104 static tree
5105 obtain_incomplete_type (tree type_name)
5106 {
5107   tree ptr = NULL_TREE, name;
5108
5109   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5110     name = EXPR_WFL_NODE (type_name);
5111   else if (INCOMPLETE_TYPE_P (type_name))
5112     name = TYPE_NAME (type_name);
5113   else
5114     abort ();
5115
5116   /* Workaround from build_pointer_type for incomplete types.  */
5117   BUILD_PTR_FROM_NAME (ptr, name);
5118   TYPE_MODE (ptr) = ptr_mode;
5119   layout_type (ptr);
5120
5121   return ptr;
5122 }
5123
5124 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5125    non NULL instead of computing a new fake type based on WFL. The new
5126    dependency is inserted in the current type dependency list, in FIFO
5127    manner.  */
5128
5129 static tree
5130 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5131 {
5132   jdep *new = xmalloc (sizeof (jdep));
5133
5134   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5135     ptr = obtain_incomplete_type (wfl);
5136
5137   JDEP_KIND (new) = kind;
5138   JDEP_DECL (new) = decl;
5139   JDEP_TO_RESOLVE (new) = ptr;
5140   JDEP_WFL (new) = wfl;
5141   JDEP_CHAIN (new) = NULL;
5142   JDEP_MISC (new) = NULL_TREE;
5143   /* For some dependencies, set the enclosing class of the current
5144      class to be the enclosing context */
5145   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5146       && GET_ENCLOSING_CPC ())
5147     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5148   else if (kind == JDEP_SUPER)
5149     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5150                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5151   else
5152     JDEP_ENCLOSING (new) = GET_CPC ();
5153   JDEP_GET_PATCH (new) = (tree *)NULL;
5154
5155   JDEP_INSERT (ctxp->classd_list, new);
5156
5157   return ptr;
5158 }
5159
5160 /* This checks for circular references with innerclasses. We start
5161    from SOURCE and should never reach TARGET. Extended/implemented
5162    types in SOURCE have their enclosing context checked not to reach
5163    TARGET. When the last enclosing context of SOURCE is reached, its
5164    extended/implemented types are also checked not to reach TARGET.
5165    In case of error, WFL of the offending type is returned; NULL_TREE
5166    otherwise.  */
5167
5168 static tree
5169 check_inner_circular_reference (tree source, tree target)
5170 {
5171   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5172   tree ctx, cl;
5173   int i;
5174
5175   if (!basetype_vec)
5176     return NULL_TREE;
5177
5178   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5179     {
5180       tree su;
5181
5182       /* We can end up with a NULL_TREE or an incomplete type here if
5183          we encountered previous type resolution errors. It's safe to
5184          simply ignore these cases.  */
5185       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5186         continue;
5187       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5188       if (INCOMPLETE_TYPE_P (su))
5189         continue;
5190
5191       if (inherits_from_p (su, target))
5192         return lookup_cl (TYPE_NAME (su));
5193
5194       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5195         {
5196           /* An enclosing context shouldn't be TARGET */
5197           if (ctx == TYPE_NAME (target))
5198             return lookup_cl (TYPE_NAME (su));
5199
5200           /* When we reach the enclosing last context, start a check
5201              on it, with the same target */
5202           if (! DECL_CONTEXT (ctx) &&
5203               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5204             return cl;
5205         }
5206     }
5207   return NULL_TREE;
5208 }
5209
5210 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5211    offending type if a circularity is detected. NULL_TREE is returned
5212    otherwise. TYPE can be an interface or a class.   */
5213
5214 static tree
5215 check_circular_reference (tree type)
5216 {
5217   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5218   int i;
5219
5220   if (!basetype_vec)
5221     return NULL_TREE;
5222
5223   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5224     {
5225       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5226         return lookup_cl (TYPE_NAME (type));
5227       return NULL_TREE;
5228     }
5229
5230   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5231     {
5232       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5233       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5234           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5235         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5236     }
5237   return NULL_TREE;
5238 }
5239
5240 void
5241 java_check_circular_reference (void)
5242 {
5243   tree current;
5244   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5245     {
5246       tree type = TREE_TYPE (current);
5247       tree cl;
5248
5249       cl = check_circular_reference (type);
5250       if (! cl)
5251         cl = check_inner_circular_reference (type, type);
5252       if (cl)
5253         parse_error_context (cl, "Cyclic class inheritance%s",
5254                              (cyclic_inheritance_report ?
5255                               cyclic_inheritance_report : ""));
5256     }
5257 }
5258
5259 /* Augment the parameter list PARM with parameters crafted to
5260    initialize outer context locals aliases. Through ARTIFICIAL, a
5261    count is kept of the number of crafted parameters. MODE governs
5262    what eventually gets created: something suitable for a function
5263    creation or a function invocation, either the constructor or
5264    finit$.  */
5265
5266 static tree
5267 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5268                                         int *artificial)
5269 {
5270   tree field;
5271   tree additional_parms = NULL_TREE;
5272
5273   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5274     if (FIELD_LOCAL_ALIAS (field))
5275       {
5276         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5277         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5278         tree mangled_id;
5279
5280         switch (mode)
5281           {
5282           case AIPL_FUNCTION_DECLARATION:
5283             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5284                                                          &buffer [4]);
5285             purpose = build_wfl_node (mangled_id);
5286             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5287               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5288             else
5289               value = TREE_TYPE (field);
5290             break;
5291
5292           case AIPL_FUNCTION_CREATION:
5293             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5294                                                          &buffer [4]);
5295             value = TREE_TYPE (field);
5296             break;
5297
5298           case AIPL_FUNCTION_FINIT_INVOCATION:
5299             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5300                                                          &buffer [4]);
5301             /* Now, this is wrong. purpose should always be the NAME
5302                of something and value its matching value (decl, type,
5303                etc...) FIXME -- but there is a lot to fix. */
5304
5305             /* When invoked for this kind of operation, we already
5306                know whether a field is used or not. */
5307             purpose = TREE_TYPE (field);
5308             value = build_wfl_node (mangled_id);
5309             break;
5310
5311           case AIPL_FUNCTION_CTOR_INVOCATION:
5312             /* There are two case: the constructor invokation happends
5313                outside the local inner, in which case, locales from the outer
5314                context are directly used.
5315
5316                Otherwise, we fold to using the alias directly. */
5317             if (class_type == current_class)
5318               value = field;
5319             else
5320               {
5321                 name = get_identifier (&buffer[4]);
5322                 value = IDENTIFIER_LOCAL_VALUE (name);
5323               }
5324             break;
5325           }
5326         additional_parms = tree_cons (purpose, value, additional_parms);
5327         if (artificial)
5328           *artificial +=1;
5329       }
5330   if (additional_parms)
5331     {
5332       if (ANONYMOUS_CLASS_P (class_type)
5333           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5334         additional_parms = nreverse (additional_parms);
5335       parm = chainon (additional_parms, parm);
5336     }
5337
5338    return parm;
5339 }
5340
5341 /* Craft a constructor for CLASS_DECL -- what we should do when none
5342    where found. ARGS is non NULL when a special signature must be
5343    enforced. This is the case for anonymous classes.  */
5344
5345 static tree
5346 craft_constructor (tree class_decl, tree args)
5347 {
5348   tree class_type = TREE_TYPE (class_decl);
5349   tree parm = NULL_TREE;
5350   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5351                ACC_PUBLIC : 0);
5352   int i = 0, artificial = 0;
5353   tree decl, ctor_name;
5354   char buffer [80];
5355
5356   /* The constructor name is <init> unless we're dealing with an
5357      anonymous class, in which case the name will be fixed after having
5358      be expanded. */
5359   if (ANONYMOUS_CLASS_P (class_type))
5360     ctor_name = DECL_NAME (class_decl);
5361   else
5362     ctor_name = init_identifier_node;
5363
5364   /* If we're dealing with an inner class constructor, we hide the
5365      this$<n> decl in the name field of its parameter declaration. */
5366   if (PURE_INNER_CLASS_TYPE_P (class_type))
5367     {
5368       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5369       parm = tree_cons (build_current_thisn (class_type),
5370                         build_pointer_type (type), parm);
5371
5372       /* Some more arguments to be hidden here. The values of the local
5373          variables of the outer context that the inner class needs to see. */
5374       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5375                                                      class_type, parm,
5376                                                      &artificial);
5377     }
5378
5379   /* Then if there are any args to be enforced, enforce them now */
5380   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5381     {
5382       sprintf (buffer, "parm%d", i++);
5383       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5384     }
5385
5386   CRAFTED_PARAM_LIST_FIXUP (parm);
5387   decl = create_artificial_method (class_type, flags, void_type_node,
5388                                    ctor_name, parm);
5389   fix_method_argument_names (parm, decl);
5390   /* Now, mark the artificial parameters. */
5391   DECL_FUNCTION_NAP (decl) = artificial;
5392   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5393   return decl;
5394 }
5395
5396
5397 /* Fix the constructors. This will be called right after circular
5398    references have been checked. It is necessary to fix constructors
5399    early even if no code generation will take place for that class:
5400    some generated constructor might be required by the class whose
5401    compilation triggered this one to be simply loaded.  */
5402
5403 void
5404 java_fix_constructors (void)
5405 {
5406   tree current;
5407
5408   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5409     {
5410       tree class_type = TREE_TYPE (current);
5411       int saw_ctor = 0;
5412       tree decl;
5413
5414       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5415         continue;
5416
5417       current_class = class_type;
5418       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5419         {
5420           if (DECL_CONSTRUCTOR_P (decl))
5421             {
5422               fix_constructors (decl);
5423               saw_ctor = 1;
5424             }
5425         }
5426
5427       /* Anonymous class constructor can't be generated that early. */
5428       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5429         craft_constructor (current, NULL_TREE);
5430     }
5431 }
5432
5433 /* safe_layout_class just makes sure that we can load a class without
5434    disrupting the current_class, input_file, lineno, etc, information
5435    about the class processed currently.  */
5436
5437 void
5438 safe_layout_class (tree class)
5439 {
5440   tree save_current_class = current_class;
5441   const char *save_input_filename = input_filename;
5442   int save_lineno = lineno;
5443
5444   layout_class (class);
5445
5446   current_class = save_current_class;
5447   input_filename = save_input_filename;
5448   lineno = save_lineno;
5449 }
5450
5451 static tree
5452 jdep_resolve_class (jdep *dep)
5453 {
5454   tree decl;
5455
5456   if (JDEP_RESOLVED_P (dep))
5457     decl = JDEP_RESOLVED_DECL (dep);
5458   else
5459     {
5460       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5461                             JDEP_DECL (dep), JDEP_WFL (dep));
5462       JDEP_RESOLVED (dep, decl);
5463     }
5464
5465   if (!decl)
5466     complete_class_report_errors (dep);
5467   else if (PURE_INNER_CLASS_DECL_P (decl))
5468     {
5469       tree inner = TREE_TYPE (decl);
5470       if (! CLASS_LOADED_P (inner))
5471         {
5472           safe_layout_class (inner);
5473           if (TYPE_SIZE (inner) == error_mark_node)
5474             TYPE_SIZE (inner) = NULL_TREE;
5475         }
5476       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5477     }
5478   return decl;
5479 }
5480
5481 /* Complete unsatisfied class declaration and their dependencies */
5482
5483 void
5484 java_complete_class (void)
5485 {
5486   tree cclass;
5487   jdeplist *cclassd;
5488   int error_found;
5489   tree type;
5490
5491   /* Process imports */
5492   process_imports ();
5493
5494   /* Reverse things so we have the right order */
5495   ctxp->class_list = nreverse (ctxp->class_list);
5496   ctxp->classd_list = reverse_jdep_list (ctxp);
5497
5498   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5499        cclass && cclassd;
5500        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5501     {
5502       jdep *dep;
5503
5504       /* We keep the compilation unit imports in the class so that
5505          they can be used later to resolve type dependencies that
5506          aren't necessary to solve now. */
5507       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5508       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5509
5510       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5511         {
5512           tree decl;
5513           if (!(decl = jdep_resolve_class (dep)))
5514             continue;
5515
5516           /* Now it's time to patch */
5517           switch (JDEP_KIND (dep))
5518             {
5519             case JDEP_SUPER:
5520               /* Simply patch super */
5521               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5522                 continue;
5523               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5524                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5525               break;
5526
5527             case JDEP_FIELD:
5528               {
5529                 /* We do part of the job done in add_field */
5530                 tree field_decl = JDEP_DECL (dep);
5531                 tree field_type = TREE_TYPE (decl);
5532                 if (TREE_CODE (field_type) == RECORD_TYPE)
5533                   field_type = promote_type (field_type);
5534                 TREE_TYPE (field_decl) = field_type;
5535                 DECL_ALIGN (field_decl) = 0;
5536                 DECL_USER_ALIGN (field_decl) = 0;
5537                 layout_decl (field_decl, 0);
5538                 SOURCE_FRONTEND_DEBUG
5539                   (("Completed field/var decl `%s' with `%s'",
5540                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5541                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5542                 break;
5543               }
5544             case JDEP_METHOD:   /* We start patching a method */
5545             case JDEP_METHOD_RETURN:
5546               error_found = 0;
5547               while (1)
5548                 {
5549                   if (decl)
5550                     {
5551                       type = TREE_TYPE(decl);
5552                       if (TREE_CODE (type) == RECORD_TYPE)
5553                         type = promote_type (type);
5554                       JDEP_APPLY_PATCH (dep, type);
5555                       SOURCE_FRONTEND_DEBUG
5556                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5557                            "Completing fct `%s' with ret type `%s'":
5558                            "Completing arg `%s' with type `%s'"),
5559                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5560                                               (JDEP_DECL_WFL (dep))),
5561                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5562                     }
5563                   else
5564                     error_found = 1;
5565                   dep = JDEP_CHAIN (dep);
5566                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5567                     break;
5568                   else
5569                     decl = jdep_resolve_class (dep);
5570                 }
5571               if (!error_found)
5572                 {
5573                   tree mdecl = JDEP_DECL (dep), signature;
5574                   /* Recompute and reset the signature, check first that
5575                      all types are now defined. If they're not,
5576                      don't build the signature. */
5577                   if (check_method_types_complete (mdecl))
5578                     {
5579                       signature = build_java_signature (TREE_TYPE (mdecl));
5580                       set_java_signature (TREE_TYPE (mdecl), signature);
5581                     }
5582                 }
5583               else
5584                 continue;
5585               break;
5586
5587             case JDEP_INTERFACE:
5588               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5589                                                 JDEP_WFL (dep)))
5590                 continue;
5591               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5592               break;
5593
5594             case JDEP_PARM:
5595             case JDEP_VARIABLE:
5596               type = TREE_TYPE(decl);
5597               if (TREE_CODE (type) == RECORD_TYPE)
5598                 type = promote_type (type);
5599               JDEP_APPLY_PATCH (dep, type);
5600               break;
5601
5602             case JDEP_TYPE:
5603               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5604               SOURCE_FRONTEND_DEBUG
5605                 (("Completing a random type dependency on a '%s' node",
5606                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5607               break;
5608
5609             case JDEP_EXCEPTION:
5610               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5611               SOURCE_FRONTEND_DEBUG
5612                 (("Completing `%s' `throws' argument node",
5613                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5614               break;
5615
5616             case JDEP_ANONYMOUS:
5617               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5618               break;
5619
5620             default:
5621               abort ();
5622             }
5623         }
5624     }
5625   return;
5626 }
5627
5628 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5629    array.  */
5630
5631 static tree
5632 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5633 {
5634   tree tname = TYPE_NAME (class_type);
5635   tree resolved_type = TREE_TYPE (class_type);
5636   int array_dims = 0;
5637   tree resolved_type_decl;
5638
5639   if (resolved_type != NULL_TREE)
5640     {
5641       tree resolved_type_decl = TYPE_NAME (resolved_type);
5642       if (resolved_type_decl == NULL_TREE
5643           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5644         {
5645           resolved_type_decl = build_decl (TYPE_DECL,
5646                                            TYPE_NAME (class_type),
5647                                            resolved_type);
5648         }
5649       return resolved_type_decl;
5650     }
5651
5652   /* 1- Check to see if we have an array. If true, find what we really
5653      want to resolve  */
5654   if ((array_dims = build_type_name_from_array_name (tname,
5655                                                      &TYPE_NAME (class_type))))
5656     WFL_STRIP_BRACKET (cl, cl);
5657
5658   /* 2- Resolve the bare type */
5659   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5660                                                decl, cl)))
5661     return NULL_TREE;
5662   resolved_type = TREE_TYPE (resolved_type_decl);
5663
5664   /* 3- If we have an array, reconstruct the array down to its nesting */
5665   if (array_dims)
5666     {
5667       for (; array_dims; array_dims--)
5668         resolved_type = build_java_array_type (resolved_type, -1);
5669       resolved_type_decl = TYPE_NAME (resolved_type);
5670     }
5671   TREE_TYPE (class_type) = resolved_type;
5672   return resolved_type_decl;
5673 }
5674
5675 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5676    are used to report error messages. Do not try to replace TYPE_NAME
5677    (class_type) by a variable, since it is changed by
5678    find_in_imports{_on_demand} and (but it doesn't really matter)
5679    qualify_and_find.  */
5680
5681 tree
5682 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5683 {
5684   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5685   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5686   tree decl_result;
5687   htab_t circularity_hash;
5688
5689   if (QUALIFIED_P (TYPE_NAME (class_type)))
5690     {
5691       /* If the type name is of the form `Q . Id', then Q is either a
5692          package name or a class name.  First we try to find Q as a
5693          class and then treat Id as a member type.  If we can't find Q
5694          as a class then we fall through.  */
5695       tree q, left, left_type, right;
5696       breakdown_qualified (&left, &right, TYPE_NAME (class_type));
5697       BUILD_PTR_FROM_NAME (left_type, left);
5698       q = do_resolve_class (enclosing, left_type, decl, cl);
5699       if (q)
5700         {
5701           enclosing = q;
5702           saved_enclosing_type = TREE_TYPE (q);
5703           BUILD_PTR_FROM_NAME (class_type, right);
5704         }
5705     }
5706
5707   if (enclosing)
5708     {
5709       /* This hash table is used to register the classes we're going
5710          through when searching the current class as an inner class, in
5711          order to detect circular references. Remember to free it before
5712          returning the section 0- of this function. */
5713       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5714                                       NULL);
5715
5716       /* 0- Search in the current class as an inner class.
5717          Maybe some code here should be added to load the class or
5718          something, at least if the class isn't an inner class and ended
5719          being loaded from class file. FIXME. */
5720       while (enclosing)
5721         {
5722           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5723                                                 &super, class_type);
5724           if (new_class_decl)
5725             break;
5726
5727           /* If we haven't found anything because SUPER reached Object and
5728              ENCLOSING happens to be an innerclass, try the enclosing context. */
5729           if ((!super || super == object_type_node) &&
5730               enclosing && INNER_CLASS_DECL_P (enclosing))
5731             enclosing = DECL_CONTEXT (enclosing);
5732           else
5733             enclosing = NULL_TREE;
5734         }
5735
5736       htab_delete (circularity_hash);
5737
5738       if (new_class_decl)
5739         return new_class_decl;
5740     }
5741
5742   /* 1- Check for the type in single imports. This will change
5743      TYPE_NAME() if something relevant is found */
5744   find_in_imports (saved_enclosing_type, class_type);
5745
5746   /* 2- And check for the type in the current compilation unit */
5747   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5748     {
5749       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5750           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5751         load_class (TYPE_NAME (class_type), 0);
5752       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5753     }
5754
5755   /* 3- Search according to the current package definition */
5756   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5757     {
5758       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5759                                              TYPE_NAME (class_type))))
5760         return new_class_decl;
5761     }
5762
5763   /* 4- Check the import on demands. Don't allow bar.baz to be
5764      imported from foo.* */
5765   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5766     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5767       return NULL_TREE;
5768
5769   /* If found in find_in_imports_on_demand, the type has already been
5770      loaded. */
5771   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5772     return new_class_decl;
5773
5774   /* 5- Try with a name qualified with the package name we've seen so far */
5775   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5776     {
5777       tree package;
5778
5779       /* If there is a current package (ctxp->package), it's the first
5780          element of package_list and we can skip it. */
5781       for (package = (ctxp->package ?
5782                       TREE_CHAIN (package_list) : package_list);
5783            package; package = TREE_CHAIN (package))
5784         if ((new_class_decl = qualify_and_find (class_type,
5785                                                TREE_PURPOSE (package),
5786                                                TYPE_NAME (class_type))))
5787           return new_class_decl;
5788     }
5789
5790   /* 5- Check another compilation unit that bears the name of type */
5791   load_class (TYPE_NAME (class_type), 0);
5792
5793   if (!cl)
5794     cl = lookup_cl (decl);
5795
5796   /* If we don't have a value for CL, then we're being called recursively.
5797      We can't check package access just yet, but it will be taken care of
5798      by the caller. */
5799   if (cl)
5800     {
5801       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5802         return NULL_TREE;
5803     }
5804
5805   /* 6- Last call for a resolution */
5806   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5807
5808   /* The final lookup might have registered a.b.c into a.b$c If we
5809      failed at the first lookup, progressively change the name if
5810      applicable and use the matching DECL instead. */
5811   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5812     {
5813       char *separator;
5814       tree name = TYPE_NAME (class_type);
5815       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5816
5817       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5818
5819       do {
5820
5821        /* Reach the last '.', and if applicable, replace it by a `$' and
5822           see if this exists as a type. */
5823        if ((separator = strrchr (namebuffer, '.')))
5824          {
5825            *separator = '$';
5826            name = get_identifier (namebuffer);
5827            decl_result = IDENTIFIER_CLASS_VALUE (name);
5828          }
5829       } while (!decl_result && separator);
5830     }
5831   return decl_result;
5832 }
5833
5834 static tree
5835 qualify_and_find (tree class_type, tree package, tree name)
5836 {
5837   tree new_qualified = merge_qualified_name (package, name);
5838   tree new_class_decl;
5839
5840   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5841     load_class (new_qualified, 0);
5842   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5843     {
5844       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5845           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5846         load_class (new_qualified, 0);
5847       TYPE_NAME (class_type) = new_qualified;
5848       return IDENTIFIER_CLASS_VALUE (new_qualified);
5849     }
5850   return NULL_TREE;
5851 }
5852
5853 /* Resolve NAME and lay it out (if not done and if not the current
5854    parsed class). Return a decl node. This function is meant to be
5855    called when type resolution is necessary during the walk pass.  */
5856
5857 static tree
5858 resolve_and_layout (tree something, tree cl)
5859 {
5860   tree decl, decl_type;
5861
5862   /* Don't do that on the current class */
5863   if (something == current_class)
5864     return TYPE_NAME (current_class);
5865
5866   /* Don't do anything for void and other primitive types */
5867   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5868     return NULL_TREE;
5869
5870   /* Pointer types can be reall pointer types or fake pointers. When
5871      finding a real pointer, recheck for primitive types */
5872   if (TREE_CODE (something) == POINTER_TYPE)
5873     {
5874       if (TREE_TYPE (something))
5875         {
5876           something = TREE_TYPE (something);
5877           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5878             return NULL_TREE;
5879         }
5880       else
5881         something = TYPE_NAME (something);
5882     }
5883
5884   /* Don't do anything for arrays of primitive types */
5885   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5886       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5887     return NULL_TREE;
5888
5889   /* Something might be a WFL */
5890   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5891     something = EXPR_WFL_NODE (something);
5892
5893   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5894      TYPE_DECL or a real TYPE */
5895   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5896     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5897             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5898
5899   if (!(decl = resolve_no_layout (something, cl)))
5900     return NULL_TREE;
5901
5902   /* Resolve and layout if necessary */
5903   decl_type = TREE_TYPE (decl);
5904   layout_class_methods (decl_type);
5905   /* Check methods */
5906   if (CLASS_FROM_SOURCE_P (decl_type))
5907     java_check_methods (decl);
5908   /* Layout the type if necessary */
5909   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5910     safe_layout_class (decl_type);
5911
5912   return decl;
5913 }
5914
5915 /* Resolve a class, returns its decl but doesn't perform any
5916    layout. The current parsing context is saved and restored */
5917
5918 static tree
5919 resolve_no_layout (tree name, tree cl)
5920 {
5921   tree ptr, decl;
5922   BUILD_PTR_FROM_NAME (ptr, name);
5923   java_parser_context_save_global ();
5924   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5925   java_parser_context_restore_global ();
5926
5927   return decl;
5928 }
5929
5930 /* Called when reporting errors. Skip the '[]'s in a complex array
5931    type description that failed to be resolved. purify_type_name can't
5932    use an identifier tree.  */
5933
5934 static const char *
5935 purify_type_name (const char *name)
5936 {
5937   int len = strlen (name);
5938   int bracket_found;
5939
5940   STRING_STRIP_BRACKETS (name, len, bracket_found);
5941   if (bracket_found)
5942     {
5943       char *stripped_name = xmemdup (name, len, len+1);
5944       stripped_name [len] = '\0';
5945       return stripped_name;
5946     }
5947   return name;
5948 }
5949
5950 /* The type CURRENT refers to can't be found. We print error messages.  */
5951
5952 static void
5953 complete_class_report_errors (jdep *dep)
5954 {
5955   const char *name;
5956
5957   if (!JDEP_WFL (dep))
5958     return;
5959
5960   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
5961   switch (JDEP_KIND (dep))
5962     {
5963     case JDEP_SUPER:
5964       parse_error_context
5965         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
5966          purify_type_name (name),
5967          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5968       break;
5969     case JDEP_FIELD:
5970       parse_error_context
5971         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
5972          purify_type_name (name),
5973          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5974       break;
5975     case JDEP_METHOD:           /* Covers arguments */
5976       parse_error_context
5977         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
5978          purify_type_name (name),
5979          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
5980          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
5981       break;
5982     case JDEP_METHOD_RETURN:    /* Covers return type */
5983       parse_error_context
5984         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
5985          purify_type_name (name),
5986          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
5987       break;
5988     case JDEP_INTERFACE:
5989       parse_error_context
5990         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
5991          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
5992          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
5993          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5994       break;
5995     case JDEP_VARIABLE:
5996       parse_error_context
5997         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
5998          purify_type_name (IDENTIFIER_POINTER
5999                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6000          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6001       break;
6002     case JDEP_EXCEPTION:        /* As specified by `throws' */
6003       parse_error_context
6004           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6005          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6006       break;
6007     default:
6008       /* Fix for -Wall. Just break doing nothing. The error will be
6009          caught later */
6010       break;
6011     }
6012 }
6013
6014 /* Return a static string containing the DECL prototype string. If
6015    DECL is a constructor, use the class name instead of the form
6016    <init> */
6017
6018 static const char *
6019 get_printable_method_name (tree decl)
6020 {
6021   const char *to_return;
6022   tree name = NULL_TREE;
6023
6024   if (DECL_CONSTRUCTOR_P (decl))
6025     {
6026       name = DECL_NAME (decl);
6027       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6028     }
6029
6030   to_return = lang_printable_name (decl, 0);
6031   if (DECL_CONSTRUCTOR_P (decl))
6032     DECL_NAME (decl) = name;
6033
6034   return to_return;
6035 }
6036
6037 /* Track method being redefined inside the same class. As a side
6038    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6039    function it's a FWL, so we can track errors more accurately.)  */
6040
6041 static int
6042 check_method_redefinition (tree class, tree method)
6043 {
6044   tree redef, sig;
6045
6046   /* There's no need to verify <clinit> and finit$ and instinit$ */
6047   if (DECL_CLINIT_P (method)
6048       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6049     return 0;
6050
6051   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6052   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6053     {
6054       if (redef == method)
6055         break;
6056       if (DECL_NAME (redef) == DECL_NAME (method)
6057           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6058           && !DECL_ARTIFICIAL (method))
6059         {
6060           parse_error_context
6061             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6062              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6063              get_printable_method_name (redef));
6064           return 1;
6065         }
6066     }
6067   return 0;
6068 }
6069
6070 /* Return 1 if check went ok, 0 otherwise.  */
6071 static int
6072 check_abstract_method_definitions (int do_interface, tree class_decl,
6073                                    tree type)
6074 {
6075   tree class = TREE_TYPE (class_decl);
6076   tree method, end_type;
6077   int ok = 1;
6078
6079   end_type = (do_interface ? object_type_node : type);
6080   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6081     {
6082       tree other_super, other_method, method_sig, method_name;
6083       int found = 0;
6084       int end_type_reached = 0;
6085
6086       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6087         continue;
6088
6089       /* Now verify that somewhere in between TYPE and CLASS,
6090          abstract method METHOD gets a non abstract definition
6091          that is inherited by CLASS.  */
6092
6093       method_sig = build_java_signature (TREE_TYPE (method));
6094       method_name = DECL_NAME (method);
6095       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6096         method_name = EXPR_WFL_NODE (method_name);
6097
6098       other_super = class;
6099       do {
6100         if (other_super == end_type)
6101           end_type_reached = 1;
6102
6103         /* Method search */
6104         for (other_method = TYPE_METHODS (other_super); other_method;
6105             other_method = TREE_CHAIN (other_method))
6106           {
6107             tree s = build_java_signature (TREE_TYPE (other_method));
6108             tree other_name = DECL_NAME (other_method);
6109
6110             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6111               other_name = EXPR_WFL_NODE (other_name);
6112             if (!DECL_CLINIT_P (other_method)
6113                 && !DECL_CONSTRUCTOR_P (other_method)
6114                 && method_name == other_name
6115                 && method_sig == s
6116                 && !METHOD_ABSTRACT (other_method))
6117              {
6118                found = 1;
6119                break;
6120              }
6121           }
6122         other_super = CLASSTYPE_SUPER (other_super);
6123       } while (!end_type_reached);
6124
6125       /* Report that abstract METHOD didn't find an implementation
6126          that CLASS can use. */
6127       if (!found)
6128         {
6129           char *t = xstrdup (lang_printable_name
6130                             (TREE_TYPE (TREE_TYPE (method)), 0));
6131           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6132
6133           parse_error_context
6134             (lookup_cl (class_decl),
6135              "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",
6136              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6137              t, lang_printable_name (method, 0),
6138              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6139               "interface" : "class"),
6140              IDENTIFIER_POINTER (ccn),
6141              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6142              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6143           ok = 0;
6144           free (t);
6145         }
6146     }
6147
6148   if (ok && do_interface)
6149     {
6150       /* Check for implemented interfaces. */
6151       int i;
6152       tree vector = TYPE_BINFO_BASETYPES (type);
6153       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6154         {
6155           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6156           ok = check_abstract_method_definitions (1, class_decl, super);
6157         }
6158     }
6159
6160   return ok;
6161 }
6162
6163 /* Check that CLASS_DECL somehow implements all inherited abstract
6164    methods.  */
6165
6166 static void
6167 java_check_abstract_method_definitions (tree class_decl)
6168 {
6169   tree class = TREE_TYPE (class_decl);
6170   tree super, vector;
6171   int i;
6172
6173   if (CLASS_ABSTRACT (class_decl))
6174     return;
6175
6176   /* Check for inherited types */
6177   super = class;
6178   do {
6179     super = CLASSTYPE_SUPER (super);
6180     check_abstract_method_definitions (0, class_decl, super);
6181   } while (super != object_type_node);
6182
6183   /* Check for implemented interfaces. */
6184   vector = TYPE_BINFO_BASETYPES (class);
6185   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6186     {
6187       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6188       check_abstract_method_definitions (1, class_decl, super);
6189     }
6190 }
6191
6192 /* Check all the types method DECL uses and return 1 if all of them
6193    are now complete, 0 otherwise. This is used to check whether its
6194    safe to build a method signature or not.  */
6195
6196 static int
6197 check_method_types_complete (tree decl)
6198 {
6199   tree type = TREE_TYPE (decl);
6200   tree args;
6201
6202   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6203     return 0;
6204
6205   args = TYPE_ARG_TYPES (type);
6206   if (TREE_CODE (type) == METHOD_TYPE)
6207     args = TREE_CHAIN (args);
6208   for (; args != end_params_node; args = TREE_CHAIN (args))
6209     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6210       return 0;
6211
6212   return 1;
6213 }
6214
6215 /* Visible interface to check methods contained in CLASS_DECL */
6216
6217 void
6218 java_check_methods (tree class_decl)
6219 {
6220   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6221     return;
6222
6223   if (CLASS_INTERFACE (class_decl))
6224     java_check_abstract_methods (class_decl);
6225   else
6226     java_check_regular_methods (class_decl);
6227
6228   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6229 }
6230
6231 /* Check all the methods of CLASS_DECL. Methods are first completed
6232    then checked according to regular method existence rules.  If no
6233    constructor for CLASS_DECL were encountered, then build its
6234    declaration.  */
6235
6236 static void
6237 java_check_regular_methods (tree class_decl)
6238 {
6239   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6240   tree method;
6241   tree class = TREE_TYPE (class_decl);
6242   tree found = NULL_TREE;
6243   tree mthrows;
6244
6245   /* It is not necessary to check methods defined in java.lang.Object */
6246   if (class == object_type_node)
6247     return;
6248
6249   if (!TYPE_NVIRTUALS (class))
6250     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6251
6252   /* Should take interfaces into account. FIXME */
6253   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6254     {
6255       tree sig;
6256       tree method_wfl = DECL_FUNCTION_WFL (method);
6257       int aflags;
6258
6259       /* Check for redefinitions */
6260       if (check_method_redefinition (class, method))
6261         continue;
6262
6263       /* We verify things thrown by the method.  They must inherit from
6264          java.lang.Throwable.  */
6265       for (mthrows = DECL_FUNCTION_THROWS (method);
6266            mthrows; mthrows = TREE_CHAIN (mthrows))
6267         {
6268           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6269             parse_error_context
6270               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6271                IDENTIFIER_POINTER
6272                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6273         }
6274
6275       /* If we see one constructor a mark so we don't generate the
6276          default one.  Also skip other verifications: constructors
6277          can't be inherited hence hidden or overridden.  */
6278       if (DECL_CONSTRUCTOR_P (method))
6279         {
6280           saw_constructor = 1;
6281           continue;
6282         }
6283
6284       sig = build_java_argument_signature (TREE_TYPE (method));
6285       found = lookup_argument_method2 (class, DECL_NAME (method), sig);
6286
6287       /* Inner class can't declare static methods */
6288       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6289         {
6290           char *t = xstrdup (lang_printable_name (class, 0));
6291           parse_error_context
6292             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6293              lang_printable_name (method, 0), t);
6294           free (t);
6295         }
6296
6297       /* Nothing overrides or it's a private method. */
6298       if (!found)
6299         continue;
6300       if (METHOD_PRIVATE (found))
6301         {
6302           found = NULL_TREE;
6303           continue;
6304         }
6305
6306       /* If `found' is declared in an interface, make sure the
6307          modifier matches. */
6308       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6309           && clinit_identifier_node != DECL_NAME (found)
6310           && !METHOD_PUBLIC (method))
6311         {
6312           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6313           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6314                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6315                                lang_printable_name (method, 0),
6316                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6317         }
6318
6319       /* Can't override a method with the same name and different return
6320          types. */
6321       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6322         {
6323           char *t = xstrdup
6324             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6325           parse_error_context
6326             (method_wfl,
6327              "Method `%s' was defined with return type `%s' in class `%s'",
6328              lang_printable_name (found, 0), t,
6329              IDENTIFIER_POINTER
6330                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6331           free (t);
6332         }
6333
6334       aflags = get_access_flags_from_decl (found);
6335
6336       /* Can't override final. Can't override static. */
6337       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6338         {
6339           /* Static *can* override static */
6340           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6341             continue;
6342           parse_error_context
6343             (method_wfl,
6344              "%s methods can't be overriden. Method `%s' is %s in class `%s'",
6345              (METHOD_FINAL (found) ? "Final" : "Static"),
6346              lang_printable_name (found, 0),
6347              (METHOD_FINAL (found) ? "final" : "static"),
6348              IDENTIFIER_POINTER
6349                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6350           continue;
6351         }
6352
6353       /* Static method can't override instance method. */
6354       if (METHOD_STATIC (method))
6355         {
6356           parse_error_context
6357             (method_wfl,
6358              "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
6359              lang_printable_name (found, 0),
6360              IDENTIFIER_POINTER
6361                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6362           continue;
6363         }
6364
6365       /* - Overriding/hiding public must be public
6366          - Overriding/hiding protected must be protected or public
6367          - If the overriden or hidden method has default (package)
6368            access, then the overriding or hiding method must not be
6369            private; otherwise, a compile-time error occurs.  If
6370            `found' belongs to an interface, things have been already
6371            taken care of.  */
6372       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6373           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6374               || (METHOD_PROTECTED (found)
6375                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6376               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6377                   && METHOD_PRIVATE (method))))
6378         {
6379           parse_error_context
6380             (method_wfl,
6381              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6382              (METHOD_PUBLIC (method) ? "public" :
6383               (METHOD_PRIVATE (method) ? "private" : "protected")),
6384              IDENTIFIER_POINTER (DECL_NAME
6385                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6386           continue;
6387         }
6388
6389       /* Overriding methods must have compatible `throws' clauses on checked
6390          exceptions, if any */
6391       check_throws_clauses (method, method_wfl, found);
6392
6393       /* Inheriting multiple methods with the same signature. FIXME */
6394     }
6395
6396   if (!TYPE_NVIRTUALS (class))
6397     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6398
6399   /* Search for inherited abstract method not yet implemented in this
6400      class.  */
6401   java_check_abstract_method_definitions (class_decl);
6402
6403   if (!saw_constructor)
6404     abort ();
6405 }
6406
6407 /* Return a nonzero value if the `throws' clause of METHOD (if any)
6408    is incompatible with the `throws' clause of FOUND (if any).  */
6409
6410 static void
6411 check_throws_clauses (tree method, tree method_wfl, tree found)
6412 {
6413   tree mthrows, fthrows;
6414
6415   /* Can't check these things with class loaded from bytecode. FIXME */
6416   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6417     return;
6418
6419   for (mthrows = DECL_FUNCTION_THROWS (method);
6420        mthrows; mthrows = TREE_CHAIN (mthrows))
6421     {
6422       /* We don't verify unchecked expressions */
6423       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6424         continue;
6425       /* Checked expression must be compatible */
6426       for (fthrows = DECL_FUNCTION_THROWS (found);
6427            fthrows; fthrows = TREE_CHAIN (fthrows))
6428         if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6429           break;
6430       if (!fthrows)
6431         {
6432           parse_error_context
6433             (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'",
6434              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6435              lang_printable_name (found, 0),
6436              IDENTIFIER_POINTER
6437                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6438         }
6439     }
6440 }
6441
6442 /* Check abstract method of interface INTERFACE */
6443
6444 static void
6445 java_check_abstract_methods (tree interface_decl)
6446 {
6447   int i, n;
6448   tree method, basetype_vec, found;
6449   tree interface = TREE_TYPE (interface_decl);
6450
6451   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6452     {
6453       /* 2- Check for double definition inside the defining interface */
6454       if (check_method_redefinition (interface, method))
6455         continue;
6456
6457       /* 3- Overriding is OK as far as we preserve the return type and
6458          the thrown exceptions (FIXME) */
6459       found = lookup_java_interface_method2 (interface, method);
6460       if (found)
6461         {
6462           char *t;
6463           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6464           parse_error_context
6465             (DECL_FUNCTION_WFL (found),
6466              "Method `%s' was defined with return type `%s' in class `%s'",
6467              lang_printable_name (found, 0), t,
6468              IDENTIFIER_POINTER
6469                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6470           free (t);
6471           continue;
6472         }
6473     }
6474
6475   /* 4- Inherited methods can't differ by their returned types */
6476   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6477     return;
6478   n = TREE_VEC_LENGTH (basetype_vec);
6479   for (i = 0; i < n; i++)
6480     {
6481       tree sub_interface_method, sub_interface;
6482       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6483       if (!vec_elt)
6484         continue;
6485       sub_interface = BINFO_TYPE (vec_elt);
6486       for (sub_interface_method = TYPE_METHODS (sub_interface);
6487            sub_interface_method;
6488            sub_interface_method = TREE_CHAIN (sub_interface_method))
6489         {
6490           found = lookup_java_interface_method2 (interface,
6491                                                  sub_interface_method);
6492           if (found && (found != sub_interface_method))
6493             {
6494               parse_error_context
6495                 (lookup_cl (sub_interface_method),
6496                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6497                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6498                  lang_printable_name (found, 0),
6499                  IDENTIFIER_POINTER
6500                    (DECL_NAME (TYPE_NAME
6501                                (DECL_CONTEXT (sub_interface_method)))),
6502                  IDENTIFIER_POINTER
6503                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6504             }
6505         }
6506     }
6507 }
6508
6509 /* Lookup methods in interfaces using their name and partial
6510    signature. Return a matching method only if their types differ.  */
6511
6512 static tree
6513 lookup_java_interface_method2 (tree class, tree method_decl)
6514 {
6515   int i, n;
6516   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6517
6518   if (!basetype_vec)
6519     return NULL_TREE;
6520
6521   n = TREE_VEC_LENGTH (basetype_vec);
6522   for (i = 0; i < n; i++)
6523     {
6524       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6525       if ((BINFO_TYPE (vec_elt) != object_type_node)
6526           && (to_return =
6527               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6528         return to_return;
6529     }
6530   for (i = 0; i < n; i++)
6531     {
6532       to_return = lookup_java_interface_method2
6533         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6534       if (to_return)
6535         return to_return;
6536     }
6537
6538   return NULL_TREE;
6539 }
6540
6541 /* Lookup method using their name and partial signature. Return a
6542    matching method only if their types differ.  */
6543
6544 static tree
6545 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6546 {
6547   tree method, method_signature, method_name, method_type, name;
6548
6549   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6550   name = DECL_NAME (method_decl);
6551   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6552                  EXPR_WFL_NODE (name) : name);
6553   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6554
6555   while (clas != NULL_TREE)
6556     {
6557       for (method = TYPE_METHODS (clas);
6558            method != NULL_TREE;  method = TREE_CHAIN (method))
6559         {
6560           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6561           tree name = DECL_NAME (method);
6562           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6563                EXPR_WFL_NODE (name) : name) == method_name
6564               && method_sig == method_signature
6565               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6566             return method;
6567         }
6568       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6569     }
6570   return NULL_TREE;
6571 }
6572
6573 /* Return the line that matches DECL line number, and try its best to
6574    position the column number. Used during error reports.  */
6575
6576 static GTY(()) tree cl_v;
6577 static tree
6578 lookup_cl (tree decl)
6579 {
6580   char *line, *found;
6581
6582   if (!decl)
6583     return NULL_TREE;
6584
6585   if (cl_v == NULL_TREE)
6586     {
6587       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6588     }
6589
6590   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6591   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE_FIRST (decl), -1);
6592
6593   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6594                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6595
6596   found = strstr ((const char *)line,
6597                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6598   if (found)
6599     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6600
6601   return cl_v;
6602 }
6603
6604 /* Look for a simple name in the single-type import list */
6605
6606 static tree
6607 find_name_in_single_imports (tree name)
6608 {
6609   tree node;
6610
6611   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6612     if (TREE_VALUE (node) == name)
6613       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6614
6615   return NULL_TREE;
6616 }
6617
6618 /* Process all single-type import. */
6619
6620 static int
6621 process_imports (void)
6622 {
6623   tree import;
6624   int error_found;
6625
6626   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6627     {
6628       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6629       char *original_name;
6630
6631       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6632                                IDENTIFIER_LENGTH (to_be_found),
6633                                IDENTIFIER_LENGTH (to_be_found) + 1);
6634
6635       /* Don't load twice something already defined. */
6636       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6637         continue;
6638
6639       while (1)
6640         {
6641           tree left;
6642
6643           QUALIFIED_P (to_be_found) = 1;
6644           load_class (to_be_found, 0);
6645           error_found =
6646             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6647
6648           /* We found it, we can bail out */
6649           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6650             break;
6651
6652           /* We haven't found it. Maybe we're trying to access an
6653              inner class.  The only way for us to know is to try again
6654              after having dropped a qualifier. If we can't break it further,
6655              we have an error. */
6656           if (breakdown_qualified (&left, NULL, to_be_found))
6657             break;
6658
6659           to_be_found = left;
6660         }
6661       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6662         {
6663           parse_error_context (TREE_PURPOSE (import),
6664                                "Class or interface `%s' not found in import",
6665                                original_name);
6666           error_found = 1;
6667         }
6668
6669       free (original_name);
6670       if (error_found)
6671         return 1;
6672     }
6673   return 0;
6674 }
6675
6676 /* Possibly find and mark a class imported by a single-type import
6677    statement.  */
6678
6679 static void
6680 find_in_imports (tree enclosing_type, tree class_type)
6681 {
6682   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6683                  ctxp->import_list);
6684   while (import)
6685     {
6686       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6687         {
6688           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6689           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6690           return;
6691         }
6692       import = TREE_CHAIN (import);
6693     }
6694 }
6695
6696 static int
6697 note_possible_classname (const char *name, int len)
6698 {
6699   tree node;
6700   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6701     len = len - 5;
6702   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6703     len = len - 6;
6704   else
6705     return 0;
6706   node = ident_subst (name, len, "", '/', '.', "");
6707   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6708   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6709   return 1;
6710 }
6711
6712 /* Read a import directory, gathering potential match for further type
6713    references. Indifferently reads a filesystem or a ZIP archive
6714    directory.  */
6715
6716 static void
6717 read_import_dir (tree wfl)
6718 {
6719   tree package_id = EXPR_WFL_NODE (wfl);
6720   const char *package_name = IDENTIFIER_POINTER (package_id);
6721   int package_length = IDENTIFIER_LENGTH (package_id);
6722   DIR *dirp = NULL;
6723   JCF *saved_jcf = current_jcf;
6724
6725   int found = 0;
6726   int k;
6727   void *entry;
6728   struct buffer filename[1];
6729
6730   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6731     return;
6732   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6733
6734   BUFFER_INIT (filename);
6735   buffer_grow (filename, package_length + 100);
6736
6737   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6738     {
6739       const char *entry_name = jcf_path_name (entry);
6740       int entry_length = strlen (entry_name);
6741       if (jcf_path_is_zipfile (entry))
6742         {
6743           ZipFile *zipf;
6744           buffer_grow (filename, entry_length);
6745           memcpy (filename->data, entry_name, entry_length - 1);
6746           filename->data[entry_length-1] = '\0';
6747           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6748           if (zipf == NULL)
6749             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6750           else
6751             {
6752               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6753               BUFFER_RESET (filename);
6754               for (k = 0; k < package_length; k++)
6755                 {
6756                   char ch = package_name[k];
6757                   *filename->ptr++ = ch == '.' ? '/' : ch;
6758                 }
6759               *filename->ptr++ = '/';
6760
6761               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6762                 {
6763                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6764                   int current_entry_len = zipd->filename_length;
6765
6766                   if (current_entry_len >= BUFFER_LENGTH (filename)
6767                       && strncmp (filename->data, current_entry,
6768                                   BUFFER_LENGTH (filename)) != 0)
6769                     continue;
6770                   found |= note_possible_classname (current_entry,
6771                                                     current_entry_len);
6772                 }
6773             }
6774         }
6775       else
6776         {
6777           BUFFER_RESET (filename);
6778           buffer_grow (filename, entry_length + package_length + 4);
6779           strcpy (filename->data, entry_name);
6780           filename->ptr = filename->data + entry_length;
6781           for (k = 0; k < package_length; k++)
6782             {
6783               char ch = package_name[k];
6784               *filename->ptr++ = ch == '.' ? '/' : ch;
6785             }
6786           *filename->ptr = '\0';
6787
6788           dirp = opendir (filename->data);
6789           if (dirp == NULL)
6790             continue;
6791           *filename->ptr++ = '/';
6792           for (;;)
6793             {
6794               int len;
6795               const char *d_name;
6796               struct dirent *direntp = readdir (dirp);
6797               if (!direntp)
6798                 break;
6799               d_name = direntp->d_name;
6800               len = strlen (direntp->d_name);
6801               buffer_grow (filename, len+1);
6802               strcpy (filename->ptr, d_name);
6803               found |= note_possible_classname (filename->data + entry_length,
6804                                                 package_length+len+1);
6805             }
6806           if (dirp)
6807             closedir (dirp);
6808         }
6809     }
6810
6811   free (filename->data);
6812
6813   /* Here we should have a unified way of retrieving an entry, to be
6814      indexed. */
6815   if (!found)
6816     {
6817       static int first = 1;
6818       if (first)
6819         {
6820           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6821           java_error_count++;
6822           first = 0;
6823         }
6824       else
6825         parse_error_context (wfl, "Package `%s' not found in import",
6826                              package_name);
6827       current_jcf = saved_jcf;
6828       return;
6829     }
6830   current_jcf = saved_jcf;
6831 }
6832
6833 /* Possibly find a type in the import on demands specified
6834    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6835    entire list, to detected potential double definitions.  */
6836
6837 static int
6838 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6839 {
6840   tree class_type_name = TYPE_NAME (class_type);
6841   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
6842                   ctxp->import_demand_list);
6843   tree cl = NULL_TREE;
6844   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
6845   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
6846   tree node;
6847
6848   for (; import; import = TREE_CHAIN (import))
6849     {
6850       int saved_lineno = lineno;
6851       int access_check;
6852       const char *id_name;
6853       tree decl, type_name_copy;
6854
6855       obstack_grow (&temporary_obstack,
6856                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6857                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6858       obstack_1grow (&temporary_obstack, '.');
6859       obstack_grow0 (&temporary_obstack,
6860                      IDENTIFIER_POINTER (class_type_name),
6861                      IDENTIFIER_LENGTH (class_type_name));
6862       id_name = obstack_finish (&temporary_obstack);
6863
6864       if (! (node = maybe_get_identifier (id_name)))
6865         continue;
6866
6867       /* Setup lineno so that it refers to the line of the import (in
6868          case we parse a class file and encounter errors */
6869       lineno = EXPR_WFL_LINENO (TREE_PURPOSE (import));
6870
6871       type_name_copy = TYPE_NAME (class_type);
6872       TYPE_NAME (class_type) = node;
6873       QUALIFIED_P (node) = 1;
6874       decl = IDENTIFIER_CLASS_VALUE (node);
6875       access_check = -1;
6876       /* If there is no DECL set for the class or if the class isn't
6877          loaded and not seen in source yet, then load */
6878       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
6879                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
6880         {
6881           load_class (node, 0);
6882           decl = IDENTIFIER_CLASS_VALUE (node);
6883         }
6884       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
6885         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
6886                                                false);
6887       else
6888         /* 6.6.1: Inner classes are subject to member access rules. */
6889         access_check = 0;
6890
6891       lineno = saved_lineno;
6892
6893       /* If the loaded class is not accessible or couldn't be loaded,
6894          we restore the original TYPE_NAME and process the next
6895          import. */
6896       if (access_check || !decl)
6897         {
6898           TYPE_NAME (class_type) = type_name_copy;
6899           continue;
6900         }
6901
6902       /* If the loaded class is accessible, we keep a tab on it to
6903          detect and report multiple inclusions. */
6904       if (IS_A_CLASSFILE_NAME (node))
6905         {
6906           if (seen_once < 0)
6907             {
6908               cl = TREE_PURPOSE (import);
6909               seen_once = 1;
6910             }
6911           else if (seen_once >= 0)
6912             {
6913               tree location = (cl ? cl : TREE_PURPOSE (import));
6914               tree package = (cl ? EXPR_WFL_NODE (cl) :
6915                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
6916               seen_once++;
6917               parse_error_context
6918                 (location,
6919                  "Type `%s' also potentially defined in package `%s'",
6920                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6921                  IDENTIFIER_POINTER (package));
6922             }
6923         }
6924       to_return = access_check;
6925     }
6926
6927   if (seen_once == 1)
6928     return to_return;
6929   else
6930     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
6931 }
6932
6933 /* Add package NAME to the list of packages encountered so far. To
6934    speed up class lookup in do_resolve_class, we make sure a
6935    particular package is added only once.  */
6936
6937 static void
6938 register_package (tree name)
6939 {
6940   static htab_t pht;
6941   void **e;
6942
6943   if (pht == NULL)
6944     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
6945
6946   e = htab_find_slot (pht, name, INSERT);
6947   if (*e == NULL)
6948     {
6949       package_list = chainon (package_list, build_tree_list (name, NULL));
6950       *e = name;
6951     }
6952 }
6953
6954 static tree
6955 resolve_package (tree pkg, tree *next, tree *type_name)
6956 {
6957   tree current;
6958   tree decl = NULL_TREE;
6959   *type_name = NULL_TREE;
6960
6961   /* The trick is to determine when the package name stops and were
6962      the name of something contained in the package starts. Then we
6963      return a fully qualified name of what we want to get. */
6964
6965   *next = EXPR_WFL_QUALIFICATION (pkg);
6966
6967   /* Try to progressively construct a type name */
6968   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
6969     for (current = EXPR_WFL_QUALIFICATION (pkg);
6970          current; current = TREE_CHAIN (current))
6971       {
6972         /* If we don't have what we're expecting, exit now. TYPE_NAME
6973            will be null and the error caught later. */
6974         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
6975           break;
6976         *type_name =
6977           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
6978         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
6979           {
6980             /* resolve_package should be used in a loop, hence we
6981                point at this one to naturally process the next one at
6982                the next iteration. */
6983             *next = current;
6984             break;
6985           }
6986       }
6987   return decl;
6988 }
6989
6990
6991 /* Check accessibility of inner classes according to member access rules.
6992    DECL is the inner class, ENCLOSING_DECL is the class from which the
6993    access is being attempted. */
6994
6995 static void
6996 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
6997 {
6998   const char *access;
6999   tree enclosing_decl_type;
7000
7001   /* We don't issue an error message when CL is null. CL can be null
7002      as a result of processing a JDEP crafted by source_start_java_method
7003      for the purpose of patching its parm decl. But the error would
7004      have been already trapped when fixing the method's signature.
7005      DECL can also be NULL in case of earlier errors. */
7006   if (!decl || !cl)
7007     return;
7008
7009   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7010
7011   if (CLASS_PRIVATE (decl))
7012     {
7013       /* Access is permitted only within the body of the top-level
7014          class in which DECL is declared. */
7015       tree top_level = decl;
7016       while (DECL_CONTEXT (top_level))
7017         top_level = DECL_CONTEXT (top_level);
7018       while (DECL_CONTEXT (enclosing_decl))
7019         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7020       if (top_level == enclosing_decl)
7021         return;
7022       access = "private";
7023     }
7024   else if (CLASS_PROTECTED (decl))
7025     {
7026       tree decl_context;
7027       /* Access is permitted from within the same package... */
7028       if (in_same_package (decl, enclosing_decl))
7029         return;
7030
7031       /* ... or from within the body of a subtype of the context in which
7032          DECL is declared. */
7033       decl_context = DECL_CONTEXT (decl);
7034       while (enclosing_decl)
7035         {
7036           if (CLASS_INTERFACE (decl))
7037             {
7038               if (interface_of_p (TREE_TYPE (decl_context),
7039                                   enclosing_decl_type))
7040                 return;
7041             }
7042           else
7043             {
7044               /* Eww. The order of the arguments is different!! */
7045               if (inherits_from_p (enclosing_decl_type,
7046                                    TREE_TYPE (decl_context)))
7047                 return;
7048             }
7049           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7050         }
7051       access = "protected";
7052     }
7053   else if (! CLASS_PUBLIC (decl))
7054     {
7055       /* Access is permitted only from within the same package as DECL. */
7056       if (in_same_package (decl, enclosing_decl))
7057         return;
7058       access = "non-public";
7059     }
7060   else
7061     /* Class is public. */
7062     return;
7063
7064   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7065                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7066                        lang_printable_name (decl, 0), access);
7067 }
7068
7069 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7070    foreign package, it must be PUBLIC. Return 0 if no access
7071    violations were found, 1 otherwise. If VERBOSE is true and an error
7072    was found, it is reported and accounted for.  */
7073
7074 static int
7075 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7076 {
7077   tree type;
7078
7079   if (!IDENTIFIER_CLASS_VALUE (class_name))
7080     return 0;
7081
7082   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7083     return 0;
7084
7085   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7086     {
7087       /* Access to a private class within the same package is
7088          allowed. */
7089       tree l, r;
7090       breakdown_qualified (&l, &r, class_name);
7091       if (!QUALIFIED_P (class_name) && !ctxp->package)
7092         /* Both in the empty package. */
7093         return 0;
7094       if (l == ctxp->package)
7095         /* Both in the same package. */
7096         return 0;
7097
7098       if (verbose)
7099         parse_error_context
7100           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7101            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7102            IDENTIFIER_POINTER (class_name));
7103       return 1;
7104     }
7105   return 0;
7106 }
7107
7108 /* Local variable declaration. */
7109
7110 static void
7111 declare_local_variables (int modifier, tree type, tree vlist)
7112 {
7113   tree decl, current, saved_type;
7114   tree type_wfl = NULL_TREE;
7115   int must_chain = 0;
7116   int final_p = 0;
7117
7118   /* Push a new block if statements were seen between the last time we
7119      pushed a block and now. Keep a count of blocks to close */
7120   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7121     {
7122       tree b = enter_block ();
7123       BLOCK_IS_IMPLICIT (b) = 1;
7124     }
7125
7126   if (modifier)
7127     {
7128       size_t i;
7129       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7130         if (1 << i & modifier)
7131           break;
7132       if (modifier == ACC_FINAL)
7133         final_p = 1;
7134       else
7135         {
7136           parse_error_context
7137             (ctxp->modifier_ctx [i],
7138              "Only `final' is allowed as a local variables modifier");
7139           return;
7140         }
7141     }
7142
7143   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7144      hold the TYPE value if a new incomplete has to be created (as
7145      opposed to being found already existing and reused). */
7146   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7147
7148   /* If TYPE is fully resolved and we don't have a reference, make one */
7149   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7150
7151   /* Go through all the declared variables */
7152   for (current = vlist, saved_type = type; current;
7153        current = TREE_CHAIN (current), type = saved_type)
7154     {
7155       tree other, real_type;
7156       tree wfl  = TREE_PURPOSE (current);
7157       tree name = EXPR_WFL_NODE (wfl);
7158       tree init = TREE_VALUE (current);
7159
7160       /* Process NAME, as it may specify extra dimension(s) for it */
7161       type = build_array_from_name (type, type_wfl, name, &name);
7162
7163       /* Variable redefinition check */
7164       if ((other = lookup_name_in_blocks (name)))
7165         {
7166           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7167                                        DECL_SOURCE_LINE (other));
7168           continue;
7169         }
7170
7171       /* Type adjustment. We may have just readjusted TYPE because
7172          the variable specified more dimensions. Make sure we have
7173          a reference if we can and don't have one already. */
7174       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7175
7176       real_type = GET_REAL_TYPE (type);
7177       /* Never layout this decl. This will be done when its scope
7178          will be entered */
7179       decl = build_decl (VAR_DECL, name, real_type);
7180       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7181       DECL_FINAL (decl) = final_p;
7182       BLOCK_CHAIN_DECL (decl);
7183
7184       /* If doing xreferencing, replace the line number with the WFL
7185          compound value */
7186       if (flag_emit_xref)
7187         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7188
7189       /* Don't try to use an INIT statement when an error was found */
7190       if (init && java_error_count)
7191         init = NULL_TREE;
7192
7193       /* Add the initialization function to the current function's code */
7194       if (init)
7195         {
7196           /* Name might have been readjusted */
7197           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7198           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7199           java_method_add_stmt (current_function_decl,
7200                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7201                                                       init));
7202         }
7203
7204       /* Setup dependency the type of the decl */
7205       if (must_chain)
7206         {
7207           jdep *dep;
7208           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7209           dep = CLASSD_LAST (ctxp->classd_list);
7210           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7211         }
7212     }
7213   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7214 }
7215
7216 /* Called during parsing. Build decls from argument list.  */
7217
7218 static void
7219 source_start_java_method (tree fndecl)
7220 {
7221   tree tem;
7222   tree parm_decl;
7223   int i;
7224
7225   if (!fndecl)
7226     return;
7227
7228   current_function_decl = fndecl;
7229
7230   /* New scope for the function */
7231   enter_block ();
7232   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7233        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7234     {
7235       tree type = TREE_VALUE (tem);
7236       tree name = TREE_PURPOSE (tem);
7237
7238       /* If type is incomplete. Create an incomplete decl and ask for
7239          the decl to be patched later */
7240       if (INCOMPLETE_TYPE_P (type))
7241         {
7242           jdep *jdep;
7243           tree real_type = GET_REAL_TYPE (type);
7244           parm_decl = build_decl (PARM_DECL, name, real_type);
7245           type = obtain_incomplete_type (type);
7246           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7247           jdep = CLASSD_LAST (ctxp->classd_list);
7248           JDEP_MISC (jdep) = name;
7249           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7250         }
7251       else
7252         parm_decl = build_decl (PARM_DECL, name, type);
7253
7254       /* Remember if a local variable was declared final (via its
7255          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7256       if (ARG_FINAL_P (tem))
7257         {
7258           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7259           DECL_FINAL (parm_decl) = 1;
7260         }
7261
7262       BLOCK_CHAIN_DECL (parm_decl);
7263     }
7264   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7265   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7266     nreverse (tem);
7267   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7268   DECL_MAX_LOCALS (current_function_decl) = i;
7269 }
7270
7271 /* Called during parsing. Creates an artificial method declaration.  */
7272
7273 static tree
7274 create_artificial_method (tree class, int flags, tree type,
7275                           tree name, tree args)
7276 {
7277   tree mdecl;
7278
7279   java_parser_context_save_global ();
7280   lineno = 0;
7281   mdecl = make_node (FUNCTION_TYPE);
7282   TREE_TYPE (mdecl) = type;
7283   TYPE_ARG_TYPES (mdecl) = args;
7284   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7285   java_parser_context_restore_global ();
7286   DECL_ARTIFICIAL (mdecl) = 1;
7287   return mdecl;
7288 }
7289
7290 /* Starts the body if an artificial method.  */
7291
7292 static void
7293 start_artificial_method_body (tree mdecl)
7294 {
7295   DECL_SOURCE_LINE (mdecl) = 1;
7296   DECL_SOURCE_LINE_MERGE (mdecl, 1);
7297   source_start_java_method (mdecl);
7298   enter_block ();
7299 }
7300
7301 static void
7302 end_artificial_method_body (tree mdecl)
7303 {
7304   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7305      It has to be evaluated first. (if mdecl is current_function_decl,
7306      we have an undefined behavior if no temporary variable is used.) */
7307   tree b = exit_block ();
7308   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7309   exit_block ();
7310 }
7311
7312 /* Dump a tree of some kind.  This is a convenience wrapper for the
7313    dump_* functions in tree-dump.c.  */
7314 static void
7315 dump_java_tree (enum tree_dump_index phase, tree t)
7316 {
7317   FILE *stream;
7318   int flags;
7319
7320   stream = dump_begin (phase, &flags);
7321   flags |= TDF_SLIM;
7322   if (stream)
7323     {
7324       dump_node (t, flags, stream);
7325       dump_end (phase, stream);
7326     }
7327 }
7328
7329 /* Terminate a function and expand its body.  */
7330
7331 static void
7332 source_end_java_method (void)
7333 {
7334   tree fndecl = current_function_decl;
7335
7336   if (!fndecl)
7337     return;
7338
7339   java_parser_context_save_global ();
7340   lineno = ctxp->last_ccb_indent1;
7341
7342   /* Turn function bodies with only a NOP expr null, so they don't get
7343      generated at all and we won't get warnings when using the -W
7344      -Wall flags. */
7345   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7346     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7347
7348   /* We've generated all the trees for this function, and it has been
7349      patched.  Dump it to a file if the user requested it.  */
7350   dump_java_tree (TDI_original, fndecl);
7351
7352   java_optimize_inline (fndecl);
7353
7354   /* Generate function's code */
7355   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7356       && ! flag_emit_class_files
7357       && ! flag_emit_xref)
7358     expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
7359
7360   /* pop out of its parameters */
7361   pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7362   poplevel (1, 0, 1);
7363   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7364
7365   /* Generate rtl for function exit.  */
7366   if (! flag_emit_class_files && ! flag_emit_xref)
7367     {
7368       lineno = DECL_SOURCE_LINE_LAST (fndecl);
7369       expand_function_end (input_filename, lineno, 0);
7370
7371       DECL_SOURCE_LINE (fndecl) = DECL_SOURCE_LINE_FIRST (fndecl);
7372
7373       /* Run the optimizers and output assembler code for this function. */
7374       rest_of_compilation (fndecl);
7375     }
7376
7377   current_function_decl = NULL_TREE;
7378   java_parser_context_restore_global ();
7379 }
7380
7381 /* Record EXPR in the current function block. Complements compound
7382    expression second operand if necessary.  */
7383
7384 tree
7385 java_method_add_stmt (tree fndecl, tree expr)
7386 {
7387   if (!GET_CURRENT_BLOCK (fndecl))
7388     return NULL_TREE;
7389   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7390 }
7391
7392 static tree
7393 add_stmt_to_block (tree b, tree type, tree stmt)
7394 {
7395   tree body = BLOCK_EXPR_BODY (b), c;
7396
7397   if (java_error_count)
7398     return body;
7399
7400   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7401     return body;
7402
7403   BLOCK_EXPR_BODY (b) = c;
7404   TREE_SIDE_EFFECTS (c) = 1;
7405   return c;
7406 }
7407
7408 /* Add STMT to EXISTING if possible, otherwise create a new
7409    COMPOUND_EXPR and add STMT to it. */
7410
7411 static tree
7412 add_stmt_to_compound (tree existing, tree type, tree stmt)
7413 {
7414   /* Keep track of this for inlining.  */
7415   if (current_function_decl)
7416     ++DECL_NUM_STMTS (current_function_decl);
7417
7418   if (existing)
7419     return build (COMPOUND_EXPR, type, existing, stmt);
7420   else
7421     return stmt;
7422 }
7423
7424 void java_layout_seen_class_methods (void)
7425 {
7426   tree previous_list = all_class_list;
7427   tree end = NULL_TREE;
7428   tree current;
7429
7430   while (1)
7431     {
7432       for (current = previous_list;
7433            current != end; current = TREE_CHAIN (current))
7434         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7435
7436       if (previous_list != all_class_list)
7437         {
7438           end = previous_list;
7439           previous_list = all_class_list;
7440         }
7441       else
7442         break;
7443     }
7444 }
7445
7446 static GTY(()) tree stop_reordering;
7447 void
7448 java_reorder_fields (void)
7449 {
7450   tree current;
7451
7452   for (current = gclass_list; current; current = TREE_CHAIN (current))
7453     {
7454       current_class = TREE_TYPE (TREE_VALUE (current));
7455
7456       if (current_class == stop_reordering)
7457         break;
7458
7459       /* Reverse the fields, but leave the dummy field in front.
7460          Fields are already ordered for Object and Class */
7461       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7462           && current_class != class_type_node)
7463       {
7464         /* If the dummy field is there, reverse the right fields and
7465            just layout the type for proper fields offset */
7466         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7467           {
7468             tree fields = TYPE_FIELDS (current_class);
7469             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7470             TYPE_SIZE (current_class) = NULL_TREE;
7471           }
7472         /* We don't have a dummy field, we need to layout the class,
7473            after having reversed the fields */
7474         else
7475           {
7476             TYPE_FIELDS (current_class) =
7477               nreverse (TYPE_FIELDS (current_class));
7478             TYPE_SIZE (current_class) = NULL_TREE;
7479           }
7480       }
7481     }
7482   /* There are cases were gclass_list will be empty. */
7483   if (gclass_list)
7484     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7485 }
7486
7487 /* Layout the methods of all classes loaded in one way or another.
7488    Check methods of source parsed classes. Then reorder the
7489    fields and layout the classes or the type of all source parsed
7490    classes */
7491
7492 void
7493 java_layout_classes (void)
7494 {
7495   tree current;
7496   int save_error_count = java_error_count;
7497
7498   /* Layout the methods of all classes seen so far */
7499   java_layout_seen_class_methods ();
7500   java_parse_abort_on_error ();
7501   all_class_list = NULL_TREE;
7502
7503   /* Then check the methods of all parsed classes */
7504   for (current = gclass_list; current; current = TREE_CHAIN (current))
7505     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7506       java_check_methods (TREE_VALUE (current));
7507   java_parse_abort_on_error ();
7508
7509   for (current = gclass_list; current; current = TREE_CHAIN (current))
7510     {
7511       current_class = TREE_TYPE (TREE_VALUE (current));
7512       layout_class (current_class);
7513
7514       /* Error reported by the caller */
7515       if (java_error_count)
7516         return;
7517     }
7518
7519   /* We might have reloaded classes durign the process of laying out
7520      classes for code generation. We must layout the methods of those
7521      late additions, as constructor checks might use them */
7522   java_layout_seen_class_methods ();
7523   java_parse_abort_on_error ();
7524 }
7525
7526 /* Expand methods in the current set of classes rememebered for
7527    generation.  */
7528
7529 static void
7530 java_complete_expand_classes (void)
7531 {
7532   tree current;
7533
7534   do_not_fold = flag_emit_xref;
7535
7536   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7537     if (!INNER_CLASS_DECL_P (current))
7538       java_complete_expand_class (current);
7539 }
7540
7541 /* Expand the methods found in OUTER, starting first by OUTER's inner
7542    classes, if any.  */
7543
7544 static void
7545 java_complete_expand_class (tree outer)
7546 {
7547   tree inner_list;
7548
7549   set_nested_class_simple_name_value (outer, 1); /* Set */
7550
7551   /* We need to go after all inner classes and start expanding them,
7552      starting with most nested ones. We have to do that because nested
7553      classes might add functions to outer classes */
7554
7555   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7556        inner_list; inner_list = TREE_CHAIN (inner_list))
7557     java_complete_expand_class (TREE_PURPOSE (inner_list));
7558
7559   java_complete_expand_methods (outer);
7560   set_nested_class_simple_name_value (outer, 0); /* Reset */
7561 }
7562
7563 /* Expand methods registered in CLASS_DECL. The general idea is that
7564    we expand regular methods first. This allows us get an estimate on
7565    how outer context local alias fields are really used so we can add
7566    to the constructor just enough code to initialize them properly (it
7567    also lets us generate finit$ correctly.) Then we expand the
7568    constructors and then <clinit>.  */
7569
7570 static void
7571 java_complete_expand_methods (tree class_decl)
7572 {
7573   tree clinit, decl, first_decl;
7574
7575   current_class = TREE_TYPE (class_decl);
7576
7577   /* Initialize a new constant pool */
7578   init_outgoing_cpool ();
7579
7580   /* Pre-expand <clinit> to figure whether we really need it or
7581      not. If we do need it, we pre-expand the static fields so they're
7582      ready to be used somewhere else. <clinit> will be fully expanded
7583      after we processed the constructors. */
7584   first_decl = TYPE_METHODS (current_class);
7585   clinit = maybe_generate_pre_expand_clinit (current_class);
7586
7587   /* Then generate finit$ (if we need to) because constructors will
7588    try to use it.*/
7589   if (TYPE_FINIT_STMT_LIST (current_class))
7590     java_complete_expand_method (generate_finit (current_class));
7591
7592   /* Then generate instinit$ (if we need to) because constructors will
7593      try to use it. */
7594   if (TYPE_II_STMT_LIST (current_class))
7595     java_complete_expand_method (generate_instinit (current_class));
7596
7597   /* Now do the constructors */
7598   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7599     {
7600       int no_body;
7601
7602       if (!DECL_CONSTRUCTOR_P (decl))
7603         continue;
7604
7605       no_body = !DECL_FUNCTION_BODY (decl);
7606       /* Don't generate debug info on line zero when expanding a
7607          generated constructor. */
7608       if (no_body)
7609         restore_line_number_status (1);
7610
7611       java_complete_expand_method (decl);
7612
7613       if (no_body)
7614         restore_line_number_status (0);
7615     }
7616
7617   /* First, do the ordinary methods. */
7618   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7619     {
7620       /* Ctors aren't part of this batch. */
7621       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7622         continue;
7623
7624       /* Skip abstract or native methods -- but do handle native
7625          methods when generating JNI stubs.  */
7626       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7627         {
7628           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7629           continue;
7630         }
7631
7632       if (METHOD_NATIVE (decl))
7633         {
7634           tree body;
7635           current_function_decl = decl;
7636           body = build_jni_stub (decl);
7637           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7638         }
7639
7640       java_complete_expand_method (decl);
7641     }
7642
7643   /* If there is indeed a <clinit>, fully expand it now */
7644   if (clinit)
7645     {
7646       /* Prevent the use of `this' inside <clinit> */
7647       ctxp->explicit_constructor_p = 1;
7648       java_complete_expand_method (clinit);
7649       ctxp->explicit_constructor_p = 0;
7650     }
7651
7652   /* We might have generated a class$ that we now want to expand */
7653   if (TYPE_DOT_CLASS (current_class))
7654     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7655
7656   /* Now verify constructor circularity (stop after the first one we
7657      prove wrong.) */
7658   if (!CLASS_INTERFACE (class_decl))
7659     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7660       if (DECL_CONSTRUCTOR_P (decl)
7661           && verify_constructor_circularity (decl, decl))
7662         break;
7663
7664   /* Save the constant pool. We'll need to restore it later. */
7665   TYPE_CPOOL (current_class) = outgoing_cpool;
7666 }
7667
7668 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7669    safely used in some other methods/constructors.  */
7670
7671 static tree
7672 maybe_generate_pre_expand_clinit (tree class_type)
7673 {
7674   tree current, mdecl;
7675
7676   if (!TYPE_CLINIT_STMT_LIST (class_type))
7677     return NULL_TREE;
7678
7679   /* Go through all static fields and pre expand them */
7680   for (current = TYPE_FIELDS (class_type); current;
7681        current = TREE_CHAIN (current))
7682     if (FIELD_STATIC (current))
7683       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7684
7685   /* Then build the <clinit> method */
7686   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7687                                     clinit_identifier_node, end_params_node);
7688   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7689                        mdecl, NULL_TREE);
7690   start_artificial_method_body (mdecl);
7691
7692   /* We process the list of assignment we produced as the result of
7693      the declaration of initialized static field and add them as
7694      statement to the <clinit> method. */
7695   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7696        current = TREE_CHAIN (current))
7697     {
7698       tree stmt = current;
7699       /* We build the assignment expression that will initialize the
7700          field to its value. There are strict rules on static
7701          initializers (8.5). FIXME */
7702       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7703         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7704       java_method_add_stmt (mdecl, stmt);
7705     }
7706
7707   end_artificial_method_body (mdecl);
7708
7709   /* Now we want to place <clinit> as the last method (because we need
7710      it at least for interface so that it doesn't interfere with the
7711      dispatch table based lookup. */
7712   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7713     {
7714       current = TREE_CHAIN (TYPE_METHODS (class_type));
7715       TYPE_METHODS (class_type) = current;
7716
7717       while (TREE_CHAIN (current))
7718         current = TREE_CHAIN (current);
7719
7720       TREE_CHAIN (current) = mdecl;
7721       TREE_CHAIN (mdecl) = NULL_TREE;
7722     }
7723
7724   return mdecl;
7725 }
7726
7727 /* Analyzes a method body and look for something that isn't a
7728    MODIFY_EXPR with a constant value.  */
7729
7730 static int
7731 analyze_clinit_body (tree this_class, tree bbody)
7732 {
7733   while (bbody)
7734     switch (TREE_CODE (bbody))
7735       {
7736       case BLOCK:
7737         bbody = BLOCK_EXPR_BODY (bbody);
7738         break;
7739
7740       case EXPR_WITH_FILE_LOCATION:
7741         bbody = EXPR_WFL_NODE (bbody);
7742         break;
7743
7744       case COMPOUND_EXPR:
7745         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7746           return 1;
7747         bbody = TREE_OPERAND (bbody, 1);
7748         break;
7749
7750       case MODIFY_EXPR:
7751         /* If we're generating to class file and we're dealing with an
7752            array initialization, we return 1 to keep <clinit> */
7753         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7754             && flag_emit_class_files)
7755           return 1;
7756
7757         /* There are a few cases where we're required to keep
7758            <clinit>:
7759            - If this is an assignment whose operand is not constant,
7760            - If this is an assignment to a non-initialized field,
7761            - If this field is not a member of the current class.
7762         */
7763         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7764                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7765                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7766
7767       default:
7768         return 1;
7769       }
7770   return 0;
7771 }
7772
7773
7774 /* See whether we could get rid of <clinit>. Criteria are: all static
7775    final fields have constant initial values and the body of <clinit>
7776    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7777
7778 static int
7779 maybe_yank_clinit (tree mdecl)
7780 {
7781   tree type, current;
7782   tree fbody, bbody;
7783
7784   if (!DECL_CLINIT_P (mdecl))
7785     return 0;
7786
7787   /* If the body isn't empty, then we keep <clinit>. Note that if
7788      we're emitting classfiles, this isn't enough not to rule it
7789      out. */
7790   fbody = DECL_FUNCTION_BODY (mdecl);
7791   bbody = BLOCK_EXPR_BODY (fbody);
7792   if (bbody && bbody != error_mark_node)
7793     bbody = BLOCK_EXPR_BODY (bbody);
7794   else
7795     return 0;
7796   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7797     return 0;
7798
7799   type = DECL_CONTEXT (mdecl);
7800   current = TYPE_FIELDS (type);
7801
7802   for (current = (current ? TREE_CHAIN (current) : current);
7803        current; current = TREE_CHAIN (current))
7804     {
7805       tree f_init;
7806
7807       /* We're not interested in non-static fields.  */
7808       if (!FIELD_STATIC (current))
7809         continue;
7810
7811       /* Nor in fields without initializers. */
7812       f_init = DECL_INITIAL (current);
7813       if (f_init == NULL_TREE)
7814         continue;
7815
7816       /* Anything that isn't String or a basic type is ruled out -- or
7817          if we know how to deal with it (when doing things natively) we
7818          should generated an empty <clinit> so that SUID are computed
7819          correctly. */
7820       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7821           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7822         return 0;
7823
7824       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7825         return 0;
7826     }
7827
7828   /* Now we analyze the method body and look for something that
7829      isn't a MODIFY_EXPR */
7830   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7831     return 0;
7832
7833   /* Get rid of <clinit> in the class' list of methods */
7834   if (TYPE_METHODS (type) == mdecl)
7835     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7836   else
7837     for (current = TYPE_METHODS (type); current;
7838          current = TREE_CHAIN (current))
7839       if (TREE_CHAIN (current) == mdecl)
7840         {
7841           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7842           break;
7843         }
7844
7845   return 1;
7846 }
7847
7848 /* Install the argument from MDECL. Suitable to completion and
7849    expansion of mdecl's body.  */
7850
7851 static void
7852 start_complete_expand_method (tree mdecl)
7853 {
7854   tree tem;
7855
7856   pushlevel (1);                /* Prepare for a parameter push */
7857   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7858   DECL_ARGUMENTS (mdecl) = tem;
7859
7860   for (; tem; tem = TREE_CHAIN (tem))
7861     {
7862       /* TREE_CHAIN (tem) will change after pushdecl. */
7863       tree next = TREE_CHAIN (tem);
7864       tree type = TREE_TYPE (tem);
7865       if (PROMOTE_PROTOTYPES
7866           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7867           && INTEGRAL_TYPE_P (type))
7868         type = integer_type_node;
7869       DECL_ARG_TYPE (tem) = type;
7870       layout_decl (tem, 0);
7871       pushdecl (tem);
7872       /* Re-install the next so that the list is kept and the loop
7873          advances. */
7874       TREE_CHAIN (tem) = next;
7875     }
7876   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7877   lineno = DECL_SOURCE_LINE_FIRST (mdecl);
7878   build_result_decl (mdecl);
7879 }
7880
7881
7882 /* Complete and expand a method.  */
7883
7884 static void
7885 java_complete_expand_method (tree mdecl)
7886 {
7887   tree fbody, block_body, exception_copy;
7888
7889   current_function_decl = mdecl;
7890   /* Fix constructors before expanding them */
7891   if (DECL_CONSTRUCTOR_P (mdecl))
7892     fix_constructors (mdecl);
7893
7894   /* Expand functions that have a body */
7895   if (!DECL_FUNCTION_BODY (mdecl))
7896     return;
7897
7898   fbody = DECL_FUNCTION_BODY (mdecl);
7899   block_body = BLOCK_EXPR_BODY (fbody);
7900   exception_copy = NULL_TREE;
7901
7902   current_function_decl = mdecl;
7903
7904   if (! quiet_flag)
7905     fprintf (stderr, " [%s.",
7906              lang_printable_name (DECL_CONTEXT (mdecl), 0));
7907   announce_function (mdecl);
7908   if (! quiet_flag)
7909     fprintf (stderr, "]");
7910
7911   /* Prepare the function for tree completion */
7912   start_complete_expand_method (mdecl);
7913
7914   /* Install the current this */
7915   current_this = (!METHOD_STATIC (mdecl) ?
7916                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
7917
7918   /* Purge the `throws' list of unchecked exceptions (we save a copy
7919      of the list and re-install it later.) */
7920   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
7921   purge_unchecked_exceptions (mdecl);
7922
7923   /* Install exceptions thrown with `throws' */
7924   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
7925
7926   if (block_body != NULL_TREE)
7927     {
7928       block_body = java_complete_tree (block_body);
7929
7930       /* Before we check initialization, attached all class initialization
7931          variable to the block_body */
7932       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
7933                      attach_init_test_initialization_flags, block_body);
7934
7935       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
7936         {
7937           check_for_initialization (block_body, mdecl);
7938
7939           /* Go through all the flags marking the initialization of
7940              static variables and see whether they're definitively
7941              assigned, in which case the type is remembered as
7942              definitively initialized in MDECL. */
7943           if (STATIC_CLASS_INIT_OPT_P ())
7944             {
7945               /* Always register the context as properly initialized in
7946                  MDECL. This used with caution helps removing extra
7947                  initialization of self. */
7948               if (METHOD_STATIC (mdecl))
7949                 {
7950                   *(htab_find_slot
7951                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
7952                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
7953                 }
7954             }
7955         }
7956       ctxp->explicit_constructor_p = 0;
7957     }
7958
7959   BLOCK_EXPR_BODY (fbody) = block_body;
7960
7961   /* If we saw a return but couldn't evaluate it properly, we'll have
7962      an error_mark_node here. */
7963   if (block_body != error_mark_node
7964       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
7965       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
7966       && !flag_emit_xref)
7967     missing_return_error (current_function_decl);
7968
7969   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
7970   maybe_yank_clinit (mdecl);
7971
7972   /* Pop the current level, with special measures if we found errors. */
7973   if (java_error_count)
7974     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7975   poplevel (1, 0, 1);
7976
7977   /* Pop the exceptions and sanity check */
7978   POP_EXCEPTIONS();
7979   if (currently_caught_type_list)
7980     abort ();
7981
7982   /* Restore the copy of the list of exceptions if emitting xrefs. */
7983   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
7984 }
7985
7986 /* For with each class for which there's code to generate. */
7987
7988 static void
7989 java_expand_method_bodies (tree class)
7990 {
7991   tree decl;
7992   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
7993     {
7994       if (!DECL_FUNCTION_BODY (decl))
7995         continue;
7996
7997       current_function_decl = decl;
7998
7999       /* Save the function for inlining.  */
8000       if (flag_inline_trees)
8001         DECL_SAVED_TREE (decl) =
8002           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8003
8004       /* It's time to assign the variable flagging static class
8005          initialization based on which classes invoked static methods
8006          are definitely initializing. This should be flagged. */
8007       if (STATIC_CLASS_INIT_OPT_P ())
8008         {
8009           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8010           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8011             {
8012               /* Executed for each statement calling a static function.
8013                  LIST is a TREE_LIST whose PURPOSE is the called function
8014                  and VALUE is a compound whose second operand can be patched
8015                  with static class initialization flag assignments.  */
8016
8017               tree called_method = TREE_PURPOSE (list);
8018               tree compound = TREE_VALUE (list);
8019               tree assignment_compound_list
8020                 = build_tree_list (called_method, NULL);
8021
8022               /* For each class definitely initialized in
8023                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8024                  assignment to the class initialization flag. */
8025               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8026                              emit_test_initialization,
8027                              assignment_compound_list);
8028
8029               if (TREE_VALUE (assignment_compound_list))
8030                 TREE_OPERAND (compound, 1)
8031                   = TREE_VALUE (assignment_compound_list);
8032             }
8033         }
8034
8035       /* Prepare the function for RTL expansion */
8036       start_complete_expand_method (decl);
8037
8038       /* Expand function start, generate initialization flag
8039          assignment, and handle synchronized methods. */
8040       complete_start_java_method (decl);
8041
8042       /* Expand the rest of the function body and terminate
8043          expansion. */
8044       source_end_java_method ();
8045     }
8046 }
8047
8048 \f
8049
8050 /* This section of the code deals with accessing enclosing context
8051    fields either directly by using the relevant access to this$<n> or
8052    by invoking an access method crafted for that purpose.  */
8053
8054 /* Build the necessary access from an inner class to an outer
8055    class. This routine could be optimized to cache previous result
8056    (decl, current_class and returned access).  When an access method
8057    needs to be generated, it always takes the form of a read. It might
8058    be later turned into a write by calling outer_field_access_fix.  */
8059
8060 static tree
8061 build_outer_field_access (tree id, tree decl)
8062 {
8063   tree access = NULL_TREE;
8064   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8065   tree decl_ctx = DECL_CONTEXT (decl);
8066
8067   /* If the immediate enclosing context of the current class is the
8068      field decl's class or inherits from it; build the access as
8069      `this$<n>.<field>'. Note that we will break the `private' barrier
8070      if we're not emitting bytecodes. */
8071   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8072       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8073     {
8074       tree thisn = build_current_thisn (current_class);
8075       access = make_qualified_primary (build_wfl_node (thisn),
8076                                        id, EXPR_WFL_LINECOL (id));
8077     }
8078   /* Otherwise, generate access methods to outer this and access the
8079      field (either using an access method or by direct access.) */
8080   else
8081     {
8082       int lc = EXPR_WFL_LINECOL (id);
8083
8084       /* Now we chain the required number of calls to the access$0 to
8085          get a hold to the enclosing instance we need, and then we
8086          build the field access. */
8087       access = build_access_to_thisn (current_class, decl_ctx, lc);
8088
8089       /* If the field is private and we're generating bytecode, then
8090          we generate an access method */
8091       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8092         {
8093           tree name = build_outer_field_access_methods (decl);
8094           access = build_outer_field_access_expr (lc, decl_ctx,
8095                                                   name, access, NULL_TREE);
8096         }
8097       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8098          Once again we break the `private' access rule from a foreign
8099          class. */
8100       else
8101         access = make_qualified_primary (access, id, lc);
8102     }
8103   return resolve_expression_name (access, NULL);
8104 }
8105
8106 /* Return a nonzero value if NODE describes an outer field inner
8107    access.  */
8108
8109 static int
8110 outer_field_access_p (tree type, tree decl)
8111 {
8112   if (!INNER_CLASS_TYPE_P (type)
8113       || TREE_CODE (decl) != FIELD_DECL
8114       || DECL_CONTEXT (decl) == type)
8115     return 0;
8116
8117   /* If the inner class extends the declaration context of the field
8118      we're try to acces, then this isn't an outer field access */
8119   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8120     return 0;
8121
8122   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8123        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8124     {
8125       if (type == DECL_CONTEXT (decl))
8126         return 1;
8127
8128       if (!DECL_CONTEXT (TYPE_NAME (type)))
8129         {
8130           /* Before we give up, see whether the field is inherited from
8131              the enclosing context we're considering. */
8132           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8133             return 1;
8134           break;
8135         }
8136     }
8137
8138   return 0;
8139 }
8140
8141 /* Return a nonzero value if NODE represents an outer field inner
8142    access that was been already expanded. As a side effect, it returns
8143    the name of the field being accessed and the argument passed to the
8144    access function, suitable for a regeneration of the access method
8145    call if necessary. */
8146
8147 static int
8148 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8149                                tree *arg)
8150 {
8151   int identified = 0;
8152
8153   if (TREE_CODE (node) != CALL_EXPR)
8154     return 0;
8155
8156   /* Well, gcj generates slightly different tree nodes when compiling
8157      to native or bytecodes. It's the case for function calls. */
8158
8159   if (flag_emit_class_files
8160       && TREE_CODE (node) == CALL_EXPR
8161       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8162     identified = 1;
8163   else if (!flag_emit_class_files)
8164     {
8165       node = TREE_OPERAND (node, 0);
8166
8167       if (node && TREE_OPERAND (node, 0)
8168           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8169         {
8170           node = TREE_OPERAND (node, 0);
8171           if (TREE_OPERAND (node, 0)
8172               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8173               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8174                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8175             identified = 1;
8176         }
8177     }
8178
8179   if (identified && name && arg_type && arg)
8180     {
8181       tree argument = TREE_OPERAND (node, 1);
8182       *name = DECL_NAME (TREE_OPERAND (node, 0));
8183       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8184       *arg = TREE_VALUE (argument);
8185     }
8186   return identified;
8187 }
8188
8189 /* Detect in NODE an outer field read access from an inner class and
8190    transform it into a write with RHS as an argument. This function is
8191    called from the java_complete_lhs when an assignment to a LHS can
8192    be identified. */
8193
8194 static tree
8195 outer_field_access_fix (tree wfl, tree node, tree rhs)
8196 {
8197   tree name, arg_type, arg;
8198
8199   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8200     {
8201       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8202                                             arg_type, name, arg, rhs);
8203       return java_complete_tree (node);
8204     }
8205   return NULL_TREE;
8206 }
8207
8208 /* Construct the expression that calls an access method:
8209      <type>.access$<n>(<arg1> [, <arg2>]);
8210
8211    ARG2 can be NULL and will be omitted in that case. It will denote a
8212    read access.  */
8213
8214 static tree
8215 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8216                                tree arg1, tree arg2)
8217 {
8218   tree args, cn, access;
8219
8220   args = arg1 ? arg1 :
8221     build_wfl_node (build_current_thisn (current_class));
8222   args = build_tree_list (NULL_TREE, args);
8223
8224   if (arg2)
8225     args = tree_cons (NULL_TREE, arg2, args);
8226
8227   access = build_method_invocation (build_wfl_node (access_method_name), args);
8228   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8229   return make_qualified_primary (cn, access, lc);
8230 }
8231
8232 static tree
8233 build_new_access_id (void)
8234 {
8235   static int access_n_counter = 1;
8236   char buffer [128];
8237
8238   sprintf (buffer, "access$%d", access_n_counter++);
8239   return get_identifier (buffer);
8240 }
8241
8242 /* Create the static access functions for the outer field DECL. We define a
8243    read:
8244      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8245        return inst$.field;
8246      }
8247    and a write access:
8248      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8249                                      TREE_TYPE (<field>) value$) {
8250        return inst$.field = value$;
8251      }
8252    We should have a usage flags on the DECL so we can lazily turn the ones
8253    we're using for code generation. FIXME.
8254 */
8255
8256 static tree
8257 build_outer_field_access_methods (tree decl)
8258 {
8259   tree id, args, stmt, mdecl;
8260
8261   if (FIELD_INNER_ACCESS_P (decl))
8262     return FIELD_INNER_ACCESS (decl);
8263
8264   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8265
8266   /* Create the identifier and a function named after it. */
8267   id = build_new_access_id ();
8268
8269   /* The identifier is marked as bearing the name of a generated write
8270      access function for outer field accessed from inner classes. */
8271   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8272
8273   /* Create the read access */
8274   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8275   TREE_CHAIN (args) = end_params_node;
8276   stmt = make_qualified_primary (build_wfl_node (inst_id),
8277                                  build_wfl_node (DECL_NAME (decl)), 0);
8278   stmt = build_return (0, stmt);
8279   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8280                                            TREE_TYPE (decl), id, args, stmt);
8281   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8282
8283   /* Create the write access method. No write access for final variable */
8284   if (!FIELD_FINAL (decl))
8285     {
8286       args = build_tree_list (inst_id,
8287                               build_pointer_type (DECL_CONTEXT (decl)));
8288       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8289       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8290       stmt = make_qualified_primary (build_wfl_node (inst_id),
8291                                      build_wfl_node (DECL_NAME (decl)), 0);
8292       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8293                                                 build_wfl_node (wpv_id)));
8294       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8295                                                TREE_TYPE (decl), id,
8296                                                args, stmt);
8297     }
8298   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8299
8300   /* Return the access name */
8301   return FIELD_INNER_ACCESS (decl) = id;
8302 }
8303
8304 /* Build an field access method NAME.  */
8305
8306 static tree
8307 build_outer_field_access_method (tree class, tree type, tree name,
8308                                  tree args, tree body)
8309 {
8310   tree saved_current_function_decl, mdecl;
8311
8312   /* Create the method */
8313   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8314   fix_method_argument_names (args, mdecl);
8315   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8316
8317   /* Attach the method body. */
8318   saved_current_function_decl = current_function_decl;
8319   start_artificial_method_body (mdecl);
8320   java_method_add_stmt (mdecl, body);
8321   end_artificial_method_body (mdecl);
8322   current_function_decl = saved_current_function_decl;
8323
8324   return mdecl;
8325 }
8326
8327 \f
8328 /* This section deals with building access function necessary for
8329    certain kinds of method invocation from inner classes.  */
8330
8331 static tree
8332 build_outer_method_access_method (tree decl)
8333 {
8334   tree saved_current_function_decl, mdecl;
8335   tree args = NULL_TREE, call_args = NULL_TREE;
8336   tree carg, id, body, class;
8337   char buffer [80];
8338   int parm_id_count = 0;
8339
8340   /* Test this abort with an access to a private field */
8341   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8342     abort ();
8343
8344   /* Check the cache first */
8345   if (DECL_FUNCTION_INNER_ACCESS (decl))
8346     return DECL_FUNCTION_INNER_ACCESS (decl);
8347
8348   class = DECL_CONTEXT (decl);
8349
8350   /* Obtain an access identifier and mark it */
8351   id = build_new_access_id ();
8352   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8353
8354   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8355   /* Create the arguments, as much as the original */
8356   for (; carg && carg != end_params_node;
8357        carg = TREE_CHAIN (carg))
8358     {
8359       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8360       args = chainon (args, build_tree_list (get_identifier (buffer),
8361                                              TREE_VALUE (carg)));
8362     }
8363   args = chainon (args, end_params_node);
8364
8365   /* Create the method */
8366   mdecl = create_artificial_method (class, ACC_STATIC,
8367                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8368   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8369   /* There is a potential bug here. We should be able to use
8370      fix_method_argument_names, but then arg names get mixed up and
8371      eventually a constructor will have its this$0 altered and the
8372      outer context won't be assignment properly. The test case is
8373      stub.java FIXME */
8374   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8375
8376   /* Attach the method body. */
8377   saved_current_function_decl = current_function_decl;
8378   start_artificial_method_body (mdecl);
8379
8380   /* The actual method invocation uses the same args. When invoking a
8381      static methods that way, we don't want to skip the first
8382      argument. */
8383   carg = args;
8384   if (!METHOD_STATIC (decl))
8385     carg = TREE_CHAIN (carg);
8386   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8387     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8388                            call_args);
8389
8390   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8391                                   call_args);
8392   if (!METHOD_STATIC (decl))
8393     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8394                                    body, 0);
8395   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8396     body = build_return (0, body);
8397   java_method_add_stmt (mdecl,body);
8398   end_artificial_method_body (mdecl);
8399   current_function_decl = saved_current_function_decl;
8400
8401   /* Back tag the access function so it know what it accesses */
8402   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8403
8404   /* Tag the current method so it knows it has an access generated */
8405   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8406 }
8407
8408 \f
8409 /* This section of the code deals with building expressions to access
8410    the enclosing instance of an inner class. The enclosing instance is
8411    kept in a generated field called this$<n>, with <n> being the
8412    inner class nesting level (starting from 0.)  */
8413
8414 /* Build an access to a given this$<n>, always chaining access call to
8415    others. Access methods to this$<n> are build on the fly if
8416    necessary. This CAN'T be used to solely access this$<n-1> from
8417    this$<n> (which alway yield to special cases and optimization, see
8418    for example build_outer_field_access).  */
8419
8420 static tree
8421 build_access_to_thisn (tree from, tree to, int lc)
8422 {
8423   tree access = NULL_TREE;
8424
8425   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8426     {
8427       if (!access)
8428         {
8429           access = build_current_thisn (from);
8430           access = build_wfl_node (access);
8431         }
8432       else
8433         {
8434           tree access0_wfl, cn;
8435
8436           maybe_build_thisn_access_method (from);
8437           access0_wfl = build_wfl_node (access0_identifier_node);
8438           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8439           EXPR_WFL_LINECOL (access0_wfl) = lc;
8440           access = build_tree_list (NULL_TREE, access);
8441           access = build_method_invocation (access0_wfl, access);
8442           access = make_qualified_primary (cn, access, lc);
8443         }
8444
8445       /* If FROM isn't an inner class, that's fine, we've done enough.
8446          What we're looking for can be accessed from there.  */
8447       from = DECL_CONTEXT (TYPE_NAME (from));
8448       if (!from)
8449         break;
8450       from = TREE_TYPE (from);
8451     }
8452   return access;
8453 }
8454
8455 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8456    is returned if nothing needs to be generated. Otherwise, the method
8457    generated and a method decl is returned.
8458
8459    NOTE: These generated methods should be declared in a class file
8460    attribute so that they can't be referred to directly.  */
8461
8462 static tree
8463 maybe_build_thisn_access_method (tree type)
8464 {
8465   tree mdecl, args, stmt, rtype;
8466   tree saved_current_function_decl;
8467
8468   /* If TYPE is a top-level class, no access method is required.
8469      If there already is such an access method, bail out. */
8470   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8471     return NULL_TREE;
8472
8473   /* We generate the method. The method looks like:
8474      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8475   */
8476   args = build_tree_list (inst_id, build_pointer_type (type));
8477   TREE_CHAIN (args) = end_params_node;
8478   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8479   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8480                                     access0_identifier_node, args);
8481   fix_method_argument_names (args, mdecl);
8482   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8483   stmt = build_current_thisn (type);
8484   stmt = make_qualified_primary (build_wfl_node (inst_id),
8485                                  build_wfl_node (stmt), 0);
8486   stmt = build_return (0, stmt);
8487
8488   saved_current_function_decl = current_function_decl;
8489   start_artificial_method_body (mdecl);
8490   java_method_add_stmt (mdecl, stmt);
8491   end_artificial_method_body (mdecl);
8492   current_function_decl = saved_current_function_decl;
8493
8494   CLASS_ACCESS0_GENERATED_P (type) = 1;
8495
8496   return mdecl;
8497 }
8498
8499 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8500    the first level of innerclassing. this$1 for the next one, etc...
8501    This function can be invoked with TYPE to NULL, available and then
8502    has to count the parser context.  */
8503
8504 static GTY(()) tree saved_thisn;
8505 static GTY(()) tree saved_type;
8506
8507 static tree
8508 build_current_thisn (tree type)
8509 {
8510   static int saved_i = -1;
8511   static int saved_type_i = 0;
8512   tree decl;
8513   char buffer [24];
8514   int i = 0;
8515
8516   if (type)
8517     {
8518       if (type == saved_type)
8519         i = saved_type_i;
8520       else
8521         {
8522           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8523                decl; decl = DECL_CONTEXT (decl), i++)
8524             ;
8525
8526           saved_type = type;
8527           saved_type_i = i;
8528         }
8529     }
8530   else
8531     i = list_length (GET_CPC_LIST ())-2;
8532
8533   if (i == saved_i)
8534     return saved_thisn;
8535
8536   sprintf (buffer, "this$%d", i);
8537   saved_i = i;
8538   saved_thisn = get_identifier (buffer);
8539   return saved_thisn;
8540 }
8541
8542 /* Return the assignement to the hidden enclosing context `this$<n>'
8543    by the second incoming parameter to the innerclass constructor. The
8544    form used is `this.this$<n> = this$<n>;'.  */
8545
8546 static tree
8547 build_thisn_assign (void)
8548 {
8549   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8550     {
8551       tree thisn = build_current_thisn (current_class);
8552       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8553                                          build_wfl_node (thisn), 0);
8554       tree rhs = build_wfl_node (thisn);
8555       EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
8556       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8557     }
8558   return NULL_TREE;
8559 }
8560
8561 \f
8562 /* Building the synthetic `class$' used to implement the `.class' 1.1
8563    extension for non primitive types. This method looks like:
8564
8565     static Class class$(String type) throws NoClassDefFoundError
8566     {
8567       try {return (java.lang.Class.forName (String));}
8568       catch (ClassNotFoundException e) {
8569         throw new NoClassDefFoundError(e.getMessage());}
8570     } */
8571
8572 static GTY(()) tree get_message_wfl;
8573 static GTY(()) tree type_parm_wfl;
8574
8575 static tree
8576 build_dot_class_method (tree class)
8577 {
8578 #define BWF(S) build_wfl_node (get_identifier ((S)))
8579 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8580   tree args, tmp, saved_current_function_decl, mdecl;
8581   tree stmt, throw_stmt;
8582
8583   if (!get_message_wfl)
8584     {
8585       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8586       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8587     }
8588
8589   /* Build the arguments */
8590   args = build_tree_list (get_identifier ("type$"),
8591                           build_pointer_type (string_type_node));
8592   TREE_CHAIN (args) = end_params_node;
8593
8594   /* Build the qualified name java.lang.Class.forName */
8595   tmp = MQN (MQN (MQN (BWF ("java"),
8596                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8597   load_class (class_not_found_type_node, 1);
8598   load_class (no_class_def_found_type_node, 1);
8599
8600   /* Create the "class$" function */
8601   mdecl = create_artificial_method (class, ACC_STATIC,
8602                                     build_pointer_type (class_type_node),
8603                                     classdollar_identifier_node, args);
8604   DECL_FUNCTION_THROWS (mdecl) =
8605     build_tree_list (NULL_TREE, no_class_def_found_type_node);
8606
8607   /* We start by building the try block. We need to build:
8608        return (java.lang.Class.forName (type)); */
8609   stmt = build_method_invocation (tmp,
8610                                   build_tree_list (NULL_TREE, type_parm_wfl));
8611   stmt = build_return (0, stmt);
8612
8613   /* Now onto the catch block. We start by building the expression
8614      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8615   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8616                                     get_message_wfl, 0);
8617   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8618
8619   /* Build new NoClassDefFoundError (_.getMessage) */
8620   throw_stmt = build_new_invocation
8621     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8622      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8623
8624   /* Build the throw, (it's too early to use BUILD_THROW) */
8625   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8626
8627   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8628   stmt = encapsulate_with_try_catch (0, class_not_found_type_node,
8629                                      stmt, throw_stmt);
8630
8631   fix_method_argument_names (args, mdecl);
8632   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8633   saved_current_function_decl = current_function_decl;
8634   start_artificial_method_body (mdecl);
8635   java_method_add_stmt (mdecl, stmt);
8636   end_artificial_method_body (mdecl);
8637   current_function_decl = saved_current_function_decl;
8638   TYPE_DOT_CLASS (class) = mdecl;
8639
8640   return mdecl;
8641 }
8642
8643 static tree
8644 build_dot_class_method_invocation (tree type)
8645 {
8646   tree sig_id, s;
8647
8648   if (TYPE_ARRAY_P (type))
8649     sig_id = build_java_signature (type);
8650   else
8651     sig_id = DECL_NAME (TYPE_NAME (type));
8652
8653   /* Ensure that the proper name separator is used */
8654   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8655                                IDENTIFIER_LENGTH (sig_id));
8656
8657   s = build_string (IDENTIFIER_LENGTH (sig_id),
8658                     IDENTIFIER_POINTER (sig_id));
8659   return build_method_invocation (build_wfl_node (classdollar_identifier_node),
8660                                   build_tree_list (NULL_TREE, s));
8661 }
8662
8663 /* This section of the code deals with constructor.  */
8664
8665 /* Craft a body for default constructor. Patch existing constructor
8666    bodies with call to super() and field initialization statements if
8667    necessary.  */
8668
8669 static void
8670 fix_constructors (tree mdecl)
8671 {
8672   tree iii;                     /* Instance Initializer Invocation */
8673   tree body = DECL_FUNCTION_BODY (mdecl);
8674   tree thisn_assign, compound = NULL_TREE;
8675   tree class_type = DECL_CONTEXT (mdecl);
8676
8677   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8678     return;
8679   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8680
8681   if (!body)
8682     {
8683       /* It is an error for the compiler to generate a default
8684          constructor if the superclass doesn't have a constructor that
8685          takes no argument, or the same args for an anonymous class */
8686       if (verify_constructor_super (mdecl))
8687         {
8688           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8689           tree save = DECL_NAME (mdecl);
8690           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8691           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8692           parse_error_context
8693             (lookup_cl (TYPE_NAME (class_type)),
8694              "No constructor matching `%s' found in class `%s'",
8695              lang_printable_name (mdecl, 0), n);
8696           DECL_NAME (mdecl) = save;
8697         }
8698
8699       /* The constructor body must be crafted by hand. It's the
8700          constructor we defined when we realize we didn't have the
8701          CLASSNAME() constructor */
8702       start_artificial_method_body (mdecl);
8703
8704       /* Insert an assignment to the this$<n> hidden field, if
8705          necessary */
8706       if ((thisn_assign = build_thisn_assign ()))
8707         java_method_add_stmt (mdecl, thisn_assign);
8708
8709       /* We don't generate a super constructor invocation if we're
8710          compiling java.lang.Object. build_super_invocation takes care
8711          of that. */
8712       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8713
8714       /* FIXME */
8715       if ((iii = build_instinit_invocation (class_type)))
8716         java_method_add_stmt (mdecl, iii);
8717
8718       end_artificial_method_body (mdecl);
8719     }
8720   /* Search for an explicit constructor invocation */
8721   else
8722     {
8723       int found = 0;
8724       int invokes_this = 0;
8725       tree found_call = NULL_TREE;
8726       tree main_block = BLOCK_EXPR_BODY (body);
8727
8728       while (body)
8729         switch (TREE_CODE (body))
8730           {
8731           case CALL_EXPR:
8732             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8733             if (CALL_THIS_CONSTRUCTOR_P (body))
8734               invokes_this = 1;
8735             body = NULL_TREE;
8736             break;
8737           case COMPOUND_EXPR:
8738           case EXPR_WITH_FILE_LOCATION:
8739             found_call = body;
8740             body = TREE_OPERAND (body, 0);
8741             break;
8742           case BLOCK:
8743             found_call = body;
8744             body = BLOCK_EXPR_BODY (body);
8745             break;
8746           default:
8747             found = 0;
8748             body = NULL_TREE;
8749           }
8750
8751       /* Generate the assignment to this$<n>, if necessary */
8752       if ((thisn_assign = build_thisn_assign ()))
8753         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8754
8755       /* The constructor is missing an invocation of super() */
8756       if (!found)
8757         compound = add_stmt_to_compound (compound, NULL_TREE,
8758                                          build_super_invocation (mdecl));
8759       /* Explicit super() invokation should take place before the
8760          instance initializer blocks. */
8761       else
8762         {
8763           compound = add_stmt_to_compound (compound, NULL_TREE,
8764                                            TREE_OPERAND (found_call, 0));
8765           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8766         }
8767
8768       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8769
8770       /* Insert the instance initializer block right after. */
8771       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8772         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8773
8774       /* Fix the constructor main block if we're adding extra stmts */
8775       if (compound)
8776         {
8777           compound = add_stmt_to_compound (compound, NULL_TREE,
8778                                            BLOCK_EXPR_BODY (main_block));
8779           BLOCK_EXPR_BODY (main_block) = compound;
8780         }
8781     }
8782 }
8783
8784 /* Browse constructors in the super class, searching for a constructor
8785    that doesn't take any argument. Return 0 if one is found, 1
8786    otherwise.  If the current class is an anonymous inner class, look
8787    for something that has the same signature. */
8788
8789 static int
8790 verify_constructor_super (tree mdecl)
8791 {
8792   tree class = CLASSTYPE_SUPER (current_class);
8793   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8794   tree sdecl;
8795
8796   if (!class)
8797     return 0;
8798
8799   if (ANONYMOUS_CLASS_P (current_class))
8800     {
8801       tree mdecl_arg_type;
8802       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8803       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8804         if (DECL_CONSTRUCTOR_P (sdecl))
8805           {
8806             tree m_arg_type;
8807             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8808             if (super_inner)
8809               arg_type = TREE_CHAIN (arg_type);
8810             for (m_arg_type = mdecl_arg_type;
8811                  (arg_type != end_params_node
8812                   && m_arg_type != end_params_node);
8813                  arg_type = TREE_CHAIN (arg_type),
8814                    m_arg_type = TREE_CHAIN (m_arg_type))
8815               if (!valid_method_invocation_conversion_p
8816                      (TREE_VALUE (arg_type),
8817                       TREE_VALUE (m_arg_type)))
8818                 break;
8819
8820             if (arg_type == end_params_node && m_arg_type == end_params_node)
8821               return 0;
8822           }
8823     }
8824   else
8825     {
8826       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8827         {
8828           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8829           if (super_inner)
8830             arg = TREE_CHAIN (arg);
8831           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8832             return 0;
8833         }
8834     }
8835   return 1;
8836 }
8837
8838 /* Generate code for all context remembered for code generation.  */
8839
8840 static GTY(()) tree reversed_class_list;
8841 void
8842 java_expand_classes (void)
8843 {
8844   int save_error_count = 0;
8845   static struct parser_ctxt *cur_ctxp = NULL;
8846
8847   java_parse_abort_on_error ();
8848   if (!(ctxp = ctxp_for_generation))
8849     return;
8850   java_layout_classes ();
8851   java_parse_abort_on_error ();
8852
8853   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8854     {
8855       ctxp = cur_ctxp;
8856       input_filename = ctxp->filename;
8857       lang_init_source (2);            /* Error msgs have method prototypes */
8858       java_complete_expand_classes (); /* Complete and expand classes */
8859       java_parse_abort_on_error ();
8860     }
8861   input_filename = main_input_filename;
8862
8863
8864   /* Find anonymous classes and expand their constructor. This extra pass is
8865      neccessary because the constructor itself is only generated when the
8866      method in which it is defined is expanded. */
8867   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8868     {
8869       tree current;
8870       ctxp = cur_ctxp;
8871       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8872         {
8873           current_class = TREE_TYPE (current);
8874           if (ANONYMOUS_CLASS_P (current_class))
8875             {
8876               tree d;
8877               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
8878                 {
8879                   if (DECL_CONSTRUCTOR_P (d))
8880                     {
8881                       restore_line_number_status (1);
8882                       java_complete_expand_method (d);
8883                       restore_line_number_status (0);
8884                       break;    /* There is only one constructor. */
8885                     }
8886                 }
8887             }
8888         }
8889     }
8890
8891   /* Expanding the constructors of anonymous classes generates access
8892      methods.  Scan all the methods looking for null DECL_RESULTs --
8893      this will be the case if a method hasn't been expanded.  */
8894   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8895     {
8896       tree current;
8897       ctxp = cur_ctxp;
8898       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8899         {
8900           tree d;
8901           current_class = TREE_TYPE (current);
8902           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
8903             {
8904               if (DECL_RESULT (d) == NULL_TREE)
8905                 {
8906                   restore_line_number_status (1);
8907                   java_complete_expand_method (d);
8908                   restore_line_number_status (0);
8909                 }
8910             }
8911         }
8912     }
8913
8914   /* ???  Instead of all this we could iterate around the list of
8915      classes until there were no more un-expanded methods.  It would
8916      take a little longer -- one pass over the whole list of methods
8917      -- but it would be simpler.  Like this:  */
8918 #if 0
8919     {
8920       int something_changed;
8921
8922       do
8923         {
8924           something_changed = 0;
8925           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8926             {
8927               tree current;
8928               ctxp = cur_ctxp;
8929               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8930                 {
8931                   tree d;
8932                   current_class = TREE_TYPE (current);
8933                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
8934                     {
8935                       if (DECL_RESULT (d) == NULL_TREE)
8936                         {
8937                           something_changed = 1;
8938                           restore_line_number_status (1);
8939                           java_complete_expand_method (d);
8940                           restore_line_number_status (0);
8941                         }
8942                     }
8943                 }
8944             }
8945         }
8946       while (something_changed);
8947     }
8948 #endif
8949
8950   /* If we've found error at that stage, don't try to generate
8951      anything, unless we're emitting xrefs or checking the syntax only
8952      (but not using -fsyntax-only for the purpose of generating
8953      bytecode. */
8954   if (java_error_count && !flag_emit_xref
8955       && (!flag_syntax_only && !flag_emit_class_files))
8956     return;
8957
8958   /* Now things are stable, go for generation of the class data. */
8959
8960   /* We pessimistically marked all fields external until we knew
8961      what set of classes we were planning to compile.  Now mark
8962      those that will be generated locally as not external.  */
8963   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8964     {
8965       tree current;
8966       ctxp = cur_ctxp;
8967       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8968         {
8969           tree class = TREE_TYPE (current);
8970           tree field;
8971           for (field = TYPE_FIELDS (class); field ; field = TREE_CHAIN (field))
8972             if (FIELD_STATIC (field))
8973               DECL_EXTERNAL (field) = 0;
8974         }
8975     }
8976
8977   /* Compile the classes.  */
8978   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8979     {
8980       tree current;
8981       reversed_class_list = NULL;
8982
8983       ctxp = cur_ctxp;
8984
8985       /* We write out the classes in reverse order.  This ensures that
8986          inner classes are written before their containing classes,
8987          which is important for parallel builds.  Otherwise, the
8988          class file for the outer class may be found, but the class
8989          file for the inner class may not be present.  In that
8990          situation, the compiler cannot fall back to the original
8991          source, having already read the outer class, so we must
8992          prevent that situation.  */
8993       for (current = ctxp->class_list;
8994            current;
8995            current = TREE_CHAIN (current))
8996         reversed_class_list
8997           = tree_cons (NULL_TREE, current, reversed_class_list);
8998
8999       for (current = reversed_class_list;
9000            current;
9001            current = TREE_CHAIN (current))
9002         {
9003           current_class = TREE_TYPE (TREE_VALUE (current));
9004           outgoing_cpool = TYPE_CPOOL (current_class);
9005           if (flag_emit_class_files)
9006             write_classfile (current_class);
9007           if (flag_emit_xref)
9008             expand_xref (current_class);
9009           else if (! flag_syntax_only)
9010             {
9011               java_expand_method_bodies (current_class);
9012               finish_class ();
9013             }
9014         }
9015     }
9016 }
9017
9018 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9019    a tree list node containing RIGHT. Fore coming RIGHTs will be
9020    chained to this hook. LOCATION contains the location of the
9021    separating `.' operator.  */
9022
9023 static tree
9024 make_qualified_primary (tree primary, tree right, int location)
9025 {
9026   tree wfl;
9027
9028   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9029     wfl = build_wfl_wrap (primary, location);
9030   else
9031     {
9032       wfl = primary;
9033       /* If wfl wasn't qualified, we build a first anchor */
9034       if (!EXPR_WFL_QUALIFICATION (wfl))
9035         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9036     }
9037
9038   /* And chain them */
9039   EXPR_WFL_LINECOL (right) = location;
9040   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9041   PRIMARY_P (wfl) =  1;
9042   return wfl;
9043 }
9044
9045 /* Simple merge of two name separated by a `.' */
9046
9047 static tree
9048 merge_qualified_name (tree left, tree right)
9049 {
9050   tree node;
9051   if (!left && !right)
9052     return NULL_TREE;
9053
9054   if (!left)
9055     return right;
9056
9057   if (!right)
9058     return left;
9059
9060   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9061                 IDENTIFIER_LENGTH (left));
9062   obstack_1grow (&temporary_obstack, '.');
9063   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9064                  IDENTIFIER_LENGTH (right));
9065   node =  get_identifier (obstack_base (&temporary_obstack));
9066   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9067   QUALIFIED_P (node) = 1;
9068   return node;
9069 }
9070
9071 /* Merge the two parts of a qualified name into LEFT.  Set the
9072    location information of the resulting node to LOCATION, usually
9073    inherited from the location information of the `.' operator. */
9074
9075 static tree
9076 make_qualified_name (tree left, tree right, int location)
9077 {
9078 #ifdef USE_COMPONENT_REF
9079   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9080   EXPR_WFL_LINECOL (node) = location;
9081   return node;
9082 #else
9083   tree left_id = EXPR_WFL_NODE (left);
9084   tree right_id = EXPR_WFL_NODE (right);
9085   tree wfl, merge;
9086
9087   merge = merge_qualified_name (left_id, right_id);
9088
9089   /* Left wasn't qualified and is now qualified */
9090   if (!QUALIFIED_P (left_id))
9091     {
9092       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9093       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9094       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9095     }
9096
9097   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9098   EXPR_WFL_LINECOL (wfl) = location;
9099   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9100
9101   EXPR_WFL_NODE (left) = merge;
9102   return left;
9103 #endif
9104 }
9105
9106 /* Extract the last identifier component of the qualified in WFL. The
9107    last identifier is removed from the linked list */
9108
9109 static tree
9110 cut_identifier_in_qualified (tree wfl)
9111 {
9112   tree q;
9113   tree previous = NULL_TREE;
9114   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9115     if (!TREE_CHAIN (q))
9116       {
9117         if (!previous)
9118           /* Operating on a non qualified qualified WFL.  */
9119           abort ();
9120
9121         TREE_CHAIN (previous) = NULL_TREE;
9122         return TREE_PURPOSE (q);
9123       }
9124 }
9125
9126 /* Resolve the expression name NAME. Return its decl.  */
9127
9128 static tree
9129 resolve_expression_name (tree id, tree *orig)
9130 {
9131   tree name = EXPR_WFL_NODE (id);
9132   tree decl;
9133
9134   /* 6.5.5.1: Simple expression names */
9135   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9136     {
9137       /* 15.13.1: NAME can appear within the scope of a local variable
9138          declaration */
9139       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9140         return decl;
9141
9142       /* 15.13.1: NAME can appear within a class declaration */
9143       else
9144         {
9145           decl = lookup_field_wrapper (current_class, name);
9146           if (decl)
9147             {
9148               tree access = NULL_TREE;
9149               int fs = FIELD_STATIC (decl);
9150
9151               /* If we're accessing an outer scope local alias, make
9152                  sure we change the name of the field we're going to
9153                  build access to. */
9154               if (FIELD_LOCAL_ALIAS_USED (decl))
9155                 name = DECL_NAME (decl);
9156
9157               /* Instance variable (8.3.1.1) can't appear within
9158                  static method, static initializer or initializer for
9159                  a static variable. */
9160               if (!fs && METHOD_STATIC (current_function_decl))
9161                 {
9162                   static_ref_err (id, name, current_class);
9163                   return error_mark_node;
9164                 }
9165               /* Instance variables can't appear as an argument of
9166                  an explicit constructor invocation */
9167               if (!fs && ctxp->explicit_constructor_p
9168                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9169                 {
9170                   parse_error_context
9171                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9172                   return error_mark_node;
9173                 }
9174
9175               /* If we're processing an inner class and we're trying
9176                  to access a field belonging to an outer class, build
9177                  the access to the field */
9178               if (!fs && outer_field_access_p (current_class, decl))
9179                 {
9180                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9181                     {
9182                       static_ref_err (id, DECL_NAME (decl), current_class);
9183                       return error_mark_node;
9184                     }
9185                   access = build_outer_field_access (id, decl);
9186                   if (orig)
9187                     *orig = access;
9188                   return access;
9189                 }
9190
9191               /* Otherwise build what it takes to access the field */
9192               access = build_field_ref ((fs ? NULL_TREE : current_this),
9193                                         DECL_CONTEXT (decl), name);
9194               if (fs)
9195                 access = maybe_build_class_init_for_field (decl, access);
9196               /* We may be asked to save the real field access node */
9197               if (orig)
9198                 *orig = access;
9199               /* And we return what we got */
9200               return access;
9201             }
9202           /* Fall down to error report on undefined variable */
9203         }
9204     }
9205   /* 6.5.5.2 Qualified Expression Names */
9206   else
9207     {
9208       if (orig)
9209         *orig = NULL_TREE;
9210       qualify_ambiguous_name (id);
9211       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9212       /* 15.10.2: Accessing Superclass Members using super */
9213       return resolve_field_access (id, orig, NULL);
9214     }
9215
9216   /* We've got an error here */
9217   if (INNER_CLASS_TYPE_P (current_class))
9218     parse_error_context (id,
9219                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9220                          IDENTIFIER_POINTER (name),
9221                          IDENTIFIER_POINTER (DECL_NAME
9222                                              (TYPE_NAME (current_class))));
9223   else
9224     parse_error_context (id, "Undefined variable `%s'",
9225                          IDENTIFIER_POINTER (name));
9226
9227   return error_mark_node;
9228 }
9229
9230 static void
9231 static_ref_err (tree wfl, tree field_id, tree class_type)
9232 {
9233   parse_error_context
9234     (wfl,
9235      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9236      IDENTIFIER_POINTER (field_id),
9237      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9238 }
9239
9240 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9241    We return something suitable to generate the field access. We also
9242    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9243    recipient's address can be null. */
9244
9245 static tree
9246 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9247 {
9248   int is_static = 0;
9249   tree field_ref;
9250   tree decl, where_found, type_found;
9251
9252   if (resolve_qualified_expression_name (qual_wfl, &decl,
9253                                          &where_found, &type_found))
9254     return error_mark_node;
9255
9256   /* Resolve the LENGTH field of an array here */
9257   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9258       && type_found && TYPE_ARRAY_P (type_found)
9259       && ! flag_emit_class_files && ! flag_emit_xref)
9260     {
9261       tree length = build_java_array_length_access (where_found);
9262       field_ref = length;
9263
9264       /* In case we're dealing with a static array, we need to
9265          initialize its class before the array length can be fetched.
9266          It's also a good time to create a DECL_RTL for the field if
9267          none already exists, otherwise if the field was declared in a
9268          class found in an external file and hasn't been (and won't
9269          be) accessed for its value, none will be created. */
9270       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9271         {
9272           build_static_field_ref (where_found);
9273           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9274         }
9275     }
9276   /* We might have been trying to resolve field.method(). In which
9277      case, the resolution is over and decl is the answer */
9278   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9279     field_ref = decl;
9280   else if (JDECL_P (decl))
9281     {
9282       if (!type_found)
9283         type_found = DECL_CONTEXT (decl);
9284       is_static = FIELD_STATIC (decl);
9285       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9286                                     NULL_TREE : where_found),
9287                                    type_found, DECL_NAME (decl));
9288       if (field_ref == error_mark_node)
9289         return error_mark_node;
9290       if (is_static)
9291         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9292     }
9293   else
9294     field_ref = decl;
9295
9296   if (field_decl)
9297     *field_decl = decl;
9298   if (field_type)
9299     *field_type = (QUAL_DECL_TYPE (decl) ?
9300                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9301   return field_ref;
9302 }
9303
9304 /* If NODE is an access to f static field, strip out the class
9305    initialization part and return the field decl, otherwise, return
9306    NODE. */
9307
9308 static tree
9309 strip_out_static_field_access_decl (tree node)
9310 {
9311   if (TREE_CODE (node) == COMPOUND_EXPR)
9312     {
9313       tree op1 = TREE_OPERAND (node, 1);
9314       if (TREE_CODE (op1) == COMPOUND_EXPR)
9315          {
9316            tree call = TREE_OPERAND (op1, 0);
9317            if (TREE_CODE (call) == CALL_EXPR
9318                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9319                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9320                == soft_initclass_node)
9321              return TREE_OPERAND (op1, 1);
9322          }
9323       else if (JDECL_P (op1))
9324         return op1;
9325     }
9326   return node;
9327 }
9328
9329 /* 6.5.5.2: Qualified Expression Names */
9330
9331 static int
9332 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9333                                    tree *where_found, tree *type_found)
9334 {
9335   int from_type = 0;            /* Field search initiated from a type */
9336   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9337   int previous_call_static = 0;
9338   int is_static;
9339   tree decl = NULL_TREE, type = NULL_TREE, q;
9340   /* For certain for of inner class instantiation */
9341   tree saved_current, saved_this;
9342 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9343   { current_class = saved_current; current_this = saved_this;}
9344
9345   *type_found = *where_found = NULL_TREE;
9346
9347   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9348     {
9349       tree qual_wfl = QUAL_WFL (q);
9350       tree ret_decl;            /* for EH checking */
9351       int location;             /* for EH checking */
9352
9353       /* 15.10.1 Field Access Using a Primary */
9354       switch (TREE_CODE (qual_wfl))
9355         {
9356         case CALL_EXPR:
9357         case NEW_CLASS_EXPR:
9358           /* If the access to the function call is a non static field,
9359              build the code to access it. */
9360           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9361             {
9362               decl = maybe_access_field (decl, *where_found,
9363                                          DECL_CONTEXT (decl));
9364               if (decl == error_mark_node)
9365                 return 1;
9366             }
9367
9368           /* And code for the function call */
9369           if (complete_function_arguments (qual_wfl))
9370             return 1;
9371
9372           /* We might have to setup a new current class and a new this
9373              for the search of an inner class, relative to the type of
9374              a expression resolved as `decl'. The current values are
9375              saved and restored shortly after */
9376           saved_current = current_class;
9377           saved_this = current_this;
9378           if (decl
9379               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9380                   || from_qualified_this))
9381             {
9382               /* If we still have `from_qualified_this', we have the form
9383                  <T>.this.f() and we need to build <T>.this */
9384               if (from_qualified_this)
9385                 {
9386                   decl = build_access_to_thisn (current_class, type, 0);
9387                   decl = java_complete_tree (decl);
9388                   type = TREE_TYPE (TREE_TYPE (decl));
9389                 }
9390               current_class = type;
9391               current_this = decl;
9392               from_qualified_this = 0;
9393             }
9394
9395           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9396             CALL_USING_SUPER (qual_wfl) = 1;
9397           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9398                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9399           *where_found = patch_method_invocation (qual_wfl, decl, type,
9400                                                   from_super,
9401                                                   &is_static, &ret_decl);
9402           from_super = 0;
9403           if (*where_found == error_mark_node)
9404             {
9405               RESTORE_THIS_AND_CURRENT_CLASS;
9406               return 1;
9407             }
9408           *type_found = type = QUAL_DECL_TYPE (*where_found);
9409
9410           *where_found = force_evaluation_order (*where_found);
9411
9412           /* If we're creating an inner class instance, check for that
9413              an enclosing instance is in scope */
9414           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9415               && INNER_ENCLOSING_SCOPE_CHECK (type))
9416             {
9417               parse_error_context
9418                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9419                  lang_printable_name (type, 0),
9420                  (!current_this ? "" :
9421                   "; an explicit one must be provided when creating this inner class"));
9422               RESTORE_THIS_AND_CURRENT_CLASS;
9423               return 1;
9424             }
9425
9426           /* In case we had to change then to resolve a inner class
9427              instantiation using a primary qualified by a `new' */
9428           RESTORE_THIS_AND_CURRENT_CLASS;
9429
9430           /* EH check. No check on access$<n> functions */
9431           if (location
9432               && !OUTER_FIELD_ACCESS_IDENTIFIER_P
9433                     (DECL_NAME (current_function_decl)))
9434             check_thrown_exceptions (location, ret_decl);
9435
9436           /* If the previous call was static and this one is too,
9437              build a compound expression to hold the two (because in
9438              that case, previous function calls aren't transported as
9439              forcoming function's argument. */
9440           if (previous_call_static && is_static)
9441             {
9442               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9443                             decl, *where_found);
9444               TREE_SIDE_EFFECTS (decl) = 1;
9445             }
9446           else
9447             {
9448               previous_call_static = is_static;
9449               decl = *where_found;
9450             }
9451           from_type = 0;
9452           continue;
9453
9454         case NEW_ARRAY_EXPR:
9455         case NEW_ANONYMOUS_ARRAY_EXPR:
9456           *where_found = decl = java_complete_tree (qual_wfl);
9457           if (decl == error_mark_node)
9458             return 1;
9459           *type_found = type = QUAL_DECL_TYPE (decl);
9460           continue;
9461
9462         case CONVERT_EXPR:
9463           *where_found = decl = java_complete_tree (qual_wfl);
9464           if (decl == error_mark_node)
9465             return 1;
9466           *type_found = type = QUAL_DECL_TYPE (decl);
9467           from_cast = 1;
9468           continue;
9469
9470         case CONDITIONAL_EXPR:
9471         case STRING_CST:
9472         case MODIFY_EXPR:
9473           *where_found = decl = java_complete_tree (qual_wfl);
9474           if (decl == error_mark_node)
9475             return 1;
9476           *type_found = type = QUAL_DECL_TYPE (decl);
9477           continue;
9478
9479         case ARRAY_REF:
9480           /* If the access to the function call is a non static field,
9481              build the code to access it. */
9482           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9483             {
9484               decl = maybe_access_field (decl, *where_found, type);
9485               if (decl == error_mark_node)
9486                 return 1;
9487             }
9488           /* And code for the array reference expression */
9489           decl = java_complete_tree (qual_wfl);
9490           if (decl == error_mark_node)
9491             return 1;
9492           type = QUAL_DECL_TYPE (decl);
9493           continue;
9494
9495         case PLUS_EXPR:
9496           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9497             return 1;
9498           if ((type = patch_string (decl)))
9499             decl = type;
9500           *where_found = QUAL_RESOLUTION (q) = decl;
9501           *type_found = type = TREE_TYPE (decl);
9502           break;
9503
9504         case CLASS_LITERAL:
9505           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9506             return 1;
9507           *where_found = QUAL_RESOLUTION (q) = decl;
9508           *type_found = type = TREE_TYPE (decl);
9509           break;
9510
9511         default:
9512           /* Fix for -Wall Just go to the next statement. Don't
9513              continue */
9514           break;
9515         }
9516
9517       /* If we fall here, we weren't processing a (static) function call. */
9518       previous_call_static = 0;
9519
9520       /* It can be the keyword THIS */
9521       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9522           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9523         {
9524           if (!current_this)
9525             {
9526               parse_error_context
9527                 (wfl, "Keyword `this' used outside allowed context");
9528               return 1;
9529             }
9530           if (ctxp->explicit_constructor_p
9531               && type == current_class)
9532             {
9533               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9534               return 1;
9535             }
9536           /* We have to generate code for intermediate access */
9537           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9538             {
9539               *where_found = decl = current_this;
9540               *type_found = type = QUAL_DECL_TYPE (decl);
9541             }
9542           /* We're trying to access the this from somewhere else. Make sure
9543              it's allowed before doing so. */
9544           else
9545             {
9546               if (!enclosing_context_p (type, current_class))
9547                 {
9548                   char *p  = xstrdup (lang_printable_name (type, 0));
9549                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9550                                        p, p,
9551                                        lang_printable_name (current_class, 0));
9552                   free (p);
9553                   return 1;
9554                 }
9555               from_qualified_this = 1;
9556               /* If there's nothing else after that, we need to
9557                  produce something now, otherwise, the section of the
9558                  code that needs to produce <T>.this will generate
9559                  what is necessary. */
9560               if (!TREE_CHAIN (q))
9561                 {
9562                   decl = build_access_to_thisn (current_class, type, 0);
9563                   *where_found = decl = java_complete_tree (decl);
9564                   *type_found = type = TREE_TYPE (decl);
9565                 }
9566             }
9567
9568           from_type = 0;
9569           continue;
9570         }
9571
9572       /* 15.10.2 Accessing Superclass Members using SUPER */
9573       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9574           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9575         {
9576           tree node;
9577           /* Check on the restricted use of SUPER */
9578           if (METHOD_STATIC (current_function_decl)
9579               || current_class == object_type_node)
9580             {
9581               parse_error_context
9582                 (wfl, "Keyword `super' used outside allowed context");
9583               return 1;
9584             }
9585           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9586           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9587                              CLASSTYPE_SUPER (current_class),
9588                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9589           *where_found = decl = java_complete_tree (node);
9590           if (decl == error_mark_node)
9591             return 1;
9592           *type_found = type = QUAL_DECL_TYPE (decl);
9593           from_super = from_type = 1;
9594           continue;
9595         }
9596
9597       /* 15.13.1: Can't search for field name in packages, so we
9598          assume a variable/class name was meant. */
9599       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9600         {
9601           tree name;
9602           if ((decl = resolve_package (wfl, &q, &name)))
9603             {
9604               tree list;
9605               *where_found = decl;
9606
9607               /* We want to be absolutely sure that the class is laid
9608                  out. We're going to search something inside it. */
9609               *type_found = type = TREE_TYPE (decl);
9610               layout_class (type);
9611               from_type = 1;
9612
9613               /* Fix them all the way down, if any are left. */
9614               if (q)
9615                 {
9616                   list = TREE_CHAIN (q);
9617                   while (list)
9618                     {
9619                       RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9620                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9621                       list = TREE_CHAIN (list);
9622                     }
9623                 }
9624             }
9625           else
9626             {
9627               if (from_super || from_cast)
9628                 parse_error_context
9629                   ((from_cast ? qual_wfl : wfl),
9630                    "No variable `%s' defined in class `%s'",
9631                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9632                    lang_printable_name (type, 0));
9633               else
9634                 parse_error_context
9635                   (qual_wfl, "Undefined variable or class name: `%s'",
9636                    IDENTIFIER_POINTER (name));
9637               return 1;
9638             }
9639         }
9640
9641       /* We have a type name. It's been already resolved when the
9642          expression was qualified. */
9643       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9644         {
9645           decl = QUAL_RESOLUTION (q);
9646
9647           /* Sneak preview. If next we see a `new', we're facing a
9648              qualification with resulted in a type being selected
9649              instead of a field.  Report the error */
9650           if(TREE_CHAIN (q)
9651              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9652             {
9653               parse_error_context (qual_wfl, "Undefined variable `%s'",
9654                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9655               return 1;
9656             }
9657
9658           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9659             {
9660               parse_error_context
9661                 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
9662                  java_accstring_lookup (get_access_flags_from_decl (decl)),
9663                  GET_TYPE_NAME (type),
9664                  IDENTIFIER_POINTER (DECL_NAME (decl)),
9665                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9666               return 1;
9667             }
9668           check_deprecation (qual_wfl, decl);
9669
9670           type = TREE_TYPE (decl);
9671           from_type = 1;
9672         }
9673       /* We resolve an expression name */
9674       else
9675         {
9676           tree field_decl = NULL_TREE;
9677
9678           /* If there exists an early resolution, use it. That occurs
9679              only once and we know that there are more things to
9680              come. Don't do that when processing something after SUPER
9681              (we need more thing to be put in place below */
9682           if (!from_super && QUAL_RESOLUTION (q))
9683             {
9684               decl = QUAL_RESOLUTION (q);
9685               if (!type)
9686                 {
9687                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9688                     {
9689                       if (current_this)
9690                         *where_found = current_this;
9691                       else
9692                         {
9693                           static_ref_err (qual_wfl, DECL_NAME (decl),
9694                                           current_class);
9695                           return 1;
9696                         }
9697                       if (outer_field_access_p (current_class, decl))
9698                         decl = build_outer_field_access (qual_wfl, decl);
9699                     }
9700                   else
9701                     {
9702                       *where_found = TREE_TYPE (decl);
9703                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9704                         *where_found = TREE_TYPE (*where_found);
9705                     }
9706                 }
9707             }
9708
9709           /* Report and error if we're using a numerical litteral as a
9710              qualifier. It can only be an INTEGER_CST. */
9711           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9712             {
9713               parse_error_context
9714                 (wfl, "Can't use type `%s' as a qualifier",
9715                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9716               return 1;
9717             }
9718
9719           /* We have to search for a field, knowing the type of its
9720              container. The flag FROM_TYPE indicates that we resolved
9721              the last member of the expression as a type name, which
9722              means that for the resolution of this field, we'll look
9723              for other errors than if it was resolved as a member of
9724              an other field. */
9725           else
9726             {
9727               int is_static;
9728               tree field_decl_type; /* For layout */
9729
9730               if (!from_type && !JREFERENCE_TYPE_P (type))
9731                 {
9732                   parse_error_context
9733                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9734                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9735                      lang_printable_name (type, 0),
9736                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9737                   return 1;
9738                 }
9739
9740               field_decl = lookup_field_wrapper (type,
9741                                                  EXPR_WFL_NODE (qual_wfl));
9742
9743               /* Maybe what we're trying to access to is an inner
9744                  class, only if decl is a TYPE_DECL. */
9745               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9746                 {
9747                   tree ptr, inner_decl;
9748
9749                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9750                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9751                   if (inner_decl)
9752                     {
9753                       check_inner_class_access (inner_decl, decl, qual_wfl);
9754                       type = TREE_TYPE (inner_decl);
9755                       decl = inner_decl;
9756                       from_type = 1;
9757                       continue;
9758                     }
9759                 }
9760
9761               if (field_decl == NULL_TREE)
9762                 {
9763                   parse_error_context
9764                     (qual_wfl, "No variable `%s' defined in type `%s'",
9765                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9766                      GET_TYPE_NAME (type));
9767                   return 1;
9768                 }
9769               if (field_decl == error_mark_node)
9770                 return 1;
9771
9772               /* Layout the type of field_decl, since we may need
9773                  it. Don't do primitive types or loaded classes. The
9774                  situation of non primitive arrays may not handled
9775                  properly here. FIXME */
9776               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9777                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9778               else
9779                 field_decl_type = TREE_TYPE (field_decl);
9780               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9781                   && !CLASS_LOADED_P (field_decl_type)
9782                   && !TYPE_ARRAY_P (field_decl_type))
9783                 resolve_and_layout (field_decl_type, NULL_TREE);
9784
9785               /* Check on accessibility here */
9786               if (not_accessible_p (current_class, field_decl,
9787                                     DECL_CONTEXT (field_decl), from_super))
9788                 {
9789                   parse_error_context
9790                     (qual_wfl,
9791                      "Can't access %s field `%s.%s' from `%s'",
9792                      java_accstring_lookup
9793                        (get_access_flags_from_decl (field_decl)),
9794                      GET_TYPE_NAME (type),
9795                      IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9796                      IDENTIFIER_POINTER
9797                        (DECL_NAME (TYPE_NAME (current_class))));
9798                   return 1;
9799                 }
9800               check_deprecation (qual_wfl, field_decl);
9801
9802               /* There are things to check when fields are accessed
9803                  from type. There are no restrictions on a static
9804                  declaration of the field when it is accessed from an
9805                  interface */
9806               is_static = FIELD_STATIC (field_decl);
9807               if (!from_super && from_type
9808                   && !TYPE_INTERFACE_P (type)
9809                   && !is_static
9810                   && (current_function_decl
9811                       && METHOD_STATIC (current_function_decl)))
9812                 {
9813                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9814                   return 1;
9815                 }
9816               from_cast = from_super = 0;
9817
9818               /* It's an access from a type but it isn't static, we
9819                  make it relative to `this'. */
9820               if (!is_static && from_type)
9821                 decl = current_this;
9822
9823               /* If we need to generate something to get a proper
9824                  handle on what this field is accessed from, do it
9825                  now. */
9826               if (!is_static)
9827                 {
9828                   decl = maybe_access_field (decl, *where_found, *type_found);
9829                   if (decl == error_mark_node)
9830                     return 1;
9831                 }
9832
9833               /* We want to keep the location were found it, and the type
9834                  we found. */
9835               *where_found = decl;
9836               *type_found = type;
9837
9838               /* Generate the correct expression for field access from
9839                  qualified this */
9840               if (from_qualified_this)
9841                 {
9842                   field_decl = build_outer_field_access (qual_wfl, field_decl);
9843                   from_qualified_this = 0;
9844                 }
9845
9846               /* This is the decl found and eventually the next one to
9847                  search from */
9848               decl = field_decl;
9849             }
9850           from_type = 0;
9851           type = QUAL_DECL_TYPE (decl);
9852
9853           /* Sneak preview. If decl is qualified by a `new', report
9854              the error here to be accurate on the peculiar construct */
9855           if (TREE_CHAIN (q)
9856               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9857               && !JREFERENCE_TYPE_P (type))
9858             {
9859               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9860                                    lang_printable_name (type, 0));
9861               return 1;
9862             }
9863         }
9864       /* `q' might have changed due to a after package resolution
9865          re-qualification */
9866       if (!q)
9867         break;
9868     }
9869   *found_decl = decl;
9870   return 0;
9871 }
9872
9873 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9874    can't be accessed from REFERENCE (a record type). If MEMBER
9875    features a protected access, we then use WHERE which, if non null,
9876    holds the type of MEMBER's access that is checked against
9877    6.6.2.1. This function should be used when decl is a field or a
9878    method.  */
9879
9880 static int
9881 not_accessible_p (tree reference, tree member, tree where, int from_super)
9882 {
9883   int access_flag = get_access_flags_from_decl (member);
9884
9885   /* Inner classes are processed by check_inner_class_access */
9886   if (INNER_CLASS_TYPE_P (reference))
9887     return 0;
9888
9889   /* Access always granted for members declared public */
9890   if (access_flag & ACC_PUBLIC)
9891     return 0;
9892
9893   /* Check access on protected members */
9894   if (access_flag & ACC_PROTECTED)
9895     {
9896       /* Access granted if it occurs from within the package
9897          containing the class in which the protected member is
9898          declared */
9899       if (class_in_current_package (DECL_CONTEXT (member)))
9900         return 0;
9901
9902       /* If accessed with the form `super.member', then access is granted */
9903       if (from_super)
9904         return 0;
9905
9906       /* If where is active, access was made through a
9907          qualifier. Access is granted if the type of the qualifier is
9908          or is a sublass of the type the access made from (6.6.2.1.)  */
9909       if (where && !inherits_from_p (reference, where))
9910         return 1;
9911
9912       /* Otherwise, access is granted if occurring from the class where
9913          member is declared or a subclass of it. Find the right
9914          context to perform the check */
9915       if (PURE_INNER_CLASS_TYPE_P (reference))
9916         {
9917           while (INNER_CLASS_TYPE_P (reference))
9918             {
9919               if (inherits_from_p (reference, DECL_CONTEXT (member)))
9920                 return 0;
9921               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
9922             }
9923         }
9924       if (inherits_from_p (reference, DECL_CONTEXT (member)))
9925         return 0;
9926       return 1;
9927     }
9928
9929   /* Check access on private members. Access is granted only if it
9930      occurs from within the class in which it is declared -- that does
9931      it for innerclasses too. */
9932   if (access_flag & ACC_PRIVATE)
9933     {
9934       if (reference == DECL_CONTEXT (member))
9935         return 0;
9936       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
9937         return 0;
9938       return 1;
9939     }
9940
9941   /* Default access are permitted only when occurring within the
9942      package in which the type (REFERENCE) is declared. In other words,
9943      REFERENCE is defined in the current package */
9944   if (ctxp->package)
9945     return !class_in_current_package (reference);
9946
9947   /* Otherwise, access is granted */
9948   return 0;
9949 }
9950
9951 /* Test deprecated decl access.  */
9952 static void
9953 check_deprecation (tree wfl, tree decl)
9954 {
9955   const char *file = DECL_SOURCE_FILE (decl);
9956   /* Complain if the field is deprecated and the file it was defined
9957      in isn't compiled at the same time the file which contains its
9958      use is */
9959   if (DECL_DEPRECATED (decl)
9960       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
9961     {
9962       char the [20];
9963       switch (TREE_CODE (decl))
9964         {
9965         case FUNCTION_DECL:
9966           strcpy (the, "method");
9967           break;
9968         case FIELD_DECL:
9969         case VAR_DECL:
9970           strcpy (the, "field");
9971           break;
9972         case TYPE_DECL:
9973           parse_warning_context (wfl, "The class `%s' has been deprecated",
9974                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
9975           return;
9976         default:
9977           abort ();
9978         }
9979       /* Don't issue a message if the context as been deprecated as a
9980          whole. */
9981       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
9982         parse_warning_context
9983           (wfl, "The %s `%s' in class `%s' has been deprecated",
9984            the, lang_printable_name (decl, 0),
9985            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
9986     }
9987 }
9988
9989 /* Returns 1 if class was declared in the current package, 0 otherwise */
9990
9991 static GTY(()) tree cicp_cache;
9992 static int
9993 class_in_current_package (tree class)
9994 {
9995   int qualified_flag;
9996   tree left;
9997
9998   if (cicp_cache == class)
9999     return 1;
10000
10001   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10002
10003   /* If the current package is empty and the name of CLASS is
10004      qualified, class isn't in the current package.  If there is a
10005      current package and the name of the CLASS is not qualified, class
10006      isn't in the current package */
10007   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10008     return 0;
10009
10010   /* If there is not package and the name of CLASS isn't qualified,
10011      they belong to the same unnamed package */
10012   if (!ctxp->package && !qualified_flag)
10013     return 1;
10014
10015   /* Compare the left part of the name of CLASS with the package name */
10016   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10017   if (ctxp->package == left)
10018     {
10019       cicp_cache = class;
10020       return 1;
10021     }
10022   return 0;
10023 }
10024
10025 /* This function may generate code to access DECL from WHERE. This is
10026    done only if certain conditions meet.  */
10027
10028 static tree
10029 maybe_access_field (tree decl, tree where, tree type)
10030 {
10031   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10032       && !FIELD_STATIC (decl))
10033     decl = build_field_ref (where ? where : current_this,
10034                             (type ? type : DECL_CONTEXT (decl)),
10035                             DECL_NAME (decl));
10036   return decl;
10037 }
10038
10039 /* Build a method invocation, by patching PATCH. If non NULL
10040    and according to the situation, PRIMARY and WHERE may be
10041    used. IS_STATIC is set to 1 if the invoked function is static. */
10042
10043 static tree
10044 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10045                          int *is_static, tree *ret_decl)
10046 {
10047   tree wfl = TREE_OPERAND (patch, 0);
10048   tree args = TREE_OPERAND (patch, 1);
10049   tree name = EXPR_WFL_NODE (wfl);
10050   tree list;
10051   int is_static_flag = 0;
10052   int is_super_init = 0;
10053   tree this_arg = NULL_TREE;
10054   int is_array_clone_call = 0;
10055
10056   /* Should be overriden if everything goes well. Otherwise, if
10057      something fails, it should keep this value. It stop the
10058      evaluation of a bogus assignment. See java_complete_tree,
10059      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10060      evaluating an assignment */
10061   TREE_TYPE (patch) = error_mark_node;
10062
10063   /* Since lookup functions are messing with line numbers, save the
10064      context now.  */
10065   java_parser_context_save_global ();
10066
10067   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10068
10069   /* Resolution of qualified name, excluding constructors */
10070   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10071     {
10072       tree identifier, identifier_wfl, type, resolved;
10073       /* Extract the last IDENTIFIER of the qualified
10074          expression. This is a wfl and we will use it's location
10075          data during error report. */
10076       identifier_wfl = cut_identifier_in_qualified (wfl);
10077       identifier = EXPR_WFL_NODE (identifier_wfl);
10078
10079       /* Given the context, IDENTIFIER is syntactically qualified
10080          as a MethodName. We need to qualify what's before */
10081       qualify_ambiguous_name (wfl);
10082       resolved = resolve_field_access (wfl, NULL, NULL);
10083
10084       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10085          && FIELD_FINAL (resolved)
10086          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10087          && !flag_emit_class_files && !flag_emit_xref)
10088        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10089
10090       if (resolved == error_mark_node)
10091         PATCH_METHOD_RETURN_ERROR ();
10092
10093       type = GET_SKIP_TYPE (resolved);
10094       resolve_and_layout (type, NULL_TREE);
10095
10096       if (JPRIMITIVE_TYPE_P (type))
10097         {
10098           parse_error_context
10099             (identifier_wfl,
10100              "Can't invoke a method on primitive type `%s'",
10101              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10102           PATCH_METHOD_RETURN_ERROR ();
10103         }
10104
10105       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10106       args = nreverse (args);
10107
10108       /* We're resolving a call from a type */
10109       if (TREE_CODE (resolved) == TYPE_DECL)
10110         {
10111           if (CLASS_INTERFACE (resolved))
10112             {
10113               parse_error_context
10114                 (identifier_wfl,
10115                 "Can't make static reference to method `%s' in interface `%s'",
10116                  IDENTIFIER_POINTER (identifier),
10117                  IDENTIFIER_POINTER (name));
10118               PATCH_METHOD_RETURN_ERROR ();
10119             }
10120           if (list && !METHOD_STATIC (list))
10121             {
10122               char *fct_name = xstrdup (lang_printable_name (list, 0));
10123               parse_error_context
10124                 (identifier_wfl,
10125                  "Can't make static reference to method `%s %s' in class `%s'",
10126                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10127                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10128               free (fct_name);
10129               PATCH_METHOD_RETURN_ERROR ();
10130             }
10131         }
10132       else
10133         this_arg = primary = resolved;
10134
10135       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10136         is_array_clone_call = 1;
10137
10138       /* IDENTIFIER_WFL will be used to report any problem further */
10139       wfl = identifier_wfl;
10140     }
10141   /* Resolution of simple names, names generated after a primary: or
10142      constructors */
10143   else
10144     {
10145       tree class_to_search = NULL_TREE;
10146       int lc;                   /* Looking for Constructor */
10147
10148       /* We search constructor in their target class */
10149       if (CALL_CONSTRUCTOR_P (patch))
10150         {
10151           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10152             class_to_search = EXPR_WFL_NODE (wfl);
10153           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10154                    this_identifier_node)
10155             class_to_search = NULL_TREE;
10156           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10157                    super_identifier_node)
10158             {
10159               is_super_init = 1;
10160               if (CLASSTYPE_SUPER (current_class))
10161                 class_to_search =
10162                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10163               else
10164                 {
10165                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10166                   PATCH_METHOD_RETURN_ERROR ();
10167                 }
10168             }
10169
10170           /* Class to search is NULL if we're searching the current one */
10171           if (class_to_search)
10172             {
10173               class_to_search = resolve_and_layout (class_to_search, wfl);
10174
10175               if (!class_to_search)
10176                 {
10177                   parse_error_context
10178                     (wfl, "Class `%s' not found in type declaration",
10179                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10180                   PATCH_METHOD_RETURN_ERROR ();
10181                 }
10182
10183               /* Can't instantiate an abstract class, but we can
10184                  invoke it's constructor. It's use within the `new'
10185                  context is denied here. */
10186               if (CLASS_ABSTRACT (class_to_search)
10187                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10188                 {
10189                   parse_error_context
10190                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10191                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10192                   PATCH_METHOD_RETURN_ERROR ();
10193                 }
10194
10195               class_to_search = TREE_TYPE (class_to_search);
10196             }
10197           else
10198             class_to_search = current_class;
10199           lc = 1;
10200         }
10201       /* This is a regular search in the local class, unless an
10202          alternate class is specified. */
10203       else
10204         {
10205           if (where != NULL_TREE)
10206             class_to_search = where;
10207           else if (QUALIFIED_P (name))
10208             class_to_search = current_class;
10209           else
10210             {
10211               class_to_search = current_class;
10212
10213               for (;;)
10214                 {
10215                   if (has_method (class_to_search, name))
10216                     break;
10217                   if (! INNER_CLASS_TYPE_P (class_to_search))
10218                     {
10219                       parse_error_context (wfl,
10220                                            "No method named `%s' in scope",
10221                                            IDENTIFIER_POINTER (name));
10222                       PATCH_METHOD_RETURN_ERROR ();
10223                     }
10224                   class_to_search
10225                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10226                 }
10227             }
10228           lc = 0;
10229         }
10230
10231       /* NAME is a simple identifier or comes from a primary. Search
10232          in the class whose declaration contain the method being
10233          invoked. */
10234       resolve_and_layout (class_to_search, NULL_TREE);
10235
10236       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10237       /* Don't continue if no method were found, as the next statement
10238          can't be executed then. */
10239       if (!list)
10240         PATCH_METHOD_RETURN_ERROR ();
10241
10242       if (TYPE_ARRAY_P (class_to_search)
10243           && DECL_NAME (list) == get_identifier ("clone"))
10244         is_array_clone_call = 1;
10245
10246       /* Check for static reference if non static methods */
10247       if (check_for_static_method_reference (wfl, patch, list,
10248                                              class_to_search, primary))
10249         PATCH_METHOD_RETURN_ERROR ();
10250
10251       /* Check for inner classes creation from illegal contexts */
10252       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10253                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10254           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10255           && !DECL_INIT_P (current_function_decl))
10256         {
10257           parse_error_context
10258             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10259              lang_printable_name (class_to_search, 0),
10260              (!current_this ? "" :
10261               "; an explicit one must be provided when creating this inner class"));
10262           PATCH_METHOD_RETURN_ERROR ();
10263         }
10264
10265       /* Non static methods are called with the current object extra
10266          argument. If patch a `new TYPE()', the argument is the value
10267          returned by the object allocator. If method is resolved as a
10268          primary, use the primary otherwise use the current THIS. */
10269       args = nreverse (args);
10270       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10271         {
10272           this_arg = primary ? primary : current_this;
10273
10274           /* If we're using an access method, things are different.
10275              There are two familly of cases:
10276
10277              1) We're not generating bytecodes:
10278
10279              - LIST is non static. It's invocation is transformed from
10280                x(a1,...,an) into this$<n>.x(a1,....an).
10281              - LIST is static. It's invocation is transformed from
10282                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10283
10284              2) We're generating bytecodes:
10285
10286              - LIST is non static. It's invocation is transformed from
10287                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10288              - LIST is static. It's invocation is transformed from
10289                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10290
10291              Of course, this$<n> can be abitrary complex, ranging from
10292              this$0 (the immediate outer context) to
10293              access$0(access$0(...(this$0))).
10294
10295              maybe_use_access_method returns a nonzero value if the
10296              this_arg has to be moved into the (then generated) stub
10297              argument list. In the meantime, the selected function
10298              might have be replaced by a generated stub. */
10299           if (!primary &&
10300               maybe_use_access_method (is_super_init, &list, &this_arg))
10301             {
10302               args = tree_cons (NULL_TREE, this_arg, args);
10303               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10304             }
10305         }
10306     }
10307
10308   /* Merge point of all resolution schemes. If we have nothing, this
10309      is an error, already signaled */
10310   if (!list)
10311     PATCH_METHOD_RETURN_ERROR ();
10312
10313   /* Check accessibility, position the is_static flag, build and
10314      return the call */
10315   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10316                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10317                          NULL_TREE), from_super)
10318       /* Calls to clone() on array types are permitted as a special-case. */
10319       && !is_array_clone_call)
10320     {
10321       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10322       const char *const access =
10323         java_accstring_lookup (get_access_flags_from_decl (list));
10324       const char *const klass =
10325         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10326       const char *const refklass =
10327         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10328       const char *const what = (DECL_CONSTRUCTOR_P (list)
10329                                 ? "constructor" : "method");
10330       /* FIXME: WFL yields the wrong message here but I don't know
10331          what else to use.  */
10332       parse_error_context (wfl,
10333                            "Can't access %s %s `%s.%s' from `%s'",
10334                            access, what, klass, fct_name, refklass);
10335       PATCH_METHOD_RETURN_ERROR ();
10336     }
10337
10338   /* Deprecation check: check whether the method being invoked or the
10339      instance-being-created's type are deprecated. */
10340   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10341     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10342   else
10343     check_deprecation (wfl, list);
10344
10345   /* If invoking a innerclass constructor, there are hidden parameters
10346      to pass */
10347   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10348       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10349     {
10350       /* And make sure we add the accessed local variables to be saved
10351          in field aliases. */
10352       args = build_alias_initializer_parameter_list
10353         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10354
10355       /* Secretly pass the current_this/primary as a second argument */
10356       if (primary || current_this)
10357         {
10358           tree extra_arg;
10359           tree this_type = (current_this ?
10360                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10361           /* Method's (list) enclosing context */
10362           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10363           /* If we have a primary, use it. */
10364           if (primary)
10365             extra_arg = primary;
10366           /* The current `this' is an inner class but isn't a direct
10367              enclosing context for the inner class we're trying to
10368              create. Build an access to the proper enclosing context
10369              and use it. */
10370           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10371                    && this_type != TREE_TYPE (mec))
10372             {
10373
10374               extra_arg = build_access_to_thisn (current_class,
10375                                                  TREE_TYPE (mec), 0);
10376               extra_arg = java_complete_tree (extra_arg);
10377             }
10378           /* Otherwise, just use the current `this' as an enclosing
10379              context. */
10380           else
10381             extra_arg = current_this;
10382           args = tree_cons (NULL_TREE, extra_arg, args);
10383         }
10384       else
10385         args = tree_cons (NULL_TREE, integer_zero_node, args);
10386     }
10387
10388   /* This handles the situation where a constructor invocation needs
10389      to have an enclosing context passed as a second parameter (the
10390      constructor is one of an inner class). */
10391   if ((is_super_init ||
10392        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10393       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10394     {
10395       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10396       tree extra_arg =
10397         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10398       extra_arg = java_complete_tree (extra_arg);
10399       args = tree_cons (NULL_TREE, extra_arg, args);
10400     }
10401
10402   is_static_flag = METHOD_STATIC (list);
10403   if (! is_static_flag && this_arg != NULL_TREE)
10404     args = tree_cons (NULL_TREE, this_arg, args);
10405
10406   /* In the context of an explicit constructor invocation, we can't
10407      invoke any method relying on `this'. Exceptions are: we're
10408      invoking a static function, primary exists and is not the current
10409      this, we're creating a new object. */
10410   if (ctxp->explicit_constructor_p
10411       && !is_static_flag
10412       && (!primary || primary == current_this)
10413       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10414     {
10415       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10416       PATCH_METHOD_RETURN_ERROR ();
10417     }
10418   java_parser_context_restore_global ();
10419   if (is_static)
10420     *is_static = is_static_flag;
10421   /* Sometimes, we want the decl of the selected method. Such as for
10422      EH checking */
10423   if (ret_decl)
10424     *ret_decl = list;
10425   patch = patch_invoke (patch, list, args);
10426
10427   /* Now is a good time to insert the call to finit$ */
10428   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10429     {
10430       tree finit_parms, finit_call;
10431
10432       /* Prepare to pass hidden parameters to finit$, if any. */
10433       finit_parms = build_alias_initializer_parameter_list
10434         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10435
10436       finit_call =
10437         build_method_invocation (build_wfl_node (finit_identifier_node),
10438                                  finit_parms);
10439
10440       /* Generate the code used to initialize fields declared with an
10441          initialization statement and build a compound statement along
10442          with the super constructor invocation. */
10443       CAN_COMPLETE_NORMALLY (patch) = 1;
10444       patch = build (COMPOUND_EXPR, void_type_node, patch,
10445                      java_complete_tree (finit_call));
10446     }
10447   return patch;
10448 }
10449
10450 /* Check that we're not trying to do a static reference to a method in
10451    non static method. Return 1 if it's the case, 0 otherwise. */
10452
10453 static int
10454 check_for_static_method_reference (tree wfl, tree node, tree method,
10455                                    tree where, tree primary)
10456 {
10457   if (METHOD_STATIC (current_function_decl)
10458       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10459     {
10460       char *fct_name = xstrdup (lang_printable_name (method, 0));
10461       parse_error_context
10462         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10463          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10464          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10465       free (fct_name);
10466       return 1;
10467     }
10468   return 0;
10469 }
10470
10471 /* Fix the invocation of *MDECL if necessary in the case of a
10472    invocation from an inner class. *THIS_ARG might be modified
10473    appropriately and an alternative access to *MDECL might be
10474    returned.  */
10475
10476 static int
10477 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10478 {
10479   tree ctx;
10480   tree md = *mdecl, ta = *this_arg;
10481   int to_return = 0;
10482   int non_static_context = !METHOD_STATIC (md);
10483
10484   if (is_super_init
10485       || DECL_CONTEXT (md) == current_class
10486       || !PURE_INNER_CLASS_TYPE_P (current_class)
10487       || DECL_FINIT_P (md)
10488       || DECL_INSTINIT_P (md))
10489     return 0;
10490
10491   /* If we're calling a method found in an enclosing class, generate
10492      what it takes to retrieve the right this. Don't do that if we're
10493      invoking a static method. Note that if MD's type is unrelated to
10494      CURRENT_CLASS, then the current this can be used. */
10495
10496   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10497     {
10498       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10499       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10500         {
10501           ta = build_current_thisn (current_class);
10502           ta = build_wfl_node (ta);
10503         }
10504       else
10505         {
10506           tree type = ctx;
10507           while (type)
10508             {
10509               maybe_build_thisn_access_method (type);
10510               if (inherits_from_p (type, DECL_CONTEXT (md)))
10511                 {
10512                   ta = build_access_to_thisn (ctx, type, 0);
10513                   break;
10514                 }
10515               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10516                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10517             }
10518         }
10519       ta = java_complete_tree (ta);
10520     }
10521
10522   /* We might have to use an access method to get to MD. We can
10523      break the method access rule as far as we're not generating
10524      bytecode */
10525   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10526     {
10527       md = build_outer_method_access_method (md);
10528       to_return = 1;
10529     }
10530
10531   *mdecl = md;
10532   *this_arg = ta;
10533
10534   /* Returnin a nonzero value indicates we were doing a non static
10535      method invokation that is now a static invocation. It will have
10536      callee displace `this' to insert it in the regular argument
10537      list. */
10538   return (non_static_context && to_return);
10539 }
10540
10541 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10542    mode.  */
10543
10544 static tree
10545 patch_invoke (tree patch, tree method, tree args)
10546 {
10547   tree dtable, func;
10548   tree original_call, t, ta;
10549   tree check = NULL_TREE;
10550
10551   /* Last step for args: convert build-in types. If we're dealing with
10552      a new TYPE() type call, the first argument to the constructor
10553      isn't found in the incoming argument list, but delivered by
10554      `new' */
10555   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10556   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10557     t = TREE_CHAIN (t);
10558   for (ta = args; t != end_params_node && ta;
10559        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10560     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10561         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10562       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10563
10564   /* Resolve unresolved returned type isses */
10565   t = TREE_TYPE (TREE_TYPE (method));
10566   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10567     resolve_and_layout (TREE_TYPE (t), NULL);
10568
10569   if (flag_emit_class_files || flag_emit_xref)
10570     func = method;
10571   else
10572     {
10573       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10574         {
10575         case INVOKE_VIRTUAL:
10576           dtable = invoke_build_dtable (0, args);
10577           func = build_invokevirtual (dtable, method);
10578           break;
10579
10580         case INVOKE_NONVIRTUAL:
10581           /* If the object for the method call is null, we throw an
10582              exception.  We don't do this if the object is the current
10583              method's `this'.  In other cases we just rely on an
10584              optimization pass to eliminate redundant checks.  */
10585           if (TREE_VALUE (args) != current_this)
10586             {
10587               /* We use a save_expr here to make sure we only evaluate
10588                  the new `self' expression once.  */
10589               tree save_arg = save_expr (TREE_VALUE (args));
10590               TREE_VALUE (args) = save_arg;
10591               check = java_check_reference (save_arg, 1);
10592             }
10593           /* Fall through.  */
10594
10595         case INVOKE_SUPER:
10596         case INVOKE_STATIC:
10597           {
10598             tree signature = build_java_signature (TREE_TYPE (method));
10599             func = build_known_method_ref (method, TREE_TYPE (method),
10600                                            DECL_CONTEXT (method),
10601                                            signature, args);
10602           }
10603           break;
10604
10605         case INVOKE_INTERFACE:
10606           dtable = invoke_build_dtable (1, args);
10607           func = build_invokeinterface (dtable, method);
10608           break;
10609
10610         default:
10611           abort ();
10612         }
10613
10614       /* Ensure self_type is initialized, (invokestatic). FIXME */
10615       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10616     }
10617
10618   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10619   TREE_OPERAND (patch, 0) = func;
10620   TREE_OPERAND (patch, 1) = args;
10621   patch = check_for_builtin (method, patch);
10622   original_call = patch;
10623
10624   /* We're processing a `new TYPE ()' form. New is called and its
10625      returned value is the first argument to the constructor. We build
10626      a COMPOUND_EXPR and use saved expression so that the overall NEW
10627      expression value is a pointer to a newly created and initialized
10628      class. */
10629   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10630     {
10631       tree class = DECL_CONTEXT (method);
10632       tree c1, saved_new, size, new;
10633       tree alloc_node;
10634
10635       if (flag_emit_class_files || flag_emit_xref)
10636         {
10637           TREE_TYPE (patch) = build_pointer_type (class);
10638           return patch;
10639         }
10640       if (!TYPE_SIZE (class))
10641         safe_layout_class (class);
10642       size = size_in_bytes (class);
10643       alloc_node =
10644         (class_has_finalize_method (class) ? alloc_object_node
10645                                            : alloc_no_finalizer_node);
10646       new = build (CALL_EXPR, promote_type (class),
10647                    build_address_of (alloc_node),
10648                    tree_cons (NULL_TREE, build_class_ref (class),
10649                               build_tree_list (NULL_TREE,
10650                                                size_in_bytes (class))),
10651                    NULL_TREE);
10652       saved_new = save_expr (new);
10653       c1 = build_tree_list (NULL_TREE, saved_new);
10654       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10655       TREE_OPERAND (original_call, 1) = c1;
10656       TREE_SET_CODE (original_call, CALL_EXPR);
10657       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10658     }
10659
10660   /* If CHECK is set, then we are building a check to see if the object
10661      is NULL.  */
10662   if (check != NULL_TREE)
10663     {
10664       /* We have to call force_evaluation_order now because creating a
10665          COMPOUND_EXPR wraps the arg list in a way that makes it
10666          unrecognizable by force_evaluation_order later.  Yuk.  */
10667       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10668                      force_evaluation_order (patch));
10669       TREE_SIDE_EFFECTS (patch) = 1;
10670     }
10671
10672   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10673      put it as the first expression of a COMPOUND_EXPR. The second
10674      expression being an empty statement to be later patched if
10675      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10676      the VALUE is the compound) in a hashtable and return a
10677      COMPOUND_EXPR built so that the result of the evaluation of the
10678      original PATCH node is returned. */
10679   if (STATIC_CLASS_INIT_OPT_P ()
10680       && current_function_decl && METHOD_STATIC (method))
10681     {
10682       tree list;
10683       tree fndecl = current_function_decl;
10684       /* We have to call force_evaluation_order now because creating a
10685          COMPOUND_EXPR wraps the arg list in a way that makes it
10686          unrecognizable by force_evaluation_order later.  Yuk.  */
10687       tree save = save_expr (force_evaluation_order (patch));
10688       tree type = TREE_TYPE (patch);
10689
10690       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10691       list = tree_cons (method, patch,
10692                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10693
10694       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10695
10696       patch = build (COMPOUND_EXPR, type, patch, save);
10697     }
10698
10699   return patch;
10700 }
10701
10702 static int
10703 invocation_mode (tree method, int super)
10704 {
10705   int access = get_access_flags_from_decl (method);
10706
10707   if (super)
10708     return INVOKE_SUPER;
10709
10710   if (access & ACC_STATIC)
10711     return INVOKE_STATIC;
10712
10713   /* We have to look for a constructor before we handle nonvirtual
10714      calls; otherwise the constructor will look nonvirtual.  */
10715   if (DECL_CONSTRUCTOR_P (method))
10716     return INVOKE_STATIC;
10717
10718   if (access & ACC_FINAL || access & ACC_PRIVATE)
10719     return INVOKE_NONVIRTUAL;
10720
10721   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10722     return INVOKE_NONVIRTUAL;
10723
10724   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10725     return INVOKE_INTERFACE;
10726
10727   return INVOKE_VIRTUAL;
10728 }
10729
10730 /* Retrieve a refined list of matching methods. It covers the step
10731    15.11.2 (Compile-Time Step 2) */
10732
10733 static tree
10734 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10735 {
10736   tree atl = end_params_node;           /* Arg Type List */
10737   tree method, signature, list, node;
10738   const char *candidates;               /* Used for error report */
10739   char *dup;
10740
10741   /* Fix the arguments */
10742   for (node = arg_list; node; node = TREE_CHAIN (node))
10743     {
10744       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10745       /* Non primitive type may have to be resolved */
10746       if (!JPRIMITIVE_TYPE_P (current_arg))
10747         resolve_and_layout (current_arg, NULL_TREE);
10748       /* And promoted */
10749       if (TREE_CODE (current_arg) == RECORD_TYPE)
10750         current_arg = promote_type (current_arg);
10751       atl = tree_cons (NULL_TREE, current_arg, atl);
10752     }
10753
10754   /* Presto. If we're dealing with an anonymous class and a
10755      constructor call, generate the right constructor now, since we
10756      know the arguments' types. */
10757
10758   if (lc && ANONYMOUS_CLASS_P (class))
10759     {
10760       tree saved_current_class;
10761       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10762       saved_current_class = current_class;
10763       current_class = class;
10764       fix_constructors (mdecl);
10765       current_class = saved_current_class;
10766     }
10767
10768   /* Find all candidates and then refine the list, searching for the
10769      most specific method. */
10770   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10771   list = find_most_specific_methods_list (list);
10772   if (list && !TREE_CHAIN (list))
10773     return TREE_VALUE (list);
10774
10775   /* Issue an error. List candidates if any. Candidates are listed
10776      only if accessible (non accessible methods may end-up here for
10777      the sake of a better error report). */
10778   candidates = NULL;
10779   if (list)
10780     {
10781       tree current;
10782       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10783       for (current = list; current; current = TREE_CHAIN (current))
10784         {
10785           tree cm = TREE_VALUE (current);
10786           char string [4096];
10787           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10788             continue;
10789           sprintf
10790             (string, "  `%s' in `%s'%s",
10791              get_printable_method_name (cm),
10792              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10793              (TREE_CHAIN (current) ? "\n" : ""));
10794           obstack_grow (&temporary_obstack, string, strlen (string));
10795         }
10796       obstack_1grow (&temporary_obstack, '\0');
10797       candidates = obstack_finish (&temporary_obstack);
10798     }
10799   /* Issue the error message */
10800   method = make_node (FUNCTION_TYPE);
10801   TYPE_ARG_TYPES (method) = atl;
10802   signature = build_java_argument_signature (method);
10803   dup = xstrdup (lang_printable_name (class, 0));
10804   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10805                        (lc ? "constructor" : "method"),
10806                        (lc ? dup : IDENTIFIER_POINTER (name)),
10807                        IDENTIFIER_POINTER (signature), dup,
10808                        (candidates ? candidates : ""));
10809   free (dup);
10810   return NULL_TREE;
10811 }
10812
10813 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10814    when we're looking for a constructor. */
10815
10816 static tree
10817 find_applicable_accessible_methods_list (int lc, tree class, tree name,
10818                                          tree arglist)
10819 {
10820   static htab_t searched_classes;
10821   static int search_not_done = 0;
10822   tree list = NULL_TREE, all_list = NULL_TREE;
10823
10824   /* Check the hash table to determine if this class has been searched
10825      already. */
10826   if (searched_classes)
10827     {
10828       if (htab_find (searched_classes, class) != NULL)
10829         return NULL;
10830     }
10831   else
10832     {
10833       searched_classes = htab_create (10, htab_hash_pointer,
10834                                       htab_eq_pointer, NULL);
10835     }
10836
10837   search_not_done++;
10838   *htab_find_slot (searched_classes, class, INSERT) = class;
10839
10840   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
10841     {
10842       load_class (class, 1);
10843       safe_layout_class (class);
10844     }
10845
10846   /* Search interfaces */
10847   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
10848       && CLASS_INTERFACE (TYPE_NAME (class)))
10849     {
10850       int i, n;
10851       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
10852       search_applicable_methods_list (lc, TYPE_METHODS (class),
10853                                       name, arglist, &list, &all_list);
10854       n = TREE_VEC_LENGTH (basetype_vec);
10855       for (i = 1; i < n; i++)
10856         {
10857           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10858           tree rlist;
10859
10860           rlist = find_applicable_accessible_methods_list (lc,  t, name,
10861                                                            arglist);
10862           list = chainon (rlist, list);
10863         }
10864     }
10865   /* Search classes */
10866   else
10867     {
10868       search_applicable_methods_list (lc, TYPE_METHODS (class),
10869                                       name, arglist, &list, &all_list);
10870
10871       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
10872          that we only search in class. Note that we should have found
10873          something at this point. */
10874       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
10875         {
10876           lc = 1;
10877           if (!list)
10878             abort ();
10879         }
10880
10881       /* We must search all interfaces of this class */
10882       if (!lc)
10883       {
10884         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
10885         int n = TREE_VEC_LENGTH (basetype_vec), i;
10886         for (i = 1; i < n; i++)
10887           {
10888             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10889             if (t != object_type_node)
10890               {
10891                 tree rlist
10892                   = find_applicable_accessible_methods_list (lc, t,
10893                                                              name, arglist);
10894                 list = chainon (rlist, list);
10895               }
10896           }
10897       }
10898
10899       /* Search superclass */
10900       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
10901         {
10902           tree rlist;
10903           class = CLASSTYPE_SUPER (class);
10904           rlist = find_applicable_accessible_methods_list (lc, class,
10905                                                            name, arglist);
10906           list = chainon (rlist, list);
10907         }
10908     }
10909
10910   search_not_done--;
10911
10912   /* We're done. Reset the searched classes list and finally search
10913      java.lang.Object if it wasn't searched already. */
10914   if (!search_not_done)
10915     {
10916       if (!lc
10917           && TYPE_METHODS (object_type_node)
10918           && htab_find (searched_classes, object_type_node) == NULL)
10919         {
10920           search_applicable_methods_list (lc,
10921                                           TYPE_METHODS (object_type_node),
10922                                           name, arglist, &list, &all_list);
10923         }
10924       htab_delete (searched_classes);
10925       searched_classes = NULL;
10926     }
10927
10928   /* Either return the list obtained or all selected (but
10929      inaccessible) methods for better error report. */
10930   return (!list ? all_list : list);
10931 }
10932
10933 /* Effectively search for the appropriate method in method */
10934
10935 static void
10936 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
10937                                 tree *list, tree *all_list)
10938 {
10939   for (; method; method = TREE_CHAIN (method))
10940     {
10941       /* When dealing with constructor, stop here, otherwise search
10942          other classes */
10943       if (lc && !DECL_CONSTRUCTOR_P (method))
10944         continue;
10945       else if (!lc && (DECL_CONSTRUCTOR_P (method)
10946                        || (DECL_NAME (method) != name)))
10947         continue;
10948
10949       if (argument_types_convertible (method, arglist))
10950         {
10951           /* Retain accessible methods only */
10952           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
10953                                  method, NULL_TREE, 0))
10954             *list = tree_cons (NULL_TREE, method, *list);
10955           else
10956             /* Also retain all selected method here */
10957             *all_list = tree_cons (NULL_TREE, method, *list);
10958         }
10959     }
10960 }
10961
10962 /* 15.11.2.2 Choose the Most Specific Method */
10963
10964 static tree
10965 find_most_specific_methods_list (tree list)
10966 {
10967   int max = 0;
10968   int abstract, candidates;
10969   tree current, new_list = NULL_TREE;
10970   for (current = list; current; current = TREE_CHAIN (current))
10971     {
10972       tree method;
10973       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
10974
10975       for (method = list; method; method = TREE_CHAIN (method))
10976         {
10977           tree method_v, current_v;
10978           /* Don't test a method against itself */
10979           if (method == current)
10980             continue;
10981
10982           method_v = TREE_VALUE (method);
10983           current_v = TREE_VALUE (current);
10984
10985           /* Compare arguments and location where methods where declared */
10986           if (argument_types_convertible (method_v, current_v))
10987             {
10988               if (valid_method_invocation_conversion_p
10989                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
10990                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
10991                       && enclosing_context_p (DECL_CONTEXT (method_v),
10992                                               DECL_CONTEXT (current_v))))
10993                 {
10994                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
10995                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
10996                   max = (v > max ? v : max);
10997                 }
10998             }
10999         }
11000     }
11001
11002   /* Review the list and select the maximally specific methods */
11003   for (current = list, abstract = -1, candidates = -1;
11004        current; current = TREE_CHAIN (current))
11005     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11006       {
11007         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11008         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11009         candidates++;
11010       }
11011
11012   /* If we have several and they're all abstract, just pick the
11013      closest one. */
11014   if (candidates > 0 && (candidates == abstract))
11015     {
11016       new_list = nreverse (new_list);
11017       TREE_CHAIN (new_list) = NULL_TREE;
11018     }
11019
11020   /* We have several (we couldn't find a most specific), all but one
11021      are abstract, we pick the only non abstract one. */
11022   if (candidates > 0 && (candidates == abstract+1))
11023     {
11024       for (current = new_list; current; current = TREE_CHAIN (current))
11025         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11026           {
11027             TREE_CHAIN (current) = NULL_TREE;
11028             new_list = current;
11029           }
11030     }
11031
11032   /* If we can't find one, lower expectations and try to gather multiple
11033      maximally specific methods */
11034   while (!new_list && max)
11035     {
11036       while (--max > 0)
11037         {
11038           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11039             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11040         }
11041     }
11042
11043   return new_list;
11044 }
11045
11046 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11047    converted by method invocation conversion (5.3) to the type of the
11048    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11049    to change less often than M1. */
11050
11051 static GTY(()) tree m2_arg_value;
11052 static GTY(()) tree m2_arg_cache;
11053
11054 static int
11055 argument_types_convertible (tree m1, tree m2_or_arglist)
11056 {
11057   register tree m1_arg, m2_arg;
11058
11059   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11060
11061   if (m2_arg_value == m2_or_arglist)
11062     m2_arg = m2_arg_cache;
11063   else
11064     {
11065       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11066          argument types */
11067       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11068         {
11069           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11070           if (!METHOD_STATIC (m2_or_arglist))
11071             m2_arg = TREE_CHAIN (m2_arg);
11072         }
11073       else
11074         m2_arg = m2_or_arglist;
11075
11076       m2_arg_value = m2_or_arglist;
11077       m2_arg_cache = m2_arg;
11078     }
11079
11080   while (m1_arg != end_params_node && m2_arg != end_params_node)
11081     {
11082       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11083       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11084                                                  TREE_VALUE (m2_arg)))
11085         break;
11086       m1_arg = TREE_CHAIN (m1_arg);
11087       m2_arg = TREE_CHAIN (m2_arg);
11088     }
11089   return m1_arg == end_params_node && m2_arg == end_params_node;
11090 }
11091
11092 /* Qualification routines */
11093
11094 static void
11095 qualify_ambiguous_name (tree id)
11096 {
11097   tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
11098     saved_current_class;
11099   int again, super_found = 0, this_found = 0, new_array_found = 0;
11100   int code;
11101
11102   /* We first qualify the first element, then derive qualification of
11103      others based on the first one. If the first element is qualified
11104      by a resolution (field or type), this resolution is stored in the
11105      QUAL_RESOLUTION of the qual element being examined. We need to
11106      save the current_class since the use of SUPER might change the
11107      its value. */
11108   saved_current_class = current_class;
11109   qual = EXPR_WFL_QUALIFICATION (id);
11110   do {
11111
11112     /* Simple qualified expression feature a qual_wfl that is a
11113        WFL. Expression derived from a primary feature more complicated
11114        things like a CALL_EXPR. Expression from primary need to be
11115        worked out to extract the part on which the qualification will
11116        take place. */
11117     qual_wfl = QUAL_WFL (qual);
11118     switch (TREE_CODE (qual_wfl))
11119       {
11120       case CALL_EXPR:
11121         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11122         if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION
11123             || (EXPR_WFL_QUALIFICATION (qual_wfl)
11124                 && TREE_CODE (EXPR_WFL_QUALIFICATION (qual_wfl)) == TREE_LIST))
11125           {
11126             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11127             qual_wfl = QUAL_WFL (qual);
11128           }
11129         break;
11130       case NEW_ARRAY_EXPR:
11131       case NEW_ANONYMOUS_ARRAY_EXPR:
11132         qual = TREE_CHAIN (qual);
11133         again = new_array_found = 1;
11134         continue;
11135       case CONVERT_EXPR:
11136         break;
11137       case NEW_CLASS_EXPR:
11138         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11139         break;
11140       case ARRAY_REF:
11141         while (TREE_CODE (qual_wfl) == ARRAY_REF)
11142           qual_wfl = TREE_OPERAND (qual_wfl, 0);
11143         break;
11144       case STRING_CST:
11145         qual = TREE_CHAIN (qual);
11146         qual_wfl = QUAL_WFL (qual);
11147         break;
11148       case CLASS_LITERAL:
11149         qual = TREE_CHAIN (qual);
11150         qual_wfl = QUAL_WFL (qual);
11151       break;
11152       default:
11153         /* Fix for -Wall. Just break doing nothing */
11154         break;
11155       }
11156
11157     ptr_type = current_class;
11158     again = 0;
11159     code = TREE_CODE (qual_wfl);
11160
11161     /* Pos evaluation: non WFL leading expression nodes */
11162     if (code == CONVERT_EXPR
11163         && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
11164       name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
11165
11166     else if (code == INTEGER_CST)
11167       name = qual_wfl;
11168
11169     else if (code == CONVERT_EXPR &&
11170              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11171       name = TREE_OPERAND (qual_wfl, 0);
11172
11173     else if (code == CONVERT_EXPR
11174              && TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == CALL_EXPR
11175              && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0))
11176                  == EXPR_WITH_FILE_LOCATION))
11177       name = TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0);
11178
11179     else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
11180              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11181       name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
11182
11183     else if (code == TREE_LIST)
11184       name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
11185
11186     else if (code == STRING_CST || code == CONDITIONAL_EXPR
11187              || code == PLUS_EXPR)
11188       {
11189         qual = TREE_CHAIN (qual);
11190         qual_wfl = QUAL_WFL (qual);
11191         again = 1;
11192       }
11193     else
11194       {
11195         name = EXPR_WFL_NODE (qual_wfl);
11196         if (!name)
11197           {
11198             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11199             again = 1;
11200           }
11201       }
11202
11203     /* If we have a THIS (from a primary), we set the context accordingly */
11204     if (name == this_identifier_node)
11205       {
11206         /* This isn't really elegant. One more added irregularity
11207            before I start using COMPONENT_REF (hopefully very soon.)  */
11208         if (TREE_CODE (TREE_PURPOSE (qual)) == ARRAY_REF
11209             && TREE_CODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11210                EXPR_WITH_FILE_LOCATION
11211             && EXPR_WFL_NODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11212                this_identifier_node)
11213             {
11214               qual = TREE_OPERAND (TREE_PURPOSE (qual), 0);
11215               qual = EXPR_WFL_QUALIFICATION (qual);
11216             }
11217         qual = TREE_CHAIN (qual);
11218         qual_wfl = QUAL_WFL (qual);
11219         if (TREE_CODE (qual_wfl) == CALL_EXPR)
11220           again = 1;
11221         else if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION)
11222           name = EXPR_WFL_NODE (qual_wfl);
11223         else if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
11224           name = TREE_OPERAND (qual_wfl, 0);
11225         this_found = 1;
11226       }
11227     /* If we have a SUPER, we set the context accordingly */
11228     if (name == super_identifier_node)
11229       {
11230         current_class = CLASSTYPE_SUPER (ptr_type);
11231         /* Check that there is such a thing as a super class. If not,
11232            return.  The error will be caught later on, during the
11233            resolution */
11234         if (!current_class)
11235           {
11236             current_class = saved_current_class;
11237             return;
11238           }
11239         qual = TREE_CHAIN (qual);
11240         /* Do one more interation to set things up */
11241         super_found = again = 1;
11242       }
11243   } while (again);
11244
11245   /* If name appears within the scope of a local variable declaration
11246      or parameter declaration, then it is an expression name. We don't
11247      carry this test out if we're in the context of the use of SUPER
11248      or THIS */
11249   if (!this_found && !super_found
11250       && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
11251       && (decl = IDENTIFIER_LOCAL_VALUE (name)))
11252     {
11253       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11254       QUAL_RESOLUTION (qual) = decl;
11255     }
11256
11257   /* If within the class/interface NAME was found to be used there
11258      exists a (possibly inherited) field named NAME, then this is an
11259      expression name. If we saw a NEW_ARRAY_EXPR before and want to
11260      address length, it is OK. */
11261   else if ((decl = lookup_field_wrapper (ptr_type, name))
11262            || name == length_identifier_node)
11263     {
11264       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11265       QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
11266     }
11267
11268   /* We reclassify NAME as yielding to a type name resolution if:
11269      - NAME is a class/interface declared within the compilation
11270        unit containing NAME,
11271      - NAME is imported via a single-type-import declaration,
11272      - NAME is declared in an another compilation unit of the package
11273        of the compilation unit containing NAME,
11274      - NAME is declared by exactly on type-import-on-demand declaration
11275      of the compilation unit containing NAME.
11276      - NAME is actually a STRING_CST.
11277      This can't happen if the expression was qualified by `this.' */
11278   else if (! this_found &&
11279            (TREE_CODE (name) == STRING_CST ||
11280             TREE_CODE (name) == INTEGER_CST ||
11281             (decl = resolve_and_layout (name, NULL_TREE))))
11282     {
11283       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11284       QUAL_RESOLUTION (qual) = decl;
11285     }
11286
11287   /* Method call, array references and cast are expression name */
11288   else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
11289            || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
11290            || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR
11291            || TREE_CODE (QUAL_WFL (qual)) == MODIFY_EXPR)
11292     RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11293
11294   /* Check here that NAME isn't declared by more than one
11295      type-import-on-demand declaration of the compilation unit
11296      containing NAME. FIXME */
11297
11298   /* Otherwise, NAME is reclassified as a package name */
11299   else
11300     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11301
11302   /* Propagate the qualification accross other components of the
11303      qualified name */
11304   for (qual = TREE_CHAIN (qual); qual;
11305        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11306     {
11307       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11308         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11309       else
11310         RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
11311     }
11312
11313   /* Store the global qualification for the ambiguous part of ID back
11314      into ID fields */
11315   if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
11316     RESOLVE_EXPRESSION_NAME_P (id) = 1;
11317   else if (RESOLVE_TYPE_NAME_P (qual_wfl))
11318     RESOLVE_TYPE_NAME_P (id) = 1;
11319   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11320     RESOLVE_PACKAGE_NAME_P (id) = 1;
11321
11322   /* Restore the current class */
11323   current_class = saved_current_class;
11324 }
11325
11326 static int
11327 breakdown_qualified (tree *left, tree *right, tree source)
11328 {
11329   char *p, *base;
11330   int l = IDENTIFIER_LENGTH (source);
11331
11332   base = alloca (l + 1);
11333   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11334
11335   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11336   p = base + l - 1;
11337   while (*p != '.' && p != base)
11338     p--;
11339
11340   /* We didn't find a '.'. Return an error.  */
11341   if (p == base)
11342     return 1;
11343
11344   *p = '\0';
11345   if (right)
11346     *right = get_identifier (p+1);
11347   *left = get_identifier (base);
11348
11349   return 0;
11350 }
11351
11352 /* Return TRUE if two classes are from the same package. */
11353
11354 static int
11355 in_same_package (tree name1, tree name2)
11356 {
11357   tree tmp;
11358   tree pkg1;
11359   tree pkg2;
11360
11361   if (TREE_CODE (name1) == TYPE_DECL)
11362     name1 = DECL_NAME (name1);
11363   if (TREE_CODE (name2) == TYPE_DECL)
11364     name2 = DECL_NAME (name2);
11365
11366   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11367     /* One in empty package. */
11368     return 0;
11369
11370   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11371     /* Both in empty package. */
11372     return 1;
11373
11374   breakdown_qualified (&pkg1, &tmp, name1);
11375   breakdown_qualified (&pkg2, &tmp, name2);
11376
11377   return (pkg1 == pkg2);
11378 }
11379
11380 /* Patch tree nodes in a function body. When a BLOCK is found, push
11381    local variable decls if present.
11382    Same as java_complete_lhs, but does resolve static finals to values. */
11383
11384 static tree
11385 java_complete_tree (tree node)
11386 {
11387   node = java_complete_lhs (node);
11388   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11389       && DECL_INITIAL (node) != NULL_TREE
11390       && !flag_emit_xref)
11391     {
11392       tree value = fold_constant_for_init (node, node);
11393       if (value != NULL_TREE)
11394         return value;
11395     }
11396   return node;
11397 }
11398
11399 static tree
11400 java_stabilize_reference (tree node)
11401 {
11402   if (TREE_CODE (node) == COMPOUND_EXPR)
11403     {
11404       tree op0 = TREE_OPERAND (node, 0);
11405       tree op1 = TREE_OPERAND (node, 1);
11406       TREE_OPERAND (node, 0) = save_expr (op0);
11407       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11408       return node;
11409     }
11410   return stabilize_reference (node);
11411 }
11412
11413 /* Patch tree nodes in a function body. When a BLOCK is found, push
11414    local variable decls if present.
11415    Same as java_complete_tree, but does not resolve static finals to values. */
11416
11417 static tree
11418 java_complete_lhs (tree node)
11419 {
11420   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11421   int flag;
11422
11423   /* CONVERT_EXPR always has its type set, even though it needs to be
11424      worked out. */
11425   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11426     return node;
11427
11428   /* The switch block implements cases processing container nodes
11429      first.  Contained nodes are always written back. Leaves come
11430      next and return a value. */
11431   switch (TREE_CODE (node))
11432     {
11433     case BLOCK:
11434
11435       /* 1- Block section.
11436          Set the local values on decl names so we can identify them
11437          faster when they're referenced. At that stage, identifiers
11438          are legal so we don't check for declaration errors. */
11439       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11440         {
11441           DECL_CONTEXT (cn) = current_function_decl;
11442           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11443         }
11444       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11445           CAN_COMPLETE_NORMALLY (node) = 1;
11446       else
11447         {
11448           tree stmt = BLOCK_EXPR_BODY (node);
11449           tree *ptr;
11450           int error_seen = 0;
11451           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11452             {
11453               /* Re-order from (((A; B); C); ...; Z) to
11454                  (A; (B; (C ; (...; Z)))).
11455                  This makes it easier to scan the statements left-to-right
11456                  without using recursion (which might overflow the stack
11457                  if the block has many statements. */
11458               for (;;)
11459                 {
11460                   tree left = TREE_OPERAND (stmt, 0);
11461                   if (TREE_CODE (left) != COMPOUND_EXPR)
11462                     break;
11463                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11464                   TREE_OPERAND (left, 1) = stmt;
11465                   stmt = left;
11466                 }
11467               BLOCK_EXPR_BODY (node) = stmt;
11468             }
11469
11470           /* Now do the actual complete, without deep recursion for
11471              long blocks. */
11472           ptr = &BLOCK_EXPR_BODY (node);
11473           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11474                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11475             {
11476               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11477               tree *next = &TREE_OPERAND (*ptr, 1);
11478               TREE_OPERAND (*ptr, 0) = cur;
11479               if (cur == empty_stmt_node)
11480                 {
11481                   /* Optimization;  makes it easier to detect empty bodies.
11482                      Most useful for <clinit> with all-constant initializer. */
11483                   *ptr = *next;
11484                   continue;
11485                 }
11486               if (TREE_CODE (cur) == ERROR_MARK)
11487                 error_seen++;
11488               else if (! CAN_COMPLETE_NORMALLY (cur))
11489                 {
11490                   wfl_op2 = *next;
11491                   for (;;)
11492                     {
11493                       if (TREE_CODE (wfl_op2) == BLOCK)
11494                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11495                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11496                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11497                       else
11498                         break;
11499                     }
11500                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11501                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11502                     unreachable_stmt_error (*ptr);
11503                 }
11504               ptr = next;
11505             }
11506           *ptr = java_complete_tree (*ptr);
11507
11508           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11509             return error_mark_node;
11510           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11511         }
11512       /* Turn local bindings to null */
11513       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11514         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11515
11516       TREE_TYPE (node) = void_type_node;
11517       break;
11518
11519       /* 2- They are expressions but ultimately deal with statements */
11520
11521     case THROW_EXPR:
11522       wfl_op1 = TREE_OPERAND (node, 0);
11523       COMPLETE_CHECK_OP_0 (node);
11524       /* 14.19 A throw statement cannot complete normally. */
11525       CAN_COMPLETE_NORMALLY (node) = 0;
11526       return patch_throw_statement (node, wfl_op1);
11527
11528     case SYNCHRONIZED_EXPR:
11529       wfl_op1 = TREE_OPERAND (node, 0);
11530       return patch_synchronized_statement (node, wfl_op1);
11531
11532     case TRY_EXPR:
11533       return patch_try_statement (node);
11534
11535     case TRY_FINALLY_EXPR:
11536       COMPLETE_CHECK_OP_0 (node);
11537       COMPLETE_CHECK_OP_1 (node);
11538       if (TREE_OPERAND (node, 0) == empty_stmt_node)
11539         return TREE_OPERAND (node, 1);
11540       if (TREE_OPERAND (node, 1) == empty_stmt_node)
11541         return TREE_OPERAND (node, 0);
11542       CAN_COMPLETE_NORMALLY (node)
11543         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11544            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11545       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11546       return node;
11547
11548     case LABELED_BLOCK_EXPR:
11549       PUSH_LABELED_BLOCK (node);
11550       if (LABELED_BLOCK_BODY (node))
11551         COMPLETE_CHECK_OP_1 (node);
11552       TREE_TYPE (node) = void_type_node;
11553       POP_LABELED_BLOCK ();
11554
11555       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11556         {
11557           LABELED_BLOCK_BODY (node) = NULL_TREE;
11558           CAN_COMPLETE_NORMALLY (node) = 1;
11559         }
11560       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11561         CAN_COMPLETE_NORMALLY (node) = 1;
11562       return node;
11563
11564     case EXIT_BLOCK_EXPR:
11565       /* We don't complete operand 1, because it's the return value of
11566          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11567       return patch_bc_statement (node);
11568
11569     case CASE_EXPR:
11570       cn = java_complete_tree (TREE_OPERAND (node, 0));
11571       if (cn == error_mark_node)
11572         return cn;
11573
11574       /* First, the case expression must be constant. Values of final
11575          fields are accepted. */
11576       cn = fold (cn);
11577       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11578           && JDECL_P (TREE_OPERAND (cn, 1))
11579           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11580           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11581         {
11582           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11583                                        TREE_OPERAND (cn, 1));
11584         }
11585       /* Accept final locals too. */
11586       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11587         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11588
11589       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11590         {
11591           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11592           parse_error_context (node, "Constant expression required");
11593           return error_mark_node;
11594         }
11595
11596       nn = ctxp->current_loop;
11597
11598       /* It must be assignable to the type of the switch expression. */
11599       if (!try_builtin_assignconv (NULL_TREE,
11600                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11601         {
11602           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11603           parse_error_context
11604             (wfl_operator,
11605              "Incompatible type for case. Can't convert `%s' to `int'",
11606              lang_printable_name (TREE_TYPE (cn), 0));
11607           return error_mark_node;
11608         }
11609
11610       cn = fold (convert (int_type_node, cn));
11611       TREE_CONSTANT_OVERFLOW (cn) = 0;
11612       CAN_COMPLETE_NORMALLY (cn) = 1;
11613
11614       /* Save the label on a list so that we can later check for
11615          duplicates.  */
11616       case_label_list = tree_cons (node, cn, case_label_list);
11617
11618       /* Multiple instance of a case label bearing the same value is
11619          checked later. The case expression is all right so far. */
11620       if (TREE_CODE (cn) == VAR_DECL)
11621         cn = DECL_INITIAL (cn);
11622       TREE_OPERAND (node, 0) = cn;
11623       TREE_TYPE (node) = void_type_node;
11624       CAN_COMPLETE_NORMALLY (node) = 1;
11625       TREE_SIDE_EFFECTS (node) = 1;
11626       break;
11627
11628     case DEFAULT_EXPR:
11629       nn = ctxp->current_loop;
11630       /* Only one default label is allowed per switch statement */
11631       if (SWITCH_HAS_DEFAULT (nn))
11632         {
11633           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11634           parse_error_context (wfl_operator,
11635                                "Duplicate case label: `default'");
11636           return error_mark_node;
11637         }
11638       else
11639         SWITCH_HAS_DEFAULT (nn) = 1;
11640       TREE_TYPE (node) = void_type_node;
11641       TREE_SIDE_EFFECTS (node) = 1;
11642       CAN_COMPLETE_NORMALLY (node) = 1;
11643       break;
11644
11645     case SWITCH_EXPR:
11646     case LOOP_EXPR:
11647       PUSH_LOOP (node);
11648       /* Check whether the loop was enclosed in a labeled
11649          statement. If not, create one, insert the loop in it and
11650          return the node */
11651       nn = patch_loop_statement (node);
11652
11653       /* Anyways, walk the body of the loop */
11654       if (TREE_CODE (node) == LOOP_EXPR)
11655         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11656       /* Switch statement: walk the switch expression and the cases */
11657       else
11658         node = patch_switch_statement (node);
11659
11660       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11661         nn = error_mark_node;
11662       else
11663         {
11664           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11665           /* If we returned something different, that's because we
11666              inserted a label. Pop the label too. */
11667           if (nn != node)
11668             {
11669               if (CAN_COMPLETE_NORMALLY (node))
11670                 CAN_COMPLETE_NORMALLY (nn) = 1;
11671               POP_LABELED_BLOCK ();
11672             }
11673         }
11674       POP_LOOP ();
11675       return nn;
11676
11677     case EXIT_EXPR:
11678       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11679       return patch_exit_expr (node);
11680
11681     case COND_EXPR:
11682       /* Condition */
11683       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11684       if (TREE_OPERAND (node, 0) == error_mark_node)
11685         return error_mark_node;
11686       /* then-else branches */
11687       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11688       if (TREE_OPERAND (node, 1) == error_mark_node)
11689         return error_mark_node;
11690       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11691       if (TREE_OPERAND (node, 2) == error_mark_node)
11692         return error_mark_node;
11693       return patch_if_else_statement (node);
11694       break;
11695
11696     case CONDITIONAL_EXPR:
11697       /* Condition */
11698       wfl_op1 = TREE_OPERAND (node, 0);
11699       COMPLETE_CHECK_OP_0 (node);
11700       wfl_op2 = TREE_OPERAND (node, 1);
11701       COMPLETE_CHECK_OP_1 (node);
11702       wfl_op3 = TREE_OPERAND (node, 2);
11703       COMPLETE_CHECK_OP_2 (node);
11704       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11705
11706       /* 3- Expression section */
11707     case COMPOUND_EXPR:
11708       wfl_op2 = TREE_OPERAND (node, 1);
11709       TREE_OPERAND (node, 0) = nn =
11710         java_complete_tree (TREE_OPERAND (node, 0));
11711       if (wfl_op2 == empty_stmt_node)
11712         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11713       else
11714         {
11715           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11716             {
11717               /* An unreachable condition in a do-while statement
11718                  is *not* (technically) an unreachable statement. */
11719               nn = wfl_op2;
11720               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11721                 nn = EXPR_WFL_NODE (nn);
11722               if (TREE_CODE (nn) != EXIT_EXPR)
11723                 {
11724                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11725                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11726                     {
11727                       /* Perhaps this warning should have an
11728                          associated flag.  The code being compiled is
11729                          pedantically correct, but useless.  */
11730                       parse_warning_context (wfl_operator,
11731                                              "Unreachable statement");
11732                     }
11733                   else
11734                     parse_error_context (wfl_operator,
11735                                          "Unreachable statement");
11736                 }
11737             }
11738           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11739           if (TREE_OPERAND (node, 1) == error_mark_node)
11740             return error_mark_node;
11741           /* Even though we might allow the case where the first
11742              operand doesn't return normally, we still should compute
11743              CAN_COMPLETE_NORMALLY correctly.  */
11744           CAN_COMPLETE_NORMALLY (node)
11745             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11746                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11747         }
11748       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11749       break;
11750
11751     case RETURN_EXPR:
11752       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11753       return patch_return (node);
11754
11755     case EXPR_WITH_FILE_LOCATION:
11756       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11757           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11758         {
11759           tree wfl = node;
11760           node = resolve_expression_name (node, NULL);
11761           if (node == error_mark_node)
11762             return node;
11763           /* Keep line number information somewhere were it doesn't
11764              disrupt the completion process. */
11765           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11766             {
11767               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11768               TREE_OPERAND (node, 1) = wfl;
11769             }
11770           CAN_COMPLETE_NORMALLY (node) = 1;
11771         }
11772       else
11773         {
11774           tree body;
11775           int save_lineno = lineno;
11776           lineno = EXPR_WFL_LINENO (node);
11777           body = java_complete_tree (EXPR_WFL_NODE (node));
11778           lineno = save_lineno;
11779           EXPR_WFL_NODE (node) = body;
11780           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11781           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11782           if (body == empty_stmt_node || TREE_CONSTANT (body))
11783             {
11784               /* Makes it easier to constant fold, detect empty bodies. */
11785               return body;
11786             }
11787           if (body == error_mark_node)
11788             {
11789               /* Its important for the evaluation of assignment that
11790                  this mark on the TREE_TYPE is propagated. */
11791               TREE_TYPE (node) = error_mark_node;
11792               return error_mark_node;
11793             }
11794           else
11795             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11796
11797         }
11798       break;
11799
11800     case NEW_ARRAY_EXPR:
11801       /* Patch all the dimensions */
11802       flag = 0;
11803       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11804         {
11805           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11806           tree dim = convert (int_type_node,
11807                               java_complete_tree (TREE_VALUE (cn)));
11808           if (dim == error_mark_node)
11809             {
11810               flag = 1;
11811               continue;
11812             }
11813           else
11814             {
11815               TREE_VALUE (cn) = dim;
11816               /* Setup the location of the current dimension, for
11817                  later error report. */
11818               TREE_PURPOSE (cn) =
11819                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11820               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11821             }
11822         }
11823       /* They complete the array creation expression, if no errors
11824          were found. */
11825       CAN_COMPLETE_NORMALLY (node) = 1;
11826       return (flag ? error_mark_node
11827               : force_evaluation_order (patch_newarray (node)));
11828
11829     case NEW_ANONYMOUS_ARRAY_EXPR:
11830       /* Create the array type if necessary. */
11831       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11832         {
11833           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11834           if (!(type = resolve_type_during_patch (type)))
11835             return error_mark_node;
11836           type = build_array_from_name (type, NULL_TREE,
11837                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11838           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11839         }
11840       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11841                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11842       if (node == error_mark_node)
11843         return error_mark_node;
11844       CAN_COMPLETE_NORMALLY (node) = 1;
11845       return node;
11846
11847     case NEW_CLASS_EXPR:
11848     case CALL_EXPR:
11849       /* Complete function's argument(s) first */
11850       if (complete_function_arguments (node))
11851         return error_mark_node;
11852       else
11853         {
11854           tree decl, wfl = TREE_OPERAND (node, 0);
11855           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11856           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11857                            super_identifier_node);
11858
11859           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11860                                           from_super, 0, &decl);
11861           if (node == error_mark_node)
11862             return error_mark_node;
11863
11864           check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
11865           /* If we call this(...), register signature and positions */
11866           if (in_this)
11867             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11868               tree_cons (wfl, decl,
11869                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11870           CAN_COMPLETE_NORMALLY (node) = 1;
11871           return force_evaluation_order (node);
11872         }
11873
11874     case MODIFY_EXPR:
11875       /* Save potential wfls */
11876       wfl_op1 = TREE_OPERAND (node, 0);
11877       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11878
11879       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11880           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11881           && DECL_INITIAL (nn) != NULL_TREE)
11882         {
11883           tree value;
11884
11885           value = fold_constant_for_init (nn, nn);
11886
11887           /* When we have a primitype type, or a string and we're not
11888              emitting a class file, we actually don't want to generate
11889              anything for the assignment. */
11890           if (value != NULL_TREE &&
11891               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11892                (TREE_TYPE (value) == string_ptr_type_node &&
11893                 ! flag_emit_class_files)))
11894             {
11895               /* Prepare node for patch_assignment */
11896               TREE_OPERAND (node, 1) = value;
11897               /* Call patch assignment to verify the assignment */
11898               if (patch_assignment (node, wfl_op1) == error_mark_node)
11899                 return error_mark_node;
11900               /* Set DECL_INITIAL properly (a conversion might have
11901                  been decided by patch_assignment) and return the
11902                  empty statement. */
11903               else
11904                 {
11905                   tree patched = patch_string (TREE_OPERAND (node, 1));
11906                   if (patched)
11907                     DECL_INITIAL (nn) = patched;
11908                   else
11909                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11910                   DECL_FIELD_FINAL_IUD (nn) = 1;
11911                   return empty_stmt_node;
11912                 }
11913             }
11914           if (! flag_emit_class_files)
11915             DECL_INITIAL (nn) = NULL_TREE;
11916         }
11917       wfl_op2 = TREE_OPERAND (node, 1);
11918
11919       if (TREE_OPERAND (node, 0) == error_mark_node)
11920         return error_mark_node;
11921
11922       flag = COMPOUND_ASSIGN_P (wfl_op2);
11923       if (flag)
11924         {
11925           /* This might break when accessing outer field from inner
11926              class. TESTME, FIXME */
11927           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11928
11929           /* Hand stabilize the lhs on both places */
11930           TREE_OPERAND (node, 0) = lvalue;
11931           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11932             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11933
11934           /* 15.25.2.a: Left hand is not an array access. FIXME */
11935           /* Now complete the RHS. We write it back later on. */
11936           nn = java_complete_tree (TREE_OPERAND (node, 1));
11937
11938           if ((cn = patch_string (nn)))
11939             nn = cn;
11940
11941           /* The last part of the rewrite for E1 op= E2 is to have
11942              E1 = (T)(E1 op E2), with T being the type of E1. */
11943           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11944                                                TREE_TYPE (lvalue), nn));
11945
11946           /* If the assignment is compound and has reference type,
11947              then ensure the LHS has type String and nothing else.  */
11948           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
11949               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
11950             parse_error_context (wfl_op2,
11951                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
11952                                  lang_printable_name (TREE_TYPE (lvalue), 0));
11953
11954           /* 15.25.2.b: Left hand is an array access. FIXME */
11955         }
11956
11957       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11958          function to complete this RHS. Note that a NEW_ARRAY_INIT
11959          might have been already fully expanded if created as a result
11960          of processing an anonymous array initializer. We avoid doing
11961          the operation twice by testing whether the node already bears
11962          a type. */
11963       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
11964         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
11965                                    TREE_OPERAND (node, 1));
11966       /* Otherwise we simply complete the RHS */
11967       else
11968         nn = java_complete_tree (TREE_OPERAND (node, 1));
11969
11970       if (nn == error_mark_node)
11971         return error_mark_node;
11972
11973       /* Write back the RHS as we evaluated it. */
11974       TREE_OPERAND (node, 1) = nn;
11975
11976       /* In case we're handling = with a String as a RHS, we need to
11977          produce a String out of the RHS (it might still be a
11978          STRING_CST or a StringBuffer at this stage */
11979       if ((nn = patch_string (TREE_OPERAND (node, 1))))
11980         TREE_OPERAND (node, 1) = nn;
11981
11982       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11983                                         TREE_OPERAND (node, 1))))
11984         {
11985           /* We return error_mark_node if outer_field_access_fix
11986              detects we write into a final. */
11987           if (nn == error_mark_node)
11988             return error_mark_node;
11989           node = nn;
11990         }
11991       else
11992         {
11993           node = patch_assignment (node, wfl_op1);
11994           if (node == error_mark_node)
11995             return error_mark_node;
11996           /* Reorganize the tree if necessary. */
11997           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11998                        || JSTRING_P (TREE_TYPE (node))))
11999             node = java_refold (node);
12000         }
12001
12002       /* Seek to set DECL_INITIAL to a proper value, since it might have
12003          undergone a conversion in patch_assignment. We do that only when
12004          it's necessary to have DECL_INITIAL properly set. */
12005       nn = TREE_OPERAND (node, 0);
12006       if (TREE_CODE (nn) == VAR_DECL
12007           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12008           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12009           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12010               || TREE_TYPE (nn) == string_ptr_type_node))
12011         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12012
12013       CAN_COMPLETE_NORMALLY (node) = 1;
12014       return node;
12015
12016     case MULT_EXPR:
12017     case PLUS_EXPR:
12018     case MINUS_EXPR:
12019     case LSHIFT_EXPR:
12020     case RSHIFT_EXPR:
12021     case URSHIFT_EXPR:
12022     case BIT_AND_EXPR:
12023     case BIT_XOR_EXPR:
12024     case BIT_IOR_EXPR:
12025     case TRUNC_MOD_EXPR:
12026     case TRUNC_DIV_EXPR:
12027     case RDIV_EXPR:
12028     case TRUTH_ANDIF_EXPR:
12029     case TRUTH_ORIF_EXPR:
12030     case EQ_EXPR:
12031     case NE_EXPR:
12032     case GT_EXPR:
12033     case GE_EXPR:
12034     case LT_EXPR:
12035     case LE_EXPR:
12036       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12037          knows how to handle those cases. */
12038       wfl_op1 = TREE_OPERAND (node, 0);
12039       wfl_op2 = TREE_OPERAND (node, 1);
12040
12041       CAN_COMPLETE_NORMALLY (node) = 1;
12042       /* Don't complete string nodes if dealing with the PLUS operand. */
12043       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12044         {
12045           nn = java_complete_tree (wfl_op1);
12046           if (nn == error_mark_node)
12047             return error_mark_node;
12048
12049           TREE_OPERAND (node, 0) = nn;
12050         }
12051       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12052         {
12053           nn = java_complete_tree (wfl_op2);
12054           if (nn == error_mark_node)
12055             return error_mark_node;
12056
12057           TREE_OPERAND (node, 1) = nn;
12058         }
12059       return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
12060
12061     case INSTANCEOF_EXPR:
12062       wfl_op1 = TREE_OPERAND (node, 0);
12063       COMPLETE_CHECK_OP_0 (node);
12064       if (flag_emit_xref)
12065         {
12066           TREE_TYPE (node) = boolean_type_node;
12067           return node;
12068         }
12069       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12070
12071     case UNARY_PLUS_EXPR:
12072     case NEGATE_EXPR:
12073     case TRUTH_NOT_EXPR:
12074     case BIT_NOT_EXPR:
12075     case PREDECREMENT_EXPR:
12076     case PREINCREMENT_EXPR:
12077     case POSTDECREMENT_EXPR:
12078     case POSTINCREMENT_EXPR:
12079     case CONVERT_EXPR:
12080       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12081          how to handle those cases. */
12082       wfl_op1 = TREE_OPERAND (node, 0);
12083       CAN_COMPLETE_NORMALLY (node) = 1;
12084       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12085       if (TREE_OPERAND (node, 0) == error_mark_node)
12086         return error_mark_node;
12087       node = patch_unaryop (node, wfl_op1);
12088       CAN_COMPLETE_NORMALLY (node) = 1;
12089       break;
12090
12091     case ARRAY_REF:
12092       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12093          how to handle those cases. */
12094       wfl_op1 = TREE_OPERAND (node, 0);
12095       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12096       if (TREE_OPERAND (node, 0) == error_mark_node)
12097         return error_mark_node;
12098       if (!flag_emit_class_files && !flag_emit_xref)
12099         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12100       /* The same applies to wfl_op2 */
12101       wfl_op2 = TREE_OPERAND (node, 1);
12102       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12103       if (TREE_OPERAND (node, 1) == error_mark_node)
12104         return error_mark_node;
12105       if (!flag_emit_class_files && !flag_emit_xref)
12106         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12107       return patch_array_ref (node);
12108
12109     case RECORD_TYPE:
12110       return node;;
12111
12112     case COMPONENT_REF:
12113       /* The first step in the re-write of qualified name handling.  FIXME.
12114          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12115       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12116       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12117         {
12118           tree name = TREE_OPERAND (node, 1);
12119           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12120           if (field == NULL_TREE)
12121             {
12122               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12123               return error_mark_node;
12124             }
12125           if (! FIELD_STATIC (field))
12126             {
12127               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12128               return error_mark_node;
12129             }
12130           return field;
12131         }
12132       else
12133         abort ();
12134       break;
12135
12136     case THIS_EXPR:
12137       /* Can't use THIS in a static environment */
12138       if (!current_this)
12139         {
12140           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12141           parse_error_context (wfl_operator,
12142                                "Keyword `this' used outside allowed context");
12143           TREE_TYPE (node) = error_mark_node;
12144           return error_mark_node;
12145         }
12146       if (ctxp->explicit_constructor_p)
12147         {
12148           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12149           parse_error_context
12150             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12151           TREE_TYPE (node) = error_mark_node;
12152           return error_mark_node;
12153         }
12154       return current_this;
12155
12156     case CLASS_LITERAL:
12157       CAN_COMPLETE_NORMALLY (node) = 1;
12158       node = patch_incomplete_class_ref (node);
12159       if (node == error_mark_node)
12160         return error_mark_node;
12161       break;
12162
12163     default:
12164       CAN_COMPLETE_NORMALLY (node) = 1;
12165       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12166          and it's time to turn it into the appropriate String object */
12167       if ((nn = patch_string (node)))
12168         node = nn;
12169       else
12170         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12171     }
12172   return node;
12173 }
12174
12175 /* Complete function call's argument. Return a nonzero value is an
12176    error was found.  */
12177
12178 static int
12179 complete_function_arguments (tree node)
12180 {
12181   int flag = 0;
12182   tree cn;
12183
12184   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12185   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12186     {
12187       tree wfl = TREE_VALUE (cn), parm, temp;
12188       parm = java_complete_tree (wfl);
12189
12190       if (parm == error_mark_node)
12191         {
12192           flag = 1;
12193           continue;
12194         }
12195       /* If have a string literal that we haven't transformed yet or a
12196          crafted string buffer, as a result of use of the the String
12197          `+' operator. Build `parm.toString()' and expand it. */
12198       if ((temp = patch_string (parm)))
12199         parm = temp;
12200
12201       TREE_VALUE (cn) = parm;
12202     }
12203   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12204   return flag;
12205 }
12206
12207 /* Sometimes (for loops and variable initialized during their
12208    declaration), we want to wrap a statement around a WFL and turn it
12209    debugable.  */
12210
12211 static tree
12212 build_debugable_stmt (int location, tree stmt)
12213 {
12214   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12215     {
12216       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12217       EXPR_WFL_LINECOL (stmt) = location;
12218     }
12219   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12220   return stmt;
12221 }
12222
12223 static tree
12224 build_expr_block (tree body, tree decls)
12225
12226 {
12227   tree node = make_node (BLOCK);
12228   BLOCK_EXPR_DECLS (node) = decls;
12229   BLOCK_EXPR_BODY (node) = body;
12230   if (body)
12231     TREE_TYPE (node) = TREE_TYPE (body);
12232   TREE_SIDE_EFFECTS (node) = 1;
12233   return node;
12234 }
12235
12236 /* Create a new function block and link it appropriately to current
12237    function block chain */
12238
12239 static tree
12240 enter_block (void)
12241 {
12242   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12243
12244   /* Link block B supercontext to the previous block. The current
12245      function DECL is used as supercontext when enter_a_block is called
12246      for the first time for a given function. The current function body
12247      (DECL_FUNCTION_BODY) is set to be block B.  */
12248
12249   tree fndecl = current_function_decl;
12250
12251   if (!fndecl) {
12252     BLOCK_SUPERCONTEXT (b) = current_static_block;
12253     current_static_block = b;
12254   }
12255
12256   else if (!DECL_FUNCTION_BODY (fndecl))
12257     {
12258       BLOCK_SUPERCONTEXT (b) = fndecl;
12259       DECL_FUNCTION_BODY (fndecl) = b;
12260     }
12261   else
12262     {
12263       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12264       DECL_FUNCTION_BODY (fndecl) = b;
12265     }
12266   return b;
12267 }
12268
12269 /* Exit a block by changing the current function body
12270    (DECL_FUNCTION_BODY) to the current block super context, only if
12271    the block being exited isn't the method's top level one.  */
12272
12273 static tree
12274 exit_block (void)
12275 {
12276   tree b;
12277   if (current_function_decl)
12278     {
12279       b = DECL_FUNCTION_BODY (current_function_decl);
12280       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12281         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12282     }
12283   else
12284     {
12285       b = current_static_block;
12286
12287       if (BLOCK_SUPERCONTEXT (b))
12288         current_static_block = BLOCK_SUPERCONTEXT (b);
12289     }
12290   return b;
12291 }
12292
12293 /* Lookup for NAME in the nested function's blocks, all the way up to
12294    the current toplevel one. It complies with Java's local variable
12295    scoping rules.  */
12296
12297 static tree
12298 lookup_name_in_blocks (tree name)
12299 {
12300   tree b = GET_CURRENT_BLOCK (current_function_decl);
12301
12302   while (b != current_function_decl)
12303     {
12304       tree current;
12305
12306       /* Paranoid sanity check. To be removed */
12307       if (TREE_CODE (b) != BLOCK)
12308         abort ();
12309
12310       for (current = BLOCK_EXPR_DECLS (b); current;
12311            current = TREE_CHAIN (current))
12312         if (DECL_NAME (current) == name)
12313           return current;
12314       b = BLOCK_SUPERCONTEXT (b);
12315     }
12316   return NULL_TREE;
12317 }
12318
12319 static void
12320 maybe_absorb_scoping_blocks (void)
12321 {
12322   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12323     {
12324       tree b = exit_block ();
12325       java_method_add_stmt (current_function_decl, b);
12326       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
12327     }
12328 }
12329
12330 \f
12331 /* This section of the source is reserved to build_* functions that
12332    are building incomplete tree nodes and the patch_* functions that
12333    are completing them.  */
12334
12335 /* Wrap a non WFL node around a WFL.  */
12336
12337 static tree
12338 build_wfl_wrap (tree node, int location)
12339 {
12340   tree wfl, node_to_insert = node;
12341
12342   /* We want to process THIS . xxx symbolicaly, to keep it consistent
12343      with the way we're processing SUPER. A THIS from a primary as a
12344      different form than a SUPER. Turn THIS into something symbolic */
12345   if (TREE_CODE (node) == THIS_EXPR)
12346     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12347   else
12348     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12349
12350   EXPR_WFL_LINECOL (wfl) = location;
12351   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12352   return wfl;
12353 }
12354
12355 /* Build a super() constructor invocation. Returns empty_stmt_node if
12356    we're currently dealing with the class java.lang.Object. */
12357
12358 static tree
12359 build_super_invocation (tree mdecl)
12360 {
12361   if (DECL_CONTEXT (mdecl) == object_type_node)
12362     return empty_stmt_node;
12363   else
12364     {
12365       tree super_wfl = build_wfl_node (super_identifier_node);
12366       tree a = NULL_TREE, t;
12367       /* If we're dealing with an anonymous class, pass the arguments
12368          of the crafted constructor along. */
12369       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12370         {
12371           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12372           for (; t != end_params_node; t = TREE_CHAIN (t))
12373             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12374         }
12375       return build_method_invocation (super_wfl, a);
12376     }
12377 }
12378
12379 /* Build a SUPER/THIS qualified method invocation.  */
12380
12381 static tree
12382 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12383                                        int lloc, int rloc)
12384 {
12385   tree invok;
12386   tree wfl =
12387     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12388   EXPR_WFL_LINECOL (wfl) = lloc;
12389   invok = build_method_invocation (name, args);
12390   return make_qualified_primary (wfl, invok, rloc);
12391 }
12392
12393 /* Build an incomplete CALL_EXPR node. */
12394
12395 static tree
12396 build_method_invocation (tree name, tree args)
12397 {
12398   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12399   TREE_SIDE_EFFECTS (call) = 1;
12400   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12401   return call;
12402 }
12403
12404 /* Build an incomplete new xxx(...) node. */
12405
12406 static tree
12407 build_new_invocation (tree name, tree args)
12408 {
12409   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12410   TREE_SIDE_EFFECTS (call) = 1;
12411   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12412   return call;
12413 }
12414
12415 /* Build an incomplete assignment expression. */
12416
12417 static tree
12418 build_assignment (int op, int op_location, tree lhs, tree rhs)
12419 {
12420   tree assignment;
12421   /* Build the corresponding binop if we deal with a Compound
12422      Assignment operator. Mark the binop sub-tree as part of a
12423      Compound Assignment expression */
12424   if (op != ASSIGN_TK)
12425     {
12426       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12427       COMPOUND_ASSIGN_P (rhs) = 1;
12428     }
12429   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12430   TREE_SIDE_EFFECTS (assignment) = 1;
12431   EXPR_WFL_LINECOL (assignment) = op_location;
12432   return assignment;
12433 }
12434
12435 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12436    the buffer.  This is used only for string conversion.  */
12437 static char *
12438 string_convert_int_cst (tree node)
12439 {
12440   static char buffer[80];
12441
12442   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12443   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12444   char *p = buffer + sizeof (buffer) - 1;
12445   int neg = 0;
12446
12447   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12448                                   << (HOST_BITS_PER_WIDE_INT - 1));
12449
12450   *p-- = '\0';
12451
12452   /* If negative, note the fact and negate the value.  */
12453   if ((hi & hibit))
12454     {
12455       lo = ~lo;
12456       hi = ~hi;
12457       if (++lo == 0)
12458         ++hi;
12459       neg = 1;
12460     }
12461
12462   /* Divide by 10 until there are no bits left.  */
12463   while (hi || lo)
12464     {
12465       unsigned HOST_WIDE_INT acc = 0;
12466       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12467       unsigned int i;
12468
12469       /* Use long division to compute the result and the remainder.  */
12470       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12471         {
12472           /* Shift a bit into accumulator.  */
12473           acc <<= 1;
12474           if ((hi & hibit))
12475             acc |= 1;
12476
12477           /* Shift the value.  */
12478           hi <<= 1;
12479           if ((lo & hibit))
12480             hi |= 1;
12481           lo <<= 1;
12482
12483           /* Shift the correct bit into the result.  */
12484           outhi <<= 1;
12485           if ((outlo & hibit))
12486             outhi |= 1;
12487           outlo <<= 1;
12488           if (acc >= 10)
12489             {
12490               acc -= 10;
12491               outlo |= 1;
12492             }
12493         }
12494
12495       /* FIXME: ASCII assumption.  */
12496       *p-- = '0' + acc;
12497
12498       hi = outhi;
12499       lo = outlo;
12500     }
12501
12502   if (neg)
12503     *p-- = '-';
12504
12505   return p + 1;
12506 }
12507
12508 /* Print an INTEGER_CST node in a static buffer, and return the
12509    buffer.  This is used only for error handling.  */
12510 char *
12511 print_int_node (tree node)
12512 {
12513   static char buffer [80];
12514   if (TREE_CONSTANT_OVERFLOW (node))
12515     sprintf (buffer, "<overflow>");
12516
12517   if (TREE_INT_CST_HIGH (node) == 0)
12518     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12519              TREE_INT_CST_LOW (node));
12520   else if (TREE_INT_CST_HIGH (node) == -1
12521            && TREE_INT_CST_LOW (node) != 0)
12522     {
12523       buffer [0] = '-';
12524       sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
12525                -TREE_INT_CST_LOW (node));
12526     }
12527   else
12528     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12529              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12530
12531   return buffer;
12532 }
12533
12534 \f
12535 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12536    context.  */
12537
12538 /* 15.25 Assignment operators. */
12539
12540 static tree
12541 patch_assignment (tree node, tree wfl_op1)
12542 {
12543   tree rhs = TREE_OPERAND (node, 1);
12544   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12545   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12546   int error_found = 0;
12547   int lvalue_from_array = 0;
12548   int is_return = 0;
12549
12550   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12551
12552   /* Lhs can be a named variable */
12553   if (JDECL_P (lvalue))
12554     {
12555       lhs_type = TREE_TYPE (lvalue);
12556     }
12557   /* Or Lhs can be an array access. */
12558   else if (TREE_CODE (lvalue) == ARRAY_REF)
12559     {
12560       lhs_type = TREE_TYPE (lvalue);
12561       lvalue_from_array = 1;
12562     }
12563   /* Or a field access */
12564   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12565     lhs_type = TREE_TYPE (lvalue);
12566   /* Or a function return slot */
12567   else if (TREE_CODE (lvalue) == RESULT_DECL)
12568     {
12569       /* If the return type is an integral type, then we create the
12570          RESULT_DECL with a promoted type, but we need to do these
12571          checks against the unpromoted type to ensure type safety.  So
12572          here we look at the real type, not the type of the decl we
12573          are modifying.  */
12574       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12575       is_return = 1;
12576     }
12577   /* Otherwise, we might want to try to write into an optimized static
12578      final, this is an of a different nature, reported further on. */
12579   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12580            && resolve_expression_name (wfl_op1, &llvalue))
12581     {
12582       lhs_type = TREE_TYPE (lvalue);
12583     }
12584   else
12585     {
12586       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12587       error_found = 1;
12588     }
12589
12590   rhs_type = TREE_TYPE (rhs);
12591
12592   /* 5.1 Try the assignment conversion for builtin type. */
12593   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12594
12595   /* 5.2 If it failed, try a reference conversion */
12596   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
12597     lhs_type = promote_type (rhs_type);
12598
12599   /* 15.25.2 If we have a compound assignment, convert RHS into the
12600      type of the LHS */
12601   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12602     new_rhs = convert (lhs_type, rhs);
12603
12604   /* Explicit cast required. This is an error */
12605   if (!new_rhs)
12606     {
12607       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12608       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12609       tree wfl;
12610       char operation [32];      /* Max size known */
12611
12612       /* If the assignment is part of a declaration, we use the WFL of
12613          the declared variable to point out the error and call it a
12614          declaration problem. If the assignment is a genuine =
12615          operator, we call is a operator `=' problem, otherwise we
12616          call it an assignment problem. In both of these last cases,
12617          we use the WFL of the operator to indicate the error. */
12618
12619       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12620         {
12621           wfl = wfl_op1;
12622           strcpy (operation, "declaration");
12623         }
12624       else
12625         {
12626           wfl = wfl_operator;
12627           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12628             strcpy (operation, "assignment");
12629           else if (is_return)
12630             strcpy (operation, "`return'");
12631           else
12632             strcpy (operation, "`='");
12633         }
12634
12635       if (!valid_cast_to_p (rhs_type, lhs_type))
12636         parse_error_context
12637           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12638            operation, t1, t2);
12639       else
12640         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12641                              operation, t1, t2);
12642       free (t1); free (t2);
12643       error_found = 1;
12644     }
12645
12646   if (error_found)
12647     return error_mark_node;
12648
12649   /* If we're processing a `return' statement, promote the actual type
12650      to the promoted type.  */
12651   if (is_return)
12652     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12653
12654   /* 10.10: Array Store Exception runtime check */
12655   if (!flag_emit_class_files
12656       && !flag_emit_xref
12657       && lvalue_from_array
12658       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12659     {
12660       tree array, store_check, base, index_expr;
12661
12662       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12663       new_rhs = save_expr (new_rhs);
12664
12665       /* Get the INDIRECT_REF. */
12666       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12667       /* Get the array pointer expr. */
12668       array = TREE_OPERAND (array, 0);
12669       store_check = build_java_arraystore_check (array, new_rhs);
12670
12671       index_expr = TREE_OPERAND (lvalue, 1);
12672
12673       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12674         {
12675           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12676              happen before the store check, so prepare to insert the store
12677              check within the second operand of the existing COMPOUND_EXPR. */
12678           base = index_expr;
12679         }
12680       else
12681         base = lvalue;
12682
12683       index_expr = TREE_OPERAND (base, 1);
12684       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12685                                       store_check, index_expr);
12686     }
12687
12688   /* Final locals can be used as case values in switch
12689      statement. Prepare them for this eventuality. */
12690   if (TREE_CODE (lvalue) == VAR_DECL
12691       && DECL_FINAL (lvalue)
12692       && TREE_CONSTANT (new_rhs)
12693       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12694       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12695       )
12696     {
12697       TREE_CONSTANT (lvalue) = 1;
12698       DECL_INITIAL (lvalue) = new_rhs;
12699     }
12700
12701   /* Copy the rhs if it's a reference.  */
12702   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12703     {
12704       switch (TREE_CODE (new_rhs))
12705         {
12706         case ARRAY_REF:
12707         case INDIRECT_REF:
12708         case COMPONENT_REF:
12709           /* Transform a = foo.bar
12710              into a = { int tmp; tmp = foo.bar; tmp; ).
12711              We need to ensure that if a read from memory fails
12712              because of a NullPointerException, a destination variable
12713              will remain unchanged.  An explicit temporary does what
12714              we need.
12715
12716              If flag_check_references is set, this is unnecessary
12717              because we'll check each reference before doing any
12718              reads.  If optimize is not set the result will never be
12719              written to a stack slot that contains the LHS.  */
12720           {
12721             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12722                                    TREE_TYPE (new_rhs));
12723             tree block = build (BLOCK, TREE_TYPE (new_rhs), NULL);
12724             tree assignment
12725               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12726             BLOCK_VARS (block) = tmp;
12727             BLOCK_EXPR_BODY (block)
12728               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12729             TREE_SIDE_EFFECTS (block) = 1;
12730             new_rhs = block;
12731           }
12732           break;
12733         default:
12734           break;
12735         }
12736     }
12737
12738   TREE_OPERAND (node, 0) = lvalue;
12739   TREE_OPERAND (node, 1) = new_rhs;
12740   TREE_TYPE (node) = lhs_type;
12741   return node;
12742 }
12743
12744 /* Check that type SOURCE can be cast into type DEST. If the cast
12745    can't occur at all, return NULL; otherwise, return a possibly
12746    modified rhs.  */
12747
12748 static tree
12749 try_reference_assignconv (tree lhs_type, tree rhs)
12750 {
12751   tree new_rhs = NULL_TREE;
12752   tree rhs_type = TREE_TYPE (rhs);
12753
12754   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12755     {
12756       /* `null' may be assigned to any reference type */
12757       if (rhs == null_pointer_node)
12758         new_rhs = null_pointer_node;
12759       /* Try the reference assignment conversion */
12760       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12761         new_rhs = rhs;
12762       /* This is a magic assignment that we process differently */
12763       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12764         new_rhs = rhs;
12765     }
12766   return new_rhs;
12767 }
12768
12769 /* Check that RHS can be converted into LHS_TYPE by the assignment
12770    conversion (5.2), for the cases of RHS being a builtin type. Return
12771    NULL_TREE if the conversion fails or if because RHS isn't of a
12772    builtin type. Return a converted RHS if the conversion is possible.  */
12773
12774 static tree
12775 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12776 {
12777   tree new_rhs = NULL_TREE;
12778   tree rhs_type = TREE_TYPE (rhs);
12779
12780   /* Handle boolean specially.  */
12781   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12782       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12783     {
12784       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12785           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12786         new_rhs = rhs;
12787     }
12788
12789   /* 5.1.1 Try Identity Conversion,
12790      5.1.2 Try Widening Primitive Conversion */
12791   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12792     new_rhs = convert (lhs_type, rhs);
12793
12794   /* Try a narrowing primitive conversion (5.1.3):
12795        - expression is a constant expression of type byte, short, char,
12796          or int, AND
12797        - variable is byte, short or char AND
12798        - The value of the expression is representable in the type of the
12799          variable */
12800   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12801             || rhs_type == char_type_node || rhs_type == int_type_node)
12802             && TREE_CONSTANT (rhs)
12803            && (lhs_type == byte_type_node || lhs_type == char_type_node
12804                || lhs_type == short_type_node))
12805     {
12806       if (int_fits_type_p (rhs, lhs_type))
12807         new_rhs = convert (lhs_type, rhs);
12808       else if (wfl_op1)         /* Might be called with a NULL */
12809         parse_warning_context
12810           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12811            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12812       /* Reported a warning that will turn into an error further
12813          down, so we don't return */
12814     }
12815
12816   return new_rhs;
12817 }
12818
12819 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12820    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12821    0 is the conversion test fails.  This implements parts the method
12822    invocation convertion (5.3).  */
12823
12824 static int
12825 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12826 {
12827   /* 5.1.1: This is the identity conversion part. */
12828   if (lhs_type == rhs_type)
12829     return 1;
12830
12831   /* Reject non primitive types and boolean conversions.  */
12832   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12833     return 0;
12834
12835   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12836      than a char can't be converted into a char. Short can't too, but
12837      the < test below takes care of that */
12838   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12839     return 0;
12840
12841   /* Accept all promoted type here. Note, we can't use <= in the test
12842      below, because we still need to bounce out assignments of short
12843      to char and the likes */
12844   if (lhs_type == int_type_node
12845       && (rhs_type == promoted_byte_type_node
12846           || rhs_type == promoted_short_type_node
12847           || rhs_type == promoted_char_type_node
12848           || rhs_type == promoted_boolean_type_node))
12849     return 1;
12850
12851   /* From here, an integral is widened if its precision is smaller
12852      than the precision of the LHS or if the LHS is a floating point
12853      type, or the RHS is a float and the RHS a double. */
12854   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12855        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12856       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12857       || (rhs_type == float_type_node && lhs_type == double_type_node))
12858     return 1;
12859
12860   return 0;
12861 }
12862
12863 /* Check that something of SOURCE type can be assigned or cast to
12864    something of DEST type at runtime. Return 1 if the operation is
12865    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12866    were SOURCE is cast into DEST, which borrows a lot of the
12867    assignment check. */
12868
12869 static int
12870 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12871 {
12872   /* SOURCE or DEST might be null if not from a declared entity. */
12873   if (!source || !dest)
12874     return 0;
12875   if (JNULLP_TYPE_P (source))
12876     return 1;
12877   if (TREE_CODE (source) == POINTER_TYPE)
12878     source = TREE_TYPE (source);
12879   if (TREE_CODE (dest) == POINTER_TYPE)
12880     dest = TREE_TYPE (dest);
12881
12882   /* If source and dest are being compiled from bytecode, they may need to
12883      be loaded. */
12884   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12885     {
12886       load_class (source, 1);
12887       safe_layout_class (source);
12888     }
12889   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12890     {
12891       load_class (dest, 1);
12892       safe_layout_class (dest);
12893     }
12894
12895   /* Case where SOURCE is a class type */
12896   if (TYPE_CLASS_P (source))
12897     {
12898       if (TYPE_CLASS_P (dest))
12899         return  (source == dest
12900                  || inherits_from_p (source, dest)
12901                  || (cast && inherits_from_p (dest, source)));
12902       if (TYPE_INTERFACE_P (dest))
12903         {
12904           /* If doing a cast and SOURCE is final, the operation is
12905              always correct a compile time (because even if SOURCE
12906              does not implement DEST, a subclass of SOURCE might). */
12907           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12908             return 1;
12909           /* Otherwise, SOURCE must implement DEST */
12910           return interface_of_p (dest, source);
12911         }
12912       /* DEST is an array, cast permited if SOURCE is of Object type */
12913       return (cast && source == object_type_node ? 1 : 0);
12914     }
12915   if (TYPE_INTERFACE_P (source))
12916     {
12917       if (TYPE_CLASS_P (dest))
12918         {
12919           /* If not casting, DEST must be the Object type */
12920           if (!cast)
12921             return dest == object_type_node;
12922           /* We're doing a cast. The cast is always valid is class
12923              DEST is not final, otherwise, DEST must implement SOURCE */
12924           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12925             return 1;
12926           else
12927             return interface_of_p (source, dest);
12928         }
12929       if (TYPE_INTERFACE_P (dest))
12930         {
12931           /* If doing a cast, then if SOURCE and DEST contain method
12932              with the same signature but different return type, then
12933              this is a (compile time) error */
12934           if (cast)
12935             {
12936               tree method_source, method_dest;
12937               tree source_type;
12938               tree source_sig;
12939               tree source_name;
12940               for (method_source = TYPE_METHODS (source); method_source;
12941                    method_source = TREE_CHAIN (method_source))
12942                 {
12943                   source_sig =
12944                     build_java_argument_signature (TREE_TYPE (method_source));
12945                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12946                   source_name = DECL_NAME (method_source);
12947                   for (method_dest = TYPE_METHODS (dest);
12948                        method_dest; method_dest = TREE_CHAIN (method_dest))
12949                     if (source_sig ==
12950                         build_java_argument_signature (TREE_TYPE (method_dest))
12951                         && source_name == DECL_NAME (method_dest)
12952                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12953                       return 0;
12954                 }
12955               return 1;
12956             }
12957           else
12958             return source == dest || interface_of_p (dest, source);
12959         }
12960       else
12961         {
12962           /* Array */
12963           return (cast
12964                   && (DECL_NAME (TYPE_NAME (source))
12965                       == java_lang_cloneable_identifier_node
12966                       || (DECL_NAME (TYPE_NAME (source))
12967                           == java_io_serializable_identifier_node)));
12968         }
12969     }
12970   if (TYPE_ARRAY_P (source))
12971     {
12972       if (TYPE_CLASS_P (dest))
12973         return dest == object_type_node;
12974       /* Can't cast an array to an interface unless the interface is
12975          java.lang.Cloneable or java.io.Serializable.  */
12976       if (TYPE_INTERFACE_P (dest))
12977         return (DECL_NAME (TYPE_NAME (dest))
12978                 == java_lang_cloneable_identifier_node
12979                 || (DECL_NAME (TYPE_NAME (dest))
12980                     == java_io_serializable_identifier_node));
12981       else                      /* Arrays */
12982         {
12983           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12984           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12985
12986           /* In case of severe errors, they turn out null */
12987           if (!dest_element_type || !source_element_type)
12988             return 0;
12989           if (source_element_type == dest_element_type)
12990             return 1;
12991           return valid_ref_assignconv_cast_p (source_element_type,
12992                                               dest_element_type, cast);
12993         }
12994       return 0;
12995     }
12996   return 0;
12997 }
12998
12999 static int
13000 valid_cast_to_p (tree source, tree dest)
13001 {
13002   if (TREE_CODE (source) == POINTER_TYPE)
13003     source = TREE_TYPE (source);
13004   if (TREE_CODE (dest) == POINTER_TYPE)
13005     dest = TREE_TYPE (dest);
13006
13007   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13008     return valid_ref_assignconv_cast_p (source, dest, 1);
13009
13010   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13011     return 1;
13012
13013   else if (TREE_CODE (source) == BOOLEAN_TYPE
13014            && TREE_CODE (dest) == BOOLEAN_TYPE)
13015     return 1;
13016
13017   return 0;
13018 }
13019
13020 static tree
13021 do_unary_numeric_promotion (tree arg)
13022 {
13023   tree type = TREE_TYPE (arg);
13024   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13025       || TREE_CODE (type) == CHAR_TYPE)
13026     arg = convert (int_type_node, arg);
13027   return arg;
13028 }
13029
13030 /* Return a nonzero value if SOURCE can be converted into DEST using
13031    the method invocation conversion rule (5.3).  */
13032 static int
13033 valid_method_invocation_conversion_p (tree dest, tree source)
13034 {
13035   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13036            && valid_builtin_assignconv_identity_widening_p (dest, source))
13037           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13038               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13039               && valid_ref_assignconv_cast_p (source, dest, 0)));
13040 }
13041
13042 /* Build an incomplete binop expression. */
13043
13044 static tree
13045 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13046 {
13047   tree binop = build (op, NULL_TREE, op1, op2);
13048   TREE_SIDE_EFFECTS (binop) = 1;
13049   /* Store the location of the operator, for better error report. The
13050      string of the operator will be rebuild based on the OP value. */
13051   EXPR_WFL_LINECOL (binop) = op_location;
13052   return binop;
13053 }
13054
13055 /* Build the string of the operator retained by NODE. If NODE is part
13056    of a compound expression, add an '=' at the end of the string. This
13057    function is called when an error needs to be reported on an
13058    operator. The string is returned as a pointer to a static character
13059    buffer. */
13060
13061 static char *
13062 operator_string (tree node)
13063 {
13064 #define BUILD_OPERATOR_STRING(S)                                        \
13065   {                                                                     \
13066     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13067     return buffer;                                                      \
13068   }
13069
13070   static char buffer [10];
13071   switch (TREE_CODE (node))
13072     {
13073     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13074     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13075     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13076     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13077     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13078     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13079     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13080     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13081     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13082     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13083     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13084     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13085     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13086     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13087     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13088     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13089     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13090     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13091     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13092     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13093     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13094     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13095     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13096     case PREINCREMENT_EXPR:     /* Fall through */
13097     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13098     case PREDECREMENT_EXPR:     /* Fall through */
13099     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13100     default:
13101       internal_error ("unregistered operator %s",
13102                       tree_code_name [TREE_CODE (node)]);
13103     }
13104   return NULL;
13105 #undef BUILD_OPERATOR_STRING
13106 }
13107
13108 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13109
13110 static int
13111 java_decl_equiv (tree var_acc1, tree var_acc2)
13112 {
13113   if (JDECL_P (var_acc1))
13114     return (var_acc1 == var_acc2);
13115
13116   return (TREE_CODE (var_acc1) == COMPONENT_REF
13117           && TREE_CODE (var_acc2) == COMPONENT_REF
13118           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13119              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13120           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13121 }
13122
13123 /* Return a nonzero value if CODE is one of the operators that can be
13124    used in conjunction with the `=' operator in a compound assignment.  */
13125
13126 static int
13127 binop_compound_p (enum tree_code code)
13128 {
13129   int i;
13130   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13131     if (binop_lookup [i] == code)
13132       break;
13133
13134   return i < BINOP_COMPOUND_CANDIDATES;
13135 }
13136
13137 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13138
13139 static tree
13140 java_refold (tree t)
13141 {
13142   tree c, b, ns, decl;
13143
13144   if (TREE_CODE (t) != MODIFY_EXPR)
13145     return t;
13146
13147   c = TREE_OPERAND (t, 1);
13148   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13149          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13150          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13151     return t;
13152
13153   /* Now the left branch of the binary operator. */
13154   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13155   if (! (b && TREE_CODE (b) == NOP_EXPR
13156          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13157     return t;
13158
13159   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13160   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13161          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13162     return t;
13163
13164   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13165   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13166       /* It's got to be the an equivalent decl */
13167       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13168     {
13169       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13170       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13171       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13172       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13173       /* Change the right part of the BINOP_EXPR */
13174       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13175     }
13176
13177   return t;
13178 }
13179
13180 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13181    errors but we modify NODE so that it contains the type computed
13182    according to the expression, when it's fixed. Otherwise, we write
13183    error_mark_node as the type. It allows us to further the analysis
13184    of remaining nodes and detects more errors in certain cases.  */
13185
13186 static tree
13187 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13188 {
13189   tree op1 = TREE_OPERAND (node, 0);
13190   tree op2 = TREE_OPERAND (node, 1);
13191   tree op1_type = TREE_TYPE (op1);
13192   tree op2_type = TREE_TYPE (op2);
13193   tree prom_type = NULL_TREE, cn;
13194   enum tree_code code = TREE_CODE (node);
13195
13196   /* If 1, tell the routine that we have to return error_mark_node
13197      after checking for the initialization of the RHS */
13198   int error_found = 0;
13199
13200   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13201
13202   /* If either op<n>_type are NULL, this might be early signs of an
13203      error situation, unless it's too early to tell (in case we're
13204      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13205      correctly so the error can be later on reported accurately. */
13206   if (! (code == PLUS_EXPR || code == NE_EXPR
13207          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13208     {
13209       tree n;
13210       if (! op1_type)
13211         {
13212           n = java_complete_tree (op1);
13213           op1_type = TREE_TYPE (n);
13214         }
13215       if (! op2_type)
13216         {
13217           n = java_complete_tree (op2);
13218           op2_type = TREE_TYPE (n);
13219         }
13220     }
13221
13222   switch (code)
13223     {
13224     /* 15.16 Multiplicative operators */
13225     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13226     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13227     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13228     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13229       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13230         {
13231           if (!JNUMERIC_TYPE_P (op1_type))
13232             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13233           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13234             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13235           TREE_TYPE (node) = error_mark_node;
13236           error_found = 1;
13237           break;
13238         }
13239       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13240
13241       /* Detect integral division by zero */
13242       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13243           && TREE_CODE (prom_type) == INTEGER_TYPE
13244           && (op2 == integer_zero_node || op2 == long_zero_node ||
13245               (TREE_CODE (op2) == INTEGER_CST &&
13246                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13247         {
13248           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13249           TREE_CONSTANT (node) = 0;
13250         }
13251
13252       /* Change the division operator if necessary */
13253       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13254         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13255
13256       /* Before divisions as is disapear, try to simplify and bail if
13257          applicable, otherwise we won't perform even simple
13258          simplifications like (1-1)/3. We can't do that with floating
13259          point number, folds can't handle them at this stage. */
13260       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13261           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13262         {
13263           TREE_TYPE (node) = prom_type;
13264           node = fold (node);
13265           if (TREE_CODE (node) != code)
13266             return node;
13267         }
13268
13269       if (TREE_CODE (prom_type) == INTEGER_TYPE
13270           && flag_use_divide_subroutine
13271           && ! flag_emit_class_files
13272           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13273         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13274
13275       /* This one is more complicated. FLOATs are processed by a
13276          function call to soft_fmod. Duplicate the value of the
13277          COMPOUND_ASSIGN_P flag. */
13278       if (code == TRUNC_MOD_EXPR)
13279         {
13280           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13281           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13282           TREE_SIDE_EFFECTS (mod)
13283             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13284           return mod;
13285         }
13286       break;
13287
13288     /* 15.17 Additive Operators */
13289     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13290
13291       /* Operation is valid if either one argument is a string
13292          constant, a String object or a StringBuffer crafted for the
13293          purpose of the a previous usage of the String concatenation
13294          operator */
13295
13296       if (TREE_CODE (op1) == STRING_CST
13297           || TREE_CODE (op2) == STRING_CST
13298           || JSTRING_TYPE_P (op1_type)
13299           || JSTRING_TYPE_P (op2_type)
13300           || IS_CRAFTED_STRING_BUFFER_P (op1)
13301           || IS_CRAFTED_STRING_BUFFER_P (op2))
13302         return build_string_concatenation (op1, op2);
13303
13304     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13305                                    Numeric Types */
13306       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13307         {
13308           if (!JNUMERIC_TYPE_P (op1_type))
13309             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13310           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13311             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13312           TREE_TYPE (node) = error_mark_node;
13313           error_found = 1;
13314           break;
13315         }
13316       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13317       break;
13318
13319     /* 15.18 Shift Operators */
13320     case LSHIFT_EXPR:
13321     case RSHIFT_EXPR:
13322     case URSHIFT_EXPR:
13323       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13324         {
13325           if (!JINTEGRAL_TYPE_P (op1_type))
13326             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13327           else
13328             {
13329               if (JNUMERIC_TYPE_P (op2_type))
13330                 parse_error_context (wfl_operator,
13331                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13332                                      operator_string (node),
13333                                      lang_printable_name (op2_type, 0));
13334               else
13335                 parse_error_context (wfl_operator,
13336                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13337                                      operator_string (node),
13338                                      lang_printable_name (op2_type, 0));
13339             }
13340           TREE_TYPE (node) = error_mark_node;
13341           error_found = 1;
13342           break;
13343         }
13344
13345       /* Unary numeric promotion (5.6.1) is performed on each operand
13346          separately */
13347       op1 = do_unary_numeric_promotion (op1);
13348       op2 = do_unary_numeric_promotion (op2);
13349
13350       /* If the right hand side is of type `long', first cast it to
13351          `int'.  */
13352       if (TREE_TYPE (op2) == long_type_node)
13353         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13354
13355       /* The type of the shift expression is the type of the promoted
13356          type of the left-hand operand */
13357       prom_type = TREE_TYPE (op1);
13358
13359       /* Shift int only up to 0x1f and long up to 0x3f */
13360       if (prom_type == int_type_node)
13361         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13362                            build_int_2 (0x1f, 0)));
13363       else
13364         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13365                            build_int_2 (0x3f, 0)));
13366
13367       /* The >>> operator is a >> operating on unsigned quantities */
13368       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13369         {
13370           tree to_return;
13371           tree utype = java_unsigned_type (prom_type);
13372           op1 = convert (utype, op1);
13373           TREE_SET_CODE (node, RSHIFT_EXPR);
13374           TREE_OPERAND (node, 0) = op1;
13375           TREE_OPERAND (node, 1) = op2;
13376           TREE_TYPE (node) = utype;
13377           to_return = convert (prom_type, node);
13378           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13379           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13380           TREE_SIDE_EFFECTS (to_return)
13381             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13382           return to_return;
13383         }
13384       break;
13385
13386       /* 15.19.1 Type Comparison Operator instaceof */
13387     case INSTANCEOF_EXPR:
13388
13389       TREE_TYPE (node) = boolean_type_node;
13390
13391       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13392       if ((cn = patch_string (op1)))
13393         {
13394           op1 = cn;
13395           op1_type = TREE_TYPE (op1);
13396         }
13397       if (op1_type == NULL_TREE)
13398         abort ();
13399
13400       if (!(op2_type = resolve_type_during_patch (op2)))
13401         return error_mark_node;
13402
13403       /* The first operand must be a reference type or the null type */
13404       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13405         error_found = 1;        /* Error reported further below */
13406
13407       /* The second operand must be a reference type */
13408       if (!JREFERENCE_TYPE_P (op2_type))
13409         {
13410           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13411           parse_error_context
13412             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13413              lang_printable_name (op2_type, 0));
13414           error_found = 1;
13415         }
13416
13417       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13418         {
13419           /* If the first operand is null, the result is always false */
13420           if (op1 == null_pointer_node)
13421             return boolean_false_node;
13422           else if (flag_emit_class_files)
13423             {
13424               TREE_OPERAND (node, 1) = op2_type;
13425               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13426               return node;
13427             }
13428           /* Otherwise we have to invoke instance of to figure it out */
13429           else
13430             return build_instanceof (op1, op2_type);
13431         }
13432       /* There is no way the expression operand can be an instance of
13433          the type operand. This is a compile time error. */
13434       else
13435         {
13436           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13437           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13438           parse_error_context
13439             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13440              t1, lang_printable_name (op2_type, 0));
13441           free (t1);
13442           error_found = 1;
13443         }
13444
13445       break;
13446
13447       /* 15.21 Bitwise and Logical Operators */
13448     case BIT_AND_EXPR:
13449     case BIT_XOR_EXPR:
13450     case BIT_IOR_EXPR:
13451       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13452         /* Binary numeric promotion is performed on both operand and the
13453            expression retain that type */
13454         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13455
13456       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13457                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13458         /* The type of the bitwise operator expression is BOOLEAN */
13459         prom_type = boolean_type_node;
13460       else
13461         {
13462           if (!JINTEGRAL_TYPE_P (op1_type))
13463             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13464           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13465             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13466           TREE_TYPE (node) = error_mark_node;
13467           error_found = 1;
13468           /* Insert a break here if adding thing before the switch's
13469              break for this case */
13470         }
13471       break;
13472
13473       /* 15.22 Conditional-And Operator */
13474     case TRUTH_ANDIF_EXPR:
13475       /* 15.23 Conditional-Or Operator */
13476     case TRUTH_ORIF_EXPR:
13477       /* Operands must be of BOOLEAN type */
13478       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13479           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13480         {
13481           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13482             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13483           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13484             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13485           TREE_TYPE (node) = boolean_type_node;
13486           error_found = 1;
13487           break;
13488         }
13489       else if (integer_zerop (op1))
13490         {
13491           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13492         }
13493       else if (integer_onep (op1))
13494         {
13495           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13496         }
13497       /* The type of the conditional operators is BOOLEAN */
13498       prom_type = boolean_type_node;
13499       break;
13500
13501       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13502     case LT_EXPR:
13503     case GT_EXPR:
13504     case LE_EXPR:
13505     case GE_EXPR:
13506       /* The type of each of the operands must be a primitive numeric
13507          type */
13508       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13509         {
13510           if (!JNUMERIC_TYPE_P (op1_type))
13511             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13512           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13513             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13514           TREE_TYPE (node) = boolean_type_node;
13515           error_found = 1;
13516           break;
13517         }
13518       /* Binary numeric promotion is performed on the operands */
13519       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13520       /* The type of the relation expression is always BOOLEAN */
13521       prom_type = boolean_type_node;
13522       break;
13523
13524       /* 15.20 Equality Operator */
13525     case EQ_EXPR:
13526     case NE_EXPR:
13527       /* It's time for us to patch the strings. */
13528       if ((cn = patch_string (op1)))
13529        {
13530          op1 = cn;
13531          op1_type = TREE_TYPE (op1);
13532        }
13533       if ((cn = patch_string (op2)))
13534        {
13535          op2 = cn;
13536          op2_type = TREE_TYPE (op2);
13537        }
13538
13539       /* 15.20.1 Numerical Equality Operators == and != */
13540       /* Binary numeric promotion is performed on the operands */
13541       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13542         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13543
13544       /* 15.20.2 Boolean Equality Operators == and != */
13545       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13546           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13547         ;                       /* Nothing to do here */
13548
13549       /* 15.20.3 Reference Equality Operators == and != */
13550       /* Types have to be either references or the null type. If
13551          they're references, it must be possible to convert either
13552          type to the other by casting conversion. */
13553       else if (op1 == null_pointer_node || op2 == null_pointer_node
13554                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13555                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13556                        || valid_ref_assignconv_cast_p (op2_type,
13557                                                        op1_type, 1))))
13558         ;                       /* Nothing to do here */
13559
13560       /* Else we have an error figure what can't be converted into
13561          what and report the error */
13562       else
13563         {
13564           char *t1;
13565           t1 = xstrdup (lang_printable_name (op1_type, 0));
13566           parse_error_context
13567             (wfl_operator,
13568              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13569              operator_string (node), t1,
13570              lang_printable_name (op2_type, 0));
13571           free (t1);
13572           TREE_TYPE (node) = boolean_type_node;
13573           error_found = 1;
13574           break;
13575         }
13576       prom_type = boolean_type_node;
13577       break;
13578     default:
13579       abort ();
13580     }
13581
13582   if (error_found)
13583     return error_mark_node;
13584
13585   TREE_OPERAND (node, 0) = op1;
13586   TREE_OPERAND (node, 1) = op2;
13587   TREE_TYPE (node) = prom_type;
13588   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13589
13590   if (flag_emit_xref)
13591     return node;
13592
13593   /* fold does not respect side-effect order as required for Java but not C.
13594    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13595    * bytecode.
13596    */
13597   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13598       : ! TREE_SIDE_EFFECTS (node))
13599     node = fold (node);
13600   return node;
13601 }
13602
13603 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13604    zero value, the value of CSTE comes after the valude of STRING */
13605
13606 static tree
13607 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13608 {
13609   const char *old = TREE_STRING_POINTER (cste);
13610   int old_len = TREE_STRING_LENGTH (cste);
13611   int len = old_len + string_len;
13612   char *new = alloca (len+1);
13613
13614   if (after)
13615     {
13616       memcpy (new, string, string_len);
13617       memcpy (&new [string_len], old, old_len);
13618     }
13619   else
13620     {
13621       memcpy (new, old, old_len);
13622       memcpy (&new [old_len], string, string_len);
13623     }
13624   new [len] = '\0';
13625   return build_string (len, new);
13626 }
13627
13628 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13629    new STRING_CST on success, NULL_TREE on failure */
13630
13631 static tree
13632 merge_string_cste (tree op1, tree op2, int after)
13633 {
13634   /* Handle two string constants right away */
13635   if (TREE_CODE (op2) == STRING_CST)
13636     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13637                                  TREE_STRING_LENGTH (op2), after);
13638
13639   /* Reasonable integer constant can be treated right away */
13640   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13641     {
13642       static const char *const boolean_true = "true";
13643       static const char *const boolean_false = "false";
13644       static const char *const null_pointer = "null";
13645       char ch[3];
13646       const char *string;
13647
13648       if (op2 == boolean_true_node)
13649         string = boolean_true;
13650       else if (op2 == boolean_false_node)
13651         string = boolean_false;
13652       else if (op2 == null_pointer_node)
13653         string = null_pointer;
13654       else if (TREE_TYPE (op2) == char_type_node)
13655         {
13656           /* Convert the character into UTF-8.  */
13657           unsigned char c = (unsigned char) TREE_INT_CST_LOW (op2);
13658           unsigned char *p = (unsigned char *) ch;
13659           if (0x01 <= c
13660               && c <= 0x7f)
13661             *p++ = c;
13662           else
13663             {
13664               *p++ = c >> 6 | 0xc0;
13665               *p++ = (c & 0x3f) | 0x80;
13666             }
13667           *p = '\0';
13668
13669           string = ch;
13670         }
13671       else
13672         string = string_convert_int_cst (op2);
13673
13674       return do_merge_string_cste (op1, string, strlen (string), after);
13675     }
13676   return NULL_TREE;
13677 }
13678
13679 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13680    has to be a STRING_CST and the other part must be a STRING_CST or a
13681    INTEGRAL constant. Return a new STRING_CST if the operation
13682    succeed, NULL_TREE otherwise.
13683
13684    If the case we want to optimize for space, we might want to return
13685    NULL_TREE for each invocation of this routine. FIXME */
13686
13687 static tree
13688 string_constant_concatenation (tree op1, tree op2)
13689 {
13690   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13691     {
13692       tree string, rest;
13693       int invert;
13694
13695       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13696       rest   = (string == op1 ? op2 : op1);
13697       invert = (string == op1 ? 0 : 1 );
13698
13699       /* Walk REST, only if it looks reasonable */
13700       if (TREE_CODE (rest) != STRING_CST
13701           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13702           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13703           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13704         {
13705           rest = java_complete_tree (rest);
13706           if (rest == error_mark_node)
13707             return error_mark_node;
13708           rest = fold (rest);
13709         }
13710       return merge_string_cste (string, rest, invert);
13711     }
13712   return NULL_TREE;
13713 }
13714
13715 /* Implement the `+' operator. Does static optimization if possible,
13716    otherwise create (if necessary) and append elements to a
13717    StringBuffer. The StringBuffer will be carried around until it is
13718    used for a function call or an assignment. Then toString() will be
13719    called on it to turn it into a String object. */
13720
13721 static tree
13722 build_string_concatenation (tree op1, tree op2)
13723 {
13724   tree result;
13725   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13726
13727   if (flag_emit_xref)
13728     return build (PLUS_EXPR, string_type_node, op1, op2);
13729
13730   /* Try to do some static optimization */
13731   if ((result = string_constant_concatenation (op1, op2)))
13732     return result;
13733
13734   /* Discard empty strings on either side of the expression */
13735   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13736     {
13737       op1 = op2;
13738       op2 = NULL_TREE;
13739     }
13740   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13741     op2 = NULL_TREE;
13742
13743   /* If operands are string constant, turn then into object references */
13744   if (TREE_CODE (op1) == STRING_CST)
13745     op1 = patch_string_cst (op1);
13746   if (op2 && TREE_CODE (op2) == STRING_CST)
13747     op2 = patch_string_cst (op2);
13748
13749   /* If either one of the constant is null and the other non null
13750      operand is a String constant, return it. */
13751   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13752     return op1;
13753
13754   /* If OP1 isn't already a StringBuffer, create and
13755      initialize a new one */
13756   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13757     {
13758       /* Two solutions here:
13759          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13760          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13761       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13762         op1 = BUILD_STRING_BUFFER (op1);
13763       else
13764         {
13765           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13766           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13767         }
13768     }
13769
13770   if (op2)
13771     {
13772       /* OP1 is no longer the last node holding a crafted StringBuffer */
13773       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13774       /* Create a node for `{new...,xxx}.append (op2)' */
13775       if (op2)
13776         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13777     }
13778
13779   /* Mark the last node holding a crafted StringBuffer */
13780   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13781
13782   TREE_SIDE_EFFECTS (op1) = side_effects;
13783   return op1;
13784 }
13785
13786 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13787    StringBuffer. If no string were found to be patched, return
13788    NULL. */
13789
13790 static tree
13791 patch_string (tree node)
13792 {
13793   if (node == error_mark_node)
13794     return error_mark_node;
13795   if (TREE_CODE (node) == STRING_CST)
13796     return patch_string_cst (node);
13797   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13798     {
13799       int saved = ctxp->explicit_constructor_p;
13800       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13801       tree ret;
13802       /* Temporary disable forbid the use of `this'. */
13803       ctxp->explicit_constructor_p = 0;
13804       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13805       /* String concatenation arguments must be evaluated in order too. */
13806       ret = force_evaluation_order (ret);
13807       /* Restore it at its previous value */
13808       ctxp->explicit_constructor_p = saved;
13809       return ret;
13810     }
13811   return NULL_TREE;
13812 }
13813
13814 /* Build the internal representation of a string constant.  */
13815
13816 static tree
13817 patch_string_cst (tree node)
13818 {
13819   int location;
13820   if (! flag_emit_class_files)
13821     {
13822       node = get_identifier (TREE_STRING_POINTER (node));
13823       location = alloc_name_constant (CONSTANT_String, node);
13824       node = build_ref_from_constant_pool (location);
13825     }
13826   TREE_TYPE (node) = string_ptr_type_node;
13827   TREE_CONSTANT (node) = 1;
13828   return node;
13829 }
13830
13831 /* Build an incomplete unary operator expression. */
13832
13833 static tree
13834 build_unaryop (int op_token, int op_location, tree op1)
13835 {
13836   enum tree_code op;
13837   tree unaryop;
13838   switch (op_token)
13839     {
13840     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13841     case MINUS_TK: op = NEGATE_EXPR; break;
13842     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13843     case NOT_TK: op = BIT_NOT_EXPR; break;
13844     default: abort ();
13845     }
13846
13847   unaryop = build1 (op, NULL_TREE, op1);
13848   TREE_SIDE_EFFECTS (unaryop) = 1;
13849   /* Store the location of the operator, for better error report. The
13850      string of the operator will be rebuild based on the OP value. */
13851   EXPR_WFL_LINECOL (unaryop) = op_location;
13852   return unaryop;
13853 }
13854
13855 /* Special case for the ++/-- operators, since they require an extra
13856    argument to build, which is set to NULL and patched
13857    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13858
13859 static tree
13860 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13861 {
13862   static const enum tree_code lookup [2][2] =
13863     {
13864       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13865       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13866     };
13867   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13868                      NULL_TREE, op1, NULL_TREE);
13869   TREE_SIDE_EFFECTS (node) = 1;
13870   /* Store the location of the operator, for better error report. The
13871      string of the operator will be rebuild based on the OP value. */
13872   EXPR_WFL_LINECOL (node) = op_location;
13873   return node;
13874 }
13875
13876 /* Build an incomplete cast operator, based on the use of the
13877    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13878    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13879    though its type is already set.  */
13880
13881 static tree
13882 build_cast (int location, tree type, tree exp)
13883 {
13884   tree node = build1 (CONVERT_EXPR, type, exp);
13885   EXPR_WFL_LINECOL (node) = location;
13886   return node;
13887 }
13888
13889 /* Build an incomplete class reference operator.  */
13890 static tree
13891 build_incomplete_class_ref (int location, tree class_name)
13892 {
13893   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13894   EXPR_WFL_LINECOL (node) = location;
13895   return node;
13896 }
13897
13898 /* Complete an incomplete class reference operator.  */
13899 static tree
13900 patch_incomplete_class_ref (tree node)
13901 {
13902   tree type = TREE_OPERAND (node, 0);
13903   tree ref_type;
13904
13905   if (!(ref_type = resolve_type_during_patch (type)))
13906     return error_mark_node;
13907
13908   /* Generate the synthetic static method `class$'.  (Previously we
13909      deferred this, causing different method tables to be emitted
13910      for native code and bytecode.)  */
13911   if (!TYPE_DOT_CLASS (current_class))
13912       build_dot_class_method (current_class);
13913
13914   /* If we're not emitting class files and we know ref_type is a
13915      compiled class, build a direct reference.  */
13916   if ((! flag_emit_class_files && is_compiled_class (ref_type))
13917       || JPRIMITIVE_TYPE_P (ref_type)
13918       || TREE_CODE (ref_type) == VOID_TYPE)
13919     {
13920       tree dot = build_class_ref (ref_type);
13921       /* A class referenced by `foo.class' is initialized.  */
13922       if (!flag_emit_class_files)
13923        dot = build_class_init (ref_type, dot);
13924       return java_complete_tree (dot);
13925     }
13926
13927   /* If we're emitting class files and we have to deal with non
13928      primitive types, we invoke the synthetic static method `class$'.  */
13929   ref_type = build_dot_class_method_invocation (ref_type);
13930   return java_complete_tree (ref_type);
13931 }
13932
13933 /* 15.14 Unary operators. We return error_mark_node in case of error,
13934    but preserve the type of NODE if the type is fixed.  */
13935
13936 static tree
13937 patch_unaryop (tree node, tree wfl_op)
13938 {
13939   tree op = TREE_OPERAND (node, 0);
13940   tree op_type = TREE_TYPE (op);
13941   tree prom_type = NULL_TREE, value, decl;
13942   int outer_field_flag = 0;
13943   int code = TREE_CODE (node);
13944   int error_found = 0;
13945
13946   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13947
13948   switch (code)
13949     {
13950       /* 15.13.2 Postfix Increment Operator ++ */
13951     case POSTINCREMENT_EXPR:
13952       /* 15.13.3 Postfix Increment Operator -- */
13953     case POSTDECREMENT_EXPR:
13954       /* 15.14.1 Prefix Increment Operator ++ */
13955     case PREINCREMENT_EXPR:
13956       /* 15.14.2 Prefix Decrement Operator -- */
13957     case PREDECREMENT_EXPR:
13958       op = decl = strip_out_static_field_access_decl (op);
13959       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
13960       /* We might be trying to change an outer field accessed using
13961          access method. */
13962       if (outer_field_flag)
13963         {
13964           /* Retrieve the decl of the field we're trying to access. We
13965              do that by first retrieving the function we would call to
13966              access the field. It has been already verified that this
13967              field isn't final */
13968           if (flag_emit_class_files)
13969             decl = TREE_OPERAND (op, 0);
13970           else
13971             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
13972           decl = DECL_FUNCTION_ACCESS_DECL (decl);
13973         }
13974       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
13975       else if (!JDECL_P (decl)
13976           && TREE_CODE (decl) != COMPONENT_REF
13977           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
13978           && TREE_CODE (decl) != INDIRECT_REF
13979           && !(TREE_CODE (decl) == COMPOUND_EXPR
13980                && TREE_OPERAND (decl, 1)
13981                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
13982         {
13983           TREE_TYPE (node) = error_mark_node;
13984           error_found = 1;
13985         }
13986
13987       /* From now on, we know that op if a variable and that it has a
13988          valid wfl. We use wfl_op to locate errors related to the
13989          ++/-- operand. */
13990       if (!JNUMERIC_TYPE_P (op_type))
13991         {
13992           parse_error_context
13993             (wfl_op, "Invalid argument type `%s' to `%s'",
13994              lang_printable_name (op_type, 0), operator_string (node));
13995           TREE_TYPE (node) = error_mark_node;
13996           error_found = 1;
13997         }
13998       else
13999         {
14000           /* Before the addition, binary numeric promotion is performed on
14001              both operands, if really necessary */
14002           if (JINTEGRAL_TYPE_P (op_type))
14003             {
14004               value = build_int_2 (1, 0);
14005               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14006             }
14007           else
14008             {
14009               value = build_int_2 (1, 0);
14010               TREE_TYPE (node) =
14011                 binary_numeric_promotion (op_type,
14012                                           TREE_TYPE (value), &op, &value);
14013             }
14014
14015           /* We remember we might be accessing an outer field */
14016           if (outer_field_flag)
14017             {
14018               /* We re-generate an access to the field */
14019               value = build (PLUS_EXPR, TREE_TYPE (op),
14020                              build_outer_field_access (wfl_op, decl), value);
14021
14022               /* And we patch the original access$() into a write
14023                  with plus_op as a rhs */
14024               return outer_field_access_fix (node, op, value);
14025             }
14026
14027           /* And write back into the node. */
14028           TREE_OPERAND (node, 0) = op;
14029           TREE_OPERAND (node, 1) = value;
14030           /* Convert the overall back into its original type, if
14031              necessary, and return */
14032           if (JINTEGRAL_TYPE_P (op_type))
14033             return fold (node);
14034           else
14035             return fold (convert (op_type, node));
14036         }
14037       break;
14038
14039       /* 15.14.3 Unary Plus Operator + */
14040     case UNARY_PLUS_EXPR:
14041       /* 15.14.4 Unary Minus Operator - */
14042     case NEGATE_EXPR:
14043       if (!JNUMERIC_TYPE_P (op_type))
14044         {
14045           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14046           TREE_TYPE (node) = error_mark_node;
14047           error_found = 1;
14048         }
14049       /* Unary numeric promotion is performed on operand */
14050       else
14051         {
14052           op = do_unary_numeric_promotion (op);
14053           prom_type = TREE_TYPE (op);
14054           if (code == UNARY_PLUS_EXPR)
14055             return fold (op);
14056         }
14057       break;
14058
14059       /* 15.14.5 Bitwise Complement Operator ~ */
14060     case BIT_NOT_EXPR:
14061       if (!JINTEGRAL_TYPE_P (op_type))
14062         {
14063           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14064           TREE_TYPE (node) = error_mark_node;
14065           error_found = 1;
14066         }
14067       else
14068         {
14069           op = do_unary_numeric_promotion (op);
14070           prom_type = TREE_TYPE (op);
14071         }
14072       break;
14073
14074       /* 15.14.6 Logical Complement Operator ! */
14075     case TRUTH_NOT_EXPR:
14076       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14077         {
14078           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14079           /* But the type is known. We will report an error if further
14080              attempt of a assignment is made with this rhs */
14081           TREE_TYPE (node) = boolean_type_node;
14082           error_found = 1;
14083         }
14084       else
14085         prom_type = boolean_type_node;
14086       break;
14087
14088       /* 15.15 Cast Expression */
14089     case CONVERT_EXPR:
14090       value = patch_cast (node, wfl_operator);
14091       if (value == error_mark_node)
14092         {
14093           /* If this cast is part of an assignment, we tell the code
14094              that deals with it not to complain about a mismatch,
14095              because things have been cast, anyways */
14096           TREE_TYPE (node) = error_mark_node;
14097           error_found = 1;
14098         }
14099       else
14100         {
14101           value = fold (value);
14102           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14103           return value;
14104         }
14105       break;
14106     }
14107
14108   if (error_found)
14109     return error_mark_node;
14110
14111   /* There are cases where node has been replaced by something else
14112      and we don't end up returning here: UNARY_PLUS_EXPR,
14113      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14114   TREE_OPERAND (node, 0) = fold (op);
14115   TREE_TYPE (node) = prom_type;
14116   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14117   return fold (node);
14118 }
14119
14120 /* Generic type resolution that sometimes takes place during node
14121    patching. Returned the resolved type or generate an error
14122    message. Return the resolved type or NULL_TREE.  */
14123
14124 static tree
14125 resolve_type_during_patch (tree type)
14126 {
14127   if (unresolved_type_p (type, NULL))
14128     {
14129       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14130       if (!type_decl)
14131         {
14132           parse_error_context (type,
14133                                "Class `%s' not found in type declaration",
14134                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14135           return NULL_TREE;
14136         }
14137       return TREE_TYPE (type_decl);
14138     }
14139   return type;
14140 }
14141 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14142    found. Otherwise NODE or something meant to replace it is returned.  */
14143
14144 static tree
14145 patch_cast (tree node, tree wfl_op)
14146 {
14147   tree op = TREE_OPERAND (node, 0);
14148   tree cast_type = TREE_TYPE (node);
14149   tree patched, op_type;
14150   char *t1;
14151
14152   /* Some string patching might be necessary at this stage */
14153   if ((patched = patch_string (op)))
14154     TREE_OPERAND (node, 0) = op = patched;
14155   op_type = TREE_TYPE (op);
14156
14157   /* First resolve OP_TYPE if unresolved */
14158   if (!(cast_type = resolve_type_during_patch (cast_type)))
14159     return error_mark_node;
14160
14161   /* Check on cast that are proven correct at compile time */
14162   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14163     {
14164       /* Same type */
14165       if (cast_type == op_type)
14166         return node;
14167
14168       /* float and double type are converted to the original type main
14169          variant and then to the target type. */
14170       if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
14171         op = convert (integer_type_node, op);
14172
14173       /* Try widening/narowwing convertion. Potentially, things need
14174          to be worked out in gcc so we implement the extreme cases
14175          correctly. fold_convert() needs to be fixed. */
14176       return convert (cast_type, op);
14177     }
14178
14179   /* It's also valid to cast a boolean into a boolean */
14180   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14181     return node;
14182
14183   /* null can be casted to references */
14184   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14185     return build_null_of_type (cast_type);
14186
14187   /* The remaining legal casts involve conversion between reference
14188      types. Check for their compile time correctness. */
14189   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14190       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14191     {
14192       TREE_TYPE (node) = promote_type (cast_type);
14193       /* Now, the case can be determined correct at compile time if
14194          OP_TYPE can be converted into CAST_TYPE by assignment
14195          conversion (5.2) */
14196
14197       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14198         {
14199           TREE_SET_CODE (node, NOP_EXPR);
14200           return node;
14201         }
14202
14203       if (flag_emit_class_files)
14204         {
14205           TREE_SET_CODE (node, CONVERT_EXPR);
14206           return node;
14207         }
14208
14209       /* The cast requires a run-time check */
14210       return build (CALL_EXPR, promote_type (cast_type),
14211                     build_address_of (soft_checkcast_node),
14212                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14213                                build_tree_list (NULL_TREE, op)),
14214                     NULL_TREE);
14215     }
14216
14217   /* Any other casts are proven incorrect at compile time */
14218   t1 = xstrdup (lang_printable_name (op_type, 0));
14219   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14220                        t1, lang_printable_name (cast_type, 0));
14221   free (t1);
14222   return error_mark_node;
14223 }
14224
14225 /* Build a null constant and give it the type TYPE.  */
14226
14227 static tree
14228 build_null_of_type (tree type)
14229 {
14230   tree node = build_int_2 (0, 0);
14231   TREE_TYPE (node) = promote_type (type);
14232   return node;
14233 }
14234
14235 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14236    a list of indices. */
14237 static tree
14238 build_array_ref (int location, tree array, tree index)
14239 {
14240   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14241   EXPR_WFL_LINECOL (node) = location;
14242   return node;
14243 }
14244
14245 /* 15.12 Array Access Expression */
14246
14247 static tree
14248 patch_array_ref (tree node)
14249 {
14250   tree array = TREE_OPERAND (node, 0);
14251   tree array_type  = TREE_TYPE (array);
14252   tree index = TREE_OPERAND (node, 1);
14253   tree index_type = TREE_TYPE (index);
14254   int error_found = 0;
14255
14256   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14257
14258   if (TREE_CODE (array_type) == POINTER_TYPE)
14259     array_type = TREE_TYPE (array_type);
14260
14261   /* The array reference must be an array */
14262   if (!TYPE_ARRAY_P (array_type))
14263     {
14264       parse_error_context
14265         (wfl_operator,
14266          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14267          lang_printable_name (array_type, 0));
14268       TREE_TYPE (node) = error_mark_node;
14269       error_found = 1;
14270     }
14271
14272   /* The array index undergoes unary numeric promotion. The promoted
14273      type must be int */
14274   index = do_unary_numeric_promotion (index);
14275   if (TREE_TYPE (index) != int_type_node)
14276     {
14277       if (valid_cast_to_p (index_type, int_type_node))
14278         parse_error_context (wfl_operator,
14279    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14280                              lang_printable_name (index_type, 0));
14281       else
14282         parse_error_context (wfl_operator,
14283           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14284                              lang_printable_name (index_type, 0));
14285       TREE_TYPE (node) = error_mark_node;
14286       error_found = 1;
14287     }
14288
14289   if (error_found)
14290     return error_mark_node;
14291
14292   array_type = TYPE_ARRAY_ELEMENT (array_type);
14293
14294   if (flag_emit_class_files || flag_emit_xref)
14295     {
14296       TREE_OPERAND (node, 0) = array;
14297       TREE_OPERAND (node, 1) = index;
14298     }
14299   else
14300     node = build_java_arrayaccess (array, array_type, index);
14301   TREE_TYPE (node) = array_type;
14302   return node;
14303 }
14304
14305 /* 15.9 Array Creation Expressions */
14306
14307 static tree
14308 build_newarray_node (tree type, tree dims, int extra_dims)
14309 {
14310   tree node =
14311     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14312            build_int_2 (extra_dims, 0));
14313   return node;
14314 }
14315
14316 static tree
14317 patch_newarray (tree node)
14318 {
14319   tree type = TREE_OPERAND (node, 0);
14320   tree dims = TREE_OPERAND (node, 1);
14321   tree cdim, array_type;
14322   int error_found = 0;
14323   int ndims = 0;
14324   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14325
14326   /* Dimension types are verified. It's better for the types to be
14327      verified in order. */
14328   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14329     {
14330       int dim_error = 0;
14331       tree dim = TREE_VALUE (cdim);
14332
14333       /* Dim might have been saved during its evaluation */
14334       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14335
14336       /* The type of each specified dimension must be an integral type. */
14337       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14338         dim_error = 1;
14339
14340       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14341          promoted type must be int. */
14342       else
14343         {
14344           dim = do_unary_numeric_promotion (dim);
14345           if (TREE_TYPE (dim) != int_type_node)
14346             dim_error = 1;
14347         }
14348
14349       /* Report errors on types here */
14350       if (dim_error)
14351         {
14352           parse_error_context
14353             (TREE_PURPOSE (cdim),
14354              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14355              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14356               "Explicit cast needed to" : "Can't"),
14357              lang_printable_name (TREE_TYPE (dim), 0));
14358           error_found = 1;
14359         }
14360
14361       TREE_PURPOSE (cdim) = NULL_TREE;
14362     }
14363
14364   /* Resolve array base type if unresolved */
14365   if (!(type = resolve_type_during_patch (type)))
14366     error_found = 1;
14367
14368   if (error_found)
14369     {
14370       /* We don't want further evaluation of this bogus array creation
14371          operation */
14372       TREE_TYPE (node) = error_mark_node;
14373       return error_mark_node;
14374     }
14375
14376   /* Set array_type to the actual (promoted) array type of the result. */
14377   if (TREE_CODE (type) == RECORD_TYPE)
14378     type = build_pointer_type (type);
14379   while (--xdims >= 0)
14380     {
14381       type = promote_type (build_java_array_type (type, -1));
14382     }
14383   dims = nreverse (dims);
14384   array_type = type;
14385   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14386     {
14387       type = array_type;
14388       array_type
14389         = build_java_array_type (type,
14390                                  TREE_CODE (cdim) == INTEGER_CST
14391                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14392                                  : -1);
14393       array_type = promote_type (array_type);
14394     }
14395   dims = nreverse (dims);
14396
14397   /* The node is transformed into a function call. Things are done
14398      differently according to the number of dimensions. If the number
14399      of dimension is equal to 1, then the nature of the base type
14400      (primitive or not) matters. */
14401   if (ndims == 1)
14402     return build_new_array (type, TREE_VALUE (dims));
14403
14404   /* Can't reuse what's already written in expr.c because it uses the
14405      JVM stack representation. Provide a build_multianewarray. FIXME */
14406   return build (CALL_EXPR, array_type,
14407                 build_address_of (soft_multianewarray_node),
14408                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14409                            tree_cons (NULL_TREE,
14410                                       build_int_2 (ndims, 0), dims )),
14411                 NULL_TREE);
14412 }
14413
14414 /* 10.6 Array initializer.  */
14415
14416 /* Build a wfl for array element that don't have one, so we can
14417    pin-point errors.  */
14418
14419 static tree
14420 maybe_build_array_element_wfl (tree node)
14421 {
14422   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14423     return build_expr_wfl (NULL_TREE, ctxp->filename,
14424                            ctxp->elc.line, ctxp->elc.prev_col);
14425   else
14426     return NULL_TREE;
14427 }
14428
14429 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14430    identification of initialized arrays easier to detect during walk
14431    and expansion.  */
14432
14433 static tree
14434 build_new_array_init (int location, tree values)
14435 {
14436   tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
14437   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14438   EXPR_WFL_LINECOL (to_return) = location;
14439   return to_return;
14440 }
14441
14442 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14443    occurred.  Otherwise return NODE after having set its type
14444    appropriately.  */
14445
14446 static tree
14447 patch_new_array_init (tree type, tree node)
14448 {
14449   int error_seen = 0;
14450   tree current, element_type;
14451   HOST_WIDE_INT length;
14452   int all_constant = 1;
14453   tree init = TREE_OPERAND (node, 0);
14454
14455   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14456     {
14457       parse_error_context (node,
14458                            "Invalid array initializer for non-array type `%s'",
14459                            lang_printable_name (type, 1));
14460       return error_mark_node;
14461     }
14462   type = TREE_TYPE (type);
14463   element_type = TYPE_ARRAY_ELEMENT (type);
14464
14465   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14466
14467   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14468        current;  length++, current = TREE_CHAIN (current))
14469     {
14470       tree elt = TREE_VALUE (current);
14471       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14472         {
14473           error_seen |= array_constructor_check_entry (element_type, current);
14474           elt = TREE_VALUE (current);
14475           /* When compiling to native code, STRING_CST is converted to
14476              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14477           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14478             all_constant = 0;
14479         }
14480       else
14481         {
14482           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14483           TREE_PURPOSE (current) = NULL_TREE;
14484           all_constant = 0;
14485         }
14486       if (elt && TREE_CODE (elt) == TREE_LIST
14487           && TREE_VALUE (elt) == error_mark_node)
14488         error_seen = 1;
14489     }
14490
14491   if (error_seen)
14492     return error_mark_node;
14493
14494   /* Create a new type. We can't reuse the one we have here by
14495      patching its dimension because it originally is of dimension -1
14496      hence reused by gcc. This would prevent triangular arrays. */
14497   type = build_java_array_type (element_type, length);
14498   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14499   TREE_TYPE (node) = promote_type (type);
14500   TREE_CONSTANT (init) = all_constant;
14501   TREE_CONSTANT (node) = all_constant;
14502   return node;
14503 }
14504
14505 /* Verify that one entry of the initializer element list can be
14506    assigned to the array base type. Report 1 if an error occurred, 0
14507    otherwise.  */
14508
14509 static int
14510 array_constructor_check_entry (tree type, tree entry)
14511 {
14512   char *array_type_string = NULL;       /* For error reports */
14513   tree value, type_value, new_value, wfl_value, patched;
14514   int error_seen = 0;
14515
14516   new_value = NULL_TREE;
14517   wfl_value = TREE_VALUE (entry);
14518
14519   value = java_complete_tree (TREE_VALUE (entry));
14520   /* patch_string return error_mark_node if arg is error_mark_node */
14521   if ((patched = patch_string (value)))
14522     value = patched;
14523   if (value == error_mark_node)
14524     return 1;
14525
14526   type_value = TREE_TYPE (value);
14527
14528   /* At anytime, try_builtin_assignconv can report a warning on
14529      constant overflow during narrowing. */
14530   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14531   new_value = try_builtin_assignconv (wfl_operator, type, value);
14532   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14533     type_value = promote_type (type);
14534
14535   /* Check and report errors */
14536   if (!new_value)
14537     {
14538       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14539                    "Can't" : "Explicit cast needed to");
14540       if (!array_type_string)
14541         array_type_string = xstrdup (lang_printable_name (type, 1));
14542       parse_error_context
14543         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14544          msg, lang_printable_name (type_value, 1), array_type_string);
14545       error_seen = 1;
14546     }
14547
14548   if (new_value)
14549     TREE_VALUE (entry) = new_value;
14550
14551   if (array_type_string)
14552     free (array_type_string);
14553
14554   TREE_PURPOSE (entry) = NULL_TREE;
14555   return error_seen;
14556 }
14557
14558 static tree
14559 build_this (int location)
14560 {
14561   tree node = build_wfl_node (this_identifier_node);
14562   TREE_SET_CODE (node, THIS_EXPR);
14563   EXPR_WFL_LINECOL (node) = location;
14564   return node;
14565 }
14566
14567 /* 14.15 The return statement. It builds a modify expression that
14568    assigns the returned value to the RESULT_DECL that hold the value
14569    to be returned. */
14570
14571 static tree
14572 build_return (int location, tree op)
14573 {
14574   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14575   EXPR_WFL_LINECOL (node) = location;
14576   node = build_debugable_stmt (location, node);
14577   return node;
14578 }
14579
14580 static tree
14581 patch_return (tree node)
14582 {
14583   tree return_exp = TREE_OPERAND (node, 0);
14584   tree meth = current_function_decl;
14585   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14586   int error_found = 0;
14587
14588   TREE_TYPE (node) = error_mark_node;
14589   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14590
14591   /* It's invalid to have a return value within a function that is
14592      declared with the keyword void or that is a constructor */
14593   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14594     error_found = 1;
14595
14596   /* It's invalid to use a return statement in a static block */
14597   if (DECL_CLINIT_P (current_function_decl))
14598     error_found = 1;
14599
14600   /* It's invalid to have a no return value within a function that
14601      isn't declared with the keyword `void' */
14602   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14603     error_found = 2;
14604
14605   if (DECL_INSTINIT_P (current_function_decl))
14606     error_found = 1;
14607
14608   if (error_found)
14609     {
14610       if (DECL_INSTINIT_P (current_function_decl))
14611         parse_error_context (wfl_operator,
14612                              "`return' inside instance initializer");
14613
14614       else if (DECL_CLINIT_P (current_function_decl))
14615         parse_error_context (wfl_operator,
14616                              "`return' inside static initializer");
14617
14618       else if (!DECL_CONSTRUCTOR_P (meth))
14619         {
14620           char *t = xstrdup (lang_printable_name (mtype, 0));
14621           parse_error_context (wfl_operator,
14622                                "`return' with%s value from `%s %s'",
14623                                (error_found == 1 ? "" : "out"),
14624                                t, lang_printable_name (meth, 0));
14625           free (t);
14626         }
14627       else
14628         parse_error_context (wfl_operator,
14629                              "`return' with value from constructor `%s'",
14630                              lang_printable_name (meth, 0));
14631       return error_mark_node;
14632     }
14633
14634   /* If we have a return_exp, build a modify expression and expand
14635      it. Note: at that point, the assignment is declared valid, but we
14636      may want to carry some more hacks */
14637   if (return_exp)
14638     {
14639       tree exp = java_complete_tree (return_exp);
14640       tree modify, patched;
14641
14642       if ((patched = patch_string (exp)))
14643         exp = patched;
14644
14645       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14646       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14647       modify = java_complete_tree (modify);
14648
14649       if (modify != error_mark_node)
14650         {
14651           TREE_SIDE_EFFECTS (modify) = 1;
14652           TREE_OPERAND (node, 0) = modify;
14653         }
14654       else
14655         return error_mark_node;
14656     }
14657   TREE_TYPE (node) = void_type_node;
14658   TREE_SIDE_EFFECTS (node) = 1;
14659   return node;
14660 }
14661
14662 /* 14.8 The if Statement */
14663
14664 static tree
14665 build_if_else_statement (int location, tree expression, tree if_body,
14666                          tree else_body)
14667 {
14668   tree node;
14669   if (!else_body)
14670     else_body = empty_stmt_node;
14671   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14672   EXPR_WFL_LINECOL (node) = location;
14673   node = build_debugable_stmt (location, node);
14674   return node;
14675 }
14676
14677 static tree
14678 patch_if_else_statement (tree node)
14679 {
14680   tree expression = TREE_OPERAND (node, 0);
14681   int can_complete_normally
14682     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14683        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14684
14685   TREE_TYPE (node) = error_mark_node;
14686   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14687
14688   /* The type of expression must be boolean */
14689   if (TREE_TYPE (expression) != boolean_type_node
14690       && TREE_TYPE (expression) != promoted_boolean_type_node)
14691     {
14692       parse_error_context
14693         (wfl_operator,
14694          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14695          lang_printable_name (TREE_TYPE (expression), 0));
14696       return error_mark_node;
14697     }
14698
14699   if (TREE_CODE (expression) == INTEGER_CST)
14700     {
14701       if (integer_zerop (expression))
14702         node = TREE_OPERAND (node, 2);
14703       else
14704         node = TREE_OPERAND (node, 1);
14705       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14706         {
14707           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14708           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14709         }
14710       return node;
14711     }
14712   TREE_TYPE (node) = void_type_node;
14713   TREE_SIDE_EFFECTS (node) = 1;
14714   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14715   return node;
14716 }
14717
14718 /* 14.6 Labeled Statements */
14719
14720 /* Action taken when a lableled statement is parsed. a new
14721    LABELED_BLOCK_EXPR is created. No statement is attached to the
14722    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14723
14724 static tree
14725 build_labeled_block (int location, tree label)
14726 {
14727   tree label_name ;
14728   tree label_decl, node;
14729   if (label == NULL_TREE || label == continue_identifier_node)
14730     label_name = label;
14731   else
14732     {
14733       label_name = merge_qualified_name (label_id, label);
14734       /* Issue an error if we try to reuse a label that was previously
14735          declared */
14736       if (IDENTIFIER_LOCAL_VALUE (label_name))
14737         {
14738           EXPR_WFL_LINECOL (wfl_operator) = location;
14739           parse_error_context (wfl_operator,
14740             "Declaration of `%s' shadows a previous label declaration",
14741                                IDENTIFIER_POINTER (label));
14742           EXPR_WFL_LINECOL (wfl_operator) =
14743             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14744           parse_error_context (wfl_operator,
14745             "This is the location of the previous declaration of label `%s'",
14746                                IDENTIFIER_POINTER (label));
14747           java_error_count--;
14748         }
14749     }
14750
14751   label_decl = create_label_decl (label_name);
14752   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14753   EXPR_WFL_LINECOL (node) = location;
14754   TREE_SIDE_EFFECTS (node) = 1;
14755   return node;
14756 }
14757
14758 /* A labeled statement LBE is attached a statement.  */
14759
14760 static tree
14761 finish_labeled_statement (tree lbe, /* Labeled block expr */
14762                           tree statement)
14763 {
14764   /* In anyways, tie the loop to its statement */
14765   LABELED_BLOCK_BODY (lbe) = statement;
14766   pop_labeled_block ();
14767   POP_LABELED_BLOCK ();
14768   return lbe;
14769 }
14770
14771 /* 14.10, 14.11, 14.12 Loop Statements */
14772
14773 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14774    list. */
14775
14776 static tree
14777 build_new_loop (tree loop_body)
14778 {
14779   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14780   TREE_SIDE_EFFECTS (loop) = 1;
14781   PUSH_LOOP (loop);
14782   return loop;
14783 }
14784
14785 /* Create a loop body according to the following structure:
14786      COMPOUND_EXPR
14787        COMPOUND_EXPR            (loop main body)
14788          EXIT_EXPR              (this order is for while/for loops.
14789          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14790            LABEL_DECL           (a continue occurring here branches at the
14791            BODY                  end of this labeled block)
14792        INCREMENT                (if any)
14793
14794   REVERSED, if nonzero, tells that the loop condition expr comes
14795   after the body, like in the do-while loop.
14796
14797   To obtain a loop, the loop body structure described above is
14798   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14799
14800    LABELED_BLOCK_EXPR
14801      LABEL_DECL                   (use this label to exit the loop)
14802      LOOP_EXPR
14803        <structure described above> */
14804
14805 static tree
14806 build_loop_body (int location, tree condition, int reversed)
14807 {
14808   tree first, second, body;
14809
14810   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14811   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14812   condition = build_debugable_stmt (location, condition);
14813   TREE_SIDE_EFFECTS (condition) = 1;
14814
14815   body = build_labeled_block (0, continue_identifier_node);
14816   first = (reversed ? body : condition);
14817   second = (reversed ? condition : body);
14818   return
14819     build (COMPOUND_EXPR, NULL_TREE,
14820            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14821 }
14822
14823 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14824    their order) on the current loop. Unlink the current loop from the
14825    loop list.  */
14826
14827 static tree
14828 finish_loop_body (int location, tree condition, tree body, int reversed)
14829 {
14830   tree to_return = ctxp->current_loop;
14831   tree loop_body = LOOP_EXPR_BODY (to_return);
14832   if (condition)
14833     {
14834       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14835       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14836          The real EXIT_EXPR is one operand further. */
14837       EXPR_WFL_LINECOL (cnode) = location;
14838       /* This one is for accurate error reports */
14839       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14840       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14841     }
14842   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14843   POP_LOOP ();
14844   return to_return;
14845 }
14846
14847 /* Tailored version of finish_loop_body for FOR loops, when FOR
14848    loops feature the condition part */
14849
14850 static tree
14851 finish_for_loop (int location, tree condition, tree update, tree body)
14852 {
14853   /* Put the condition and the loop body in place */
14854   tree loop = finish_loop_body (location, condition, body, 0);
14855   /* LOOP is the current loop which has been now popped of the loop
14856      stack.  Mark the update block as reachable and install it.  We do
14857      this because the (current interpretation of the) JLS requires
14858      that the update expression be considered reachable even if the
14859      for loop's body doesn't complete normally.  */
14860   if (update != NULL_TREE && update != empty_stmt_node)
14861     {
14862       tree up2 = update;
14863       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14864         up2 = EXPR_WFL_NODE (up2);
14865       /* Try to detect constraint violations.  These would be
14866          programming errors somewhere.  */
14867       if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14868           || TREE_CODE (up2) == LOOP_EXPR)
14869         abort ();
14870       SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14871     }
14872   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14873   return loop;
14874 }
14875
14876 /* Try to find the loop a block might be related to. This comprises
14877    the case where the LOOP_EXPR is found as the second operand of a
14878    COMPOUND_EXPR, because the loop happens to have an initialization
14879    part, then expressed as the first operand of the COMPOUND_EXPR. If
14880    the search finds something, 1 is returned. Otherwise, 0 is
14881    returned. The search is assumed to start from a
14882    LABELED_BLOCK_EXPR's block.  */
14883
14884 static tree
14885 search_loop (tree statement)
14886 {
14887   if (TREE_CODE (statement) == LOOP_EXPR)
14888     return statement;
14889
14890   if (TREE_CODE (statement) == BLOCK)
14891     statement = BLOCK_SUBBLOCKS (statement);
14892   else
14893     return NULL_TREE;
14894
14895   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14896     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14897       statement = TREE_OPERAND (statement, 1);
14898
14899   return (TREE_CODE (statement) == LOOP_EXPR
14900           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14901 }
14902
14903 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14904    returned otherwise.  */
14905
14906 static int
14907 labeled_block_contains_loop_p (tree block, tree loop)
14908 {
14909   if (!block)
14910     return 0;
14911
14912   if (LABELED_BLOCK_BODY (block) == loop)
14913     return 1;
14914
14915   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14916     return 1;
14917
14918   return 0;
14919 }
14920
14921 /* If the loop isn't surrounded by a labeled statement, create one and
14922    insert LOOP as its body.  */
14923
14924 static tree
14925 patch_loop_statement (tree loop)
14926 {
14927   tree loop_label;
14928
14929   TREE_TYPE (loop) = void_type_node;
14930   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14931     return loop;
14932
14933   loop_label = build_labeled_block (0, NULL_TREE);
14934   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14935      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14936   LABELED_BLOCK_BODY (loop_label) = loop;
14937   PUSH_LABELED_BLOCK (loop_label);
14938   return loop_label;
14939 }
14940
14941 /* 14.13, 14.14: break and continue Statements */
14942
14943 /* Build a break or a continue statement. a null NAME indicates an
14944    unlabeled break/continue statement.  */
14945
14946 static tree
14947 build_bc_statement (int location, int is_break, tree name)
14948 {
14949   tree break_continue, label_block_expr = NULL_TREE;
14950
14951   if (name)
14952     {
14953       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14954             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14955         /* Null means that we don't have a target for this named
14956            break/continue. In this case, we make the target to be the
14957            label name, so that the error can be reported accuratly in
14958            patch_bc_statement. */
14959         label_block_expr = EXPR_WFL_NODE (name);
14960     }
14961   /* Unlabeled break/continue will be handled during the
14962      break/continue patch operation */
14963   break_continue
14964     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
14965
14966   IS_BREAK_STMT_P (break_continue) = is_break;
14967   TREE_SIDE_EFFECTS (break_continue) = 1;
14968   EXPR_WFL_LINECOL (break_continue) = location;
14969   break_continue = build_debugable_stmt (location, break_continue);
14970   return break_continue;
14971 }
14972
14973 /* Verification of a break/continue statement. */
14974
14975 static tree
14976 patch_bc_statement (tree node)
14977 {
14978   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
14979   tree labeled_block = ctxp->current_labeled_block;
14980   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14981
14982   /* Having an identifier here means that the target is unknown. */
14983   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
14984     {
14985       parse_error_context (wfl_operator, "No label definition found for `%s'",
14986                            IDENTIFIER_POINTER (bc_label));
14987       return error_mark_node;
14988     }
14989   if (! IS_BREAK_STMT_P (node))
14990     {
14991       /* It's a continue statement. */
14992       for (;; labeled_block = TREE_CHAIN (labeled_block))
14993         {
14994           if (labeled_block == NULL_TREE)
14995             {
14996               if (bc_label == NULL_TREE)
14997                 parse_error_context (wfl_operator,
14998                                      "`continue' must be in loop");
14999               else
15000                 parse_error_context
15001                   (wfl_operator, "continue label `%s' does not name a loop",
15002                    IDENTIFIER_POINTER (bc_label));
15003               return error_mark_node;
15004             }
15005           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15006                == continue_identifier_node)
15007               && (bc_label == NULL_TREE
15008                   || TREE_CHAIN (labeled_block) == bc_label))
15009             {
15010               bc_label = labeled_block;
15011               break;
15012             }
15013         }
15014     }
15015   else if (!bc_label)
15016     {
15017       for (;; labeled_block = TREE_CHAIN (labeled_block))
15018         {
15019           if (labeled_block == NULL_TREE)
15020             {
15021               parse_error_context (wfl_operator,
15022                                      "`break' must be in loop or switch");
15023               return error_mark_node;
15024             }
15025           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15026           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15027               || search_loop (target_stmt))
15028             {
15029               bc_label = labeled_block;
15030               break;
15031             }
15032         }
15033     }
15034
15035   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15036   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15037
15038   /* Our break/continue don't return values. */
15039   TREE_TYPE (node) = void_type_node;
15040   /* Encapsulate the break within a compound statement so that it's
15041      expanded all the times by expand_expr (and not clobbered
15042      sometimes, like after a if statement) */
15043   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15044   TREE_SIDE_EFFECTS (node) = 1;
15045   return node;
15046 }
15047
15048 /* Process the exit expression belonging to a loop. Its type must be
15049    boolean.  */
15050
15051 static tree
15052 patch_exit_expr (tree node)
15053 {
15054   tree expression = TREE_OPERAND (node, 0);
15055   TREE_TYPE (node) = error_mark_node;
15056   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15057
15058   /* The type of expression must be boolean */
15059   if (TREE_TYPE (expression) != boolean_type_node)
15060     {
15061       parse_error_context
15062         (wfl_operator,
15063     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15064          lang_printable_name (TREE_TYPE (expression), 0));
15065       return error_mark_node;
15066     }
15067   /* Now we know things are allright, invert the condition, fold and
15068      return */
15069   TREE_OPERAND (node, 0) =
15070     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15071
15072   if (! integer_zerop (TREE_OPERAND (node, 0))
15073       && ctxp->current_loop != NULL_TREE
15074       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15075     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15076   if (! integer_onep (TREE_OPERAND (node, 0)))
15077     CAN_COMPLETE_NORMALLY (node) = 1;
15078
15079
15080   TREE_TYPE (node) = void_type_node;
15081   return node;
15082 }
15083
15084 /* 14.9 Switch statement */
15085
15086 static tree
15087 patch_switch_statement (tree node)
15088 {
15089   tree se = TREE_OPERAND (node, 0), se_type;
15090   tree save, iter;
15091
15092   /* Complete the switch expression */
15093   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15094   se_type = TREE_TYPE (se);
15095   /* The type of the switch expression must be char, byte, short or
15096      int */
15097   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15098     {
15099       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15100       parse_error_context (wfl_operator,
15101           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15102                            lang_printable_name (se_type, 0));
15103       /* This is what java_complete_tree will check */
15104       TREE_OPERAND (node, 0) = error_mark_node;
15105       return error_mark_node;
15106     }
15107
15108   /* Save and restore the outer case label list.  */
15109   save = case_label_list;
15110   case_label_list = NULL_TREE;
15111
15112   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15113
15114   /* See if we've found a duplicate label.  We can't leave this until
15115      code generation, because in `--syntax-only' and `-C' modes we
15116      don't do ordinary code generation.  */
15117   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15118     {
15119       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15120       tree subiter;
15121       for (subiter = TREE_CHAIN (iter);
15122            subiter != NULL_TREE;
15123            subiter = TREE_CHAIN (subiter))
15124         {
15125           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15126           if (val == subval)
15127             {
15128               EXPR_WFL_LINECOL (wfl_operator)
15129                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15130               /* The case_label_list is in reverse order, so print the
15131                  outer label first.  */
15132               parse_error_context (wfl_operator, "duplicate case label: `"
15133                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15134               EXPR_WFL_LINECOL (wfl_operator)
15135                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15136               parse_error_context (wfl_operator, "original label is here");
15137
15138               break;
15139             }
15140         }
15141     }
15142
15143   case_label_list = save;
15144
15145   /* Ready to return */
15146   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15147     {
15148       TREE_TYPE (node) = error_mark_node;
15149       return error_mark_node;
15150     }
15151   TREE_TYPE (node) = void_type_node;
15152   TREE_SIDE_EFFECTS (node) = 1;
15153   CAN_COMPLETE_NORMALLY (node)
15154     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15155       || ! SWITCH_HAS_DEFAULT (node);
15156   return node;
15157 }
15158
15159 /* Assertions.  */
15160
15161 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15162    might be NULL_TREE.  */
15163 static tree
15164 build_assertion (int location, tree condition, tree value)
15165 {
15166   tree node;
15167   tree klass = GET_CPC ();
15168
15169   if (! CLASS_USES_ASSERTIONS (klass))
15170     {
15171       tree field, classdollar, id, call;
15172       tree class_type = TREE_TYPE (klass);
15173
15174       field = add_field (class_type,
15175                          get_identifier ("$assertionsDisabled"),
15176                          boolean_type_node,
15177                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15178       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15179       FIELD_SYNTHETIC (field) = 1;
15180
15181       if (!TYPE_DOT_CLASS (class_type))
15182         build_dot_class_method (class_type);
15183       classdollar = build_dot_class_method_invocation (class_type);
15184
15185       /* Call CLASS.desiredAssertionStatus().  */
15186       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15187       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15188       call = make_qualified_primary (classdollar, call, location);
15189       TREE_SIDE_EFFECTS (call) = 1;
15190
15191       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15192          seem odd, but we do it to generate code identical to that of
15193          the JDK.  */
15194       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15195       TREE_SIDE_EFFECTS (call) = 1;
15196       DECL_INITIAL (field) = call;
15197
15198       /* Record the initializer in the initializer statement list.  */
15199       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15200       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15201       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15202       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15203
15204       CLASS_USES_ASSERTIONS (klass) = 1;
15205     }
15206
15207   if (value != NULL_TREE)
15208     value = tree_cons (NULL_TREE, value, NULL_TREE);
15209
15210   node = build_wfl_node (get_identifier ("java"));
15211   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15212                               location);
15213   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15214                               location);
15215
15216   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15217   TREE_SIDE_EFFECTS (node) = 1;
15218   /* It is too early to use BUILD_THROW.  */
15219   node = build1 (THROW_EXPR, NULL_TREE, node);
15220   TREE_SIDE_EFFECTS (node) = 1;
15221
15222   /* We invert the condition; if we just put NODE as the `else' part
15223      then we generate weird-looking bytecode.  */
15224   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15225   /* Check $assertionsDisabled.  */
15226   condition
15227     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15228              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15229                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15230              condition);
15231   node = build_if_else_statement (location, condition, node, NULL_TREE);
15232   return node;
15233 }
15234
15235 /* 14.18 The try/catch statements */
15236
15237 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15238    catches TYPE and executes CATCH_STMTS.  */
15239
15240 static tree
15241 encapsulate_with_try_catch (int location, tree type, tree try_stmts,
15242                             tree catch_stmts)
15243 {
15244   tree try_block, catch_clause_param, catch_block, catch;
15245
15246   /* First build a try block */
15247   try_block = build_expr_block (try_stmts, NULL_TREE);
15248
15249   /* Build a catch block: we need a catch clause parameter */
15250   catch_clause_param = build_decl (VAR_DECL,
15251                                    wpv_id, build_pointer_type (type));
15252   /* And a block */
15253   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15254
15255   /* Initialize the variable and store in the block */
15256   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15257                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15258   add_stmt_to_block (catch_block, NULL_TREE, catch);
15259
15260   /* Add the catch statements */
15261   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15262
15263   /* Now we can build a CATCH_EXPR */
15264   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15265
15266   return build_try_statement (location, try_block, catch_block);
15267 }
15268
15269 static tree
15270 build_try_statement (int location, tree try_block, tree catches)
15271 {
15272   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15273   EXPR_WFL_LINECOL (node) = location;
15274   return node;
15275 }
15276
15277 static tree
15278 build_try_finally_statement (int location, tree try_block, tree finally)
15279 {
15280   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15281   EXPR_WFL_LINECOL (node) = location;
15282   return node;
15283 }
15284
15285 static tree
15286 patch_try_statement (tree node)
15287 {
15288   int error_found = 0;
15289   tree try = TREE_OPERAND (node, 0);
15290   /* Exception handlers are considered in left to right order */
15291   tree catch = nreverse (TREE_OPERAND (node, 1));
15292   tree current, caught_type_list = NULL_TREE;
15293
15294   /* Check catch clauses, if any. Every time we find an error, we try
15295      to process the next catch clause. We process the catch clause before
15296      the try block so that when processing the try block we can check thrown
15297      exceptions againts the caught type list. */
15298   for (current = catch; current; current = TREE_CHAIN (current))
15299     {
15300       tree carg_decl, carg_type;
15301       tree sub_current, catch_block, catch_clause;
15302       int unreachable;
15303
15304       /* At this point, the structure of the catch clause is
15305            CATCH_EXPR           (catch node)
15306              BLOCK              (with the decl of the parameter)
15307                COMPOUND_EXPR
15308                  MODIFY_EXPR   (assignment of the catch parameter)
15309                  BLOCK          (catch clause block)
15310        */
15311       catch_clause = TREE_OPERAND (current, 0);
15312       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15313       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15314
15315       /* Catch clauses can't have more than one parameter declared,
15316          but it's already enforced by the grammar. Make sure that the
15317          only parameter of the clause statement in of class Throwable
15318          or a subclass of Throwable, but that was done earlier. The
15319          catch clause parameter type has also been resolved. */
15320
15321       /* Just make sure that the catch clause parameter type inherits
15322          from java.lang.Throwable */
15323       if (!inherits_from_p (carg_type, throwable_type_node))
15324         {
15325           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15326           parse_error_context (wfl_operator,
15327                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15328                                lang_printable_name (carg_type, 0));
15329           error_found = 1;
15330           continue;
15331         }
15332
15333       /* Partial check for unreachable catch statement: The catch
15334          clause is reachable iff is no earlier catch block A in
15335          the try statement such that the type of the catch
15336          clause's parameter is the same as or a subclass of the
15337          type of A's parameter */
15338       unreachable = 0;
15339       for (sub_current = catch;
15340            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15341         {
15342           tree sub_catch_clause, decl;
15343           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15344           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15345
15346           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15347             {
15348               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15349               parse_error_context
15350                 (wfl_operator,
15351                  "`catch' not reached because of the catch clause at line %d",
15352                  EXPR_WFL_LINENO (sub_current));
15353               unreachable = error_found = 1;
15354               break;
15355             }
15356         }
15357       /* Complete the catch clause block */
15358       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15359       if (catch_block == error_mark_node)
15360         {
15361           error_found = 1;
15362           continue;
15363         }
15364       if (CAN_COMPLETE_NORMALLY (catch_block))
15365         CAN_COMPLETE_NORMALLY (node) = 1;
15366       TREE_OPERAND (current, 0) = catch_block;
15367
15368       if (unreachable)
15369         continue;
15370
15371       /* Things to do here: the exception must be thrown */
15372
15373       /* Link this type to the caught type list */
15374       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15375     }
15376
15377   PUSH_EXCEPTIONS (caught_type_list);
15378   if ((try = java_complete_tree (try)) == error_mark_node)
15379     error_found = 1;
15380   if (CAN_COMPLETE_NORMALLY (try))
15381     CAN_COMPLETE_NORMALLY (node) = 1;
15382   POP_EXCEPTIONS ();
15383
15384   /* Verification ends here */
15385   if (error_found)
15386     return error_mark_node;
15387
15388   TREE_OPERAND (node, 0) = try;
15389   TREE_OPERAND (node, 1) = catch;
15390   TREE_TYPE (node) = void_type_node;
15391   return node;
15392 }
15393
15394 /* 14.17 The synchronized Statement */
15395
15396 static tree
15397 patch_synchronized_statement (tree node, tree wfl_op1)
15398 {
15399   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15400   tree block = TREE_OPERAND (node, 1);
15401
15402   tree tmp, enter, exit, expr_decl, assignment;
15403
15404   if (expr == error_mark_node)
15405     {
15406       block = java_complete_tree (block);
15407       return expr;
15408     }
15409
15410   /* We might be trying to synchronize on a STRING_CST */
15411   if ((tmp = patch_string (expr)))
15412     expr = tmp;
15413
15414   /* The TYPE of expr must be a reference type */
15415   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15416     {
15417       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15418       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15419                            lang_printable_name (TREE_TYPE (expr), 0));
15420       return error_mark_node;
15421     }
15422
15423   if (flag_emit_xref)
15424     {
15425       TREE_OPERAND (node, 0) = expr;
15426       TREE_OPERAND (node, 1) = java_complete_tree (block);
15427       CAN_COMPLETE_NORMALLY (node) = 1;
15428       return node;
15429     }
15430
15431   /* Generate a try-finally for the synchronized statement, except
15432      that the handler that catches all throw exception calls
15433      _Jv_MonitorExit and then rethrow the exception.
15434      The synchronized statement is then implemented as:
15435      TRY
15436        {
15437          _Jv_MonitorEnter (expression)
15438          synchronized_block
15439          _Jv_MonitorExit (expression)
15440        }
15441      CATCH_ALL
15442        {
15443          e = _Jv_exception_info ();
15444          _Jv_MonitorExit (expression)
15445          Throw (e);
15446        } */
15447
15448   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15449   BUILD_MONITOR_ENTER (enter, expr_decl);
15450   BUILD_MONITOR_EXIT (exit, expr_decl);
15451   CAN_COMPLETE_NORMALLY (enter) = 1;
15452   CAN_COMPLETE_NORMALLY (exit) = 1;
15453   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15454   TREE_SIDE_EFFECTS (assignment) = 1;
15455   node = build (COMPOUND_EXPR, NULL_TREE,
15456                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15457                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15458   node = build_expr_block (node, expr_decl);
15459
15460   return java_complete_tree (node);
15461 }
15462
15463 /* 14.16 The throw Statement */
15464
15465 static tree
15466 patch_throw_statement (tree node, tree wfl_op1)
15467 {
15468   tree expr = TREE_OPERAND (node, 0);
15469   tree type = TREE_TYPE (expr);
15470   int unchecked_ok = 0, tryblock_throws_ok = 0;
15471
15472   /* Thrown expression must be assignable to java.lang.Throwable */
15473   if (!try_reference_assignconv (throwable_type_node, expr))
15474     {
15475       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15476       parse_error_context (wfl_operator,
15477     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15478                            lang_printable_name (type, 0));
15479       /* If the thrown expression was a reference, we further the
15480          compile-time check. */
15481       if (!JREFERENCE_TYPE_P (type))
15482         return error_mark_node;
15483     }
15484
15485   /* At least one of the following must be true */
15486
15487   /* The type of the throw expression is a not checked exception,
15488      i.e. is a unchecked expression. */
15489   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15490
15491   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15492   /* An instance can't throw a checked exception unless that exception
15493      is explicitly declared in the `throws' clause of each
15494      constructor. This doesn't apply to anonymous classes, since they
15495      don't have declared constructors. */
15496   if (!unchecked_ok
15497       && DECL_INSTINIT_P (current_function_decl)
15498       && !ANONYMOUS_CLASS_P (current_class))
15499     {
15500       tree current;
15501       for (current = TYPE_METHODS (current_class); current;
15502            current = TREE_CHAIN (current))
15503         if (DECL_CONSTRUCTOR_P (current)
15504             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15505           {
15506             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)",
15507                                  lang_printable_name (TREE_TYPE (expr), 0));
15508             return error_mark_node;
15509           }
15510     }
15511
15512   /* Throw is contained in a try statement and at least one catch
15513      clause can receive the thrown expression or the current method is
15514      declared to throw such an exception. Or, the throw statement is
15515      contained in a method or constructor declaration and the type of
15516      the Expression is assignable to at least one type listed in the
15517      throws clause the declaration. */
15518   if (!unchecked_ok)
15519     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15520   if (!(unchecked_ok || tryblock_throws_ok))
15521     {
15522       /* If there is a surrounding try block that has no matching
15523          clatch clause, report it first. A surrounding try block exits
15524          only if there is something after the list of checked
15525          exception thrown by the current function (if any). */
15526       if (IN_TRY_BLOCK_P ())
15527         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15528                              lang_printable_name (type, 0));
15529       /* If we have no surrounding try statement and the method doesn't have
15530          any throws, report it now. FIXME */
15531
15532       /* We report that the exception can't be throw from a try block
15533          in all circumstances but when the `throw' is inside a static
15534          block. */
15535       else if (!EXCEPTIONS_P (currently_caught_type_list)
15536                && !tryblock_throws_ok)
15537         {
15538           if (DECL_CLINIT_P (current_function_decl))
15539             parse_error_context (wfl_operator,
15540                    "Checked exception `%s' can't be thrown in initializer",
15541                                  lang_printable_name (type, 0));
15542           else
15543             parse_error_context (wfl_operator,
15544                    "Checked exception `%s' isn't thrown from a `try' block",
15545                                  lang_printable_name (type, 0));
15546         }
15547       /* Otherwise, the current method doesn't have the appropriate
15548          throws declaration */
15549       else
15550         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15551                              lang_printable_name (type, 0));
15552       return error_mark_node;
15553     }
15554
15555   if (! flag_emit_class_files && ! flag_emit_xref)
15556     BUILD_THROW (node, expr);
15557
15558   /* If doing xrefs, keep the location where the `throw' was seen. */
15559   if (flag_emit_xref)
15560     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15561   return node;
15562 }
15563
15564 /* Check that exception said to be thrown by method DECL can be
15565    effectively caught from where DECL is invoked.  */
15566
15567 static void
15568 check_thrown_exceptions (int location, tree decl)
15569 {
15570   tree throws;
15571   /* For all the unchecked exceptions thrown by DECL */
15572   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15573        throws = TREE_CHAIN (throws))
15574     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15575       {
15576 #if 1
15577         /* Temporary hack to suppresses errors about cloning arrays. FIXME */
15578         if (DECL_NAME (decl) == get_identifier ("clone"))
15579           continue;
15580 #endif
15581         EXPR_WFL_LINECOL (wfl_operator) = location;
15582         if (DECL_FINIT_P (current_function_decl))
15583           parse_error_context
15584             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15585              lang_printable_name (TREE_VALUE (throws), 0));
15586         else
15587           {
15588             parse_error_context
15589               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15590                lang_printable_name (TREE_VALUE (throws), 0),
15591                (DECL_INIT_P (current_function_decl) ?
15592                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15593                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15594           }
15595       }
15596 }
15597
15598 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15599    try-catch blocks, OR is listed in the `throws' clause of the
15600    current method.  */
15601
15602 static int
15603 check_thrown_exceptions_do (tree exception)
15604 {
15605   tree list = currently_caught_type_list;
15606   resolve_and_layout (exception, NULL_TREE);
15607   /* First, all the nested try-catch-finally at that stage. The
15608      last element contains `throws' clause exceptions, if any. */
15609   if (IS_UNCHECKED_EXCEPTION_P (exception))
15610     return 1;
15611   while (list)
15612     {
15613       tree caught;
15614       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15615         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15616           return 1;
15617       list = TREE_CHAIN (list);
15618     }
15619   return 0;
15620 }
15621
15622 static void
15623 purge_unchecked_exceptions (tree mdecl)
15624 {
15625   tree throws = DECL_FUNCTION_THROWS (mdecl);
15626   tree new = NULL_TREE;
15627
15628   while (throws)
15629     {
15630       tree next = TREE_CHAIN (throws);
15631       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15632         {
15633           TREE_CHAIN (throws) = new;
15634           new = throws;
15635         }
15636       throws = next;
15637     }
15638   /* List is inverted here, but it doesn't matter */
15639   DECL_FUNCTION_THROWS (mdecl) = new;
15640 }
15641
15642 /* This function goes over all of CLASS_TYPE ctors and checks whether
15643    each of them features at least one unchecked exception in its
15644    `throws' clause. If it's the case, it returns `true', `false'
15645    otherwise.  */
15646
15647 static bool
15648 ctors_unchecked_throws_clause_p (tree class_type)
15649 {
15650   tree current;
15651
15652   for (current = TYPE_METHODS (class_type); current;
15653        current = TREE_CHAIN (current))
15654     {
15655       bool ctu = false; /* Ctor Throws Unchecked */
15656       if (DECL_CONSTRUCTOR_P (current))
15657         {
15658           tree throws;
15659           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15660                throws = TREE_CHAIN (throws))
15661             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15662               ctu = true;
15663         }
15664       /* We return false as we found one ctor that is unfit. */
15665       if (!ctu && DECL_CONSTRUCTOR_P (current))
15666         return false;
15667     }
15668   /* All ctors feature at least one unchecked exception in their
15669      `throws' clause. */
15670   return true;
15671 }
15672
15673 /* 15.24 Conditional Operator ?: */
15674
15675 static tree
15676 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15677 {
15678   tree cond = TREE_OPERAND (node, 0);
15679   tree op1 = TREE_OPERAND (node, 1);
15680   tree op2 = TREE_OPERAND (node, 2);
15681   tree resulting_type = NULL_TREE;
15682   tree t1, t2, patched;
15683   int error_found = 0;
15684
15685   /* Operands of ?: might be StringBuffers crafted as a result of a
15686      string concatenation. Obtain a descent operand here.  */
15687   if ((patched = patch_string (op1)))
15688     TREE_OPERAND (node, 1) = op1 = patched;
15689   if ((patched = patch_string (op2)))
15690     TREE_OPERAND (node, 2) = op2 = patched;
15691
15692   t1 = TREE_TYPE (op1);
15693   t2 = TREE_TYPE (op2);
15694
15695   /* The first expression must be a boolean */
15696   if (TREE_TYPE (cond) != boolean_type_node)
15697     {
15698       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15699       parse_error_context (wfl_operator,
15700                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15701                            lang_printable_name (TREE_TYPE (cond), 0));
15702       error_found = 1;
15703     }
15704
15705   /* Second and third can be numeric, boolean (i.e. primitive),
15706      references or null. Anything else results in an error */
15707   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15708         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15709             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15710         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15711     error_found = 1;
15712
15713   /* Determine the type of the conditional expression. Same types are
15714      easy to deal with */
15715   else if (t1 == t2)
15716     resulting_type = t1;
15717
15718   /* There are different rules for numeric types */
15719   else if (JNUMERIC_TYPE_P (t1))
15720     {
15721       /* if byte/short found, the resulting type is short */
15722       if ((t1 == byte_type_node && t2 == short_type_node)
15723           || (t1 == short_type_node && t2 == byte_type_node))
15724         resulting_type = short_type_node;
15725
15726       /* If t1 is a constant int and t2 is of type byte, short or char
15727          and t1's value fits in t2, then the resulting type is t2 */
15728       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15729           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15730         resulting_type = t2;
15731
15732       /* If t2 is a constant int and t1 is of type byte, short or char
15733          and t2's value fits in t1, then the resulting type is t1 */
15734       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15735           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15736         resulting_type = t1;
15737
15738       /* Otherwise, binary numeric promotion is applied and the
15739          resulting type is the promoted type of operand 1 and 2 */
15740       else
15741         resulting_type = binary_numeric_promotion (t1, t2,
15742                                                    &TREE_OPERAND (node, 1),
15743                                                    &TREE_OPERAND (node, 2));
15744     }
15745
15746   /* Cases of a reference and a null type */
15747   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15748     resulting_type = t1;
15749
15750   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15751     resulting_type = t2;
15752
15753   /* Last case: different reference types. If a type can be converted
15754      into the other one by assignment conversion, the latter
15755      determines the type of the expression */
15756   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15757     resulting_type = promote_type (t1);
15758
15759   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15760     resulting_type = promote_type (t2);
15761
15762   /* If we don't have any resulting type, we're in trouble */
15763   if (!resulting_type)
15764     {
15765       char *t = xstrdup (lang_printable_name (t1, 0));
15766       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15767       parse_error_context (wfl_operator,
15768                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15769                            t, lang_printable_name (t2, 0));
15770       free (t);
15771       error_found = 1;
15772     }
15773
15774   if (error_found)
15775     {
15776       TREE_TYPE (node) = error_mark_node;
15777       return error_mark_node;
15778     }
15779
15780   TREE_TYPE (node) = resulting_type;
15781   TREE_SET_CODE (node, COND_EXPR);
15782   CAN_COMPLETE_NORMALLY (node) = 1;
15783   return node;
15784 }
15785
15786 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15787
15788 static tree
15789 maybe_build_class_init_for_field (tree decl, tree expr)
15790 {
15791   tree clas = DECL_CONTEXT (decl);
15792   if (flag_emit_class_files || flag_emit_xref)
15793     return expr;
15794
15795   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15796       && FIELD_FINAL (decl))
15797     {
15798       tree init = DECL_INITIAL (decl);
15799       if (init != NULL_TREE)
15800         init = fold_constant_for_init (init, decl);
15801       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15802         return expr;
15803     }
15804
15805   return build_class_init (clas, expr);
15806 }
15807
15808 /* Try to constant fold NODE.
15809    If NODE is not a constant expression, return NULL_EXPR.
15810    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15811
15812 static tree
15813 fold_constant_for_init (tree node, tree context)
15814 {
15815   tree op0, op1, val;
15816   enum tree_code code = TREE_CODE (node);
15817
15818   switch (code)
15819     {
15820     case INTEGER_CST:
15821       if (node == null_pointer_node)
15822         return NULL_TREE;
15823     case STRING_CST:
15824     case REAL_CST:
15825       return node;
15826
15827     case PLUS_EXPR:
15828     case MINUS_EXPR:
15829     case MULT_EXPR:
15830     case TRUNC_MOD_EXPR:
15831     case RDIV_EXPR:
15832     case LSHIFT_EXPR:
15833     case RSHIFT_EXPR:
15834     case URSHIFT_EXPR:
15835     case BIT_AND_EXPR:
15836     case BIT_XOR_EXPR:
15837     case BIT_IOR_EXPR:
15838     case TRUTH_ANDIF_EXPR:
15839     case TRUTH_ORIF_EXPR:
15840     case EQ_EXPR:
15841     case NE_EXPR:
15842     case GT_EXPR:
15843     case GE_EXPR:
15844     case LT_EXPR:
15845     case LE_EXPR:
15846       op0 = TREE_OPERAND (node, 0);
15847       op1 = TREE_OPERAND (node, 1);
15848       val = fold_constant_for_init (op0, context);
15849       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15850         return NULL_TREE;
15851       TREE_OPERAND (node, 0) = val;
15852       val = fold_constant_for_init (op1, context);
15853       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15854         return NULL_TREE;
15855       TREE_OPERAND (node, 1) = val;
15856       return patch_binop (node, op0, op1);
15857
15858     case UNARY_PLUS_EXPR:
15859     case NEGATE_EXPR:
15860     case TRUTH_NOT_EXPR:
15861     case BIT_NOT_EXPR:
15862     case CONVERT_EXPR:
15863       op0 = TREE_OPERAND (node, 0);
15864       val = fold_constant_for_init (op0, context);
15865       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15866         return NULL_TREE;
15867       TREE_OPERAND (node, 0) = val;
15868       return patch_unaryop (node, op0);
15869       break;
15870
15871     case COND_EXPR:
15872       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
15873       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15874         return NULL_TREE;
15875       TREE_OPERAND (node, 0) = val;
15876       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
15877       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15878         return NULL_TREE;
15879       TREE_OPERAND (node, 1) = val;
15880       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
15881       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15882         return NULL_TREE;
15883       TREE_OPERAND (node, 2) = val;
15884       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
15885         : TREE_OPERAND (node, 2);
15886
15887     case VAR_DECL:
15888     case FIELD_DECL:
15889       if (! FIELD_FINAL (node)
15890           || DECL_INITIAL (node) == NULL_TREE)
15891         return NULL_TREE;
15892       val = DECL_INITIAL (node);
15893       /* Guard against infinite recursion. */
15894       DECL_INITIAL (node) = NULL_TREE;
15895       val = fold_constant_for_init (val, node);
15896       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
15897         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
15898       DECL_INITIAL (node) = val;
15899       return val;
15900
15901     case EXPR_WITH_FILE_LOCATION:
15902       /* Compare java_complete_tree and resolve_expression_name. */
15903       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15904           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15905         {
15906           tree name = EXPR_WFL_NODE (node);
15907           tree decl;
15908           if (PRIMARY_P (node))
15909             return NULL_TREE;
15910           else if (! QUALIFIED_P (name))
15911             {
15912               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
15913               if (decl == NULL_TREE
15914                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
15915                 return NULL_TREE;
15916               return fold_constant_for_init (decl, decl);
15917             }
15918           else
15919             {
15920               /* Install the proper context for the field resolution.
15921                  The prior context is restored once the name is
15922                  properly qualified. */
15923               tree saved_current_class = current_class;
15924               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
15925               current_class = DECL_CONTEXT (context);
15926               qualify_ambiguous_name (node);
15927               current_class = saved_current_class;
15928               if (resolve_field_access (node, &decl, NULL)
15929                   && decl != NULL_TREE)
15930                 return fold_constant_for_init (decl, decl);
15931               return NULL_TREE;
15932             }
15933         }
15934       else
15935         {
15936           op0 = TREE_OPERAND (node, 0);
15937           val = fold_constant_for_init (op0, context);
15938           if (val == NULL_TREE || ! TREE_CONSTANT (val))
15939             return NULL_TREE;
15940           TREE_OPERAND (node, 0) = val;
15941           return val;
15942         }
15943
15944 #ifdef USE_COMPONENT_REF
15945     case IDENTIFIER:
15946     case COMPONENT_REF:
15947       ?;
15948 #endif
15949
15950     default:
15951       return NULL_TREE;
15952     }
15953 }
15954
15955 #ifdef USE_COMPONENT_REF
15956 /* Context is 'T' for TypeName, 'P' for PackageName,
15957    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
15958
15959 tree
15960 resolve_simple_name (tree name, int context)
15961 {
15962 }
15963
15964 tree
15965 resolve_qualified_name (tree name, int context)
15966 {
15967 }
15968 #endif
15969
15970 void
15971 init_src_parse (void)
15972 {
15973   /* Sanity check; we've been bit by this before.  */
15974   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
15975     abort ();
15976 }
15977
15978 \f
15979
15980 /* This section deals with the functions that are called when tables
15981    recording class initialization information are traversed.  */
15982
15983 /* Attach to PTR (a block) the declaration found in ENTRY. */
15984
15985 static int
15986 attach_init_test_initialization_flags (void **entry, void *ptr)
15987 {
15988   tree block = (tree)ptr;
15989   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
15990
15991   if (block != error_mark_node)
15992     {
15993       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
15994       BLOCK_EXPR_DECLS (block) = ite->value;
15995     }
15996   return true;
15997 }
15998
15999 /* This function is called for each classes that is known definitely
16000    assigned when a given static method was called. This function
16001    augments a compound expression (INFO) storing all assignment to
16002    initialized static class flags if a flag already existed, otherwise
16003    a new one is created.  */
16004
16005 static int
16006 emit_test_initialization (void **entry_p, void *info)
16007 {
16008   tree l = (tree) info;
16009   tree decl, init;
16010   tree key = (tree) *entry_p;
16011   tree *ite;
16012   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16013
16014   /* If we haven't found a flag and we're dealing with self registered
16015      with current_function_decl, then don't do anything. Self is
16016      always added as definitely initialized but this information is
16017      valid only if used outside the current function. */
16018   if (current_function_decl == TREE_PURPOSE (l)
16019       && java_treetreehash_find (cf_ht, key) == NULL)
16020     return true;
16021
16022   ite = java_treetreehash_new (cf_ht, key);
16023
16024   /* If we don't have a variable, create one and install it. */
16025   if (*ite == NULL)
16026     {
16027       tree block;
16028
16029       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16030       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16031       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16032       DECL_CONTEXT (decl) = current_function_decl;
16033       DECL_INITIAL (decl) = boolean_true_node;
16034
16035       /* The trick is to find the right context for it. */
16036       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16037       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16038       BLOCK_EXPR_DECLS (block) = decl;
16039       *ite = decl;
16040     }
16041   else
16042     decl = *ite;
16043
16044   /* Now simply augment the compound that holds all the assignments
16045      pertaining to this method invocation. */
16046   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16047   TREE_SIDE_EFFECTS (init) = 1;
16048   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16049   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16050
16051   return true;
16052 }
16053
16054 #include "gt-java-parse.h"
16055 #include "gtype-java.h"