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, tree, tree);
 308 static tree build_outer_method_access_method (tree);
 309 static tree build_new_access_id (void);
 310 static tree build_outer_field_access_method (tree, tree, tree, tree, tree);
 311
 312 static int outer_field_access_p (tree, tree);
 313 static int outer_field_expanded_access_p (tree, tree *, tree *, tree *);
 314 static tree outer_field_access_fix (tree, tree, tree);
 315 static tree build_incomplete_class_ref (int, tree);
 316 static tree patch_incomplete_class_ref (tree);
 317 static tree create_anonymous_class (int, tree);
 318 static void patch_anonymous_class (tree, tree, tree);
 319 static void add_inner_class_fields (tree, tree);
 320
 321 static tree build_dot_class_method (tree);
 322 static tree build_dot_class_method_invocation (tree);
 323 static void create_new_parser_context (int);
 324 static void mark_parser_ctxt (void *);
 325 static tree maybe_build_class_init_for_field (tree, tree);
 326
 327 static int attach_init_test_initialization_flags (PTR *, PTR);
 328 static int emit_test_initialization (PTR *, PTR);
 329
 330 static char *string_convert_int_cst (tree);
 331
 332 /* Number of error found so far. */
 333 int java_error_count;
 334 /* Number of warning found so far. */
 335 int java_warning_count;
 336 /* Tell when not to fold, when doing xrefs */
 337 int do_not_fold;
 338 /* Cyclic inheritance report, as it can be set by layout_class */
 339 const char *cyclic_inheritance_report;
 340
 341 /* The current parser context */
 342 struct parser_ctxt *ctxp;
 343
 344 /* List of things that were analyzed for which code will be generated */
 345 struct parser_ctxt *ctxp_for_generation = NULL;
 346
 347 /* binop_lookup maps token to tree_code. It is used where binary
 348    operations are involved and required by the parser. RDIV_EXPR
 349    covers both integral/floating point division. The code is changed
 350    once the type of both operator is worked out.  */
 351
 352 static const enum tree_code binop_lookup[19] =
 353   {
 354     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 355     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 356     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 357     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 358     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 359    };
 360 #define BINOP_LOOKUP(VALUE)                                             \
 361   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 362
 363 /* This is the end index for binary operators that can also be used
 364    in compound assignements. */
 365 #define BINOP_COMPOUND_CANDIDATES 11
 366
 367 /* The "$L" identifier we use to create labels.  */
 368 static GTY(()) tree label_id;
 369
 370 /* The "StringBuffer" identifier used for the String `+' operator. */
 371 static GTY(()) tree wfl_string_buffer;
 372
 373 /* The "append" identifier used for String `+' operator.  */
 374 static GTY(()) tree wfl_append;
 375
 376 /* The "toString" identifier used for String `+' operator. */
 377 static GTY(()) tree wfl_to_string;
 378
 379 /* The "java.lang" import qualified name.  */
 380 static GTY(()) tree java_lang_id;
 381
 382 /* The generated `inst$' identifier used for generated enclosing
 383    instance/field access functions.  */
 384 static GTY(()) tree inst_id;
 385
 386 /* Context and flag for static blocks */
 387 static GTY(()) tree current_static_block;
 388
 389 /* The generated `write_parm_value$' identifier.  */
 390 static GTY(()) tree wpv_id;
 391
 392 /* The list of all packages we've seen so far */
 393 static GTY(()) tree package_list;
 394
 395 /* Hold THIS for the scope of the current method decl.  */
 396 static GTY(()) tree current_this;
 397
 398 /* Hold a list of catch clauses list. The first element of this list is
 399    the list of the catch clauses of the currently analysed try block. */
 400 static GTY(()) tree currently_caught_type_list;
 401
 402 /* This holds a linked list of all the case labels for the current
 403    switch statement.  It is only used when checking to see if there
 404    are duplicate labels.  FIXME: probably this should just be attached
 405    to the switch itself; then it could be referenced via
 406    `ctxp->current_loop'.  */
 407 static GTY(()) tree case_label_list;
 408
 409 /* Anonymous class counter. Will be reset to 1 every time a non
 410    anonymous class gets created. */
 411 static int anonymous_class_counter = 1;
 412
 413 static GTY(()) tree src_parse_roots[1];
 414
 415 /* All classes seen from source code */
 416 #define gclass_list src_parse_roots[0]
 417
 418 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 419    line and point it out.  */
 420 /* Should point out the one that don't fit. ASCII/unicode, going
 421    backward. FIXME */
 422
 423 #define check_modifiers(__message, __value, __mask) do {        \
 424   if ((__value) & ~(__mask))                                    \
 425     {                                                           \
 426       size_t i, remainder = (__value) & ~(__mask);              \
 427       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 428         if ((1 << i) & remainder)                               \
 429           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 430                                java_accstring_lookup (1 << i)); \
 431     }                                                           \
 432 } while (0)
 433
 434 %}
 435
 436 %union {
 437   tree node;
 438   int sub_token;
 439   struct {
 440     int token;
 441     int location;
 442   } operator;
 443   int value;
 444 }
 445
 446 %{
 447 #include "lex.c"
 448 %}
 449
 450 %pure_parser
 451
 452 /* Things defined here have to match the order of what's in the
 453    binop_lookup table.  */
 454
 455 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 456 %token   LS_TK           SRS_TK          ZRS_TK
 457 %token   AND_TK          XOR_TK          OR_TK
 458 %token   BOOL_AND_TK BOOL_OR_TK
 459 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 460
 461 /* This maps to the same binop_lookup entry than the token above */
 462
 463 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 464 %token   REM_ASSIGN_TK
 465 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 466 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 467
 468
 469 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 470
 471 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 472 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 473 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 474 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 475 %token   MODIFIER_TK
 476
 477 /* Keep those two in order, too */
 478 %token   DECR_TK INCR_TK
 479
 480 /* From now one, things can be in any order */
 481
 482 %token   DEFAULT_TK      IF_TK              THROW_TK
 483 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 484 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 485 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 486 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 487 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 488 %token   SUPER_TK        WHILE_TK           CLASS_TK
 489 %token   SWITCH_TK       CONST_TK           TRY_TK
 490 %token   FOR_TK          NEW_TK             CONTINUE_TK
 491 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 492 %token   ASSERT_TK
 493
 494 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 495 %token   CHAR_TK         INTEGRAL_TK
 496
 497 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 498
 499 %token   ID_TK
 500
 501 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 502
 503 %token   ASSIGN_ANY_TK   ASSIGN_TK
 504 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 505
 506 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 507 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 508
 509 %type    <value>        modifiers MODIFIER_TK final synchronized
 510
 511 %type    <node>         super ID_TK identifier
 512 %type    <node>         name simple_name qualified_name
 513 %type    <node>         type_declaration compilation_unit
 514                         field_declaration method_declaration extends_interfaces
 515                         interfaces interface_type_list
 516                         import_declarations package_declaration
 517                         type_declarations interface_body
 518                         interface_member_declaration constant_declaration
 519                         interface_member_declarations interface_type
 520                         abstract_method_declaration
 521 %type    <node>         class_body_declaration class_member_declaration
 522                         static_initializer constructor_declaration block
 523 %type    <node>         class_body_declarations constructor_header
 524 %type    <node>         class_or_interface_type class_type class_type_list
 525                         constructor_declarator explicit_constructor_invocation
 526 %type    <node>         dim_expr dim_exprs this_or_super throws
 527
 528 %type    <node>         variable_declarator_id variable_declarator
 529                         variable_declarators variable_initializer
 530                         variable_initializers constructor_body
 531                         array_initializer
 532
 533 %type    <node>         class_body block_end constructor_block_end
 534 %type    <node>         statement statement_without_trailing_substatement
 535                         labeled_statement if_then_statement label_decl
 536                         if_then_else_statement while_statement for_statement
 537                         statement_nsi labeled_statement_nsi do_statement
 538                         if_then_else_statement_nsi while_statement_nsi
 539                         for_statement_nsi statement_expression_list for_init
 540                         for_update statement_expression expression_statement
 541                         primary_no_new_array expression primary
 542                         array_creation_expression array_type
 543                         class_instance_creation_expression field_access
 544                         method_invocation array_access something_dot_new
 545                         argument_list postfix_expression while_expression
 546                         post_increment_expression post_decrement_expression
 547                         unary_expression_not_plus_minus unary_expression
 548                         pre_increment_expression pre_decrement_expression
 549                         cast_expression
 550                         multiplicative_expression additive_expression
 551                         shift_expression relational_expression
 552                         equality_expression and_expression
 553                         exclusive_or_expression inclusive_or_expression
 554                         conditional_and_expression conditional_or_expression
 555                         conditional_expression assignment_expression
 556                         left_hand_side assignment for_header for_begin
 557                         constant_expression do_statement_begin empty_statement
 558                         switch_statement synchronized_statement throw_statement
 559                         try_statement assert_statement
 560                         switch_expression switch_block
 561                         catches catch_clause catch_clause_parameter finally
 562                         anonymous_class_creation trap_overflow_corner_case
 563 %type    <node>         return_statement break_statement continue_statement
 564
 565 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 566 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 567 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 568 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 569 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 570 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 571 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 572 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 573 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 574 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 575 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 576 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 577 %type    <operator>     NEW_TK ASSERT_TK
 578
 579 %type    <node>         method_body
 580
 581 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 582                         STRING_LIT_TK NULL_TK VOID_TK
 583
 584 %type    <node>         IF_TK WHILE_TK FOR_TK
 585
 586 %type    <node>         formal_parameter_list formal_parameter
 587                         method_declarator method_header
 588
 589 %type    <node>         primitive_type reference_type type
 590                         BOOLEAN_TK INTEGRAL_TK FP_TK
 591
 592 /* Added or modified JDK 1.1 rule types  */
 593 %type    <node>         type_literals
 594
 595 %%
 596 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 597 goal:
 598                 {
 599                   /* Register static variables with the garbage
 600                      collector.  */
 601                   ggc_add_root (&ctxp, 1,
 602                                 sizeof (struct parser_ctxt *),
 603                                 mark_parser_ctxt);
 604                   ggc_add_root (&ctxp_for_generation, 1,
 605                                 sizeof (struct parser_ctxt *),
 606                                 mark_parser_ctxt);
 607                 }
 608         compilation_unit
 609                 {}
 610 ;
 611
 612 /* 19.3 Productions from 3: Lexical structure  */
 613 literal:
 614         INT_LIT_TK
 615 |       FP_LIT_TK
 616 |       BOOL_LIT_TK
 617 |       CHAR_LIT_TK
 618 |       STRING_LIT_TK
 619 |       NULL_TK
 620 ;
 621
 622 /* 19.4 Productions from 4: Types, Values and Variables  */
 623 type:
 624         primitive_type
 625 |       reference_type
 626 ;
 627
 628 primitive_type:
 629         INTEGRAL_TK
 630 |       FP_TK
 631 |       BOOLEAN_TK
 632 ;
 633
 634 reference_type:
 635         class_or_interface_type
 636 |       array_type
 637 ;
 638
 639 class_or_interface_type:
 640         name
 641 ;
 642
 643 class_type:
 644         class_or_interface_type /* Default rule */
 645 ;
 646
 647 interface_type:
 648          class_or_interface_type
 649 ;
 650
 651 array_type:
 652         primitive_type dims
 653                 {
 654                   int osb = pop_current_osb (ctxp);
 655                   tree t = build_java_array_type (($1), -1);
 656                   while (--osb)
 657                     t = build_unresolved_array_type (t);
 658                   $$ = t;
 659                 }
 660 |       name dims
 661                 {
 662                   int osb = pop_current_osb (ctxp);
 663                   tree t = $1;
 664                   while (osb--)
 665                     t = build_unresolved_array_type (t);
 666                   $$ = t;
 667                 }
 668 ;
 669
 670 /* 19.5 Productions from 6: Names  */
 671 name:
 672         simple_name             /* Default rule */
 673 |       qualified_name          /* Default rule */
 674 ;
 675
 676 simple_name:
 677         identifier              /* Default rule */
 678 ;
 679
 680 qualified_name:
 681         name DOT_TK identifier
 682                 { $$ = make_qualified_name ($1, $3, $2.location); }
 683 ;
 684
 685 identifier:
 686         ID_TK
 687 ;
 688
 689 /* 19.6: Production from 7: Packages  */
 690 compilation_unit:
 691                 {$$ = NULL;}
 692 |       package_declaration
 693 |       import_declarations
 694 |       type_declarations
 695 |       package_declaration import_declarations
 696 |       package_declaration type_declarations
 697 |       import_declarations type_declarations
 698 |       package_declaration import_declarations type_declarations
 699 ;
 700
 701 import_declarations:
 702         import_declaration
 703                 {
 704                   $$ = NULL;
 705                 }
 706 |       import_declarations import_declaration
 707                 {
 708                   $$ = NULL;
 709                 }
 710 ;
 711
 712 type_declarations:
 713         type_declaration
 714 |       type_declarations type_declaration
 715 ;
 716
 717 package_declaration:
 718         PACKAGE_TK name SC_TK
 719                 {
 720                   ctxp->package = EXPR_WFL_NODE ($2);
 721                   register_package (ctxp->package);
 722                 }
 723 |       PACKAGE_TK error
 724                 {yyerror ("Missing name"); RECOVER;}
 725 |       PACKAGE_TK name error
 726                 {yyerror ("';' expected"); RECOVER;}
 727 ;
 728
 729 import_declaration:
 730         single_type_import_declaration
 731 |       type_import_on_demand_declaration
 732 ;
 733
 734 single_type_import_declaration:
 735         IMPORT_TK name SC_TK
 736                 {
 737                   tree name = EXPR_WFL_NODE ($2), last_name;
 738                   int   i = IDENTIFIER_LENGTH (name)-1;
 739                   const char *last = &IDENTIFIER_POINTER (name)[i];
 740                   while (last != IDENTIFIER_POINTER (name))
 741                     {
 742                       if (last [0] == '.')
 743                         break;
 744                       last--;
 745                     }
 746                   last_name = get_identifier (++last);
 747                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 748                     {
 749                       tree err = find_name_in_single_imports (last_name);
 750                       if (err && err != name)
 751                         parse_error_context
 752                           ($2, "Ambiguous class: `%s' and `%s'",
 753                            IDENTIFIER_POINTER (name),
 754                            IDENTIFIER_POINTER (err));
 755                       else
 756                         REGISTER_IMPORT ($2, last_name);
 757                     }
 758                   else
 759                     REGISTER_IMPORT ($2, last_name);
 760                 }
 761 |       IMPORT_TK error
 762                 {yyerror ("Missing name"); RECOVER;}
 763 |       IMPORT_TK name error
 764                 {yyerror ("';' expected"); RECOVER;}
 765 ;
 766
 767 type_import_on_demand_declaration:
 768         IMPORT_TK name DOT_TK MULT_TK SC_TK
 769                 {
 770                   tree name = EXPR_WFL_NODE ($2);
 771                   tree it;
 772                   /* Search for duplicates. */
 773                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 774                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 775                       break;
 776                   /* Don't import the same thing more than once, just ignore
 777                      duplicates (7.5.2) */
 778                   if (! it)
 779                     {
 780                       read_import_dir ($2);
 781                       ctxp->import_demand_list =
 782                         chainon (ctxp->import_demand_list,
 783                                  build_tree_list ($2, NULL_TREE));
 784                     }
 785                 }
 786 |       IMPORT_TK name DOT_TK error
 787                 {yyerror ("'*' expected"); RECOVER;}
 788 |       IMPORT_TK name DOT_TK MULT_TK error
 789                 {yyerror ("';' expected"); RECOVER;}
 790 ;
 791
 792 type_declaration:
 793         class_declaration
 794                 { end_class_declaration (0); }
 795 |       interface_declaration
 796                 { end_class_declaration (0); }
 797 |       empty_statement
 798 |       error
 799                 {
 800                   YYERROR_NOW;
 801                   yyerror ("Class or interface declaration expected");
 802                 }
 803 ;
 804
 805 /* 19.7 Shortened from the original:
 806    modifiers: modifier | modifiers modifier
 807    modifier: any of public...  */
 808 modifiers:
 809         MODIFIER_TK
 810                 {
 811                   $$ = (1 << $1);
 812                 }
 813 |       modifiers MODIFIER_TK
 814                 {
 815                   int acc = (1 << $2);
 816                   if ($$ & acc)
 817                     parse_error_context
 818                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 819                        java_accstring_lookup (acc));
 820                   else
 821                     {
 822                       $$ |= acc;
 823                     }
 824                 }
 825 ;
 826
 827 /* 19.8.1 Production from $8.1: Class Declaration */
 828 class_declaration:
 829         modifiers CLASS_TK identifier super interfaces
 830                 { create_class ($1, $3, $4, $5); }
 831         class_body
 832                 {;}
 833 |       CLASS_TK identifier super interfaces
 834                 { create_class (0, $2, $3, $4); }
 835         class_body
 836                 {;}
 837 |       modifiers CLASS_TK error
 838                 { yyerror ("Missing class name"); RECOVER; }
 839 |       CLASS_TK error
 840                 { yyerror ("Missing class name"); RECOVER; }
 841 |       CLASS_TK identifier error
 842                 {
 843                   if (!ctxp->class_err) yyerror ("'{' expected");
 844                   DRECOVER(class1);
 845                 }
 846 |       modifiers CLASS_TK identifier error
 847                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 848 ;
 849
 850 super:
 851                 { $$ = NULL; }
 852 |       EXTENDS_TK class_type
 853                 { $$ = $2; }
 854 |       EXTENDS_TK class_type error
 855                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 856 |       EXTENDS_TK error
 857                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 858 ;
 859
 860 interfaces:
 861                 { $$ = NULL_TREE; }
 862 |       IMPLEMENTS_TK interface_type_list
 863                 { $$ = $2; }
 864 |       IMPLEMENTS_TK error
 865                 {
 866                   ctxp->class_err=1;
 867                   yyerror ("Missing interface name");
 868                 }
 869 ;
 870
 871 interface_type_list:
 872         interface_type
 873                 {
 874                   ctxp->interface_number = 1;
 875                   $$ = build_tree_list ($1, NULL_TREE);
 876                 }
 877 |       interface_type_list C_TK interface_type
 878                 {
 879                   ctxp->interface_number++;
 880                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 881                 }
 882 |       interface_type_list C_TK error
 883                 {yyerror ("Missing interface name"); RECOVER;}
 884 ;
 885
 886 class_body:
 887         OCB_TK CCB_TK
 888                 {
 889                   /* Store the location of the `}' when doing xrefs */
 890                   if (flag_emit_xref)
 891                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 892                       EXPR_WFL_ADD_COL ($2.location, 1);
 893                   $$ = GET_CPC ();
 894                 }
 895 |       OCB_TK class_body_declarations CCB_TK
 896                 {
 897                   /* Store the location of the `}' when doing xrefs */
 898                   if (flag_emit_xref)
 899                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 900                       EXPR_WFL_ADD_COL ($3.location, 1);
 901                   $$ = GET_CPC ();
 902                 }
 903 ;
 904
 905 class_body_declarations:
 906         class_body_declaration
 907 |       class_body_declarations class_body_declaration
 908 ;
 909
 910 class_body_declaration:
 911         class_member_declaration
 912 |       static_initializer
 913 |       constructor_declaration
 914 |       block                   /* Added, JDK1.1, instance initializer */
 915                 {
 916                   if ($1 != empty_stmt_node)
 917                     {
 918                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 919                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 920                     }
 921                 }
 922 ;
 923
 924 class_member_declaration:
 925         field_declaration
 926 |       method_declaration
 927 |       class_declaration       /* Added, JDK1.1 inner classes */
 928                 { end_class_declaration (1); }
 929 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 930                 { end_class_declaration (1); }
 931 |       empty_statement
 932 ;
 933
 934 /* 19.8.2 Productions from 8.3: Field Declarations  */
 935 field_declaration:
 936         type variable_declarators SC_TK
 937                 { register_fields (0, $1, $2); }
 938 |       modifiers type variable_declarators SC_TK
 939                 {
 940                   check_modifiers
 941                     ("Illegal modifier `%s' for field declaration",
 942                      $1, FIELD_MODIFIERS);
 943                   check_modifiers_consistency ($1);
 944                   register_fields ($1, $2, $3);
 945                 }
 946 ;
 947
 948 variable_declarators:
 949         /* Should we use build_decl_list () instead ? FIXME */
 950         variable_declarator     /* Default rule */
 951 |       variable_declarators C_TK variable_declarator
 952                 { $$ = chainon ($1, $3); }
 953 |       variable_declarators C_TK error
 954                 {yyerror ("Missing term"); RECOVER;}
 955 ;
 956
 957 variable_declarator:
 958         variable_declarator_id
 959                 { $$ = build_tree_list ($1, NULL_TREE); }
 960 |       variable_declarator_id ASSIGN_TK variable_initializer
 961                 {
 962                   if (java_error_count)
 963                     $3 = NULL_TREE;
 964                   $$ = build_tree_list
 965                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 966                 }
 967 |       variable_declarator_id ASSIGN_TK error
 968                 {
 969                   yyerror ("Missing variable initializer");
 970                   $$ = build_tree_list ($1, NULL_TREE);
 971                   RECOVER;
 972                 }
 973 |       variable_declarator_id ASSIGN_TK variable_initializer error
 974                 {
 975                   yyerror ("';' expected");
 976                   $$ = build_tree_list ($1, NULL_TREE);
 977                   RECOVER;
 978                 }
 979 ;
 980
 981 variable_declarator_id:
 982         identifier
 983 |       variable_declarator_id OSB_TK CSB_TK
 984                 { $$ = build_unresolved_array_type ($1); }
 985 |       identifier error
 986                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 987 |       variable_declarator_id OSB_TK error
 988                 {
 989                   yyerror ("']' expected");
 990                   DRECOVER(vdi);
 991                 }
 992 |       variable_declarator_id CSB_TK error
 993                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 994 ;
 995
 996 variable_initializer:
 997         expression
 998 |       array_initializer
 999 ;
1000
1001 /* 19.8.3 Productions from 8.4: Method Declarations  */
1002 method_declaration:
1003         method_header
1004                 {
1005                   current_function_decl = $1;
1006                   if (current_function_decl
1007                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1008                     source_start_java_method (current_function_decl);
1009                   else
1010                     current_function_decl = NULL_TREE;
1011                 }
1012         method_body
1013                 { finish_method_declaration ($3); }
1014 |       method_header error
1015                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1016 ;
1017
1018 method_header:
1019         type method_declarator throws
1020                 { $$ = method_header (0, $1, $2, $3); }
1021 |       VOID_TK method_declarator throws
1022                 { $$ = method_header (0, void_type_node, $2, $3); }
1023 |       modifiers type method_declarator throws
1024                 { $$ = method_header ($1, $2, $3, $4); }
1025 |       modifiers VOID_TK method_declarator throws
1026                 { $$ = method_header ($1, void_type_node, $3, $4); }
1027 |       type error
1028                 {
1029                   yyerror ("Invalid method declaration, method name required");
1030                   RECOVER;
1031                 }
1032 |       modifiers type error
1033                 {
1034                   yyerror ("Identifier expected");
1035                   RECOVER;
1036                 }
1037 |       VOID_TK error
1038                 {
1039                   yyerror ("Identifier expected");
1040                   RECOVER;
1041                 }
1042 |       modifiers VOID_TK error
1043                 {
1044                   yyerror ("Identifier expected");
1045                   RECOVER;
1046                 }
1047 |       modifiers error
1048                 {
1049                   yyerror ("Invalid method declaration, return type required");
1050                   RECOVER;
1051                 }
1052 ;
1053
1054 method_declarator:
1055         identifier OP_TK CP_TK
1056                 {
1057                   ctxp->formal_parameter_number = 0;
1058                   $$ = method_declarator ($1, NULL_TREE);
1059                 }
1060 |       identifier OP_TK formal_parameter_list CP_TK
1061                 { $$ = method_declarator ($1, $3); }
1062 |       method_declarator OSB_TK CSB_TK
1063                 {
1064                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1065                   TREE_PURPOSE ($1) =
1066                     build_unresolved_array_type (TREE_PURPOSE ($1));
1067                   parse_warning_context
1068                     (wfl_operator,
1069                      "Discouraged form of returned type specification");
1070                 }
1071 |       identifier OP_TK error
1072                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1073 |       method_declarator OSB_TK error
1074                 {yyerror ("']' expected"); RECOVER;}
1075 ;
1076
1077 formal_parameter_list:
1078         formal_parameter
1079                 {
1080                   ctxp->formal_parameter_number = 1;
1081                 }
1082 |       formal_parameter_list C_TK formal_parameter
1083                 {
1084                   ctxp->formal_parameter_number += 1;
1085                   $$ = chainon ($1, $3);
1086                 }
1087 |       formal_parameter_list C_TK error
1088                 { yyerror ("Missing formal parameter term"); RECOVER; }
1089 ;
1090
1091 formal_parameter:
1092         type variable_declarator_id
1093                 {
1094                   $$ = build_tree_list ($2, $1);
1095                 }
1096 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1097                 {
1098                   $$ = build_tree_list ($3, $2);
1099                   ARG_FINAL_P ($$) = 1;
1100                 }
1101 |       type error
1102                 {
1103                   yyerror ("Missing identifier"); RECOVER;
1104                   $$ = NULL_TREE;
1105                 }
1106 |       final type error
1107                 {
1108                   yyerror ("Missing identifier"); RECOVER;
1109                   $$ = NULL_TREE;
1110                 }
1111 ;
1112
1113 final:
1114         modifiers
1115                 {
1116                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1117                                    $1, ACC_FINAL);
1118                   if ($1 != ACC_FINAL)
1119                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1120                 }
1121 ;
1122
1123 throws:
1124                 { $$ = NULL_TREE; }
1125 |       THROWS_TK class_type_list
1126                 { $$ = $2; }
1127 |       THROWS_TK error
1128                 {yyerror ("Missing class type term"); RECOVER;}
1129 ;
1130
1131 class_type_list:
1132         class_type
1133                 { $$ = build_tree_list ($1, $1); }
1134 |       class_type_list C_TK class_type
1135                 { $$ = tree_cons ($3, $3, $1); }
1136 |       class_type_list C_TK error
1137                 {yyerror ("Missing class type term"); RECOVER;}
1138 ;
1139
1140 method_body:
1141         block
1142 |       SC_TK { $$ = NULL_TREE; }
1143 ;
1144
1145 /* 19.8.4 Productions from 8.5: Static Initializers  */
1146 static_initializer:
1147         static block
1148                 {
1149                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1150                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1151                   current_static_block = NULL_TREE;
1152                 }
1153 ;
1154
1155 static:                         /* Test lval.sub_token here */
1156         modifiers
1157                 {
1158                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1159                   /* Can't have a static initializer in an innerclass */
1160                   if ($1 | ACC_STATIC &&
1161                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1162                     parse_error_context
1163                       (MODIFIER_WFL (STATIC_TK),
1164                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1165                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1166                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1167                 }
1168 ;
1169
1170 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1171 constructor_declaration:
1172         constructor_header
1173                 {
1174                   current_function_decl = $1;
1175                   source_start_java_method (current_function_decl);
1176                 }
1177         constructor_body
1178                 { finish_method_declaration ($3); }
1179 ;
1180
1181 constructor_header:
1182         constructor_declarator throws
1183                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1184 |       modifiers constructor_declarator throws
1185                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1186 ;
1187
1188 constructor_declarator:
1189         simple_name OP_TK CP_TK
1190                 {
1191                   ctxp->formal_parameter_number = 0;
1192                   $$ = method_declarator ($1, NULL_TREE);
1193                 }
1194 |       simple_name OP_TK formal_parameter_list CP_TK
1195                 { $$ = method_declarator ($1, $3); }
1196 ;
1197
1198 constructor_body:
1199         /* Unlike regular method, we always need a complete (empty)
1200            body so we can safely perform all the required code
1201            addition (super invocation and field initialization) */
1202         block_begin constructor_block_end
1203                 {
1204                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1205                   $$ = $2;
1206                 }
1207 |       block_begin explicit_constructor_invocation constructor_block_end
1208                 { $$ = $3; }
1209 |       block_begin block_statements constructor_block_end
1210                 { $$ = $3; }
1211 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1212                 { $$ = $4; }
1213 ;
1214
1215 constructor_block_end:
1216         block_end
1217 ;
1218
1219 /* Error recovery for that rule moved down expression_statement: rule.  */
1220 explicit_constructor_invocation:
1221         this_or_super OP_TK CP_TK SC_TK
1222                 {
1223                   $$ = build_method_invocation ($1, NULL_TREE);
1224                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1225                   $$ = java_method_add_stmt (current_function_decl, $$);
1226                 }
1227 |       this_or_super OP_TK argument_list CP_TK SC_TK
1228                 {
1229                   $$ = build_method_invocation ($1, $3);
1230                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1231                   $$ = java_method_add_stmt (current_function_decl, $$);
1232                 }
1233         /* Added, JDK1.1 inner classes. Modified because the rule
1234            'primary' couldn't work.  */
1235 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1236                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1237 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1238                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1239 ;
1240
1241 this_or_super:                  /* Added, simplifies error diagnostics */
1242         THIS_TK
1243                 {
1244                   tree wfl = build_wfl_node (this_identifier_node);
1245                   EXPR_WFL_LINECOL (wfl) = $1.location;
1246                   $$ = wfl;
1247                 }
1248 |       SUPER_TK
1249                 {
1250                   tree wfl = build_wfl_node (super_identifier_node);
1251                   EXPR_WFL_LINECOL (wfl) = $1.location;
1252                   $$ = wfl;
1253                 }
1254 ;
1255
1256 /* 19.9 Productions from 9: Interfaces  */
1257 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1258 interface_declaration:
1259         INTERFACE_TK identifier
1260                 { create_interface (0, $2, NULL_TREE); }
1261         interface_body
1262                 { ; }
1263 |       modifiers INTERFACE_TK identifier
1264                 { create_interface ($1, $3, NULL_TREE); }
1265         interface_body
1266                 { ; }
1267 |       INTERFACE_TK identifier extends_interfaces
1268                 { create_interface (0, $2, $3); }
1269         interface_body
1270                 { ; }
1271 |       modifiers INTERFACE_TK identifier extends_interfaces
1272                 { create_interface ($1, $3, $4); }
1273         interface_body
1274                 { ; }
1275 |       INTERFACE_TK identifier error
1276                 { yyerror ("'{' expected"); RECOVER; }
1277 |       modifiers INTERFACE_TK identifier error
1278                 { yyerror ("'{' expected"); RECOVER; }
1279 ;
1280
1281 extends_interfaces:
1282         EXTENDS_TK interface_type
1283                 {
1284                   ctxp->interface_number = 1;
1285                   $$ = build_tree_list ($2, NULL_TREE);
1286                 }
1287 |       extends_interfaces C_TK interface_type
1288                 {
1289                   ctxp->interface_number++;
1290                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1291                 }
1292 |       EXTENDS_TK error
1293                 {yyerror ("Invalid interface type"); RECOVER;}
1294 |       extends_interfaces C_TK error
1295                 {yyerror ("Missing term"); RECOVER;}
1296 ;
1297
1298 interface_body:
1299         OCB_TK CCB_TK
1300                 { $$ = NULL_TREE; }
1301 |       OCB_TK interface_member_declarations CCB_TK
1302                 { $$ = NULL_TREE; }
1303 ;
1304
1305 interface_member_declarations:
1306         interface_member_declaration
1307 |       interface_member_declarations interface_member_declaration
1308 ;
1309
1310 interface_member_declaration:
1311         constant_declaration
1312 |       abstract_method_declaration
1313 |       class_declaration       /* Added, JDK1.1 inner classes */
1314                 { end_class_declaration (1); }
1315 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1316                 { end_class_declaration (1); }
1317 ;
1318
1319 constant_declaration:
1320         field_declaration
1321 ;
1322
1323 abstract_method_declaration:
1324         method_header SC_TK
1325                 {
1326                   check_abstract_method_header ($1);
1327                   current_function_decl = NULL_TREE; /* FIXME ? */
1328                 }
1329 |       method_header error
1330                 {yyerror ("';' expected"); RECOVER;}
1331 ;
1332
1333 /* 19.10 Productions from 10: Arrays  */
1334 array_initializer:
1335         OCB_TK CCB_TK
1336                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1337 |       OCB_TK C_TK CCB_TK
1338                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1339 |       OCB_TK variable_initializers CCB_TK
1340                 { $$ = build_new_array_init ($1.location, $2); }
1341 |       OCB_TK variable_initializers C_TK CCB_TK
1342                 { $$ = build_new_array_init ($1.location, $2); }
1343 ;
1344
1345 variable_initializers:
1346         variable_initializer
1347                 {
1348                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1349                                   $1, NULL_TREE);
1350                 }
1351 |       variable_initializers C_TK variable_initializer
1352                 {
1353                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1354                 }
1355 |       variable_initializers C_TK error
1356                 {yyerror ("Missing term"); RECOVER;}
1357 ;
1358
1359 /* 19.11 Production from 14: Blocks and Statements  */
1360 block:
1361         OCB_TK CCB_TK
1362                 {
1363                   /* Store the location of the `}' when doing xrefs */
1364                   if (current_function_decl && flag_emit_xref)
1365                     DECL_END_SOURCE_LINE (current_function_decl) =
1366                       EXPR_WFL_ADD_COL ($2.location, 1);
1367                   $$ = empty_stmt_node;
1368                 }
1369 |       block_begin block_statements block_end
1370                 { $$ = $3; }
1371 ;
1372
1373 block_begin:
1374         OCB_TK
1375                 { enter_block (); }
1376 ;
1377
1378 block_end:
1379         CCB_TK
1380                 {
1381                   maybe_absorb_scoping_blocks ();
1382                   /* Store the location of the `}' when doing xrefs */
1383                   if (current_function_decl && flag_emit_xref)
1384                     DECL_END_SOURCE_LINE (current_function_decl) =
1385                       EXPR_WFL_ADD_COL ($1.location, 1);
1386                   $$ = exit_block ();
1387                   if (!BLOCK_SUBBLOCKS ($$))
1388                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1389                 }
1390 ;
1391
1392 block_statements:
1393         block_statement
1394 |       block_statements block_statement
1395 ;
1396
1397 block_statement:
1398         local_variable_declaration_statement
1399 |       statement
1400                 { java_method_add_stmt (current_function_decl, $1); }
1401 |       class_declaration       /* Added, JDK1.1 local classes */
1402                 {
1403                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1404                   end_class_declaration (1);
1405                 }
1406 ;
1407
1408 local_variable_declaration_statement:
1409         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1410 ;
1411
1412 local_variable_declaration:
1413         type variable_declarators
1414                 { declare_local_variables (0, $1, $2); }
1415 |       final type variable_declarators /* Added, JDK1.1 final locals */
1416                 { declare_local_variables ($1, $2, $3); }
1417 ;
1418
1419 statement:
1420         statement_without_trailing_substatement
1421 |       labeled_statement
1422 |       if_then_statement
1423 |       if_then_else_statement
1424 |       while_statement
1425 |       for_statement
1426                 { $$ = exit_block (); }
1427 ;
1428
1429 statement_nsi:
1430         statement_without_trailing_substatement
1431 |       labeled_statement_nsi
1432 |       if_then_else_statement_nsi
1433 |       while_statement_nsi
1434 |       for_statement_nsi
1435                 { $$ = exit_block (); }
1436 ;
1437
1438 statement_without_trailing_substatement:
1439         block
1440 |       empty_statement
1441 |       expression_statement
1442 |       switch_statement
1443 |       do_statement
1444 |       break_statement
1445 |       continue_statement
1446 |       return_statement
1447 |       synchronized_statement
1448 |       throw_statement
1449 |       try_statement
1450 |       assert_statement
1451 ;
1452
1453 empty_statement:
1454         SC_TK
1455                 {
1456                   if (flag_extraneous_semicolon
1457                       && ! current_static_block
1458                       && (! current_function_decl ||
1459                           /* Verify we're not in a inner class declaration */
1460                           (GET_CPC () != TYPE_NAME
1461                            (DECL_CONTEXT (current_function_decl)))))
1462
1463                     {
1464                       EXPR_WFL_SET_LINECOL (wfl_operator, lineno, -1);
1465                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1466                     }
1467                   $$ = empty_stmt_node;
1468                 }
1469 ;
1470
1471 label_decl:
1472         identifier REL_CL_TK
1473                 {
1474                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1475                                             EXPR_WFL_NODE ($1));
1476                   pushlevel (2);
1477                   push_labeled_block ($$);
1478                   PUSH_LABELED_BLOCK ($$);
1479                 }
1480 ;
1481
1482 labeled_statement:
1483         label_decl statement
1484                 { $$ = finish_labeled_statement ($1, $2); }
1485 |       identifier error
1486                 {yyerror ("':' expected"); RECOVER;}
1487 ;
1488
1489 labeled_statement_nsi:
1490         label_decl statement_nsi
1491                 { $$ = finish_labeled_statement ($1, $2); }
1492 ;
1493
1494 /* We concentrate here a bunch of error handling rules that we couldn't write
1495    earlier, because expression_statement catches a missing ';'.  */
1496 expression_statement:
1497         statement_expression SC_TK
1498                 {
1499                   /* We have a statement. Generate a WFL around it so
1500                      we can debug it */
1501                   $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1502                   /* We know we have a statement, so set the debug
1503                      info to be eventually generate here. */
1504                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1505                 }
1506 |       error SC_TK
1507                 {
1508                   YYNOT_TWICE yyerror ("Invalid expression statement");
1509                   DRECOVER (expr_stmt);
1510                 }
1511 |       error OCB_TK
1512                 {
1513                   YYNOT_TWICE yyerror ("Invalid expression statement");
1514                   DRECOVER (expr_stmt);
1515                 }
1516 |       error CCB_TK
1517                 {
1518                   YYNOT_TWICE yyerror ("Invalid expression statement");
1519                   DRECOVER (expr_stmt);
1520                 }
1521 |       this_or_super OP_TK error
1522                 {yyerror ("')' expected"); RECOVER;}
1523 |       this_or_super OP_TK CP_TK error
1524                 {
1525                   parse_ctor_invocation_error ();
1526                   RECOVER;
1527                 }
1528 |       this_or_super OP_TK argument_list error
1529                 {yyerror ("')' expected"); RECOVER;}
1530 |       this_or_super OP_TK argument_list CP_TK error
1531                 {
1532                   parse_ctor_invocation_error ();
1533                   RECOVER;
1534                 }
1535 |       name DOT_TK SUPER_TK error
1536                 {yyerror ("'(' expected"); RECOVER;}
1537 |       name DOT_TK SUPER_TK OP_TK error
1538                 {yyerror ("')' expected"); RECOVER;}
1539 |       name DOT_TK SUPER_TK OP_TK argument_list error
1540                 {yyerror ("')' expected"); RECOVER;}
1541 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1542                 {yyerror ("';' expected"); RECOVER;}
1543 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1544                 {yyerror ("';' expected"); RECOVER;}
1545 ;
1546
1547 statement_expression:
1548         assignment
1549 |       pre_increment_expression
1550 |       pre_decrement_expression
1551 |       post_increment_expression
1552 |       post_decrement_expression
1553 |       method_invocation
1554 |       class_instance_creation_expression
1555 ;
1556
1557 if_then_statement:
1558         IF_TK OP_TK expression CP_TK statement
1559                 {
1560                   $$ = build_if_else_statement ($2.location, $3,
1561                                                 $5, NULL_TREE);
1562                 }
1563 |       IF_TK error
1564                 {yyerror ("'(' expected"); RECOVER;}
1565 |       IF_TK OP_TK error
1566                 {yyerror ("Missing term"); RECOVER;}
1567 |       IF_TK OP_TK expression error
1568                 {yyerror ("')' expected"); RECOVER;}
1569 ;
1570
1571 if_then_else_statement:
1572         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1573                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1574 ;
1575
1576 if_then_else_statement_nsi:
1577         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1578                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1579 ;
1580
1581 switch_statement:
1582         switch_expression
1583                 {
1584                   enter_block ();
1585                 }
1586         switch_block
1587                 {
1588                   /* Make into "proper list" of COMPOUND_EXPRs.
1589                      I.e. make the last statement also have its own
1590                      COMPOUND_EXPR. */
1591                   maybe_absorb_scoping_blocks ();
1592                   TREE_OPERAND ($1, 1) = exit_block ();
1593                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1594                 }
1595 ;
1596
1597 switch_expression:
1598         SWITCH_TK OP_TK expression CP_TK
1599                 {
1600                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1601                   EXPR_WFL_LINECOL ($$) = $2.location;
1602                 }
1603 |       SWITCH_TK error
1604                 {yyerror ("'(' expected"); RECOVER;}
1605 |       SWITCH_TK OP_TK error
1606                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1607 |       SWITCH_TK OP_TK expression CP_TK error
1608                 {yyerror ("'{' expected"); RECOVER;}
1609 ;
1610
1611 /* Default assignment is there to avoid type node on switch_block
1612    node. */
1613
1614 switch_block:
1615         OCB_TK CCB_TK
1616                 { $$ = NULL_TREE; }
1617 |       OCB_TK switch_labels CCB_TK
1618                 { $$ = NULL_TREE; }
1619 |       OCB_TK switch_block_statement_groups CCB_TK
1620                 { $$ = NULL_TREE; }
1621 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1622                 { $$ = NULL_TREE; }
1623 ;
1624
1625 switch_block_statement_groups:
1626         switch_block_statement_group
1627 |       switch_block_statement_groups switch_block_statement_group
1628 ;
1629
1630 switch_block_statement_group:
1631         switch_labels block_statements
1632 ;
1633
1634 switch_labels:
1635         switch_label
1636 |       switch_labels switch_label
1637 ;
1638
1639 switch_label:
1640         CASE_TK constant_expression REL_CL_TK
1641                 {
1642                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1643                   EXPR_WFL_LINECOL (lab) = $1.location;
1644                   java_method_add_stmt (current_function_decl, lab);
1645                 }
1646 |       DEFAULT_TK REL_CL_TK
1647                 {
1648                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1649                   EXPR_WFL_LINECOL (lab) = $1.location;
1650                   java_method_add_stmt (current_function_decl, lab);
1651                 }
1652 |       CASE_TK error
1653                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1654 |       CASE_TK constant_expression error
1655                 {yyerror ("':' expected"); RECOVER;}
1656 |       DEFAULT_TK error
1657                 {yyerror ("':' expected"); RECOVER;}
1658 ;
1659
1660 while_expression:
1661         WHILE_TK OP_TK expression CP_TK
1662                 {
1663                   tree body = build_loop_body ($2.location, $3, 0);
1664                   $$ = build_new_loop (body);
1665                 }
1666 ;
1667
1668 while_statement:
1669         while_expression statement
1670                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1671 |       WHILE_TK error
1672                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1673 |       WHILE_TK OP_TK error
1674                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1675 |       WHILE_TK OP_TK expression error
1676                 {yyerror ("')' expected"); RECOVER;}
1677 ;
1678
1679 while_statement_nsi:
1680         while_expression statement_nsi
1681                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1682 ;
1683
1684 do_statement_begin:
1685         DO_TK
1686                 {
1687                   tree body = build_loop_body (0, NULL_TREE, 1);
1688                   $$ = build_new_loop (body);
1689                 }
1690         /* Need error handing here. FIXME */
1691 ;
1692
1693 do_statement:
1694         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1695                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1696 ;
1697
1698 for_statement:
1699         for_begin SC_TK expression SC_TK for_update CP_TK statement
1700                 {
1701                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1702                     $3 = build_wfl_node ($3);
1703                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1704                 }
1705 |       for_begin SC_TK SC_TK for_update CP_TK statement
1706                 {
1707                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1708                   /* We have not condition, so we get rid of the EXIT_EXPR */
1709                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1710                     empty_stmt_node;
1711                 }
1712 |       for_begin SC_TK error
1713                 {yyerror ("Invalid control expression"); RECOVER;}
1714 |       for_begin SC_TK expression SC_TK error
1715                 {yyerror ("Invalid update expression"); RECOVER;}
1716 |       for_begin SC_TK SC_TK error
1717                 {yyerror ("Invalid update expression"); RECOVER;}
1718 ;
1719
1720 for_statement_nsi:
1721         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1722                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1723 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1724                 {
1725                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1726                   /* We have not condition, so we get rid of the EXIT_EXPR */
1727                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1728                     empty_stmt_node;
1729                 }
1730 ;
1731
1732 for_header:
1733         FOR_TK OP_TK
1734                 {
1735                   /* This scope defined for local variable that may be
1736                      defined within the scope of the for loop */
1737                   enter_block ();
1738                 }
1739 |       FOR_TK error
1740                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1741 |       FOR_TK OP_TK error
1742                 {yyerror ("Invalid init statement"); RECOVER;}
1743 ;
1744
1745 for_begin:
1746         for_header for_init
1747                 {
1748                   /* We now declare the loop body. The loop is
1749                      declared as a for loop. */
1750                   tree body = build_loop_body (0, NULL_TREE, 0);
1751                   $$ =  build_new_loop (body);
1752                   FOR_LOOP_P ($$) = 1;
1753                   /* The loop is added to the current block the for
1754                      statement is defined within */
1755                   java_method_add_stmt (current_function_decl, $$);
1756                 }
1757 ;
1758 for_init:                       /* Can be empty */
1759                 { $$ = empty_stmt_node; }
1760 |       statement_expression_list
1761                 {
1762                   /* Init statement recorded within the previously
1763                      defined block scope */
1764                   $$ = java_method_add_stmt (current_function_decl, $1);
1765                 }
1766 |       local_variable_declaration
1767                 {
1768                   /* Local variable are recorded within the previously
1769                      defined block scope */
1770                   $$ = NULL_TREE;
1771                 }
1772 |       statement_expression_list error
1773                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1774 ;
1775
1776 for_update:                     /* Can be empty */
1777                 {$$ = empty_stmt_node;}
1778 |       statement_expression_list
1779                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1780 ;
1781
1782 statement_expression_list:
1783         statement_expression
1784                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1785 |       statement_expression_list C_TK statement_expression
1786                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1787 |       statement_expression_list C_TK error
1788                 {yyerror ("Missing term"); RECOVER;}
1789 ;
1790
1791 break_statement:
1792         BREAK_TK SC_TK
1793                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1794 |       BREAK_TK identifier SC_TK
1795                 { $$ = build_bc_statement ($1.location, 1, $2); }
1796 |       BREAK_TK error
1797                 {yyerror ("Missing term"); RECOVER;}
1798 |       BREAK_TK identifier error
1799                 {yyerror ("';' expected"); RECOVER;}
1800 ;
1801
1802 continue_statement:
1803         CONTINUE_TK SC_TK
1804                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1805 |       CONTINUE_TK identifier SC_TK
1806                 { $$ = build_bc_statement ($1.location, 0, $2); }
1807 |       CONTINUE_TK error
1808                 {yyerror ("Missing term"); RECOVER;}
1809 |       CONTINUE_TK identifier error
1810                 {yyerror ("';' expected"); RECOVER;}
1811 ;
1812
1813 return_statement:
1814         RETURN_TK SC_TK
1815                 { $$ = build_return ($1.location, NULL_TREE); }
1816 |       RETURN_TK expression SC_TK
1817                 { $$ = build_return ($1.location, $2); }
1818 |       RETURN_TK error
1819                 {yyerror ("Missing term"); RECOVER;}
1820 |       RETURN_TK expression error
1821                 {yyerror ("';' expected"); RECOVER;}
1822 ;
1823
1824 throw_statement:
1825         THROW_TK expression SC_TK
1826                 {
1827                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1828                   EXPR_WFL_LINECOL ($$) = $1.location;
1829                 }
1830 |       THROW_TK error
1831                 {yyerror ("Missing term"); RECOVER;}
1832 |       THROW_TK expression error
1833                 {yyerror ("';' expected"); RECOVER;}
1834 ;
1835
1836 assert_statement:
1837         ASSERT_TK expression REL_CL_TK expression SC_TK
1838                 {
1839                   $$ = build_assertion ($1.location, $2, $4);
1840                 }
1841 |       ASSERT_TK expression SC_TK
1842                 {
1843                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1844                 }
1845 |       ASSERT_TK error
1846                 {yyerror ("Missing term"); RECOVER;}
1847 |       ASSERT_TK expression error
1848                 {yyerror ("';' expected"); RECOVER;}
1849 ;
1850
1851 synchronized_statement:
1852         synchronized OP_TK expression CP_TK block
1853                 {
1854                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1855                   EXPR_WFL_LINECOL ($$) =
1856                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1857                 }
1858 |       synchronized OP_TK expression CP_TK error
1859                 {yyerror ("'{' expected"); RECOVER;}
1860 |       synchronized error
1861                 {yyerror ("'(' expected"); RECOVER;}
1862 |       synchronized OP_TK error CP_TK
1863                 {yyerror ("Missing term"); RECOVER;}
1864 |       synchronized OP_TK error
1865                 {yyerror ("Missing term"); RECOVER;}
1866 ;
1867
1868 synchronized:
1869         modifiers
1870                 {
1871                   check_modifiers (
1872              "Illegal modifier `%s'. Only `synchronized' was expected here",
1873                                    $1, ACC_SYNCHRONIZED);
1874                   if ($1 != ACC_SYNCHRONIZED)
1875                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1876                       build_wfl_node (NULL_TREE);
1877                 }
1878 ;
1879
1880 try_statement:
1881         TRY_TK block catches
1882                 { $$ = build_try_statement ($1.location, $2, $3); }
1883 |       TRY_TK block finally
1884                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1885 |       TRY_TK block catches finally
1886                 { $$ = build_try_finally_statement
1887                     ($1.location, build_try_statement ($1.location,
1888                                                        $2, $3), $4);
1889                 }
1890 |       TRY_TK error
1891                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1892 ;
1893
1894 catches:
1895         catch_clause
1896 |       catches catch_clause
1897                 {
1898                   TREE_CHAIN ($2) = $1;
1899                   $$ = $2;
1900                 }
1901 ;
1902
1903 catch_clause:
1904         catch_clause_parameter block
1905                 {
1906                   java_method_add_stmt (current_function_decl, $2);
1907                   exit_block ();
1908                   $$ = $1;
1909                 }
1910 ;
1911
1912 catch_clause_parameter:
1913         CATCH_TK OP_TK formal_parameter CP_TK
1914                 {
1915                   /* We add a block to define a scope for
1916                      formal_parameter (CCBP). The formal parameter is
1917                      declared initialized by the appropriate function
1918                      call */
1919                   tree ccpb = enter_block ();
1920                   tree init = build_assignment
1921                     (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1922                      build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1923                   declare_local_variables (0, TREE_VALUE ($3),
1924                                            build_tree_list (TREE_PURPOSE ($3),
1925                                                             init));
1926                   $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1927                   EXPR_WFL_LINECOL ($$) = $1.location;
1928                 }
1929 |       CATCH_TK error
1930                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1931 |       CATCH_TK OP_TK error
1932                 {
1933                   yyerror ("Missing term or ')' expected");
1934                   RECOVER; $$ = NULL_TREE;
1935                 }
1936 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1937                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1938 ;
1939
1940 finally:
1941         FINALLY_TK block
1942                 { $$ = $2; }
1943 |       FINALLY_TK error
1944                 {yyerror ("'{' expected"); RECOVER; }
1945 ;
1946
1947 /* 19.12 Production from 15: Expressions  */
1948 primary:
1949         primary_no_new_array
1950 |       array_creation_expression
1951 ;
1952
1953 primary_no_new_array:
1954         literal
1955 |       THIS_TK
1956                 { $$ = build_this ($1.location); }
1957 |       OP_TK expression CP_TK
1958                 {$$ = $2;}
1959 |       class_instance_creation_expression
1960 |       field_access
1961 |       method_invocation
1962 |       array_access
1963 |       type_literals
1964         /* Added, JDK1.1 inner classes. Documentation is wrong
1965            refering to a 'ClassName' (class_name) rule that doesn't
1966            exist. Used name: instead.  */
1967 |       name DOT_TK THIS_TK
1968                 {
1969                   tree wfl = build_wfl_node (this_identifier_node);
1970                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1971                 }
1972 |       OP_TK expression error
1973                 {yyerror ("')' expected"); RECOVER;}
1974 |       name DOT_TK error
1975                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1976 |       primitive_type DOT_TK error
1977                 {yyerror ("'class' expected" ); RECOVER;}
1978 |       VOID_TK DOT_TK error
1979                 {yyerror ("'class' expected" ); RECOVER;}
1980 ;
1981
1982 type_literals:
1983         name DOT_TK CLASS_TK
1984                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1985 |       array_type DOT_TK CLASS_TK
1986                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1987 |       primitive_type DOT_TK CLASS_TK
1988                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1989 |       VOID_TK DOT_TK CLASS_TK
1990                 {
1991                    $$ = build_incomplete_class_ref ($2.location,
1992                                                    void_type_node);
1993                 }
1994 ;
1995
1996 class_instance_creation_expression:
1997         NEW_TK class_type OP_TK argument_list CP_TK
1998                 { $$ = build_new_invocation ($2, $4); }
1999 |       NEW_TK class_type OP_TK CP_TK
2000                 { $$ = build_new_invocation ($2, NULL_TREE); }
2001 |       anonymous_class_creation
2002         /* Added, JDK1.1 inner classes, modified to use name or
2003            primary instead of primary solely which couldn't work in
2004            all situations.  */
2005 |       something_dot_new identifier OP_TK CP_TK
2006                 {
2007                   tree ctor = build_new_invocation ($2, NULL_TREE);
2008                   $$ = make_qualified_primary ($1, ctor,
2009                                                EXPR_WFL_LINECOL ($1));
2010                 }
2011 |       something_dot_new identifier OP_TK CP_TK class_body
2012 |       something_dot_new identifier OP_TK argument_list CP_TK
2013                 {
2014                   tree ctor = build_new_invocation ($2, $4);
2015                   $$ = make_qualified_primary ($1, ctor,
2016                                                EXPR_WFL_LINECOL ($1));
2017                 }
2018 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2019 |       NEW_TK error SC_TK
2020                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2021 |       NEW_TK class_type error
2022                 {yyerror ("'(' expected"); RECOVER;}
2023 |       NEW_TK class_type OP_TK error
2024                 {yyerror ("')' or term expected"); RECOVER;}
2025 |       NEW_TK class_type OP_TK argument_list error
2026                 {yyerror ("')' expected"); RECOVER;}
2027 |       something_dot_new error
2028                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2029 |       something_dot_new identifier error
2030                 {yyerror ("'(' expected"); RECOVER;}
2031 ;
2032
2033 /* Created after JDK1.1 rules originally added to
2034    class_instance_creation_expression, but modified to use
2035    'class_type' instead of 'TypeName' (type_name) which is mentionned
2036    in the documentation but doesn't exist. */
2037
2038 anonymous_class_creation:
2039         NEW_TK class_type OP_TK argument_list CP_TK
2040                 { create_anonymous_class ($1.location, $2); }
2041         class_body
2042                 {
2043                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2044                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2045
2046                   end_class_declaration (1);
2047
2048                   /* Now we can craft the new expression */
2049                   $$ = build_new_invocation (id, $4);
2050
2051                   /* Note that we can't possibly be here if
2052                      `class_type' is an interface (in which case the
2053                      anonymous class extends Object and implements
2054                      `class_type', hence its constructor can't have
2055                      arguments.) */
2056
2057                   /* Otherwise, the innerclass must feature a
2058                      constructor matching `argument_list'. Anonymous
2059                      classes are a bit special: it's impossible to
2060                      define constructor for them, hence constructors
2061                      must be generated following the hints provided by
2062                      the `new' expression. Whether a super constructor
2063                      of that nature exists or not is to be verified
2064                      later on in verify_constructor_super.
2065
2066                      It's during the expansion of a `new' statement
2067                      refering to an anonymous class that a ctor will
2068                      be generated for the anonymous class, with the
2069                      right arguments. */
2070
2071                 }
2072 |       NEW_TK class_type OP_TK CP_TK
2073                 { create_anonymous_class ($1.location, $2); }
2074         class_body
2075                 {
2076                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2077                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2078
2079                   end_class_declaration (1);
2080
2081                   /* Now we can craft the new expression. The
2082                      statement doesn't need to be remember so that a
2083                      constructor can be generated, since its signature
2084                      is already known. */
2085                   $$ = build_new_invocation (id, NULL_TREE);
2086                 }
2087 ;
2088
2089 something_dot_new:              /* Added, not part of the specs. */
2090         name DOT_TK NEW_TK
2091                 { $$ = $1; }
2092 |       primary DOT_TK NEW_TK
2093                 { $$ = $1; }
2094 ;
2095
2096 argument_list:
2097         expression
2098                 {
2099                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2100                   ctxp->formal_parameter_number = 1;
2101                 }
2102 |       argument_list C_TK expression
2103                 {
2104                   ctxp->formal_parameter_number += 1;
2105                   $$ = tree_cons (NULL_TREE, $3, $1);
2106                 }
2107 |       argument_list C_TK error
2108                 {yyerror ("Missing term"); RECOVER;}
2109 ;
2110
2111 array_creation_expression:
2112         NEW_TK primitive_type dim_exprs
2113                 { $$ = build_newarray_node ($2, $3, 0); }
2114 |       NEW_TK class_or_interface_type dim_exprs
2115                 { $$ = build_newarray_node ($2, $3, 0); }
2116 |       NEW_TK primitive_type dim_exprs dims
2117                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2118 |       NEW_TK class_or_interface_type dim_exprs dims
2119                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2120         /* Added, JDK1.1 anonymous array. Initial documentation rule
2121            modified */
2122 |       NEW_TK class_or_interface_type dims array_initializer
2123                 {
2124                   char *sig;
2125                   int osb = pop_current_osb (ctxp);
2126                   while (osb--)
2127                     obstack_grow (&temporary_obstack, "[]", 2);
2128                   obstack_1grow (&temporary_obstack, '\0');
2129                   sig = obstack_finish (&temporary_obstack);
2130                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2131                               $2, get_identifier (sig), $4);
2132                 }
2133 |       NEW_TK primitive_type dims array_initializer
2134                 {
2135                   int osb = pop_current_osb (ctxp);
2136                   tree type = $2;
2137                   while (osb--)
2138                     type = build_java_array_type (type, -1);
2139                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2140                               build_pointer_type (type), NULL_TREE, $4);
2141                 }
2142 |       NEW_TK error CSB_TK
2143                 {yyerror ("'[' expected"); DRECOVER ("]");}
2144 |       NEW_TK error OSB_TK
2145                 {yyerror ("']' expected"); RECOVER;}
2146 ;
2147
2148 dim_exprs:
2149         dim_expr
2150                 { $$ = build_tree_list (NULL_TREE, $1); }
2151 |       dim_exprs dim_expr
2152                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2153 ;
2154
2155 dim_expr:
2156         OSB_TK expression CSB_TK
2157                 {
2158                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2159                     {
2160                       $2 = build_wfl_node ($2);
2161                       TREE_TYPE ($2) = NULL_TREE;
2162                     }
2163                   EXPR_WFL_LINECOL ($2) = $1.location;
2164                   $$ = $2;
2165                 }
2166 |       OSB_TK expression error
2167                 {yyerror ("']' expected"); RECOVER;}
2168 |       OSB_TK error
2169                 {
2170                   yyerror ("Missing term");
2171                   yyerror ("']' expected");
2172                   RECOVER;
2173                 }
2174 ;
2175
2176 dims:
2177         OSB_TK CSB_TK
2178                 {
2179                   int allocate = 0;
2180                   /* If not initialized, allocate memory for the osb
2181                      numbers stack */
2182                   if (!ctxp->osb_limit)
2183                     {
2184                       allocate = ctxp->osb_limit = 32;
2185                       ctxp->osb_depth = -1;
2186                     }
2187                   /* If capacity overflown, reallocate a bigger chunk */
2188                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2189                     allocate = ctxp->osb_limit << 1;
2190
2191                   if (allocate)
2192                     {
2193                       allocate *= sizeof (int);
2194                       if (ctxp->osb_number)
2195                         ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
2196                                                             allocate);
2197                       else
2198                         ctxp->osb_number = (int *)xmalloc (allocate);
2199                     }
2200                   ctxp->osb_depth++;
2201                   CURRENT_OSB (ctxp) = 1;
2202                 }
2203 |       dims OSB_TK CSB_TK
2204                 { CURRENT_OSB (ctxp)++; }
2205 |       dims OSB_TK error
2206                 { yyerror ("']' expected"); RECOVER;}
2207 ;
2208
2209 field_access:
2210         primary DOT_TK identifier
2211                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2212                 /*  FIXME - REWRITE TO:
2213                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2214 |       SUPER_TK DOT_TK identifier
2215                 {
2216                   tree super_wfl = build_wfl_node (super_identifier_node);
2217                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2218                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2219                 }
2220 |       SUPER_TK error
2221                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2222 ;
2223
2224 method_invocation:
2225         name OP_TK CP_TK
2226                 { $$ = build_method_invocation ($1, NULL_TREE); }
2227 |       name OP_TK argument_list CP_TK
2228                 { $$ = build_method_invocation ($1, $3); }
2229 |       primary DOT_TK identifier OP_TK CP_TK
2230                 {
2231                   if (TREE_CODE ($1) == THIS_EXPR)
2232                     $$ = build_this_super_qualified_invocation
2233                       (1, $3, NULL_TREE, 0, $2.location);
2234                   else
2235                     {
2236                       tree invok = build_method_invocation ($3, NULL_TREE);
2237                       $$ = make_qualified_primary ($1, invok, $2.location);
2238                     }
2239                 }
2240 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2241                 {
2242                   if (TREE_CODE ($1) == THIS_EXPR)
2243                     $$ = build_this_super_qualified_invocation
2244                       (1, $3, $5, 0, $2.location);
2245                   else
2246                     {
2247                       tree invok = build_method_invocation ($3, $5);
2248                       $$ = make_qualified_primary ($1, invok, $2.location);
2249                     }
2250                 }
2251 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2252                 {
2253                   $$ = build_this_super_qualified_invocation
2254                     (0, $3, NULL_TREE, $1.location, $2.location);
2255                 }
2256 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2257                 {
2258                   $$ = build_this_super_qualified_invocation
2259                     (0, $3, $5, $1.location, $2.location);
2260                 }
2261         /* Screws up thing. I let it here until I'm convinced it can
2262            be removed. FIXME
2263 |       primary DOT_TK error
2264                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2265 |       SUPER_TK DOT_TK error CP_TK
2266                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2267 |       SUPER_TK DOT_TK error DOT_TK
2268                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2269 ;
2270
2271 array_access:
2272         name OSB_TK expression CSB_TK
2273                 { $$ = build_array_ref ($2.location, $1, $3); }
2274 |       primary_no_new_array OSB_TK expression CSB_TK
2275                 { $$ = build_array_ref ($2.location, $1, $3); }
2276 |       name OSB_TK error
2277                 {
2278                   yyerror ("Missing term and ']' expected");
2279                   DRECOVER(array_access);
2280                 }
2281 |       name OSB_TK expression error
2282                 {
2283                   yyerror ("']' expected");
2284                   DRECOVER(array_access);
2285                 }
2286 |       primary_no_new_array OSB_TK error
2287                 {
2288                   yyerror ("Missing term and ']' expected");
2289                   DRECOVER(array_access);
2290                 }
2291 |       primary_no_new_array OSB_TK expression error
2292                 {
2293                   yyerror ("']' expected");
2294                   DRECOVER(array_access);
2295                 }
2296 ;
2297
2298 postfix_expression:
2299         primary
2300 |       name
2301 |       post_increment_expression
2302 |       post_decrement_expression
2303 ;
2304
2305 post_increment_expression:
2306         postfix_expression INCR_TK
2307                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2308 ;
2309
2310 post_decrement_expression:
2311         postfix_expression DECR_TK
2312                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2313 ;
2314
2315 trap_overflow_corner_case:
2316         pre_increment_expression
2317 |       pre_decrement_expression
2318 |       PLUS_TK unary_expression
2319                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2320 |       unary_expression_not_plus_minus
2321 |       PLUS_TK error
2322                 {yyerror ("Missing term"); RECOVER}
2323 ;
2324
2325 unary_expression:
2326         trap_overflow_corner_case
2327                 {
2328                   error_if_numeric_overflow ($1);
2329                   $$ = $1;
2330                 }
2331 |       MINUS_TK trap_overflow_corner_case
2332                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2333 |       MINUS_TK error
2334                 {yyerror ("Missing term"); RECOVER}
2335 ;
2336
2337 pre_increment_expression:
2338         INCR_TK unary_expression
2339                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2340 |       INCR_TK error
2341                 {yyerror ("Missing term"); RECOVER}
2342 ;
2343
2344 pre_decrement_expression:
2345         DECR_TK unary_expression
2346                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2347 |       DECR_TK error
2348                 {yyerror ("Missing term"); RECOVER}
2349 ;
2350
2351 unary_expression_not_plus_minus:
2352         postfix_expression
2353 |       NOT_TK unary_expression
2354                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2355 |       NEG_TK unary_expression
2356                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2357 |       cast_expression
2358 |       NOT_TK error
2359                 {yyerror ("Missing term"); RECOVER}
2360 |       NEG_TK error
2361                 {yyerror ("Missing term"); RECOVER}
2362 ;
2363
2364 cast_expression:                /* Error handling here is potentially weak */
2365         OP_TK primitive_type dims CP_TK unary_expression
2366                 {
2367                   tree type = $2;
2368                   int osb = pop_current_osb (ctxp);
2369                   while (osb--)
2370                     type = build_java_array_type (type, -1);
2371                   $$ = build_cast ($1.location, type, $5);
2372                 }
2373 |       OP_TK primitive_type CP_TK unary_expression
2374                 { $$ = build_cast ($1.location, $2, $4); }
2375 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2376                 { $$ = build_cast ($1.location, $2, $4); }
2377 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2378                 {
2379                   const char *ptr;
2380                   int osb = pop_current_osb (ctxp);
2381                   obstack_grow (&temporary_obstack,
2382                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2383                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2384                   while (osb--)
2385                     obstack_grow (&temporary_obstack, "[]", 2);
2386                   obstack_1grow (&temporary_obstack, '\0');
2387                   ptr = obstack_finish (&temporary_obstack);
2388                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2389                   $$ = build_cast ($1.location, $2, $5);
2390                 }
2391 |       OP_TK primitive_type OSB_TK error
2392                 {yyerror ("']' expected, invalid type expression");}
2393 |       OP_TK error
2394                 {
2395                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2396                   RECOVER;
2397                 }
2398 |       OP_TK primitive_type dims CP_TK error
2399                 {yyerror ("Missing term"); RECOVER;}
2400 |       OP_TK primitive_type CP_TK error
2401                 {yyerror ("Missing term"); RECOVER;}
2402 |       OP_TK name dims CP_TK error
2403                 {yyerror ("Missing term"); RECOVER;}
2404 ;
2405
2406 multiplicative_expression:
2407         unary_expression
2408 |       multiplicative_expression MULT_TK unary_expression
2409                 {
2410                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2411                                     $2.location, $1, $3);
2412                 }
2413 |       multiplicative_expression DIV_TK unary_expression
2414                 {
2415                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2416                                     $1, $3);
2417                 }
2418 |       multiplicative_expression REM_TK unary_expression
2419                 {
2420                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2421                                     $1, $3);
2422                 }
2423 |       multiplicative_expression MULT_TK error
2424                 {yyerror ("Missing term"); RECOVER;}
2425 |       multiplicative_expression DIV_TK error
2426                 {yyerror ("Missing term"); RECOVER;}
2427 |       multiplicative_expression REM_TK error
2428                 {yyerror ("Missing term"); RECOVER;}
2429 ;
2430
2431 additive_expression:
2432         multiplicative_expression
2433 |       additive_expression PLUS_TK multiplicative_expression
2434                 {
2435                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2436                                     $1, $3);
2437                 }
2438 |       additive_expression MINUS_TK multiplicative_expression
2439                 {
2440                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2441                                     $1, $3);
2442                 }
2443 |       additive_expression PLUS_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 |       additive_expression MINUS_TK error
2446                 {yyerror ("Missing term"); RECOVER;}
2447 ;
2448
2449 shift_expression:
2450         additive_expression
2451 |       shift_expression LS_TK additive_expression
2452                 {
2453                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2454                                     $1, $3);
2455                 }
2456 |       shift_expression SRS_TK additive_expression
2457                 {
2458                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2459                                     $1, $3);
2460                 }
2461 |       shift_expression ZRS_TK additive_expression
2462                 {
2463                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2464                                     $1, $3);
2465                 }
2466 |       shift_expression LS_TK error
2467                 {yyerror ("Missing term"); RECOVER;}
2468 |       shift_expression SRS_TK error
2469                 {yyerror ("Missing term"); RECOVER;}
2470 |       shift_expression ZRS_TK error
2471                 {yyerror ("Missing term"); RECOVER;}
2472 ;
2473
2474 relational_expression:
2475         shift_expression
2476 |       relational_expression LT_TK shift_expression
2477                 {
2478                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2479                                     $1, $3);
2480                 }
2481 |       relational_expression GT_TK shift_expression
2482                 {
2483                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2484                                     $1, $3);
2485                 }
2486 |       relational_expression LTE_TK shift_expression
2487                 {
2488                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2489                                     $1, $3);
2490                 }
2491 |       relational_expression GTE_TK shift_expression
2492                 {
2493                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2494                                     $1, $3);
2495                 }
2496 |       relational_expression INSTANCEOF_TK reference_type
2497                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2498 |       relational_expression LT_TK error
2499                 {yyerror ("Missing term"); RECOVER;}
2500 |       relational_expression GT_TK error
2501                 {yyerror ("Missing term"); RECOVER;}
2502 |       relational_expression LTE_TK error
2503                 {yyerror ("Missing term"); RECOVER;}
2504 |       relational_expression GTE_TK error
2505                 {yyerror ("Missing term"); RECOVER;}
2506 |       relational_expression INSTANCEOF_TK error
2507                 {yyerror ("Invalid reference type"); RECOVER;}
2508 ;
2509
2510 equality_expression:
2511         relational_expression
2512 |       equality_expression EQ_TK relational_expression
2513                 {
2514                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2515                                     $1, $3);
2516                 }
2517 |       equality_expression NEQ_TK relational_expression
2518                 {
2519                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2520                                     $1, $3);
2521                 }
2522 |       equality_expression EQ_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 |       equality_expression NEQ_TK error
2525                 {yyerror ("Missing term"); RECOVER;}
2526 ;
2527
2528 and_expression:
2529         equality_expression
2530 |       and_expression AND_TK equality_expression
2531                 {
2532                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2533                                     $1, $3);
2534                 }
2535 |       and_expression AND_TK error
2536                 {yyerror ("Missing term"); RECOVER;}
2537 ;
2538
2539 exclusive_or_expression:
2540         and_expression
2541 |       exclusive_or_expression XOR_TK and_expression
2542                 {
2543                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2544                                     $1, $3);
2545                 }
2546 |       exclusive_or_expression XOR_TK error
2547                 {yyerror ("Missing term"); RECOVER;}
2548 ;
2549
2550 inclusive_or_expression:
2551         exclusive_or_expression
2552 |       inclusive_or_expression OR_TK exclusive_or_expression
2553                 {
2554                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2555                                     $1, $3);
2556                 }
2557 |       inclusive_or_expression OR_TK error
2558                 {yyerror ("Missing term"); RECOVER;}
2559 ;
2560
2561 conditional_and_expression:
2562         inclusive_or_expression
2563 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2564                 {
2565                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2566                                     $1, $3);
2567                 }
2568 |       conditional_and_expression BOOL_AND_TK error
2569                 {yyerror ("Missing term"); RECOVER;}
2570 ;
2571
2572 conditional_or_expression:
2573         conditional_and_expression
2574 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2575                 {
2576                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2577                                     $1, $3);
2578                 }
2579 |       conditional_or_expression BOOL_OR_TK error
2580                 {yyerror ("Missing term"); RECOVER;}
2581 ;
2582
2583 conditional_expression:         /* Error handling here is weak */
2584         conditional_or_expression
2585 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2586                 {
2587                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2588                   EXPR_WFL_LINECOL ($$) = $2.location;
2589                 }
2590 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2591                 {
2592                   YYERROR_NOW;
2593                   yyerror ("Missing term");
2594                   DRECOVER (1);
2595                 }
2596 |       conditional_or_expression REL_QM_TK error
2597                 {yyerror ("Missing term"); DRECOVER (2);}
2598 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2599                 {yyerror ("Missing term"); DRECOVER (3);}
2600 ;
2601
2602 assignment_expression:
2603         conditional_expression
2604 |       assignment
2605 ;
2606
2607 assignment:
2608         left_hand_side assignment_operator assignment_expression
2609                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2610 |       left_hand_side assignment_operator error
2611                 {
2612                   YYNOT_TWICE yyerror ("Missing term");
2613                   DRECOVER (assign);
2614                 }
2615 ;
2616
2617 left_hand_side:
2618         name
2619 |       field_access
2620 |       array_access
2621 ;
2622
2623 assignment_operator:
2624         ASSIGN_ANY_TK
2625 |       ASSIGN_TK
2626 ;
2627
2628 expression:
2629         assignment_expression
2630 ;
2631
2632 constant_expression:
2633         expression
2634 ;
2635
2636 %%
2637
2638 /* Helper function to retrieve an OSB count. Should be used when the
2639    `dims:' rule is being used.  */
2640
2641 static int
2642 pop_current_osb (ctxp)
2643      struct parser_ctxt *ctxp;
2644 {
2645   int to_return;
2646
2647   if (ctxp->osb_depth < 0)
2648     abort ();
2649
2650   to_return = CURRENT_OSB (ctxp);
2651   ctxp->osb_depth--;
2652
2653   return to_return;
2654 }
2655
2656 \f
2657
2658 /* This section of the code deal with save/restoring parser contexts.
2659    Add mode documentation here. FIXME */
2660
2661 /* Helper function. Create a new parser context. With
2662    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2663    context is copied, otherwise, the new context is zeroed. The newly
2664    created context becomes the current one.  */
2665
2666 static void
2667 create_new_parser_context (copy_from_previous)
2668     int copy_from_previous;
2669 {
2670   struct parser_ctxt *new;
2671
2672   new =  (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2673   if (copy_from_previous)
2674     {
2675       memcpy ((PTR)new, (PTR)ctxp, sizeof (struct parser_ctxt));
2676       new->saved_data_ctx = 1;
2677     }
2678   else
2679     memset ((PTR) new, 0, sizeof (struct parser_ctxt));
2680
2681   new->next = ctxp;
2682   ctxp = new;
2683 }
2684
2685 /* Create a new parser context and make it the current one. */
2686
2687 void
2688 java_push_parser_context ()
2689 {
2690   create_new_parser_context (0);
2691 }
2692
2693 void
2694 java_pop_parser_context (generate)
2695      int generate;
2696 {
2697   tree current;
2698   struct parser_ctxt *toFree, *next;
2699
2700   if (!ctxp)
2701     return;
2702
2703   toFree = ctxp;
2704   next = ctxp->next;
2705   if (next)
2706     {
2707       lineno = ctxp->lineno;
2708       current_class = ctxp->class_type;
2709     }
2710
2711   /* If the old and new lexers differ, then free the old one.  */
2712   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2713     java_destroy_lexer (ctxp->lexer);
2714
2715   /* Set the single import class file flag to 0 for the current list
2716      of imported things */
2717   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2718     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2719
2720   /* And restore those of the previous context */
2721   if ((ctxp = next))            /* Assignment is really meant here */
2722     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2723       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2724
2725   /* If we pushed a context to parse a class intended to be generated,
2726      we keep it so we can remember the class. What we could actually
2727      do is to just update a list of class names.  */
2728   if (generate)
2729     {
2730       toFree->next = ctxp_for_generation;
2731       ctxp_for_generation = toFree;
2732     }
2733   else
2734     free (toFree);
2735 }
2736
2737 /* Create a parser context for the use of saving some global
2738    variables.  */
2739
2740 void
2741 java_parser_context_save_global ()
2742 {
2743   if (!ctxp)
2744     {
2745       java_push_parser_context ();
2746       ctxp->saved_data_ctx = 1;
2747     }
2748
2749   /* If this context already stores data, create a new one suitable
2750      for data storage. */
2751   else if (ctxp->saved_data)
2752     create_new_parser_context (1);
2753
2754   ctxp->lineno = lineno;
2755   ctxp->class_type = current_class;
2756   ctxp->filename = input_filename;
2757   ctxp->function_decl = current_function_decl;
2758   ctxp->saved_data = 1;
2759 }
2760
2761 /* Restore some global variables from the previous context. Make the
2762    previous context the current one.  */
2763
2764 void
2765 java_parser_context_restore_global ()
2766 {
2767   lineno = ctxp->lineno;
2768   current_class = ctxp->class_type;
2769   input_filename = ctxp->filename;
2770   if (wfl_operator)
2771     {
2772       tree s;
2773       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2774       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2775     }
2776   current_function_decl = ctxp->function_decl;
2777   ctxp->saved_data = 0;
2778   if (ctxp->saved_data_ctx)
2779     java_pop_parser_context (0);
2780 }
2781
2782 /* Suspend vital data for the current class/function being parsed so
2783    that an other class can be parsed. Used to let local/anonymous
2784    classes be parsed.  */
2785
2786 static void
2787 java_parser_context_suspend ()
2788 {
2789   /* This makes debugging through java_debug_context easier */
2790   static const char *const name = "<inner buffer context>";
2791
2792   /* Duplicate the previous context, use it to save the globals we're
2793      interested in */
2794   create_new_parser_context (1);
2795   ctxp->function_decl = current_function_decl;
2796   ctxp->class_type = current_class;
2797
2798   /* Then create a new context which inherits all data from the
2799      previous one. This will be the new current context  */
2800   create_new_parser_context (1);
2801
2802   /* Help debugging */
2803   ctxp->next->filename = name;
2804 }
2805
2806 /* Resume vital data for the current class/function being parsed so
2807    that an other class can be parsed. Used to let local/anonymous
2808    classes be parsed.  The trick is the data storing file position
2809    informations must be restored to their current value, so parsing
2810    can resume as if no context was ever saved. */
2811
2812 static void
2813 java_parser_context_resume ()
2814 {
2815   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2816   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2817   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2818
2819   /* We need to inherit the list of classes to complete/generate */
2820   restored->classd_list = old->classd_list;
2821   restored->class_list = old->class_list;
2822
2823   /* Restore the current class and function from the saver */
2824   current_class = saver->class_type;
2825   current_function_decl = saver->function_decl;
2826
2827   /* Retrive the restored context */
2828   ctxp = restored;
2829
2830   /* Re-installed the data for the parsing to carry on */
2831   memcpy (&ctxp->marker_begining, &old->marker_begining,
2832           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2833
2834   /* Buffer context can now be discarded */
2835   free (saver);
2836   free (old);
2837 }
2838
2839 /* Add a new anchor node to which all statement(s) initializing static
2840    and non static initialized upon declaration field(s) will be
2841    linked.  */
2842
2843 static void
2844 java_parser_context_push_initialized_field ()
2845 {
2846   tree node;
2847
2848   node = build_tree_list (NULL_TREE, NULL_TREE);
2849   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2850   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2851
2852   node = build_tree_list (NULL_TREE, NULL_TREE);
2853   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2854   CPC_INITIALIZER_LIST (ctxp) = node;
2855
2856   node = build_tree_list (NULL_TREE, NULL_TREE);
2857   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2858   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2859 }
2860
2861 /* Pop the lists of initialized field. If this lists aren't empty,
2862    remember them so we can use it to create and populate the finit$
2863    or <clinit> functions. */
2864
2865 static void
2866 java_parser_context_pop_initialized_field ()
2867 {
2868   tree stmts;
2869   tree class_type = TREE_TYPE (GET_CPC ());
2870
2871   if (CPC_INITIALIZER_LIST (ctxp))
2872     {
2873       stmts = CPC_INITIALIZER_STMT (ctxp);
2874       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2875       if (stmts && !java_error_count)
2876         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2877     }
2878
2879   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2880     {
2881       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2882       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2883         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2884       /* Keep initialization in order to enforce 8.5 */
2885       if (stmts && !java_error_count)
2886         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2887     }
2888
2889   /* JDK 1.1 instance initializers */
2890   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2891     {
2892       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2893       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2894         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2895       if (stmts && !java_error_count)
2896         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2897     }
2898 }
2899
2900 static tree
2901 reorder_static_initialized (list)
2902      tree list;
2903 {
2904   /* We have to keep things in order. The alias initializer have to
2905      come first, then the initialized regular field, in reverse to
2906      keep them in lexical order. */
2907   tree marker, previous = NULL_TREE;
2908   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2909     if (TREE_CODE (marker) == TREE_LIST
2910         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2911       break;
2912
2913   /* No static initialized, the list is fine as is */
2914   if (!previous)
2915     list = TREE_CHAIN (marker);
2916
2917   /* No marker? reverse the whole list */
2918   else if (!marker)
2919     list = nreverse (list);
2920
2921   /* Otherwise, reverse what's after the marker and the new reordered
2922      sublist will replace the marker. */
2923   else
2924     {
2925       TREE_CHAIN (previous) = NULL_TREE;
2926       list = nreverse (list);
2927       list = chainon (TREE_CHAIN (marker), list);
2928     }
2929   return list;
2930 }
2931
2932 /* Helper functions to dump the parser context stack.  */
2933
2934 #define TAB_CONTEXT(C) \
2935   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2936
2937 static void
2938 java_debug_context_do (tab)
2939      int tab;
2940 {
2941   struct parser_ctxt *copy = ctxp;
2942   while (copy)
2943     {
2944       TAB_CONTEXT (tab);
2945       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2946       TAB_CONTEXT (tab);
2947       fprintf (stderr, "filename: %s\n", copy->filename);
2948       TAB_CONTEXT (tab);
2949       fprintf (stderr, "lineno: %d\n", copy->lineno);
2950       TAB_CONTEXT (tab);
2951       fprintf (stderr, "package: %s\n",
2952                (copy->package ?
2953                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2954       TAB_CONTEXT (tab);
2955       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2956       TAB_CONTEXT (tab);
2957       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2958       copy = copy->next;
2959       tab += 2;
2960     }
2961 }
2962
2963 /* Dump the stacked up parser contexts. Intended to be called from a
2964    debugger.  */
2965
2966 void
2967 java_debug_context ()
2968 {
2969   java_debug_context_do (0);
2970 }
2971
2972 \f
2973
2974 /* Flag for the error report routine to issue the error the first time
2975    it's called (overriding the default behavior which is to drop the
2976    first invocation and honor the second one, taking advantage of a
2977    richer context.  */
2978 static int force_error = 0;
2979
2980 /* Reporting an constructor invocation error.  */
2981 static void
2982 parse_ctor_invocation_error ()
2983 {
2984   if (DECL_CONSTRUCTOR_P (current_function_decl))
2985     yyerror ("Constructor invocation must be first thing in a constructor");
2986   else
2987     yyerror ("Only constructors can invoke constructors");
2988 }
2989
2990 /* Reporting JDK1.1 features not implemented.  */
2991
2992 static tree
2993 parse_jdk1_1_error (msg)
2994     const char *msg;
2995 {
2996   sorry (": `%s' JDK1.1(TM) feature", msg);
2997   java_error_count++;
2998   return empty_stmt_node;
2999 }
3000
3001 static int do_warning = 0;
3002
3003 void
3004 yyerror (msg)
3005      const char *msg;
3006 {
3007   static java_lc elc;
3008   static int  prev_lineno;
3009   static const char *prev_msg;
3010
3011   int save_lineno;
3012   char *remainder, *code_from_source;
3013
3014   if (!force_error && prev_lineno == lineno)
3015     return;
3016
3017   /* Save current error location but report latter, when the context is
3018      richer.  */
3019   if (ctxp->java_error_flag == 0)
3020     {
3021       ctxp->java_error_flag = 1;
3022       elc = ctxp->elc;
3023       /* Do something to use the previous line if we're reaching the
3024          end of the file... */
3025 #ifdef VERBOSE_SKELETON
3026       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3027 #endif
3028       return;
3029     }
3030
3031   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3032   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3033     return;
3034
3035   ctxp->java_error_flag = 0;
3036   if (do_warning)
3037     java_warning_count++;
3038   else
3039     java_error_count++;
3040
3041   if (elc.col == 0 && msg && msg[1] == ';')
3042     {
3043       elc.col  = ctxp->p_line->char_col-1;
3044       elc.line = ctxp->p_line->lineno;
3045     }
3046
3047   save_lineno = lineno;
3048   prev_lineno = lineno = elc.line;
3049   prev_msg = msg;
3050
3051   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3052   obstack_grow0 (&temporary_obstack,
3053                  code_from_source, strlen (code_from_source));
3054   remainder = obstack_finish (&temporary_obstack);
3055   if (do_warning)
3056     warning ("%s.\n%s", msg, remainder);
3057   else
3058     error ("%s.\n%s", msg, remainder);
3059
3060   /* This allow us to cheaply avoid an extra 'Invalid expression
3061      statement' error report when errors have been already reported on
3062      the same line. This occurs when we report an error but don't have
3063      a synchronization point other than ';', which
3064      expression_statement is the only one to take care of.  */
3065   ctxp->prevent_ese = lineno = save_lineno;
3066 }
3067
3068 static void
3069 issue_warning_error_from_context (cl, msg, ap)
3070      tree cl;
3071      const char *msg;
3072      va_list ap;
3073 {
3074   const char *saved, *saved_input_filename;
3075   char buffer [4096];
3076   vsprintf (buffer, msg, ap);
3077   force_error = 1;
3078
3079   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3080   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3081                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3082
3083   /* We have a CL, that's a good reason for using it if it contains data */
3084   saved = ctxp->filename;
3085   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3086     ctxp->filename = EXPR_WFL_FILENAME (cl);
3087   saved_input_filename = input_filename;
3088   input_filename = ctxp->filename;
3089   java_error (NULL);
3090   java_error (buffer);
3091   ctxp->filename = saved;
3092   input_filename = saved_input_filename;
3093   force_error = 0;
3094 }
3095
3096 /* Issue an error message at a current source line CL */
3097
3098 void
3099 parse_error_context (tree cl, const char *msg, ...)
3100 {
3101   va_list ap;
3102   va_start (ap, msg);
3103   issue_warning_error_from_context (cl, msg, ap);
3104   va_end (ap);
3105 }
3106
3107 /* Issue a warning at a current source line CL */
3108
3109 static void
3110 parse_warning_context (tree cl, const char *msg, ...)
3111 {
3112   va_list ap;
3113   va_start (ap, msg);
3114
3115   force_error = do_warning = 1;
3116   issue_warning_error_from_context (cl, msg, ap);
3117   do_warning = force_error = 0;
3118   va_end (ap);
3119 }
3120
3121 static tree
3122 find_expr_with_wfl (node)
3123      tree node;
3124 {
3125   while (node)
3126     {
3127       char code;
3128       tree to_return;
3129
3130       switch (TREE_CODE (node))
3131         {
3132         case BLOCK:
3133           node = BLOCK_EXPR_BODY (node);
3134           continue;
3135
3136         case COMPOUND_EXPR:
3137           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3138           if (to_return)
3139             return to_return;
3140           node = TREE_OPERAND (node, 1);
3141           continue;
3142
3143         case LOOP_EXPR:
3144           node = TREE_OPERAND (node, 0);
3145           continue;
3146
3147         case LABELED_BLOCK_EXPR:
3148           node = TREE_OPERAND (node, 1);
3149           continue;
3150
3151         default:
3152           code = TREE_CODE_CLASS (TREE_CODE (node));
3153           if (((code == '1') || (code == '2') || (code == 'e'))
3154               && EXPR_WFL_LINECOL (node))
3155             return node;
3156           return NULL_TREE;
3157         }
3158     }
3159   return NULL_TREE;
3160 }
3161
3162 /* Issue a missing return statement error. Uses METHOD to figure the
3163    last line of the method the error occurs in.  */
3164
3165 static void
3166 missing_return_error (method)
3167      tree method;
3168 {
3169   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
3170   parse_error_context (wfl_operator, "Missing return statement");
3171 }
3172
3173 /* Issue an unreachable statement error. From NODE, find the next
3174    statement to report appropriately.  */
3175 static void
3176 unreachable_stmt_error (node)
3177      tree node;
3178 {
3179   /* Browse node to find the next expression node that has a WFL. Use
3180      the location to report the error */
3181   if (TREE_CODE (node) == COMPOUND_EXPR)
3182     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3183   else
3184     node = find_expr_with_wfl (node);
3185
3186   if (node)
3187     {
3188       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3189       parse_error_context (wfl_operator, "Unreachable statement");
3190     }
3191   else
3192     abort ();
3193 }
3194
3195 int
3196 java_report_errors ()
3197 {
3198   if (java_error_count)
3199     fprintf (stderr, "%d error%s",
3200              java_error_count, (java_error_count == 1 ? "" : "s"));
3201   if (java_warning_count)
3202     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3203              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3204   if (java_error_count || java_warning_count)
3205     putc ('\n', stderr);
3206   return java_error_count;
3207 }
3208
3209 static char *
3210 java_accstring_lookup (flags)
3211      int flags;
3212 {
3213   static char buffer [80];
3214 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3215
3216   /* Access modifier looked-up first for easier report on forbidden
3217      access. */
3218   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3219   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3220   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3221   if (flags & ACC_STATIC) COPY_RETURN ("static");
3222   if (flags & ACC_FINAL) COPY_RETURN ("final");
3223   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3224   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3225   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3226   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3227   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3228   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3229
3230   buffer [0] = '\0';
3231   return buffer;
3232 #undef COPY_RETURN
3233 }
3234
3235 /* Issuing error messages upon redefinition of classes, interfaces or
3236    variables. */
3237
3238 static void
3239 classitf_redefinition_error (context, id, decl, cl)
3240      const char *context;
3241      tree id, decl, cl;
3242 {
3243   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3244                        context, IDENTIFIER_POINTER (id),
3245                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3246   /* Here we should point out where its redefined. It's a unicode. FIXME */
3247 }
3248
3249 static void
3250 variable_redefinition_error (context, name, type, line)
3251      tree context, name, type;
3252      int line;
3253 {
3254   const char *type_name;
3255
3256   /* Figure a proper name for type. We might haven't resolved it */
3257   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3258     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3259   else
3260     type_name = lang_printable_name (type, 0);
3261
3262   parse_error_context (context,
3263                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3264                        IDENTIFIER_POINTER (name),
3265                        type_name, IDENTIFIER_POINTER (name), line);
3266 }
3267
3268 /* If ANAME is terminated with `[]', it indicates an array. This
3269    function returns the number of `[]' found and if this number is
3270    greater than zero, it extracts the array type name and places it in
3271    the node pointed to by TRIMMED unless TRIMMED is null.  */
3272
3273 static int
3274 build_type_name_from_array_name (aname, trimmed)
3275      tree aname;
3276      tree *trimmed;
3277 {
3278   const char *name = IDENTIFIER_POINTER (aname);
3279   int len = IDENTIFIER_LENGTH (aname);
3280   int array_dims;
3281
3282   STRING_STRIP_BRACKETS (name, len, array_dims);
3283
3284   if (array_dims && trimmed)
3285     *trimmed = get_identifier_with_length (name, len);
3286
3287   return array_dims;
3288 }
3289
3290 static tree
3291 build_array_from_name (type, type_wfl, name, ret_name)
3292      tree type, type_wfl, name, *ret_name;
3293 {
3294   int more_dims = 0;
3295
3296   /* Eventually get more dims */
3297   more_dims = build_type_name_from_array_name (name, &name);
3298
3299   /* If we have, then craft a new type for this variable */
3300   if (more_dims)
3301     {
3302       tree save = type;
3303
3304       /* If we have a pointer, use its type */
3305       if (TREE_CODE (type) == POINTER_TYPE)
3306         type = TREE_TYPE (type);
3307
3308       /* Building the first dimension of a primitive type uses this
3309          function */
3310       if (JPRIMITIVE_TYPE_P (type))
3311         {
3312           type = build_java_array_type (type, -1);
3313           more_dims--;
3314         }
3315       /* Otherwise, if we have a WFL for this type, use it (the type
3316          is already an array on an unresolved type, and we just keep
3317          on adding dimensions) */
3318       else if (type_wfl)
3319         {
3320           type = type_wfl;
3321           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3322                                                         NULL);
3323         }
3324
3325       /* Add all the dimensions */
3326       while (more_dims--)
3327         type = build_unresolved_array_type (type);
3328
3329       /* The type may have been incomplete in the first place */
3330       if (type_wfl)
3331         type = obtain_incomplete_type (type);
3332     }
3333
3334   if (ret_name)
3335     *ret_name = name;
3336   return type;
3337 }
3338
3339 /* Build something that the type identifier resolver will identify as
3340    being an array to an unresolved type. TYPE_WFL is a WFL on a
3341    identifier. */
3342
3343 static tree
3344 build_unresolved_array_type (type_or_wfl)
3345      tree type_or_wfl;
3346 {
3347   const char *ptr;
3348   tree wfl;
3349
3350   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3351      just create a array type */
3352   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3353     return build_java_array_type (type_or_wfl, -1);
3354
3355   obstack_grow (&temporary_obstack,
3356                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3357                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3358   obstack_grow0 (&temporary_obstack, "[]", 2);
3359   ptr = obstack_finish (&temporary_obstack);
3360   wfl = build_expr_wfl (get_identifier (ptr),
3361                         EXPR_WFL_FILENAME (type_or_wfl),
3362                         EXPR_WFL_LINENO (type_or_wfl),
3363                         EXPR_WFL_COLNO (type_or_wfl));
3364   /* Re-install the existing qualifications so that the type can be
3365      resolved properly. */
3366   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3367   return wfl;
3368 }
3369
3370 static void
3371 parser_add_interface (class_decl, interface_decl, wfl)
3372      tree class_decl, interface_decl, wfl;
3373 {
3374   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3375     parse_error_context (wfl, "Interface `%s' repeated",
3376                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3377 }
3378
3379 /* Bulk of common class/interface checks. Return 1 if an error was
3380    encountered. TAG is 0 for a class, 1 for an interface.  */
3381
3382 static int
3383 check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
3384      int is_interface, flags;
3385      tree raw_name, qualified_name, decl, cl;
3386 {
3387   tree node;
3388   int sca = 0;                  /* Static class allowed */
3389   int icaf = 0;                 /* Inner class allowed flags */
3390   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3391
3392   if (!quiet_flag)
3393     fprintf (stderr, " %s%s %s",
3394              (CPC_INNER_P () ? "inner" : ""),
3395              (is_interface ? "interface" : "class"),
3396              IDENTIFIER_POINTER (qualified_name));
3397
3398   /* Scope of an interface/class type name:
3399        - Can't be imported by a single type import
3400        - Can't already exists in the package */
3401   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3402       && (node = find_name_in_single_imports (raw_name))
3403       && !CPC_INNER_P ())
3404     {
3405       parse_error_context
3406         (cl, "%s name `%s' clashes with imported type `%s'",
3407          (is_interface ? "Interface" : "Class"),
3408          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3409       return 1;
3410     }
3411   if (decl && CLASS_COMPLETE_P (decl))
3412     {
3413       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3414                                    qualified_name, decl, cl);
3415       return 1;
3416     }
3417
3418   if (check_inner_class_redefinition (raw_name, cl))
3419     return 1;
3420
3421   /* If public, file name should match class/interface name, except
3422      when dealing with an inner class */
3423   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3424     {
3425       const char *f;
3426
3427       for (f = &input_filename [strlen (input_filename)];
3428            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3429            f--)
3430         ;
3431       if (IS_DIR_SEPARATOR (f[0]))
3432         f++;
3433       if (strncmp (IDENTIFIER_POINTER (raw_name),
3434                    f , IDENTIFIER_LENGTH (raw_name)) ||
3435           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3436         parse_error_context
3437           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3438                              (is_interface ? "interface" : "class"),
3439                              IDENTIFIER_POINTER (qualified_name),
3440                              IDENTIFIER_POINTER (raw_name));
3441     }
3442
3443   /* Static classes can be declared only in top level classes. Note:
3444      once static, a inner class is a top level class. */
3445   if (flags & ACC_STATIC)
3446     {
3447       /* Catch the specific error of declaring an class inner class
3448          with no toplevel enclosing class. Prevent check_modifiers from
3449          complaining a second time */
3450       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3451         {
3452           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3453                                IDENTIFIER_POINTER (qualified_name));
3454           sca = ACC_STATIC;
3455         }
3456       /* Else, in the context of a top-level class declaration, let
3457          `check_modifiers' do its job, otherwise, give it a go */
3458       else
3459         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3460     }
3461
3462   /* Inner classes can be declared private or protected
3463      within their enclosing classes. */
3464   if (CPC_INNER_P ())
3465     {
3466       /* A class which is local to a block can't be public, private,
3467          protected or static. But it is created final, so allow this
3468          one. */
3469       if (current_function_decl)
3470         icaf = sca = uaaf = ACC_FINAL;
3471       else
3472         {
3473           check_modifiers_consistency (flags);
3474           icaf = ACC_PROTECTED;
3475           if (! CLASS_INTERFACE (GET_CPC ()))
3476             icaf |= ACC_PRIVATE;
3477         }
3478     }
3479
3480   if (is_interface)
3481     {
3482       if (CPC_INNER_P ())
3483         uaaf = INTERFACE_INNER_MODIFIERS;
3484       else
3485         uaaf = INTERFACE_MODIFIERS;
3486
3487       check_modifiers ("Illegal modifier `%s' for interface declaration",
3488                        flags, uaaf);
3489     }
3490   else
3491     check_modifiers ((current_function_decl ?
3492                       "Illegal modifier `%s' for local class declaration" :
3493                       "Illegal modifier `%s' for class declaration"),
3494                      flags, uaaf|sca|icaf);
3495   return 0;
3496 }
3497
3498 /* Construct a nested class name.  If the final component starts with
3499    a digit, return true.  Otherwise return false.  */
3500 static int
3501 make_nested_class_name (cpc_list)
3502      tree cpc_list;
3503 {
3504   tree name;
3505
3506   if (!cpc_list)
3507     return 0;
3508
3509   make_nested_class_name (TREE_CHAIN (cpc_list));
3510
3511   /* Pick the qualified name when dealing with the first upmost
3512      enclosing class */
3513   name = (TREE_CHAIN (cpc_list)
3514           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3515   obstack_grow (&temporary_obstack,
3516                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3517   obstack_1grow (&temporary_obstack, '$');
3518
3519   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3520 }
3521
3522 /* Can't redefine a class already defined in an earlier scope. */
3523
3524 static int
3525 check_inner_class_redefinition (raw_name, cl)
3526      tree raw_name, cl;
3527 {
3528   tree scope_list;
3529
3530   for (scope_list = GET_CPC_LIST (); scope_list;
3531        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3532     if (raw_name == GET_CPC_UN_NODE (scope_list))
3533       {
3534         parse_error_context
3535           (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",
3536            IDENTIFIER_POINTER (raw_name));
3537         return 1;
3538       }
3539   return 0;
3540 }
3541
3542 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3543    we remember ENCLOSING and SUPER.  */
3544
3545 static tree
3546 resolve_inner_class (circularity_hash, cl, enclosing, super, class_type)
3547      htab_t circularity_hash;
3548      tree cl, *enclosing, *super, class_type;
3549 {
3550   tree local_enclosing = *enclosing;
3551   tree local_super = NULL_TREE;
3552
3553   while (local_enclosing)
3554     {
3555       tree intermediate, decl;
3556
3557       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3558         local_enclosing;
3559
3560       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3561         return decl;
3562
3563       intermediate = local_enclosing;
3564       /* Explore enclosing contexts. */
3565       while (INNER_CLASS_DECL_P (intermediate))
3566         {
3567           intermediate = DECL_CONTEXT (intermediate);
3568           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3569             return decl;
3570         }
3571
3572       /* Now go to the upper classes, bail out if necessary. We will
3573          analyze the returned SUPER and act accordingly (see
3574          do_resolve_class.) */
3575       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3576       if (!local_super || local_super == object_type_node)
3577         break;
3578
3579       if (TREE_CODE (local_super) == POINTER_TYPE)
3580         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3581       else
3582         local_super = TYPE_NAME (local_super);
3583
3584       /* We may not have checked for circular inheritance yet, so do so
3585          here to prevent an infinite loop. */
3586       if (htab_find (circularity_hash, local_super) != NULL)
3587         {
3588           if (!cl)
3589             cl = lookup_cl (local_enclosing);
3590
3591           parse_error_context
3592             (cl, "Cyclic inheritance involving %s",
3593              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3594           local_enclosing = NULL_TREE;
3595         }
3596       else
3597         local_enclosing = local_super;
3598     }
3599
3600   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3601   *super = local_super;
3602   *enclosing = local_enclosing;
3603
3604   return NULL_TREE;
3605 }
3606
3607 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3608    qualified. */
3609
3610 static tree
3611 find_as_inner_class (enclosing, name, cl)
3612      tree enclosing, name, cl;
3613 {
3614   tree qual, to_return;
3615   if (!enclosing)
3616     return NULL_TREE;
3617
3618   name = TYPE_NAME (name);
3619
3620   /* First search: within the scope of `enclosing', search for name */
3621   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3622     qual = EXPR_WFL_QUALIFICATION (cl);
3623   else if (cl)
3624     qual = build_tree_list (cl, NULL_TREE);
3625   else
3626     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3627
3628   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3629     return to_return;
3630
3631   /* We're dealing with a qualified name. Try to resolve thing until
3632      we get something that is an enclosing class. */
3633   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3634     {
3635       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3636
3637       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3638            qual = TREE_CHAIN (qual))
3639         {
3640           acc = merge_qualified_name (acc,
3641                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3642           BUILD_PTR_FROM_NAME (ptr, acc);
3643           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3644         }
3645
3646       /* A NULL qual and a decl means that the search ended
3647          successfully?!? We have to do something then. FIXME */
3648
3649       if (decl)
3650         enclosing = decl;
3651       else
3652         qual = EXPR_WFL_QUALIFICATION (cl);
3653     }
3654   /* Otherwise, create a qual for the other part of the resolution. */
3655   else
3656     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3657
3658   return find_as_inner_class_do (qual, enclosing);
3659 }
3660
3661 /* We go inside the list of sub classes and try to find a way
3662    through. */
3663
3664 static tree
3665 find_as_inner_class_do (qual, enclosing)
3666      tree qual, enclosing;
3667 {
3668   if (!qual)
3669     return NULL_TREE;
3670
3671   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3672     {
3673       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3674       tree next_enclosing = NULL_TREE;
3675       tree inner_list;
3676
3677       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3678            inner_list; inner_list = TREE_CHAIN (inner_list))
3679         {
3680           if (TREE_VALUE (inner_list) == name_to_match)
3681             {
3682               next_enclosing = TREE_PURPOSE (inner_list);
3683               break;
3684             }
3685         }
3686       enclosing = next_enclosing;
3687     }
3688
3689   return (!qual && enclosing ? enclosing : NULL_TREE);
3690 }
3691
3692 /* Reach all inner classes and tie their unqualified name to a
3693    DECL. */
3694
3695 static void
3696 set_nested_class_simple_name_value (outer, set)
3697      tree outer;
3698      int set;
3699 {
3700   tree l;
3701
3702   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3703     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3704                                                 TREE_PURPOSE (l) : NULL_TREE);
3705 }
3706
3707 static void
3708 link_nested_class_to_enclosing ()
3709 {
3710   if (GET_ENCLOSING_CPC ())
3711     {
3712       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3713       DECL_INNER_CLASS_LIST (enclosing) =
3714         tree_cons (GET_CPC (), GET_CPC_UN (),
3715                    DECL_INNER_CLASS_LIST (enclosing));
3716     }
3717 }
3718
3719 static tree
3720 maybe_make_nested_class_name (name)
3721      tree name;
3722 {
3723   tree id = NULL_TREE;
3724
3725   if (CPC_INNER_P ())
3726     {
3727       /* If we're in a function, we must append a number to create the
3728          nested class name.  However, we don't do this if the class we
3729          are constructing is anonymous, because in that case we'll
3730          already have a number as the class name.  */
3731       if (! make_nested_class_name (GET_CPC_LIST ())
3732           && current_function_decl != NULL_TREE
3733           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3734         {
3735           char buf[10];
3736           sprintf (buf, "%d", anonymous_class_counter);
3737           ++anonymous_class_counter;
3738           obstack_grow (&temporary_obstack, buf, strlen (buf));
3739           obstack_1grow (&temporary_obstack, '$');
3740         }
3741       obstack_grow0 (&temporary_obstack,
3742                      IDENTIFIER_POINTER (name),
3743                      IDENTIFIER_LENGTH (name));
3744       id = get_identifier (obstack_finish (&temporary_obstack));
3745       if (ctxp->package)
3746         QUALIFIED_P (id) = 1;
3747     }
3748   return id;
3749 }
3750
3751 /* If DECL is NULL, create and push a new DECL, record the current
3752    line CL and do other maintenance things.  */
3753
3754 static tree
3755 maybe_create_class_interface_decl (decl, raw_name, qualified_name, cl)
3756      tree decl, raw_name, qualified_name, cl;
3757 {
3758   if (!decl)
3759     decl = push_class (make_class (), qualified_name);
3760
3761   /* Take care of the file and line business */
3762   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3763   /* If we're emiting xrefs, store the line/col number information */
3764   if (flag_emit_xref)
3765     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3766   else
3767     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3768   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3769   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3770   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3771     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3772
3773   PUSH_CPC (decl, raw_name);
3774   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3775
3776   /* Link the declaration to the already seen ones */
3777   TREE_CHAIN (decl) = ctxp->class_list;
3778   ctxp->class_list = decl;
3779
3780   /* Create a new nodes in the global lists */
3781   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3782   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3783
3784   /* Install a new dependency list element */
3785   create_jdep_list (ctxp);
3786
3787   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3788                           IDENTIFIER_POINTER (qualified_name)));
3789   return decl;
3790 }
3791
3792 static void
3793 add_superinterfaces (decl, interface_list)
3794      tree decl, interface_list;
3795 {
3796   tree node;
3797   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3798      takes care of ensuring that:
3799        - This is an accessible interface type,
3800        - Circularity detection.
3801    parser_add_interface is then called. If present but not defined,
3802    the check operation is delayed until the super interface gets
3803    defined.  */
3804   for (node = interface_list; node; node = TREE_CHAIN (node))
3805     {
3806       tree current = TREE_PURPOSE (node);
3807       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3808       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3809         {
3810           if (!parser_check_super_interface (idecl, decl, current))
3811             parser_add_interface (decl, idecl, current);
3812         }
3813       else
3814         register_incomplete_type (JDEP_INTERFACE,
3815                                   current, decl, NULL_TREE);
3816     }
3817 }
3818
3819 /* Create an interface in pass1 and return its decl. Return the
3820    interface's decl in pass 2.  */
3821
3822 static tree
3823 create_interface (flags, id, super)
3824      int flags;
3825      tree id, super;
3826 {
3827   tree raw_name = EXPR_WFL_NODE (id);
3828   tree q_name = parser_qualified_classname (raw_name);
3829   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3830
3831   /* Certain syntax errors are making SUPER be like ID. Avoid this
3832      case. */
3833   if (ctxp->class_err && id == super)
3834     super = NULL;
3835
3836   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3837
3838   /* Basic checks: scope, redefinition, modifiers */
3839   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3840     {
3841       PUSH_ERROR ();
3842       return NULL_TREE;
3843     }
3844
3845   /* Suspend the current parsing context if we're parsing an inner
3846      interface */
3847   if (CPC_INNER_P ())
3848     {
3849       java_parser_context_suspend ();
3850       /* Interface members are public. */
3851       if (CLASS_INTERFACE (GET_CPC ()))
3852         flags |= ACC_PUBLIC;
3853     }
3854
3855   /* Push a new context for (static) initialized upon declaration fields */
3856   java_parser_context_push_initialized_field ();
3857
3858   /* Interface modifiers check
3859        - public/abstract allowed (already done at that point)
3860        - abstract is obsolete (comes first, it's a warning, or should be)
3861        - Can't use twice the same (checked in the modifier rule) */
3862   if ((flags & ACC_ABSTRACT) && flag_redundant)
3863     parse_warning_context
3864       (MODIFIER_WFL (ABSTRACT_TK),
3865        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3866
3867   /* Create a new decl if DECL is NULL, otherwise fix it */
3868   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3869
3870   /* Set super info and mark the class a complete */
3871   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3872                   object_type_node, ctxp->interface_number);
3873   ctxp->interface_number = 0;
3874   CLASS_COMPLETE_P (decl) = 1;
3875   add_superinterfaces (decl, super);
3876
3877   return decl;
3878 }
3879
3880 /* Patch anonymous class CLASS, by either extending or implementing
3881    DEP.  */
3882
3883 static void
3884 patch_anonymous_class (type_decl, class_decl, wfl)
3885     tree type_decl, class_decl, wfl;
3886 {
3887   tree class = TREE_TYPE (class_decl);
3888   tree type =  TREE_TYPE (type_decl);
3889   tree binfo = TYPE_BINFO (class);
3890
3891   /* If it's an interface, implement it */
3892   if (CLASS_INTERFACE (type_decl))
3893     {
3894       tree s_binfo;
3895       int length;
3896
3897       if (parser_check_super_interface (type_decl, class_decl, wfl))
3898         return;
3899
3900       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3901       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3902       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3903       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3904       /* And add the interface */
3905       parser_add_interface (class_decl, type_decl, wfl);
3906     }
3907   /* Otherwise, it's a type we want to extend */
3908   else
3909     {
3910       if (parser_check_super (type_decl, class_decl, wfl))
3911         return;
3912       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3913     }
3914 }
3915
3916 static tree
3917 create_anonymous_class (location, type_name)
3918     int location;
3919     tree type_name;
3920 {
3921   char buffer [80];
3922   tree super = NULL_TREE, itf = NULL_TREE;
3923   tree id, type_decl, class;
3924
3925   /* The unqualified name of the anonymous class. It's just a number. */
3926   sprintf (buffer, "%d", anonymous_class_counter++);
3927   id = build_wfl_node (get_identifier (buffer));
3928   EXPR_WFL_LINECOL (id) = location;
3929
3930   /* We know about the type to extend/implement. We go ahead */
3931   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3932     {
3933       /* Create a class which either implements on extends the designated
3934          class. The class bears an innacessible name. */
3935       if (CLASS_INTERFACE (type_decl))
3936         {
3937           /* It's OK to modify it here. It's been already used and
3938              shouldn't be reused */
3939           ctxp->interface_number = 1;
3940           /* Interfaces should presented as a list of WFLs */
3941           itf = build_tree_list (type_name, NULL_TREE);
3942         }
3943       else
3944         super = type_name;
3945     }
3946
3947   class = create_class (ACC_FINAL, id, super, itf);
3948
3949   /* We didn't know anything about the stuff. We register a dependence. */
3950   if (!type_decl)
3951     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3952
3953   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3954   return class;
3955 }
3956
3957 /* Create a class in pass1 and return its decl. Return class
3958    interface's decl in pass 2.  */
3959
3960 static tree
3961 create_class (flags, id, super, interfaces)
3962      int flags;
3963      tree id, super, interfaces;
3964 {
3965   tree raw_name = EXPR_WFL_NODE (id);
3966   tree class_id, decl;
3967   tree super_decl_type;
3968
3969   /* Certain syntax errors are making SUPER be like ID. Avoid this
3970      case. */
3971   if (ctxp->class_err && id == super)
3972     super = NULL;
3973
3974   class_id = parser_qualified_classname (raw_name);
3975   decl = IDENTIFIER_CLASS_VALUE (class_id);
3976   EXPR_WFL_NODE (id) = class_id;
3977
3978   /* Basic check: scope, redefinition, modifiers */
3979   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3980     {
3981       PUSH_ERROR ();
3982       return NULL_TREE;
3983     }
3984
3985   /* Suspend the current parsing context if we're parsing an inner
3986      class or an anonymous class. */
3987   if (CPC_INNER_P ())
3988     {
3989       java_parser_context_suspend ();
3990       /* Interface members are public. */
3991       if (CLASS_INTERFACE (GET_CPC ()))
3992         flags |= ACC_PUBLIC;
3993     }
3994
3995   /* Push a new context for (static) initialized upon declaration fields */
3996   java_parser_context_push_initialized_field ();
3997
3998   /* Class modifier check:
3999        - Allowed modifier (already done at that point)
4000        - abstract AND final forbidden
4001        - Public classes defined in the correct file */
4002   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4003     parse_error_context
4004       (id, "Class `%s' can't be declared both abstract and final",
4005        IDENTIFIER_POINTER (raw_name));
4006
4007   /* Create a new decl if DECL is NULL, otherwise fix it */
4008   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4009
4010   /* If SUPER exists, use it, otherwise use Object */
4011   if (super)
4012     {
4013       /* Can't extend java.lang.Object */
4014       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4015         {
4016           parse_error_context (id, "Can't extend `java.lang.Object'");
4017           return NULL_TREE;
4018         }
4019
4020       super_decl_type =
4021         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4022     }
4023   else if (TREE_TYPE (decl) != object_type_node)
4024     super_decl_type = object_type_node;
4025   /* We're defining java.lang.Object */
4026   else
4027     super_decl_type = NULL_TREE;
4028
4029   /* A class nested in an interface is implicitly static. */
4030   if (INNER_CLASS_DECL_P (decl)
4031       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4032     {
4033       flags |= ACC_STATIC;
4034     }
4035
4036   /* Set super info and mark the class as complete. */
4037   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4038                   ctxp->interface_number);
4039   ctxp->interface_number = 0;
4040   CLASS_COMPLETE_P (decl) = 1;
4041   add_superinterfaces (decl, interfaces);
4042
4043   /* Add the private this$<n> field, Replicate final locals still in
4044      scope as private final fields mangled like val$<local_name>.
4045      This doesn't not occur for top level (static) inner classes. */
4046   if (PURE_INNER_CLASS_DECL_P (decl))
4047     add_inner_class_fields (decl, current_function_decl);
4048
4049   /* If doing xref, store the location at which the inherited class
4050      (if any) was seen. */
4051   if (flag_emit_xref && super)
4052     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4053
4054   /* Eventually sets the @deprecated tag flag */
4055   CHECK_DEPRECATED (decl);
4056
4057   /* Reset the anonymous class counter when declaring non inner classes */
4058   if (!INNER_CLASS_DECL_P (decl))
4059     anonymous_class_counter = 1;
4060
4061   return decl;
4062 }
4063
4064 /* End a class declaration: register the statements used to create
4065    finit$ and <clinit>, pop the current class and resume the prior
4066    parser context if necessary.  */
4067
4068 static void
4069 end_class_declaration (resume)
4070      int resume;
4071 {
4072   /* If an error occurred, context weren't pushed and won't need to be
4073      popped by a resume. */
4074   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4075
4076   if (GET_CPC () != error_mark_node)
4077     dump_java_tree (TDI_class, GET_CPC ());
4078
4079   java_parser_context_pop_initialized_field ();
4080   POP_CPC ();
4081   if (resume && no_error_occurred)
4082     java_parser_context_resume ();
4083
4084   /* We're ending a class declaration, this is a good time to reset
4085      the interface cout. Note that might have been already done in
4086      create_interface, but if at that time an inner class was being
4087      dealt with, the interface count was reset in a context created
4088      for the sake of handling inner classes declaration. */
4089   ctxp->interface_number = 0;
4090 }
4091
4092 static void
4093 add_inner_class_fields (class_decl, fct_decl)
4094      tree class_decl;
4095      tree fct_decl;
4096 {
4097   tree block, marker, f;
4098
4099   f = add_field (TREE_TYPE (class_decl),
4100                  build_current_thisn (TREE_TYPE (class_decl)),
4101                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4102                  ACC_PRIVATE);
4103   FIELD_THISN (f) = 1;
4104
4105   if (!fct_decl)
4106     return;
4107
4108   for (block = GET_CURRENT_BLOCK (fct_decl);
4109        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4110     {
4111       tree decl;
4112       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4113         {
4114           tree name, pname;
4115           tree wfl, init, list;
4116
4117           /* Avoid non final arguments. */
4118           if (!LOCAL_FINAL_P (decl))
4119             continue;
4120
4121           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4122           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4123           wfl = build_wfl_node (name);
4124           init = build_wfl_node (pname);
4125           /* Build an initialization for the field: it will be
4126              initialized by a parameter added to finit$, bearing a
4127              mangled name of the field itself (param$<n>.) The
4128              parameter is provided to finit$ by the constructor
4129              invoking it (hence the constructor will also feature a
4130              hidden parameter, set to the value of the outer context
4131              local at the time the inner class is created.)
4132
4133              Note: we take into account all possible locals that can
4134              be accessed by the inner class. It's actually not trivial
4135              to minimize these aliases down to the ones really
4136              used. One way to do that would be to expand all regular
4137              methods first, then finit$ to get a picture of what's
4138              used.  It works with the exception that we would have to
4139              go back on all constructor invoked in regular methods to
4140              have their invokation reworked (to include the right amount
4141              of alias initializer parameters.)
4142
4143              The only real way around, I think, is a first pass to
4144              identify locals really used in the inner class. We leave
4145              the flag FIELD_LOCAL_ALIAS_USED around for that future
4146              use.
4147
4148              On the other hand, it only affect local inner classes,
4149              whose constructors (and finit$ call) will be featuring
4150              unecessary arguments. It's easy for a developper to keep
4151              this number of parameter down by using the `final'
4152              keyword only when necessary. For the time being, we can
4153              issue a warning on unecessary finals. FIXME */
4154           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4155                                    wfl, init);
4156
4157           /* Register the field. The TREE_LIST holding the part
4158              initialized/initializer will be marked ARG_FINAL_P so
4159              that the created field can be marked
4160              FIELD_LOCAL_ALIAS. */
4161           list = build_tree_list (wfl, init);
4162           ARG_FINAL_P (list) = 1;
4163           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4164         }
4165     }
4166
4167   if (!CPC_INITIALIZER_STMT (ctxp))
4168     return;
4169
4170   /* If we ever registered an alias field, insert and marker to
4171      remeber where the list ends. The second part of the list (the one
4172      featuring initialized fields) so it can be later reversed to
4173      enforce 8.5. The marker will be removed during that operation. */
4174   marker = build_tree_list (NULL_TREE, NULL_TREE);
4175   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4176   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4177 }
4178
4179 /* Can't use lookup_field () since we don't want to load the class and
4180    can't set the CLASS_LOADED_P flag */
4181
4182 static tree
4183 find_field (class, name)
4184      tree class;
4185      tree name;
4186 {
4187   tree decl;
4188   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4189     {
4190       if (DECL_NAME (decl) == name)
4191         return decl;
4192     }
4193   return NULL_TREE;
4194 }
4195
4196 /* Wrap around lookup_field that doesn't potentially upset the value
4197    of CLASS */
4198
4199 static tree
4200 lookup_field_wrapper (class, name)
4201      tree class, name;
4202 {
4203   tree type = class;
4204   tree decl = NULL_TREE;
4205   java_parser_context_save_global ();
4206
4207   /* Last chance: if we're within the context of an inner class, we
4208      might be trying to access a local variable defined in an outer
4209      context. We try to look for it now. */
4210   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4211     {
4212       tree new_name;
4213       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4214       decl = lookup_field (&type, new_name);
4215       if (decl && decl != error_mark_node)
4216         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4217     }
4218   if (!decl || decl == error_mark_node)
4219     {
4220       type = class;
4221       decl = lookup_field (&type, name);
4222     }
4223
4224   /* If the field still hasn't been found, try the next enclosing context. */
4225   if (!decl && INNER_CLASS_TYPE_P (class))
4226     {
4227       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4228       decl = lookup_field_wrapper (outer_type, name);
4229     }
4230
4231   java_parser_context_restore_global ();
4232   return decl == error_mark_node ? NULL : decl;
4233 }
4234
4235 /* Find duplicate field within the same class declarations and report
4236    the error. Returns 1 if a duplicated field was found, 0
4237    otherwise.  */
4238
4239 static int
4240 duplicate_declaration_error_p (new_field_name, new_type, cl)
4241      tree new_field_name, new_type, cl;
4242 {
4243   /* This might be modified to work with method decl as well */
4244   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4245   if (decl)
4246     {
4247       char *t1 = xstrdup (purify_type_name
4248                          ((TREE_CODE (new_type) == POINTER_TYPE
4249                            && TREE_TYPE (new_type) == NULL_TREE) ?
4250                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4251                           lang_printable_name (new_type, 1)));
4252       /* The type may not have been completed by the time we report
4253          the error */
4254       char *t2 = xstrdup (purify_type_name
4255                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4256                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4257                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4258                           lang_printable_name (TREE_TYPE (decl), 1)));
4259       parse_error_context
4260         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4261          t1, IDENTIFIER_POINTER (new_field_name),
4262          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4263          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4264       free (t1);
4265       free (t2);
4266       return 1;
4267     }
4268   return 0;
4269 }
4270
4271 /* Field registration routine. If TYPE doesn't exist, field
4272    declarations are linked to the undefined TYPE dependency list, to
4273    be later resolved in java_complete_class () */
4274
4275 static void
4276 register_fields (flags, type, variable_list)
4277      int flags;
4278      tree type, variable_list;
4279 {
4280   tree current, saved_type;
4281   tree class_type = NULL_TREE;
4282   int saved_lineno = lineno;
4283   int must_chain = 0;
4284   tree wfl = NULL_TREE;
4285
4286   if (GET_CPC ())
4287     class_type = TREE_TYPE (GET_CPC ());
4288
4289   if (!class_type || class_type == error_mark_node)
4290     return;
4291
4292   /* If we're adding fields to interfaces, those fields are public,
4293      static, final */
4294   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4295     {
4296       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4297                                  flags, ACC_PUBLIC, "interface field(s)");
4298       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4299                                  flags, ACC_STATIC, "interface field(s)");
4300       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4301                                  flags, ACC_FINAL, "interface field(s)");
4302       check_modifiers ("Illegal interface member modifier `%s'", flags,
4303                        INTERFACE_FIELD_MODIFIERS);
4304       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4305     }
4306
4307   /* Obtain a suitable type for resolution, if necessary */
4308   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4309
4310   /* If TYPE is fully resolved and we don't have a reference, make one */
4311   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4312
4313   for (current = variable_list, saved_type = type; current;
4314        current = TREE_CHAIN (current), type = saved_type)
4315     {
4316       tree real_type;
4317       tree field_decl;
4318       tree cl = TREE_PURPOSE (current);
4319       tree init = TREE_VALUE (current);
4320       tree current_name = EXPR_WFL_NODE (cl);
4321
4322       /* Can't declare non-final static fields in inner classes */
4323       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4324           && !(flags & ACC_FINAL))
4325         parse_error_context
4326           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4327            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4328            lang_printable_name (class_type, 0));
4329
4330       /* Process NAME, as it may specify extra dimension(s) for it */
4331       type = build_array_from_name (type, wfl, current_name, &current_name);
4332
4333       /* Type adjustment. We may have just readjusted TYPE because
4334          the variable specified more dimensions. Make sure we have
4335          a reference if we can and don't have one already. Also
4336          change the name if we have an init. */
4337       if (type != saved_type)
4338         {
4339           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4340           if (init)
4341             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4342         }
4343
4344       real_type = GET_REAL_TYPE (type);
4345       /* Check for redeclarations */
4346       if (duplicate_declaration_error_p (current_name, real_type, cl))
4347         continue;
4348
4349       /* Set lineno to the line the field was found and create a
4350          declaration for it. Eventually sets the @deprecated tag flag. */
4351       if (flag_emit_xref)
4352         lineno = EXPR_WFL_LINECOL (cl);
4353       else
4354         lineno = EXPR_WFL_LINENO (cl);
4355       field_decl = add_field (class_type, current_name, real_type, flags);
4356       CHECK_DEPRECATED (field_decl);
4357
4358       /* If the field denotes a final instance variable, then we
4359          allocate a LANG_DECL_SPECIFIC part to keep track of its
4360          initialization. We also mark whether the field was
4361          initialized upon its declaration. We don't do that if the
4362          created field is an alias to a final local. */
4363       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4364         {
4365           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4366           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4367         }
4368
4369       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4370          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4371          hide parameters to this inner class finit$ and
4372          constructors. It also means that the field isn't final per
4373          say. */
4374       if (ARG_FINAL_P (current))
4375         {
4376           FIELD_LOCAL_ALIAS (field_decl) = 1;
4377           FIELD_FINAL (field_decl) = 0;
4378         }
4379
4380       /* Check if we must chain. */
4381       if (must_chain)
4382         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4383
4384       /* If we have an initialization value tied to the field */
4385       if (init)
4386         {
4387           /* The field is declared static */
4388           if (flags & ACC_STATIC)
4389             {
4390               /* We include the field and its initialization part into
4391                  a list used to generate <clinit>. After <clinit> is
4392                  walked, field initializations will be processed and
4393                  fields initialized with known constants will be taken
4394                  out of <clinit> and have their DECL_INITIAL set
4395                  appropriately. */
4396               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4397               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4398               if (TREE_OPERAND (init, 1)
4399                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4400                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4401             }
4402           /* A non-static field declared with an immediate initialization is
4403              to be initialized in <init>, if any.  This field is remembered
4404              to be processed at the time of the generation of <init>. */
4405           else
4406             {
4407               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4408               SET_CPC_INITIALIZER_STMT (ctxp, init);
4409             }
4410           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4411           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4412         }
4413     }
4414   lineno = saved_lineno;
4415 }
4416
4417 /* Generate finit$, using the list of initialized fields to populate
4418    its body. finit$'s parameter(s) list is adjusted to include the
4419    one(s) used to initialized the field(s) caching outer context
4420    local(s).  */
4421
4422 static tree
4423 generate_finit (class_type)
4424      tree class_type;
4425 {
4426   int count = 0;
4427   tree list = TYPE_FINIT_STMT_LIST (class_type);
4428   tree mdecl, current, parms;
4429
4430   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4431                                                   class_type, NULL_TREE,
4432                                                   &count);
4433   CRAFTED_PARAM_LIST_FIXUP (parms);
4434   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4435                                     finit_identifier_node, parms);
4436   fix_method_argument_names (parms, mdecl);
4437   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4438                        mdecl, NULL_TREE);
4439   DECL_FUNCTION_NAP (mdecl) = count;
4440   start_artificial_method_body (mdecl);
4441
4442   for (current = list; current; current = TREE_CHAIN (current))
4443     java_method_add_stmt (mdecl,
4444                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4445                                                 current));
4446   end_artificial_method_body (mdecl);
4447   return mdecl;
4448 }
4449
4450 /* Generate a function to run the instance initialization code. The
4451    private method is called `instinit$'. Unless we're dealing with an
4452    anonymous class, we determine whether all ctors of CLASS_TYPE
4453    declare a checked exception in their `throws' clause in order to
4454    see whether it's necessary to encapsulate the instance initializer
4455    statements in a try/catch/rethrow sequence.  */
4456
4457 static tree
4458 generate_instinit (class_type)
4459      tree class_type;
4460 {
4461   tree current;
4462   tree compound = NULL_TREE;
4463   tree parms = tree_cons (this_identifier_node,
4464                           build_pointer_type (class_type), end_params_node);
4465   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4466                                          void_type_node,
4467                                          instinit_identifier_node, parms);
4468
4469   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4470                        mdecl, NULL_TREE);
4471
4472   /* Gather all the statements in a compound */
4473   for (current = TYPE_II_STMT_LIST (class_type);
4474        current; current = TREE_CHAIN (current))
4475     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4476
4477   /* We need to encapsulate COMPOUND by a try/catch statement to
4478      rethrow exceptions that might occur in the instance initializer.
4479      We do that only if all ctors of CLASS_TYPE are set to catch a
4480      checked exception. This doesn't apply to anonymous classes (since
4481      they don't have declared ctors.) */
4482   if (!ANONYMOUS_CLASS_P (class_type) &&
4483       ctors_unchecked_throws_clause_p (class_type))
4484     {
4485       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4486                                              build1 (THROW_EXPR, NULL_TREE,
4487                                                      build_wfl_node (wpv_id)));
4488       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4489                                                       exception_type_node);
4490     }
4491
4492   start_artificial_method_body (mdecl);
4493   java_method_add_stmt (mdecl, compound);
4494   end_artificial_method_body (mdecl);
4495
4496   return mdecl;
4497 }
4498
4499 /* FIXME */
4500 static tree
4501 build_instinit_invocation (class_type)
4502      tree class_type;
4503 {
4504   tree to_return = NULL_TREE;
4505
4506   if (TYPE_II_STMT_LIST (class_type))
4507     {
4508       tree parm = build_tree_list (NULL_TREE,
4509                                    build_wfl_node (this_identifier_node));
4510       to_return =
4511         build_method_invocation (build_wfl_node (instinit_identifier_node),
4512                                  parm);
4513     }
4514   return to_return;
4515 }
4516
4517 /* Shared accros method_declarator and method_header to remember the
4518    patch stage that was reached during the declaration of the method.
4519    A method DECL is built differently is there is no patch
4520    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4521    pending on the currently defined method.  */
4522
4523 static int patch_stage;
4524
4525 /* Check the method declaration and add the method to its current
4526    class.  If the argument list is known to contain incomplete types,
4527    the method is partially added and the registration will be resume
4528    once the method arguments resolved. If TYPE is NULL, we're dealing
4529    with a constructor.  */
4530
4531 static tree
4532 method_header (flags, type, mdecl, throws)
4533      int flags;
4534      tree type, mdecl, throws;
4535 {
4536   tree type_wfl = NULL_TREE;
4537   tree meth_name = NULL_TREE;
4538   tree current, orig_arg, this_class = NULL;
4539   tree id, meth;
4540   int saved_lineno;
4541   int constructor_ok = 0, must_chain;
4542   int count;
4543
4544   if (mdecl == error_mark_node)
4545     return error_mark_node;
4546   meth = TREE_VALUE (mdecl);
4547   id = TREE_PURPOSE (mdecl);
4548
4549   check_modifiers_consistency (flags);
4550
4551   if (GET_CPC ())
4552     this_class = TREE_TYPE (GET_CPC ());
4553
4554   if (!this_class || this_class == error_mark_node)
4555     return NULL_TREE;
4556
4557   /* There are some forbidden modifiers for an abstract method and its
4558      class must be abstract as well.  */
4559   if (type && (flags & ACC_ABSTRACT))
4560     {
4561       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4562       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4563       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4564       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4565       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4566       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4567       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4568           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4569         parse_error_context
4570           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4571            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4572            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4573     }
4574
4575   /* Things to be checked when declaring a constructor */
4576   if (!type)
4577     {
4578       int ec = java_error_count;
4579       /* 8.6: Constructor declarations: we might be trying to define a
4580          method without specifying a return type. */
4581       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4582         parse_error_context
4583           (id, "Invalid method declaration, return type required");
4584       /* 8.6.3: Constructor modifiers */
4585       else
4586         {
4587           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4588           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4589           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4590           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4591           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4592           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4593         }
4594       /* If we found error here, we don't consider it's OK to tread
4595          the method definition as a constructor, for the rest of this
4596          function */
4597       if (ec == java_error_count)
4598         constructor_ok = 1;
4599     }
4600
4601   /* Method declared within the scope of an interface are implicitly
4602      abstract and public. Conflicts with other erroneously provided
4603      modifiers are checked right after. */
4604
4605   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4606     {
4607       /* If FLAGS isn't set because of a modifier, turn the
4608          corresponding modifier WFL to NULL so we issue a warning on
4609          the obsolete use of the modifier */
4610       if (!(flags & ACC_PUBLIC))
4611         MODIFIER_WFL (PUBLIC_TK) = NULL;
4612       if (!(flags & ACC_ABSTRACT))
4613         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4614       flags |= ACC_PUBLIC;
4615       flags |= ACC_ABSTRACT;
4616     }
4617
4618   /* Inner class can't declare static methods */
4619   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4620     {
4621       parse_error_context
4622         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4623          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4624          lang_printable_name (this_class, 0));
4625     }
4626
4627   /* Modifiers context reset moved up, so abstract method declaration
4628      modifiers can be later checked.  */
4629
4630   /* Set constructor returned type to void and method name to <init>,
4631      unless we found an error identifier the constructor (in which
4632      case we retain the original name) */
4633   if (!type)
4634     {
4635       type = void_type_node;
4636       if (constructor_ok)
4637         meth_name = init_identifier_node;
4638     }
4639   else
4640     meth_name = EXPR_WFL_NODE (id);
4641
4642   /* Do the returned type resolution and registration if necessary */
4643   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4644
4645   if (meth_name)
4646     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4647   EXPR_WFL_NODE (id) = meth_name;
4648   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4649
4650   if (must_chain)
4651     {
4652       patch_stage = JDEP_METHOD_RETURN;
4653       register_incomplete_type (patch_stage, type_wfl, id, type);
4654       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4655     }
4656   else
4657     TREE_TYPE (meth) = type;
4658
4659   saved_lineno = lineno;
4660   /* When defining an abstract or interface method, the curly
4661      bracket at level 1 doesn't exist because there is no function
4662      body */
4663   lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4664             EXPR_WFL_LINENO (id));
4665
4666   /* Remember the original argument list */
4667   orig_arg = TYPE_ARG_TYPES (meth);
4668
4669   if (patch_stage)              /* includes ret type and/or all args */
4670     {
4671       jdep *jdep;
4672       meth = add_method_1 (this_class, flags, meth_name, meth);
4673       /* Patch for the return type */
4674       if (patch_stage == JDEP_METHOD_RETURN)
4675         {
4676           jdep = CLASSD_LAST (ctxp->classd_list);
4677           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4678         }
4679       /* This is the stop JDEP. METH allows the function's signature
4680          to be computed. */
4681       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4682     }
4683   else
4684     meth = add_method (this_class, flags, meth_name,
4685                        build_java_signature (meth));
4686
4687   /* Remember final parameters */
4688   MARK_FINAL_PARMS (meth, orig_arg);
4689
4690   /* Fix the method argument list so we have the argument name
4691      information */
4692   fix_method_argument_names (orig_arg, meth);
4693
4694   /* Register the parameter number and re-install the current line
4695      number */
4696   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4697   lineno = saved_lineno;
4698
4699   /* Register exception specified by the `throws' keyword for
4700      resolution and set the method decl appropriate field to the list.
4701      Note: the grammar ensures that what we get here are class
4702      types. */
4703   if (throws)
4704     {
4705       throws = nreverse (throws);
4706       for (current = throws; current; current = TREE_CHAIN (current))
4707         {
4708           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4709                                     NULL_TREE, NULL_TREE);
4710           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4711             &TREE_VALUE (current);
4712         }
4713       DECL_FUNCTION_THROWS (meth) = throws;
4714     }
4715
4716   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4717     DECL_FUNCTION_WFL (meth) = id;
4718
4719   /* Set the flag if we correctly processed a constructor */
4720   if (constructor_ok)
4721     {
4722       DECL_CONSTRUCTOR_P (meth) = 1;
4723       /* Compute and store the number of artificial parameters declared
4724          for this constructor */
4725       for (count = 0, current = TYPE_FIELDS (this_class); current;
4726            current = TREE_CHAIN (current))
4727         if (FIELD_LOCAL_ALIAS (current))
4728           count++;
4729       DECL_FUNCTION_NAP (meth) = count;
4730     }
4731
4732   /* Eventually set the @deprecated tag flag */
4733   CHECK_DEPRECATED (meth);
4734
4735   /* If doing xref, store column and line number information instead
4736      of the line number only. */
4737   if (flag_emit_xref)
4738     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4739
4740   return meth;
4741 }
4742
4743 static void
4744 fix_method_argument_names (orig_arg, meth)
4745     tree orig_arg, meth;
4746 {
4747   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4748   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4749     {
4750       TREE_PURPOSE (arg) = this_identifier_node;
4751       arg = TREE_CHAIN (arg);
4752     }
4753   while (orig_arg != end_params_node)
4754     {
4755       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4756       orig_arg = TREE_CHAIN (orig_arg);
4757       arg = TREE_CHAIN (arg);
4758     }
4759 }
4760
4761 /* Complete the method declaration with METHOD_BODY.  */
4762
4763 static void
4764 finish_method_declaration (method_body)
4765      tree method_body;
4766 {
4767   int flags;
4768
4769   if (!current_function_decl)
4770     return;
4771
4772   flags = get_access_flags_from_decl (current_function_decl);
4773
4774   /* 8.4.5 Method Body */
4775   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4776     {
4777       tree name = DECL_NAME (current_function_decl);
4778       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4779                            "%s method `%s' can't have a body defined",
4780                            (METHOD_NATIVE (current_function_decl) ?
4781                             "Native" : "Abstract"),
4782                            IDENTIFIER_POINTER (name));
4783       method_body = NULL_TREE;
4784     }
4785   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4786     {
4787       tree name = DECL_NAME (current_function_decl);
4788       parse_error_context
4789         (DECL_FUNCTION_WFL (current_function_decl),
4790          "Non native and non abstract method `%s' must have a body defined",
4791          IDENTIFIER_POINTER (name));
4792       method_body = NULL_TREE;
4793     }
4794
4795   if (flag_emit_class_files && method_body
4796       && TREE_CODE (method_body) == NOP_EXPR
4797       && TREE_TYPE (current_function_decl)
4798       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4799     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4800
4801   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4802   maybe_absorb_scoping_blocks ();
4803   /* Exit function's body */
4804   exit_block ();
4805   /* Merge last line of the function with first line, directly in the
4806      function decl. It will be used to emit correct debug info. */
4807   if (!flag_emit_xref)
4808     DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
4809
4810   /* Since function's argument's list are shared, reset the
4811      ARG_FINAL_P parameter that might have been set on some of this
4812      function parameters. */
4813   UNMARK_FINAL_PARMS (current_function_decl);
4814
4815   /* So we don't have an irrelevant function declaration context for
4816      the next static block we'll see. */
4817   current_function_decl = NULL_TREE;
4818 }
4819
4820 /* Build a an error message for constructor circularity errors.  */
4821
4822 static char *
4823 constructor_circularity_msg (from, to)
4824      tree from, to;
4825 {
4826   static char string [4096];
4827   char *t = xstrdup (lang_printable_name (from, 0));
4828   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4829   free (t);
4830   return string;
4831 }
4832
4833 /* Verify a circular call to METH. Return 1 if an error is found, 0
4834    otherwise.  */
4835
4836 static GTY(()) tree vcc_list;
4837 static int
4838 verify_constructor_circularity (meth, current)
4839      tree meth, current;
4840 {
4841   tree c;
4842
4843   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4844     {
4845       if (TREE_VALUE (c) == meth)
4846         {
4847           char *t;
4848           if (vcc_list)
4849             {
4850               tree liste;
4851               vcc_list = nreverse (vcc_list);
4852               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4853                 {
4854                   parse_error_context
4855                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4856                      constructor_circularity_msg
4857                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4858                   java_error_count--;
4859                 }
4860             }
4861           t = xstrdup (lang_printable_name (meth, 0));
4862           parse_error_context (TREE_PURPOSE (c),
4863                                "%s: recursive invocation of constructor `%s'",
4864                                constructor_circularity_msg (current, meth), t);
4865           free (t);
4866           vcc_list = NULL_TREE;
4867           return 1;
4868         }
4869     }
4870   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4871     {
4872       vcc_list = tree_cons (c, current, vcc_list);
4873       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4874         return 1;
4875       vcc_list = TREE_CHAIN (vcc_list);
4876     }
4877   return 0;
4878 }
4879
4880 /* Check modifiers that can be declared but exclusively */
4881
4882 static void
4883 check_modifiers_consistency (flags)
4884      int flags;
4885 {
4886   int acc_count = 0;
4887   tree cl = NULL_TREE;
4888
4889   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4890   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4891   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4892   if (acc_count > 1)
4893     parse_error_context
4894       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4895
4896   acc_count = 0;
4897   cl = NULL_TREE;
4898   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4899   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4900   if (acc_count > 1)
4901     parse_error_context (cl,
4902                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4903 }
4904
4905 /* Check the methode header METH for abstract specifics features */
4906
4907 static void
4908 check_abstract_method_header (meth)
4909      tree meth;
4910 {
4911   int flags = get_access_flags_from_decl (meth);
4912
4913   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4914                               ACC_ABSTRACT, "abstract method",
4915                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4916   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4917                               ACC_PUBLIC, "abstract method",
4918                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4919
4920   check_modifiers ("Illegal modifier `%s' for interface method",
4921                   flags, INTERFACE_METHOD_MODIFIERS);
4922 }
4923
4924 /* Create a FUNCTION_TYPE node and start augmenting it with the
4925    declared function arguments. Arguments type that can't be resolved
4926    are left as they are, but the returned node is marked as containing
4927    incomplete types.  */
4928
4929 static tree
4930 method_declarator (id, list)
4931      tree id, list;
4932 {
4933   tree arg_types = NULL_TREE, current, node;
4934   tree meth = make_node (FUNCTION_TYPE);
4935   jdep *jdep;
4936
4937   patch_stage = JDEP_NO_PATCH;
4938
4939   if (GET_CPC () == error_mark_node)
4940     return error_mark_node;
4941
4942   /* If we're dealing with an inner class constructor, we hide the
4943      this$<n> decl in the name field of its parameter declaration.  We
4944      also might have to hide the outer context local alias
4945      initializers. Not done when the class is a toplevel class. */
4946   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4947       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4948     {
4949       tree aliases_list, type, thisn;
4950       /* First the aliases, linked to the regular parameters */
4951       aliases_list =
4952         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4953                                                 TREE_TYPE (GET_CPC ()),
4954                                                 NULL_TREE, NULL);
4955       list = chainon (nreverse (aliases_list), list);
4956
4957       /* Then this$<n> */
4958       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4959       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4960       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4961                         list);
4962     }
4963
4964   for (current = list; current; current = TREE_CHAIN (current))
4965     {
4966       int must_chain = 0;
4967       tree wfl_name = TREE_PURPOSE (current);
4968       tree type = TREE_VALUE (current);
4969       tree name = EXPR_WFL_NODE (wfl_name);
4970       tree already, arg_node;
4971       tree type_wfl = NULL_TREE;
4972       tree real_type;
4973
4974       /* Obtain a suitable type for resolution, if necessary */
4975       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4976
4977       /* Process NAME, as it may specify extra dimension(s) for it */
4978       type = build_array_from_name (type, type_wfl, name, &name);
4979       EXPR_WFL_NODE (wfl_name) = name;
4980
4981       real_type = GET_REAL_TYPE (type);
4982       if (TREE_CODE (real_type) == RECORD_TYPE)
4983         {
4984           real_type = promote_type (real_type);
4985           if (TREE_CODE (type) == TREE_LIST)
4986             TREE_PURPOSE (type) = real_type;
4987         }
4988
4989       /* Check redefinition */
4990       for (already = arg_types; already; already = TREE_CHAIN (already))
4991         if (TREE_PURPOSE (already) == name)
4992           {
4993             parse_error_context
4994               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4995                IDENTIFIER_POINTER (name),
4996                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4997             break;
4998           }
4999
5000       /* If we've an incomplete argument type, we know there is a location
5001          to patch when the type get resolved, later.  */
5002       jdep = NULL;
5003       if (must_chain)
5004         {
5005           patch_stage = JDEP_METHOD;
5006           type = register_incomplete_type (patch_stage,
5007                                            type_wfl, wfl_name, type);
5008           jdep = CLASSD_LAST (ctxp->classd_list);
5009           JDEP_MISC (jdep) = id;
5010         }
5011
5012       /* The argument node: a name and a (possibly) incomplete type.  */
5013       arg_node = build_tree_list (name, real_type);
5014       /* Remeber arguments declared final. */
5015       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5016
5017       if (jdep)
5018         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5019       TREE_CHAIN (arg_node) = arg_types;
5020       arg_types = arg_node;
5021     }
5022   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5023   node = build_tree_list (id, meth);
5024   return node;
5025 }
5026
5027 static int
5028 unresolved_type_p (wfl, returned)
5029      tree wfl;
5030      tree *returned;
5031
5032 {
5033   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5034     {
5035       if (returned)
5036         {
5037           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5038           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5039             *returned = TREE_TYPE (decl);
5040           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5041             *returned = TREE_TYPE (GET_CPC ());
5042           else
5043             *returned = NULL_TREE;
5044         }
5045       return 1;
5046     }
5047   if (returned)
5048     *returned = wfl;
5049   return 0;
5050 }
5051
5052 /* From NAME, build a qualified identifier node using the
5053    qualification from the current package definition. */
5054
5055 static tree
5056 parser_qualified_classname (name)
5057      tree name;
5058 {
5059   tree nested_class_name;
5060
5061   if ((nested_class_name = maybe_make_nested_class_name (name)))
5062     return nested_class_name;
5063
5064   if (ctxp->package)
5065     return merge_qualified_name (ctxp->package, name);
5066   else
5067     return name;
5068 }
5069
5070 /* Called once the type a interface extends is resolved. Returns 0 if
5071    everything is OK.  */
5072
5073 static int
5074 parser_check_super_interface (super_decl, this_decl, this_wfl)
5075      tree super_decl, this_decl, this_wfl;
5076 {
5077   tree super_type = TREE_TYPE (super_decl);
5078
5079   /* Has to be an interface */
5080   if (!CLASS_INTERFACE (super_decl))
5081     {
5082       parse_error_context
5083         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5084          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5085           "Interface" : "Class"),
5086          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5087          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5088          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5089       return 1;
5090     }
5091
5092   /* Check top-level interface access. Inner classes are subject to member
5093      access rules (6.6.1). */
5094   if (! INNER_CLASS_P (super_type)
5095       && check_pkg_class_access (DECL_NAME (super_decl),
5096                                  lookup_cl (this_decl), true))
5097     return 1;
5098
5099   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5100                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5101                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5102   return 0;
5103 }
5104
5105 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5106    0 if everthing is OK.  */
5107
5108 static int
5109 parser_check_super (super_decl, this_decl, wfl)
5110      tree super_decl, this_decl, wfl;
5111 {
5112   tree super_type = TREE_TYPE (super_decl);
5113
5114   /* SUPER should be a CLASS (neither an array nor an interface) */
5115   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5116     {
5117       parse_error_context
5118         (wfl, "Class `%s' can't subclass %s `%s'",
5119          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5120          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5121          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5122       return 1;
5123     }
5124
5125   if (CLASS_FINAL (TYPE_NAME (super_type)))
5126     {
5127       parse_error_context (wfl, "Can't subclass final classes: %s",
5128                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5129       return 1;
5130     }
5131
5132   /* Check top-level class scope. Inner classes are subject to member access
5133      rules (6.6.1). */
5134   if (! INNER_CLASS_P (super_type)
5135       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5136     return 1;
5137
5138   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5139                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5140                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5141   return 0;
5142 }
5143
5144 /* Create a new dependency list and link it (in a LIFO manner) to the
5145    CTXP list of type dependency list.  */
5146
5147 static void
5148 create_jdep_list (ctxp)
5149      struct parser_ctxt *ctxp;
5150 {
5151   jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
5152   new->first = new->last = NULL;
5153   new->next = ctxp->classd_list;
5154   ctxp->classd_list = new;
5155 }
5156
5157 static jdeplist *
5158 reverse_jdep_list (ctxp)
5159      struct parser_ctxt *ctxp;
5160 {
5161   register jdeplist *prev = NULL, *current, *next;
5162   for (current = ctxp->classd_list; current; current = next)
5163     {
5164       next = current->next;
5165       current->next = prev;
5166       prev = current;
5167     }
5168   return prev;
5169 }
5170
5171 /* Create a fake pointer based on the ID stored in
5172    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5173    registered again. */
5174
5175 static tree
5176 obtain_incomplete_type (type_name)
5177      tree type_name;
5178 {
5179   tree ptr = NULL_TREE, name;
5180
5181   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5182     name = EXPR_WFL_NODE (type_name);
5183   else if (INCOMPLETE_TYPE_P (type_name))
5184     name = TYPE_NAME (type_name);
5185   else
5186     abort ();
5187
5188   /* Workaround from build_pointer_type for incomplete types.  */
5189   BUILD_PTR_FROM_NAME (ptr, name);
5190   TYPE_MODE (ptr) = ptr_mode;
5191   layout_type (ptr);
5192
5193   return ptr;
5194 }
5195
5196 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5197    non NULL instead of computing a new fake type based on WFL. The new
5198    dependency is inserted in the current type dependency list, in FIFO
5199    manner.  */
5200
5201 static tree
5202 register_incomplete_type (kind, wfl, decl, ptr)
5203      int kind;
5204      tree wfl, decl, ptr;
5205 {
5206   jdep *new = (jdep *)xmalloc (sizeof (jdep));
5207
5208   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5209     ptr = obtain_incomplete_type (wfl);
5210
5211   JDEP_KIND (new) = kind;
5212   JDEP_DECL (new) = decl;
5213   JDEP_TO_RESOLVE (new) = ptr;
5214   JDEP_WFL (new) = wfl;
5215   JDEP_CHAIN (new) = NULL;
5216   JDEP_MISC (new) = NULL_TREE;
5217   /* For some dependencies, set the enclosing class of the current
5218      class to be the enclosing context */
5219   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5220       && GET_ENCLOSING_CPC ())
5221     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5222   else if (kind == JDEP_SUPER)
5223     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5224                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5225   else
5226     JDEP_ENCLOSING (new) = GET_CPC ();
5227   JDEP_GET_PATCH (new) = (tree *)NULL;
5228
5229   JDEP_INSERT (ctxp->classd_list, new);
5230
5231   return ptr;
5232 }
5233
5234 /* This checks for circular references with innerclasses. We start
5235    from SOURCE and should never reach TARGET. Extended/implemented
5236    types in SOURCE have their enclosing context checked not to reach
5237    TARGET. When the last enclosing context of SOURCE is reached, its
5238    extended/implemented types are also checked not to reach TARGET.
5239    In case of error, WFL of the offending type is returned; NULL_TREE
5240    otherwise.  */
5241
5242 static tree
5243 check_inner_circular_reference (source, target)
5244      tree source;
5245      tree target;
5246 {
5247   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5248   tree ctx, cl;
5249   int i;
5250
5251   if (!basetype_vec)
5252     return NULL_TREE;
5253
5254   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5255     {
5256       tree su;
5257
5258       /* We can end up with a NULL_TREE or an incomplete type here if
5259          we encountered previous type resolution errors. It's safe to
5260          simply ignore these cases.  */
5261       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5262         continue;
5263       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5264       if (INCOMPLETE_TYPE_P (su))
5265         continue;
5266
5267       if (inherits_from_p (su, target))
5268         return lookup_cl (TYPE_NAME (su));
5269
5270       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5271         {
5272           /* An enclosing context shouldn't be TARGET */
5273           if (ctx == TYPE_NAME (target))
5274             return lookup_cl (TYPE_NAME (su));
5275
5276           /* When we reach the enclosing last context, start a check
5277              on it, with the same target */
5278           if (! DECL_CONTEXT (ctx) &&
5279               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5280             return cl;
5281         }
5282     }
5283   return NULL_TREE;
5284 }
5285
5286 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5287    offending type if a circularity is detected. NULL_TREE is returned
5288    otherwise. TYPE can be an interface or a class.   */
5289
5290 static tree
5291 check_circular_reference (type)
5292      tree type;
5293 {
5294   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5295   int i;
5296
5297   if (!basetype_vec)
5298     return NULL_TREE;
5299
5300   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5301     {
5302       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5303         return lookup_cl (TYPE_NAME (type));
5304       return NULL_TREE;
5305     }
5306
5307   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5308     {
5309       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5310       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5311           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5312         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5313     }
5314   return NULL_TREE;
5315 }
5316
5317 void
5318 java_check_circular_reference ()
5319 {
5320   tree current;
5321   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5322     {
5323       tree type = TREE_TYPE (current);
5324       tree cl;
5325
5326       cl = check_circular_reference (type);
5327       if (! cl)
5328         cl = check_inner_circular_reference (type, type);
5329       if (cl)
5330         parse_error_context (cl, "Cyclic class inheritance%s",
5331                              (cyclic_inheritance_report ?
5332                               cyclic_inheritance_report : ""));
5333     }
5334 }
5335
5336 /* Augment the parameter list PARM with parameters crafted to
5337    initialize outer context locals aliases. Through ARTIFICIAL, a
5338    count is kept of the number of crafted parameters. MODE governs
5339    what eventually gets created: something suitable for a function
5340    creation or a function invocation, either the constructor or
5341    finit$.  */
5342
5343 static tree
5344 build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
5345     int mode;
5346     tree class_type, parm;
5347     int *artificial;
5348 {
5349   tree field;
5350   tree additional_parms = NULL_TREE;
5351
5352   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5353     if (FIELD_LOCAL_ALIAS (field))
5354       {
5355         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5356         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5357         tree mangled_id;
5358
5359         switch (mode)
5360           {
5361           case AIPL_FUNCTION_DECLARATION:
5362             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5363                                                          &buffer [4]);
5364             purpose = build_wfl_node (mangled_id);
5365             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5366               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5367             else
5368               value = TREE_TYPE (field);
5369             break;
5370
5371           case AIPL_FUNCTION_CREATION:
5372             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5373                                                          &buffer [4]);
5374             value = TREE_TYPE (field);
5375             break;
5376
5377           case AIPL_FUNCTION_FINIT_INVOCATION:
5378             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5379                                                          &buffer [4]);
5380             /* Now, this is wrong. purpose should always be the NAME
5381                of something and value its matching value (decl, type,
5382                etc...) FIXME -- but there is a lot to fix. */
5383
5384             /* When invoked for this kind of operation, we already
5385                know whether a field is used or not. */
5386             purpose = TREE_TYPE (field);
5387             value = build_wfl_node (mangled_id);
5388             break;
5389
5390           case AIPL_FUNCTION_CTOR_INVOCATION:
5391             /* There are two case: the constructor invokation happends
5392                outside the local inner, in which case, locales from the outer
5393                context are directly used.
5394
5395                Otherwise, we fold to using the alias directly. */
5396             if (class_type == current_class)
5397               value = field;
5398             else
5399               {
5400                 name = get_identifier (&buffer[4]);
5401                 value = IDENTIFIER_LOCAL_VALUE (name);
5402               }
5403             break;
5404           }
5405         additional_parms = tree_cons (purpose, value, additional_parms);
5406         if (artificial)
5407           *artificial +=1;
5408       }
5409   if (additional_parms)
5410     {
5411       if (ANONYMOUS_CLASS_P (class_type)
5412           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5413         additional_parms = nreverse (additional_parms);
5414       parm = chainon (additional_parms, parm);
5415     }
5416
5417    return parm;
5418 }
5419
5420 /* Craft a constructor for CLASS_DECL -- what we should do when none
5421    where found. ARGS is non NULL when a special signature must be
5422    enforced. This is the case for anonymous classes.  */
5423
5424 static tree
5425 craft_constructor (class_decl, args)
5426      tree class_decl, args;
5427 {
5428   tree class_type = TREE_TYPE (class_decl);
5429   tree parm = NULL_TREE;
5430   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5431                ACC_PUBLIC : 0);
5432   int i = 0, artificial = 0;
5433   tree decl, ctor_name;
5434   char buffer [80];
5435
5436   /* The constructor name is <init> unless we're dealing with an
5437      anonymous class, in which case the name will be fixed after having
5438      be expanded. */
5439   if (ANONYMOUS_CLASS_P (class_type))
5440     ctor_name = DECL_NAME (class_decl);
5441   else
5442     ctor_name = init_identifier_node;
5443
5444   /* If we're dealing with an inner class constructor, we hide the
5445      this$<n> decl in the name field of its parameter declaration. */
5446   if (PURE_INNER_CLASS_TYPE_P (class_type))
5447     {
5448       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5449       parm = tree_cons (build_current_thisn (class_type),
5450                         build_pointer_type (type), parm);
5451
5452       /* Some more arguments to be hidden here. The values of the local
5453          variables of the outer context that the inner class needs to see. */
5454       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5455                                                      class_type, parm,
5456                                                      &artificial);
5457     }
5458
5459   /* Then if there are any args to be enforced, enforce them now */
5460   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5461     {
5462       sprintf (buffer, "parm%d", i++);
5463       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5464     }
5465
5466   CRAFTED_PARAM_LIST_FIXUP (parm);
5467   decl = create_artificial_method (class_type, flags, void_type_node,
5468                                    ctor_name, parm);
5469   fix_method_argument_names (parm, decl);
5470   /* Now, mark the artificial parameters. */
5471   DECL_FUNCTION_NAP (decl) = artificial;
5472   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5473   return decl;
5474 }
5475
5476
5477 /* Fix the constructors. This will be called right after circular
5478    references have been checked. It is necessary to fix constructors
5479    early even if no code generation will take place for that class:
5480    some generated constructor might be required by the class whose
5481    compilation triggered this one to be simply loaded.  */
5482
5483 void
5484 java_fix_constructors ()
5485 {
5486   tree current;
5487
5488   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5489     {
5490       tree class_type = TREE_TYPE (current);
5491       int saw_ctor = 0;
5492       tree decl;
5493
5494       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5495         continue;
5496
5497       current_class = class_type;
5498       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5499         {
5500           if (DECL_CONSTRUCTOR_P (decl))
5501             {
5502               fix_constructors (decl);
5503               saw_ctor = 1;
5504             }
5505         }
5506
5507       /* Anonymous class constructor can't be generated that early. */
5508       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5509         craft_constructor (current, NULL_TREE);
5510     }
5511 }
5512
5513 /* safe_layout_class just makes sure that we can load a class without
5514    disrupting the current_class, input_file, lineno, etc, information
5515    about the class processed currently.  */
5516
5517 void
5518 safe_layout_class (class)
5519      tree class;
5520 {
5521   tree save_current_class = current_class;
5522   const char *save_input_filename = input_filename;
5523   int save_lineno = lineno;
5524
5525   layout_class (class);
5526
5527   current_class = save_current_class;
5528   input_filename = save_input_filename;
5529   lineno = save_lineno;
5530 }
5531
5532 static tree
5533 jdep_resolve_class (dep)
5534      jdep *dep;
5535 {
5536   tree decl;
5537
5538   if (JDEP_RESOLVED_P (dep))
5539     decl = JDEP_RESOLVED_DECL (dep);
5540   else
5541     {
5542       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5543                             JDEP_DECL (dep), JDEP_WFL (dep));
5544       JDEP_RESOLVED (dep, decl);
5545     }
5546
5547   if (!decl)
5548     complete_class_report_errors (dep);
5549   else if (PURE_INNER_CLASS_DECL_P (decl))
5550     {
5551       tree inner = TREE_TYPE (decl);
5552       if (! CLASS_LOADED_P (inner))
5553         {
5554           safe_layout_class (inner);
5555           if (TYPE_SIZE (inner) == error_mark_node)
5556             TYPE_SIZE (inner) = NULL_TREE;
5557         }
5558       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5559     }
5560   return decl;
5561 }
5562
5563 /* Complete unsatisfied class declaration and their dependencies */
5564
5565 void
5566 java_complete_class ()
5567 {
5568   tree cclass;
5569   jdeplist *cclassd;
5570   int error_found;
5571   tree type;
5572
5573   /* Process imports */
5574   process_imports ();
5575
5576   /* Reverse things so we have the right order */
5577   ctxp->class_list = nreverse (ctxp->class_list);
5578   ctxp->classd_list = reverse_jdep_list (ctxp);
5579
5580   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5581        cclass && cclassd;
5582        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5583     {
5584       jdep *dep;
5585
5586       /* We keep the compilation unit imports in the class so that
5587          they can be used later to resolve type dependencies that
5588          aren't necessary to solve now. */
5589       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5590       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5591
5592       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5593         {
5594           tree decl;
5595           if (!(decl = jdep_resolve_class (dep)))
5596             continue;
5597
5598           /* Now it's time to patch */
5599           switch (JDEP_KIND (dep))
5600             {
5601             case JDEP_SUPER:
5602               /* Simply patch super */
5603               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5604                 continue;
5605               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5606                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5607               break;
5608
5609             case JDEP_FIELD:
5610               {
5611                 /* We do part of the job done in add_field */
5612                 tree field_decl = JDEP_DECL (dep);
5613                 tree field_type = TREE_TYPE (decl);
5614                 if (TREE_CODE (field_type) == RECORD_TYPE)
5615                   field_type = promote_type (field_type);
5616                 TREE_TYPE (field_decl) = field_type;
5617                 DECL_ALIGN (field_decl) = 0;
5618                 DECL_USER_ALIGN (field_decl) = 0;
5619                 layout_decl (field_decl, 0);
5620                 SOURCE_FRONTEND_DEBUG
5621                   (("Completed field/var decl `%s' with `%s'",
5622                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5623                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5624                 break;
5625               }
5626             case JDEP_METHOD:   /* We start patching a method */
5627             case JDEP_METHOD_RETURN:
5628               error_found = 0;
5629               while (1)
5630                 {
5631                   if (decl)
5632                     {
5633                       type = TREE_TYPE(decl);
5634                       if (TREE_CODE (type) == RECORD_TYPE)
5635                         type = promote_type (type);
5636                       JDEP_APPLY_PATCH (dep, type);
5637                       SOURCE_FRONTEND_DEBUG
5638                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5639                            "Completing fct `%s' with ret type `%s'":
5640                            "Completing arg `%s' with type `%s'"),
5641                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5642                                               (JDEP_DECL_WFL (dep))),
5643                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5644                     }
5645                   else
5646                     error_found = 1;
5647                   dep = JDEP_CHAIN (dep);
5648                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5649                     break;
5650                   else
5651                     decl = jdep_resolve_class (dep);
5652                 }
5653               if (!error_found)
5654                 {
5655                   tree mdecl = JDEP_DECL (dep), signature;
5656                   /* Recompute and reset the signature, check first that
5657                      all types are now defined. If they're not,
5658                      don't build the signature. */
5659                   if (check_method_types_complete (mdecl))
5660                     {
5661                       signature = build_java_signature (TREE_TYPE (mdecl));
5662                       set_java_signature (TREE_TYPE (mdecl), signature);
5663                     }
5664                 }
5665               else
5666                 continue;
5667               break;
5668
5669             case JDEP_INTERFACE:
5670               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5671                                                 JDEP_WFL (dep)))
5672                 continue;
5673               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5674               break;
5675
5676             case JDEP_PARM:
5677             case JDEP_VARIABLE:
5678               type = TREE_TYPE(decl);
5679               if (TREE_CODE (type) == RECORD_TYPE)
5680                 type = promote_type (type);
5681               JDEP_APPLY_PATCH (dep, type);
5682               break;
5683
5684             case JDEP_TYPE:
5685               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5686               SOURCE_FRONTEND_DEBUG
5687                 (("Completing a random type dependency on a '%s' node",
5688                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5689               break;
5690
5691             case JDEP_EXCEPTION:
5692               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5693               SOURCE_FRONTEND_DEBUG
5694                 (("Completing `%s' `throws' argument node",
5695                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5696               break;
5697
5698             case JDEP_ANONYMOUS:
5699               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5700               break;
5701
5702             default:
5703               abort ();
5704             }
5705         }
5706     }
5707   return;
5708 }
5709
5710 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5711    array.  */
5712
5713 static tree
5714 resolve_class (enclosing, class_type, decl, cl)
5715      tree enclosing, class_type, decl, cl;
5716 {
5717   tree tname = TYPE_NAME (class_type);
5718   tree resolved_type = TREE_TYPE (class_type);
5719   int array_dims = 0;
5720   tree resolved_type_decl;
5721
5722   if (resolved_type != NULL_TREE)
5723     {
5724       tree resolved_type_decl = TYPE_NAME (resolved_type);
5725       if (resolved_type_decl == NULL_TREE
5726           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5727         {
5728           resolved_type_decl = build_decl (TYPE_DECL,
5729                                            TYPE_NAME (class_type),
5730                                            resolved_type);
5731         }
5732       return resolved_type_decl;
5733     }
5734
5735   /* 1- Check to see if we have an array. If true, find what we really
5736      want to resolve  */
5737   if ((array_dims = build_type_name_from_array_name (tname,
5738                                                      &TYPE_NAME (class_type))))
5739     WFL_STRIP_BRACKET (cl, cl);
5740
5741   /* 2- Resolve the bare type */
5742   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5743                                                decl, cl)))
5744     return NULL_TREE;
5745   resolved_type = TREE_TYPE (resolved_type_decl);
5746
5747   /* 3- If we have an array, reconstruct the array down to its nesting */
5748   if (array_dims)
5749     {
5750       for (; array_dims; array_dims--)
5751         resolved_type = build_java_array_type (resolved_type, -1);
5752       resolved_type_decl = TYPE_NAME (resolved_type);
5753     }
5754   TREE_TYPE (class_type) = resolved_type;
5755   return resolved_type_decl;
5756 }
5757
5758 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5759    are used to report error messages. Do not try to replace TYPE_NAME
5760    (class_type) by a variable, since it is changed by
5761    find_in_imports{_on_demand} and (but it doesn't really matter)
5762    qualify_and_find.  */
5763
5764 tree
5765 do_resolve_class (enclosing, class_type, decl, cl)
5766      tree enclosing, class_type, decl, cl;
5767 {
5768   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5769   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5770   tree decl_result;
5771   htab_t circularity_hash;
5772
5773   if (QUALIFIED_P (TYPE_NAME (class_type)))
5774     {
5775       /* If the type name is of the form `Q . Id', then Q is either a
5776          package name or a class name.  First we try to find Q as a
5777          class and then treat Id as a member type.  If we can't find Q
5778          as a class then we fall through.  */
5779       tree q, left, left_type, right;
5780       breakdown_qualified (&left, &right, TYPE_NAME (class_type));
5781       BUILD_PTR_FROM_NAME (left_type, left);
5782       q = do_resolve_class (enclosing, left_type, decl, cl);
5783       if (q)
5784         {
5785           enclosing = q;
5786           saved_enclosing_type = TREE_TYPE (q);
5787           BUILD_PTR_FROM_NAME (class_type, right);
5788         }
5789     }
5790
5791   if (enclosing)
5792     {
5793       /* This hash table is used to register the classes we're going
5794          through when searching the current class as an inner class, in
5795          order to detect circular references. Remember to free it before
5796          returning the section 0- of this function. */
5797       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5798                                       NULL);
5799
5800       /* 0- Search in the current class as an inner class.
5801          Maybe some code here should be added to load the class or
5802          something, at least if the class isn't an inner class and ended
5803          being loaded from class file. FIXME. */
5804       while (enclosing)
5805         {
5806           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5807                                                 &super, class_type);
5808           if (new_class_decl)
5809             break;
5810
5811           /* If we haven't found anything because SUPER reached Object and
5812              ENCLOSING happens to be an innerclass, try the enclosing context. */
5813           if ((!super || super == object_type_node) &&
5814               enclosing && INNER_CLASS_DECL_P (enclosing))
5815             enclosing = DECL_CONTEXT (enclosing);
5816           else
5817             enclosing = NULL_TREE;
5818         }
5819
5820       htab_delete (circularity_hash);
5821
5822       if (new_class_decl)
5823         return new_class_decl;
5824     }
5825
5826   /* 1- Check for the type in single imports. This will change
5827      TYPE_NAME() if something relevant is found */
5828   find_in_imports (saved_enclosing_type, class_type);
5829
5830   /* 2- And check for the type in the current compilation unit */
5831   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5832     {
5833       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5834           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5835         load_class (TYPE_NAME (class_type), 0);
5836       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5837     }
5838
5839   /* 3- Search according to the current package definition */
5840   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5841     {
5842       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5843                                              TYPE_NAME (class_type))))
5844         return new_class_decl;
5845     }
5846
5847   /* 4- Check the import on demands. Don't allow bar.baz to be
5848      imported from foo.* */
5849   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5850     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5851       return NULL_TREE;
5852
5853   /* If found in find_in_imports_on_demand, the type has already been
5854      loaded. */
5855   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5856     return new_class_decl;
5857
5858   /* 5- Try with a name qualified with the package name we've seen so far */
5859   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5860     {
5861       tree package;
5862
5863       /* If there is a current package (ctxp->package), it's the first
5864          element of package_list and we can skip it. */
5865       for (package = (ctxp->package ?
5866                       TREE_CHAIN (package_list) : package_list);
5867            package; package = TREE_CHAIN (package))
5868         if ((new_class_decl = qualify_and_find (class_type,
5869                                                TREE_PURPOSE (package),
5870                                                TYPE_NAME (class_type))))
5871           return new_class_decl;
5872     }
5873
5874   /* 5- Check another compilation unit that bears the name of type */
5875   load_class (TYPE_NAME (class_type), 0);
5876
5877   if (!cl)
5878     cl = lookup_cl (decl);
5879
5880   /* If we don't have a value for CL, then we're being called recursively.
5881      We can't check package access just yet, but it will be taken care of
5882      by the caller. */
5883   if (cl)
5884     {
5885       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5886         return NULL_TREE;
5887     }
5888
5889   /* 6- Last call for a resolution */
5890   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5891
5892   /* The final lookup might have registered a.b.c into a.b$c If we
5893      failed at the first lookup, progressively change the name if
5894      applicable and use the matching DECL instead. */
5895   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5896     {
5897       char *separator;
5898       tree name = TYPE_NAME (class_type);
5899       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5900
5901       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5902
5903       do {
5904
5905        /* Reach the last '.', and if applicable, replace it by a `$' and
5906           see if this exists as a type. */
5907        if ((separator = strrchr (namebuffer, '.')))
5908          {
5909            *separator = '$';
5910            name = get_identifier (namebuffer);
5911            decl_result = IDENTIFIER_CLASS_VALUE (name);
5912          }
5913       } while (!decl_result && separator);
5914     }
5915   return decl_result;
5916 }
5917
5918 static tree
5919 qualify_and_find (class_type, package, name)
5920      tree class_type, package, name;
5921 {
5922   tree new_qualified = merge_qualified_name (package, name);
5923   tree new_class_decl;
5924
5925   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5926     load_class (new_qualified, 0);
5927   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5928     {
5929       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5930           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5931         load_class (new_qualified, 0);
5932       TYPE_NAME (class_type) = new_qualified;
5933       return IDENTIFIER_CLASS_VALUE (new_qualified);
5934     }
5935   return NULL_TREE;
5936 }
5937
5938 /* Resolve NAME and lay it out (if not done and if not the current
5939    parsed class). Return a decl node. This function is meant to be
5940    called when type resolution is necessary during the walk pass.  */
5941
5942 static tree
5943 resolve_and_layout (something, cl)
5944      tree something;
5945      tree cl;
5946 {
5947   tree decl, decl_type;
5948
5949   /* Don't do that on the current class */
5950   if (something == current_class)
5951     return TYPE_NAME (current_class);
5952
5953   /* Don't do anything for void and other primitive types */
5954   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5955     return NULL_TREE;
5956
5957   /* Pointer types can be reall pointer types or fake pointers. When
5958      finding a real pointer, recheck for primitive types */
5959   if (TREE_CODE (something) == POINTER_TYPE)
5960     {
5961       if (TREE_TYPE (something))
5962         {
5963           something = TREE_TYPE (something);
5964           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5965             return NULL_TREE;
5966         }
5967       else
5968         something = TYPE_NAME (something);
5969     }
5970
5971   /* Don't do anything for arrays of primitive types */
5972   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5973       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5974     return NULL_TREE;
5975
5976   /* Something might be a WFL */
5977   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5978     something = EXPR_WFL_NODE (something);
5979
5980   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5981      TYPE_DECL or a real TYPE */
5982   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5983     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5984             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5985
5986   if (!(decl = resolve_no_layout (something, cl)))
5987     return NULL_TREE;
5988
5989   /* Resolve and layout if necessary */
5990   decl_type = TREE_TYPE (decl);
5991   layout_class_methods (decl_type);
5992   /* Check methods */
5993   if (CLASS_FROM_SOURCE_P (decl_type))
5994     java_check_methods (decl);
5995   /* Layout the type if necessary */
5996   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5997     safe_layout_class (decl_type);
5998
5999   return decl;
6000 }
6001
6002 /* Resolve a class, returns its decl but doesn't perform any
6003    layout. The current parsing context is saved and restored */
6004
6005 static tree
6006 resolve_no_layout (name, cl)
6007      tree name, cl;
6008 {
6009   tree ptr, decl;
6010   BUILD_PTR_FROM_NAME (ptr, name);
6011   java_parser_context_save_global ();
6012   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
6013   java_parser_context_restore_global ();
6014
6015   return decl;
6016 }
6017
6018 /* Called when reporting errors. Skip the '[]'s in a complex array
6019    type description that failed to be resolved. purify_type_name can't
6020    use an identifier tree.  */
6021
6022 static const char *
6023 purify_type_name (name)
6024      const char *name;
6025 {
6026   int len = strlen (name);
6027   int bracket_found;
6028
6029   STRING_STRIP_BRACKETS (name, len, bracket_found);
6030   if (bracket_found)
6031     {
6032       char *stripped_name = xmemdup (name, len, len+1);
6033       stripped_name [len] = '\0';
6034       return stripped_name;
6035     }
6036   return name;
6037 }
6038
6039 /* The type CURRENT refers to can't be found. We print error messages.  */
6040
6041 static void
6042 complete_class_report_errors (dep)
6043      jdep *dep;
6044 {
6045   const char *name;
6046
6047   if (!JDEP_WFL (dep))
6048     return;
6049
6050   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6051   switch (JDEP_KIND (dep))
6052     {
6053     case JDEP_SUPER:
6054       parse_error_context
6055         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6056          purify_type_name (name),
6057          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6058       break;
6059     case JDEP_FIELD:
6060       parse_error_context
6061         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6062          purify_type_name (name),
6063          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6064       break;
6065     case JDEP_METHOD:           /* Covers arguments */
6066       parse_error_context
6067         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6068          purify_type_name (name),
6069          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6070          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6071       break;
6072     case JDEP_METHOD_RETURN:    /* Covers return type */
6073       parse_error_context
6074         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6075          purify_type_name (name),
6076          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6077       break;
6078     case JDEP_INTERFACE:
6079       parse_error_context
6080         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6081          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6082          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6083          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6084       break;
6085     case JDEP_VARIABLE:
6086       parse_error_context
6087         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6088          purify_type_name (IDENTIFIER_POINTER
6089                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6090          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6091       break;
6092     case JDEP_EXCEPTION:        /* As specified by `throws' */
6093       parse_error_context
6094           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6095          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6096       break;
6097     default:
6098       /* Fix for -Wall. Just break doing nothing. The error will be
6099          caught later */
6100       break;
6101     }
6102 }
6103
6104 /* Return a static string containing the DECL prototype string. If
6105    DECL is a constructor, use the class name instead of the form
6106    <init> */
6107
6108 static const char *
6109 get_printable_method_name (decl)
6110      tree decl;
6111 {
6112   const char *to_return;
6113   tree name = NULL_TREE;
6114
6115   if (DECL_CONSTRUCTOR_P (decl))
6116     {
6117       name = DECL_NAME (decl);
6118       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6119     }
6120
6121   to_return = lang_printable_name (decl, 0);
6122   if (DECL_CONSTRUCTOR_P (decl))
6123     DECL_NAME (decl) = name;
6124
6125   return to_return;
6126 }
6127
6128 /* Track method being redefined inside the same class. As a side
6129    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6130    function it's a FWL, so we can track errors more accurately.)  */
6131
6132 static int
6133 check_method_redefinition (class, method)
6134      tree class, method;
6135 {
6136   tree redef, sig;
6137
6138   /* There's no need to verify <clinit> and finit$ and instinit$ */
6139   if (DECL_CLINIT_P (method)
6140       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6141     return 0;
6142
6143   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6144   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6145     {
6146       if (redef == method)
6147         break;
6148       if (DECL_NAME (redef) == DECL_NAME (method)
6149           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6150           && !DECL_ARTIFICIAL (method))
6151         {
6152           parse_error_context
6153             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6154              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6155              get_printable_method_name (redef));
6156           return 1;
6157         }
6158     }
6159   return 0;
6160 }
6161
6162 /* Return 1 if check went ok, 0 otherwise.  */
6163 static int
6164 check_abstract_method_definitions (do_interface, class_decl, type)
6165      int do_interface;
6166      tree class_decl, type;
6167 {
6168   tree class = TREE_TYPE (class_decl);
6169   tree method, end_type;
6170   int ok = 1;
6171
6172   end_type = (do_interface ? object_type_node : type);
6173   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6174     {
6175       tree other_super, other_method, method_sig, method_name;
6176       int found = 0;
6177       int end_type_reached = 0;
6178
6179       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6180         continue;
6181
6182       /* Now verify that somewhere in between TYPE and CLASS,
6183          abstract method METHOD gets a non abstract definition
6184          that is inherited by CLASS.  */
6185
6186       method_sig = build_java_signature (TREE_TYPE (method));
6187       method_name = DECL_NAME (method);
6188       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6189         method_name = EXPR_WFL_NODE (method_name);
6190
6191       other_super = class;
6192       do {
6193         if (other_super == end_type)
6194           end_type_reached = 1;
6195
6196         /* Method search */
6197         for (other_method = TYPE_METHODS (other_super); other_method;
6198             other_method = TREE_CHAIN (other_method))
6199           {
6200             tree s = build_java_signature (TREE_TYPE (other_method));
6201             tree other_name = DECL_NAME (other_method);
6202
6203             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6204               other_name = EXPR_WFL_NODE (other_name);
6205             if (!DECL_CLINIT_P (other_method)
6206                 && !DECL_CONSTRUCTOR_P (other_method)
6207                 && method_name == other_name
6208                 && method_sig == s
6209                 && !METHOD_ABSTRACT (other_method))
6210              {
6211                found = 1;
6212                break;
6213              }
6214           }
6215         other_super = CLASSTYPE_SUPER (other_super);
6216       } while (!end_type_reached);
6217
6218       /* Report that abstract METHOD didn't find an implementation
6219          that CLASS can use. */
6220       if (!found)
6221         {
6222           char *t = xstrdup (lang_printable_name
6223                             (TREE_TYPE (TREE_TYPE (method)), 0));
6224           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6225
6226           parse_error_context
6227             (lookup_cl (class_decl),
6228              "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",
6229              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6230              t, lang_printable_name (method, 0),
6231              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6232               "interface" : "class"),
6233              IDENTIFIER_POINTER (ccn),
6234              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6235              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6236           ok = 0;
6237           free (t);
6238         }
6239     }
6240
6241   if (ok && do_interface)
6242     {
6243       /* Check for implemented interfaces. */
6244       int i;
6245       tree vector = TYPE_BINFO_BASETYPES (type);
6246       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6247         {
6248           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6249           ok = check_abstract_method_definitions (1, class_decl, super);
6250         }
6251     }
6252
6253   return ok;
6254 }
6255
6256 /* Check that CLASS_DECL somehow implements all inherited abstract
6257    methods.  */
6258
6259 static void
6260 java_check_abstract_method_definitions (class_decl)
6261      tree class_decl;
6262 {
6263   tree class = TREE_TYPE (class_decl);
6264   tree super, vector;
6265   int i;
6266
6267   if (CLASS_ABSTRACT (class_decl))
6268     return;
6269
6270   /* Check for inherited types */
6271   super = class;
6272   do {
6273     super = CLASSTYPE_SUPER (super);
6274     check_abstract_method_definitions (0, class_decl, super);
6275   } while (super != object_type_node);
6276
6277   /* Check for implemented interfaces. */
6278   vector = TYPE_BINFO_BASETYPES (class);
6279   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6280     {
6281       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6282       check_abstract_method_definitions (1, class_decl, super);
6283     }
6284 }
6285
6286 /* Check all the types method DECL uses and return 1 if all of them
6287    are now complete, 0 otherwise. This is used to check whether its
6288    safe to build a method signature or not.  */
6289
6290 static int
6291 check_method_types_complete (decl)
6292      tree decl;
6293 {
6294   tree type = TREE_TYPE (decl);
6295   tree args;
6296
6297   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6298     return 0;
6299
6300   args = TYPE_ARG_TYPES (type);
6301   if (TREE_CODE (type) == METHOD_TYPE)
6302     args = TREE_CHAIN (args);
6303   for (; args != end_params_node; args = TREE_CHAIN (args))
6304     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6305       return 0;
6306
6307   return 1;
6308 }
6309
6310 /* Visible interface to check methods contained in CLASS_DECL */
6311
6312 void
6313 java_check_methods (class_decl)
6314      tree class_decl;
6315 {
6316   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6317     return;
6318
6319   if (CLASS_INTERFACE (class_decl))
6320     java_check_abstract_methods (class_decl);
6321   else
6322     java_check_regular_methods (class_decl);
6323
6324   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6325 }
6326
6327 /* Check all the methods of CLASS_DECL. Methods are first completed
6328    then checked according to regular method existence rules.  If no
6329    constructor for CLASS_DECL were encountered, then build its
6330    declaration.  */
6331
6332 static void
6333 java_check_regular_methods (class_decl)
6334      tree class_decl;
6335 {
6336   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6337   tree method;
6338   tree class = TREE_TYPE (class_decl);
6339   tree found = NULL_TREE;
6340   tree mthrows;
6341
6342   /* It is not necessary to check methods defined in java.lang.Object */
6343   if (class == object_type_node)
6344     return;
6345
6346   if (!TYPE_NVIRTUALS (class))
6347     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6348
6349   /* Should take interfaces into account. FIXME */
6350   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6351     {
6352       tree sig;
6353       tree method_wfl = DECL_FUNCTION_WFL (method);
6354       int aflags;
6355
6356       /* Check for redefinitions */
6357       if (check_method_redefinition (class, method))
6358         continue;
6359
6360       /* If we see one constructor a mark so we don't generate the
6361          default one. Also skip other verifications: constructors
6362          can't be inherited hence hiden or overriden */
6363      if (DECL_CONSTRUCTOR_P (method))
6364        {
6365          saw_constructor = 1;
6366          continue;
6367        }
6368
6369       /* We verify things thrown by the method. They must inherits from
6370          java.lang.Throwable */
6371       for (mthrows = DECL_FUNCTION_THROWS (method);
6372            mthrows; mthrows = TREE_CHAIN (mthrows))
6373         {
6374           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6375             parse_error_context
6376               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6377                IDENTIFIER_POINTER
6378                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6379         }
6380
6381       sig = build_java_argument_signature (TREE_TYPE (method));
6382       found = lookup_argument_method2 (class, DECL_NAME (method), sig);
6383
6384       /* Inner class can't declare static methods */
6385       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6386         {
6387           char *t = xstrdup (lang_printable_name (class, 0));
6388           parse_error_context
6389             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6390              lang_printable_name (method, 0), t);
6391           free (t);
6392         }
6393
6394       /* Nothing overrides or it's a private method. */
6395       if (!found)
6396         continue;
6397       if (METHOD_PRIVATE (found))
6398         {
6399           found = NULL_TREE;
6400           continue;
6401         }
6402
6403       /* If `found' is declared in an interface, make sure the
6404          modifier matches. */
6405       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6406           && clinit_identifier_node != DECL_NAME (found)
6407           && !METHOD_PUBLIC (method))
6408         {
6409           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6410           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6411                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6412                                lang_printable_name (method, 0),
6413                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6414         }
6415
6416       /* Can't override a method with the same name and different return
6417          types. */
6418       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6419         {
6420           char *t = xstrdup
6421             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6422           parse_error_context
6423             (method_wfl,
6424              "Method `%s' was defined with return type `%s' in class `%s'",
6425              lang_printable_name (found, 0), t,
6426              IDENTIFIER_POINTER
6427                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6428           free (t);
6429         }
6430
6431       aflags = get_access_flags_from_decl (found);
6432
6433       /* Can't override final. Can't override static. */
6434       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6435         {
6436           /* Static *can* override static */
6437           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6438             continue;
6439           parse_error_context
6440             (method_wfl,
6441              "%s methods can't be overriden. Method `%s' is %s in class `%s'",
6442              (METHOD_FINAL (found) ? "Final" : "Static"),
6443              lang_printable_name (found, 0),
6444              (METHOD_FINAL (found) ? "final" : "static"),
6445              IDENTIFIER_POINTER
6446                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6447           continue;
6448         }
6449
6450       /* Static method can't override instance method. */
6451       if (METHOD_STATIC (method))
6452         {
6453           parse_error_context
6454             (method_wfl,
6455              "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
6456              lang_printable_name (found, 0),
6457              IDENTIFIER_POINTER
6458                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6459           continue;
6460         }
6461
6462       /* - Overriding/hiding public must be public
6463          - Overriding/hiding protected must be protected or public
6464          - If the overriden or hidden method has default (package)
6465            access, then the overriding or hiding method must not be
6466            private; otherwise, a compile-time error occurs.  If
6467            `found' belongs to an interface, things have been already
6468            taken care of.  */
6469       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6470           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6471               || (METHOD_PROTECTED (found)
6472                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6473               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6474                   && METHOD_PRIVATE (method))))
6475         {
6476           parse_error_context
6477             (method_wfl,
6478              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6479              (METHOD_PUBLIC (method) ? "public" :
6480               (METHOD_PRIVATE (method) ? "private" : "protected")),
6481              IDENTIFIER_POINTER (DECL_NAME
6482                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6483           continue;
6484         }
6485
6486       /* Overriding methods must have compatible `throws' clauses on checked
6487          exceptions, if any */
6488       check_throws_clauses (method, method_wfl, found);
6489
6490       /* Inheriting multiple methods with the same signature. FIXME */
6491     }
6492
6493   if (!TYPE_NVIRTUALS (class))
6494     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6495
6496   /* Search for inherited abstract method not yet implemented in this
6497      class.  */
6498   java_check_abstract_method_definitions (class_decl);
6499
6500   if (!saw_constructor)
6501     abort ();
6502 }
6503
6504 /* Return a nonzero value if the `throws' clause of METHOD (if any)
6505    is incompatible with the `throws' clause of FOUND (if any).  */
6506
6507 static void
6508 check_throws_clauses (method, method_wfl, found)
6509      tree method, method_wfl, found;
6510 {
6511   tree mthrows, fthrows;
6512
6513   /* Can't check these things with class loaded from bytecode. FIXME */
6514   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6515     return;
6516
6517   for (mthrows = DECL_FUNCTION_THROWS (method);
6518        mthrows; mthrows = TREE_CHAIN (mthrows))
6519     {
6520       /* We don't verify unchecked expressions */
6521       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6522         continue;
6523       /* Checked expression must be compatible */
6524       for (fthrows = DECL_FUNCTION_THROWS (found);
6525            fthrows; fthrows = TREE_CHAIN (fthrows))
6526         if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6527           break;
6528       if (!fthrows)
6529         {
6530           parse_error_context
6531             (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'",
6532              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6533              lang_printable_name (found, 0),
6534              IDENTIFIER_POINTER
6535                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6536         }
6537     }
6538 }
6539
6540 /* Check abstract method of interface INTERFACE */
6541
6542 static void
6543 java_check_abstract_methods (interface_decl)
6544      tree interface_decl;
6545 {
6546   int i, n;
6547   tree method, basetype_vec, found;
6548   tree interface = TREE_TYPE (interface_decl);
6549
6550   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6551     {
6552       /* 2- Check for double definition inside the defining interface */
6553       if (check_method_redefinition (interface, method))
6554         continue;
6555
6556       /* 3- Overriding is OK as far as we preserve the return type and
6557          the thrown exceptions (FIXME) */
6558       found = lookup_java_interface_method2 (interface, method);
6559       if (found)
6560         {
6561           char *t;
6562           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6563           parse_error_context
6564             (DECL_FUNCTION_WFL (found),
6565              "Method `%s' was defined with return type `%s' in class `%s'",
6566              lang_printable_name (found, 0), t,
6567              IDENTIFIER_POINTER
6568                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6569           free (t);
6570           continue;
6571         }
6572     }
6573
6574   /* 4- Inherited methods can't differ by their returned types */
6575   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6576     return;
6577   n = TREE_VEC_LENGTH (basetype_vec);
6578   for (i = 0; i < n; i++)
6579     {
6580       tree sub_interface_method, sub_interface;
6581       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6582       if (!vec_elt)
6583         continue;
6584       sub_interface = BINFO_TYPE (vec_elt);
6585       for (sub_interface_method = TYPE_METHODS (sub_interface);
6586            sub_interface_method;
6587            sub_interface_method = TREE_CHAIN (sub_interface_method))
6588         {
6589           found = lookup_java_interface_method2 (interface,
6590                                                  sub_interface_method);
6591           if (found && (found != sub_interface_method))
6592             {
6593               parse_error_context
6594                 (lookup_cl (sub_interface_method),
6595                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6596                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6597                  lang_printable_name (found, 0),
6598                  IDENTIFIER_POINTER
6599                    (DECL_NAME (TYPE_NAME
6600                                (DECL_CONTEXT (sub_interface_method)))),
6601                  IDENTIFIER_POINTER
6602                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6603             }
6604         }
6605     }
6606 }
6607
6608 /* Lookup methods in interfaces using their name and partial
6609    signature. Return a matching method only if their types differ.  */
6610
6611 static tree
6612 lookup_java_interface_method2 (class, method_decl)
6613      tree class, method_decl;
6614 {
6615   int i, n;
6616   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6617
6618   if (!basetype_vec)
6619     return NULL_TREE;
6620
6621   n = TREE_VEC_LENGTH (basetype_vec);
6622   for (i = 0; i < n; i++)
6623     {
6624       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6625       if ((BINFO_TYPE (vec_elt) != object_type_node)
6626           && (to_return =
6627               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6628         return to_return;
6629     }
6630   for (i = 0; i < n; i++)
6631     {
6632       to_return = lookup_java_interface_method2
6633         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6634       if (to_return)
6635         return to_return;
6636     }
6637
6638   return NULL_TREE;
6639 }
6640
6641 /* Lookup method using their name and partial signature. Return a
6642    matching method only if their types differ.  */
6643
6644 static tree
6645 lookup_java_method2 (clas, method_decl, do_interface)
6646      tree clas, method_decl;
6647      int do_interface;
6648 {
6649   tree method, method_signature, method_name, method_type, name;
6650
6651   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6652   name = DECL_NAME (method_decl);
6653   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6654                  EXPR_WFL_NODE (name) : name);
6655   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6656
6657   while (clas != NULL_TREE)
6658     {
6659       for (method = TYPE_METHODS (clas);
6660            method != NULL_TREE;  method = TREE_CHAIN (method))
6661         {
6662           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6663           tree name = DECL_NAME (method);
6664           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6665                EXPR_WFL_NODE (name) : name) == method_name
6666               && method_sig == method_signature
6667               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6668             return method;
6669         }
6670       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6671     }
6672   return NULL_TREE;
6673 }
6674
6675 /* Return the line that matches DECL line number, and try its best to
6676    position the column number. Used during error reports.  */
6677
6678 static GTY(()) tree cl_v;
6679 static tree
6680 lookup_cl (decl)
6681      tree decl;
6682 {
6683   char *line, *found;
6684
6685   if (!decl)
6686     return NULL_TREE;
6687
6688   if (cl_v == NULL_TREE)
6689     {
6690       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6691     }
6692
6693   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6694   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE_FIRST (decl), -1);
6695
6696   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6697                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6698
6699   found = strstr ((const char *)line,
6700                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6701   if (found)
6702     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6703
6704   return cl_v;
6705 }
6706
6707 /* Look for a simple name in the single-type import list */
6708
6709 static tree
6710 find_name_in_single_imports (name)
6711      tree name;
6712 {
6713   tree node;
6714
6715   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6716     if (TREE_VALUE (node) == name)
6717       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6718
6719   return NULL_TREE;
6720 }
6721
6722 /* Process all single-type import. */
6723
6724 static int
6725 process_imports ()
6726 {
6727   tree import;
6728   int error_found;
6729
6730   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6731     {
6732       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6733       char *original_name;
6734
6735       obstack_grow0 (&temporary_obstack,
6736                      IDENTIFIER_POINTER (to_be_found),
6737                      IDENTIFIER_LENGTH (to_be_found));
6738       original_name = obstack_finish (&temporary_obstack);
6739
6740       /* Don't load twice something already defined. */
6741       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6742         continue;
6743
6744       while (1)
6745         {
6746           tree left;
6747
6748           QUALIFIED_P (to_be_found) = 1;
6749           load_class (to_be_found, 0);
6750           error_found =
6751             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6752
6753           /* We found it, we can bail out */
6754           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6755             break;
6756
6757           /* We haven't found it. Maybe we're trying to access an
6758              inner class.  The only way for us to know is to try again
6759              after having dropped a qualifier. If we can't break it further,
6760              we have an error. */
6761           if (breakdown_qualified (&left, NULL, to_be_found))
6762             break;
6763
6764           to_be_found = left;
6765         }
6766       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6767         {
6768           parse_error_context (TREE_PURPOSE (import),
6769                                "Class or interface `%s' not found in import",
6770                                original_name);
6771           error_found = 1;
6772         }
6773
6774       obstack_free (&temporary_obstack, original_name);
6775       if (error_found)
6776         return 1;
6777     }
6778   return 0;
6779 }
6780
6781 /* Possibly find and mark a class imported by a single-type import
6782    statement.  */
6783
6784 static void
6785 find_in_imports (enclosing_type, class_type)
6786      tree enclosing_type;
6787      tree class_type;
6788 {
6789   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6790                  ctxp->import_list);
6791   while (import)
6792     {
6793       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6794         {
6795           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6796           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6797           return;
6798         }
6799       import = TREE_CHAIN (import);
6800     }
6801 }
6802
6803 static int
6804 note_possible_classname (name, len)
6805      const char *name;
6806      int len;
6807 {
6808   tree node;
6809   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6810     len = len - 5;
6811   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6812     len = len - 6;
6813   else
6814     return 0;
6815   node = ident_subst (name, len, "", '/', '.', "");
6816   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6817   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6818   return 1;
6819 }
6820
6821 /* Read a import directory, gathering potential match for further type
6822    references. Indifferently reads a filesystem or a ZIP archive
6823    directory.  */
6824
6825 static void
6826 read_import_dir (wfl)
6827      tree wfl;
6828 {
6829   tree package_id = EXPR_WFL_NODE (wfl);
6830   const char *package_name = IDENTIFIER_POINTER (package_id);
6831   int package_length = IDENTIFIER_LENGTH (package_id);
6832   DIR *dirp = NULL;
6833   JCF *saved_jcf = current_jcf;
6834
6835   int found = 0;
6836   int k;
6837   void *entry;
6838   struct buffer filename[1];
6839
6840   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6841     return;
6842   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6843
6844   BUFFER_INIT (filename);
6845   buffer_grow (filename, package_length + 100);
6846
6847   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6848     {
6849       const char *entry_name = jcf_path_name (entry);
6850       int entry_length = strlen (entry_name);
6851       if (jcf_path_is_zipfile (entry))
6852         {
6853           ZipFile *zipf;
6854           buffer_grow (filename, entry_length);
6855           memcpy (filename->data, entry_name, entry_length - 1);
6856           filename->data[entry_length-1] = '\0';
6857           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6858           if (zipf == NULL)
6859             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6860           else
6861             {
6862               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6863               BUFFER_RESET (filename);
6864               for (k = 0; k < package_length; k++)
6865                 {
6866                   char ch = package_name[k];
6867                   *filename->ptr++ = ch == '.' ? '/' : ch;
6868                 }
6869               *filename->ptr++ = '/';
6870
6871               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6872                 {
6873                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6874                   int current_entry_len = zipd->filename_length;
6875
6876                   if (current_entry_len >= BUFFER_LENGTH (filename)
6877                       && strncmp (filename->data, current_entry,
6878                                   BUFFER_LENGTH (filename)) != 0)
6879                     continue;
6880                   found |= note_possible_classname (current_entry,
6881                                                     current_entry_len);
6882                 }
6883             }
6884         }
6885       else
6886         {
6887           BUFFER_RESET (filename);
6888           buffer_grow (filename, entry_length + package_length + 4);
6889           strcpy (filename->data, entry_name);
6890           filename->ptr = filename->data + entry_length;
6891           for (k = 0; k < package_length; k++)
6892             {
6893               char ch = package_name[k];
6894               *filename->ptr++ = ch == '.' ? '/' : ch;
6895             }
6896           *filename->ptr = '\0';
6897
6898           dirp = opendir (filename->data);
6899           if (dirp == NULL)
6900             continue;
6901           *filename->ptr++ = '/';
6902           for (;;)
6903             {
6904               int len;
6905               const char *d_name;
6906               struct dirent *direntp = readdir (dirp);
6907               if (!direntp)
6908                 break;
6909               d_name = direntp->d_name;
6910               len = strlen (direntp->d_name);
6911               buffer_grow (filename, len+1);
6912               strcpy (filename->ptr, d_name);
6913               found |= note_possible_classname (filename->data + entry_length,
6914                                                 package_length+len+1);
6915             }
6916           if (dirp)
6917             closedir (dirp);
6918         }
6919     }
6920
6921   free (filename->data);
6922
6923   /* Here we should have a unified way of retrieving an entry, to be
6924      indexed. */
6925   if (!found)
6926     {
6927       static int first = 1;
6928       if (first)
6929         {
6930           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6931           java_error_count++;
6932           first = 0;
6933         }
6934       else
6935         parse_error_context (wfl, "Package `%s' not found in import",
6936                              package_name);
6937       current_jcf = saved_jcf;
6938       return;
6939     }
6940   current_jcf = saved_jcf;
6941 }
6942
6943 /* Possibly find a type in the import on demands specified
6944    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6945    entire list, to detected potential double definitions.  */
6946
6947 static int
6948 find_in_imports_on_demand (enclosing_type, class_type)
6949      tree enclosing_type;
6950      tree class_type;
6951 {
6952   tree class_type_name = TYPE_NAME (class_type);
6953   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
6954                   ctxp->import_demand_list);
6955   tree cl = NULL_TREE;
6956   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
6957   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
6958   tree node;
6959
6960   for (; import; import = TREE_CHAIN (import))
6961     {
6962       int saved_lineno = lineno;
6963       int access_check;
6964       const char *id_name;
6965       tree decl, type_name_copy;
6966
6967       obstack_grow (&temporary_obstack,
6968                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6969                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6970       obstack_1grow (&temporary_obstack, '.');
6971       obstack_grow0 (&temporary_obstack,
6972                      IDENTIFIER_POINTER (class_type_name),
6973                      IDENTIFIER_LENGTH (class_type_name));
6974       id_name = obstack_finish (&temporary_obstack);
6975
6976       if (! (node = maybe_get_identifier (id_name)))
6977         continue;
6978
6979       /* Setup lineno so that it refers to the line of the import (in
6980          case we parse a class file and encounter errors */
6981       lineno = EXPR_WFL_LINENO (TREE_PURPOSE (import));
6982
6983       type_name_copy = TYPE_NAME (class_type);
6984       TYPE_NAME (class_type) = node;
6985       QUALIFIED_P (node) = 1;
6986       decl = IDENTIFIER_CLASS_VALUE (node);
6987       access_check = -1;
6988       /* If there is no DECL set for the class or if the class isn't
6989          loaded and not seen in source yet, then load */
6990       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
6991                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
6992         {
6993           load_class (node, 0);
6994           decl = IDENTIFIER_CLASS_VALUE (node);
6995         }
6996       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
6997         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
6998                                                false);
6999       else
7000         /* 6.6.1: Inner classes are subject to member access rules. */
7001         access_check = 0;
7002
7003       lineno = saved_lineno;
7004
7005       /* If the loaded class is not accessible or couldn't be loaded,
7006          we restore the original TYPE_NAME and process the next
7007          import. */
7008       if (access_check || !decl)
7009         {
7010           TYPE_NAME (class_type) = type_name_copy;
7011           continue;
7012         }
7013
7014       /* If the loaded class is accessible, we keep a tab on it to
7015          detect and report multiple inclusions. */
7016       if (IS_A_CLASSFILE_NAME (node))
7017         {
7018           if (seen_once < 0)
7019             {
7020               cl = TREE_PURPOSE (import);
7021               seen_once = 1;
7022             }
7023           else if (seen_once >= 0)
7024             {
7025               tree location = (cl ? cl : TREE_PURPOSE (import));
7026               tree package = (cl ? EXPR_WFL_NODE (cl) :
7027                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7028               seen_once++;
7029               parse_error_context
7030                 (location,
7031                  "Type `%s' also potentially defined in package `%s'",
7032                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7033                  IDENTIFIER_POINTER (package));
7034             }
7035         }
7036       to_return = access_check;
7037     }
7038
7039   if (seen_once == 1)
7040     return to_return;
7041   else
7042     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7043 }
7044
7045 /* Add package NAME to the list of packages encountered so far. To
7046    speed up class lookup in do_resolve_class, we make sure a
7047    particular package is added only once.  */
7048
7049 static void
7050 register_package (name)
7051      tree name;
7052 {
7053   static htab_t pht;
7054   PTR *e;
7055
7056   if (pht == NULL)
7057     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7058
7059   e = htab_find_slot (pht, name, INSERT);
7060   if (*e == NULL)
7061     {
7062       package_list = chainon (package_list, build_tree_list (name, NULL));
7063       *e = name;
7064     }
7065 }
7066
7067 static tree
7068 resolve_package (pkg, next, type_name)
7069      tree pkg, *next, *type_name;
7070 {
7071   tree current;
7072   tree decl = NULL_TREE;
7073   *type_name = NULL_TREE;
7074
7075   /* The trick is to determine when the package name stops and were
7076      the name of something contained in the package starts. Then we
7077      return a fully qualified name of what we want to get. */
7078
7079   *next = EXPR_WFL_QUALIFICATION (pkg);
7080
7081   /* Try to progressively construct a type name */
7082   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7083     for (current = EXPR_WFL_QUALIFICATION (pkg);
7084          current; current = TREE_CHAIN (current))
7085       {
7086         /* If we don't have what we're expecting, exit now. TYPE_NAME
7087            will be null and the error caught later. */
7088         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7089           break;
7090         *type_name =
7091           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7092         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7093           {
7094             /* resolve_package should be used in a loop, hence we
7095                point at this one to naturally process the next one at
7096                the next iteration. */
7097             *next = current;
7098             break;
7099           }
7100       }
7101   return decl;
7102 }
7103
7104
7105 /* Check accessibility of inner classes according to member access rules.
7106    DECL is the inner class, ENCLOSING_DECL is the class from which the
7107    access is being attempted. */
7108
7109 static void
7110 check_inner_class_access (decl, enclosing_decl, cl)
7111      tree decl, enclosing_decl, cl;
7112 {
7113   const char *access;
7114   tree enclosing_decl_type;
7115
7116   /* We don't issue an error message when CL is null. CL can be null
7117      as a result of processing a JDEP crafted by source_start_java_method
7118      for the purpose of patching its parm decl. But the error would
7119      have been already trapped when fixing the method's signature.
7120      DECL can also be NULL in case of earlier errors. */
7121   if (!decl || !cl)
7122     return;
7123
7124   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7125
7126   if (CLASS_PRIVATE (decl))
7127     {
7128       /* Access is permitted only within the body of the top-level
7129          class in which DECL is declared. */
7130       tree top_level = decl;
7131       while (DECL_CONTEXT (top_level))
7132         top_level = DECL_CONTEXT (top_level);
7133       while (DECL_CONTEXT (enclosing_decl))
7134         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7135       if (top_level == enclosing_decl)
7136         return;
7137       access = "private";
7138     }
7139   else if (CLASS_PROTECTED (decl))
7140     {
7141       tree decl_context;
7142       /* Access is permitted from within the same package... */
7143       if (in_same_package (decl, enclosing_decl))
7144         return;
7145
7146       /* ... or from within the body of a subtype of the context in which
7147          DECL is declared. */
7148       decl_context = DECL_CONTEXT (decl);
7149       while (enclosing_decl)
7150         {
7151           if (CLASS_INTERFACE (decl))
7152             {
7153               if (interface_of_p (TREE_TYPE (decl_context),
7154                                   enclosing_decl_type))
7155                 return;
7156             }
7157           else
7158             {
7159               /* Eww. The order of the arguments is different!! */
7160               if (inherits_from_p (enclosing_decl_type,
7161                                    TREE_TYPE (decl_context)))
7162                 return;
7163             }
7164           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7165         }
7166       access = "protected";
7167     }
7168   else if (! CLASS_PUBLIC (decl))
7169     {
7170       /* Access is permitted only from within the same package as DECL. */
7171       if (in_same_package (decl, enclosing_decl))
7172         return;
7173       access = "non-public";
7174     }
7175   else
7176     /* Class is public. */
7177     return;
7178
7179   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7180                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7181                        lang_printable_name (decl, 0), access);
7182 }
7183
7184 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7185    foreign package, it must be PUBLIC. Return 0 if no access
7186    violations were found, 1 otherwise. If VERBOSE is true and an error
7187    was found, it is reported and accounted for.  */
7188
7189 static int
7190 check_pkg_class_access (class_name, cl, verbose)
7191      tree class_name;
7192      tree cl;
7193      bool verbose;
7194 {
7195   tree type;
7196
7197   if (!IDENTIFIER_CLASS_VALUE (class_name))
7198     return 0;
7199
7200   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7201     return 0;
7202
7203   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7204     {
7205       /* Access to a private class within the same package is
7206          allowed. */
7207       tree l, r;
7208       breakdown_qualified (&l, &r, class_name);
7209       if (!QUALIFIED_P (class_name) && !ctxp->package)
7210         /* Both in the empty package. */
7211         return 0;
7212       if (l == ctxp->package)
7213         /* Both in the same package. */
7214         return 0;
7215
7216       if (verbose)
7217         parse_error_context
7218           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7219            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7220            IDENTIFIER_POINTER (class_name));
7221       return 1;
7222     }
7223   return 0;
7224 }
7225
7226 /* Local variable declaration. */
7227
7228 static void
7229 declare_local_variables (modifier, type, vlist)
7230      int modifier;
7231      tree type;
7232      tree vlist;
7233 {
7234   tree decl, current, saved_type;
7235   tree type_wfl = NULL_TREE;
7236   int must_chain = 0;
7237   int final_p = 0;
7238
7239   /* Push a new block if statements were seen between the last time we
7240      pushed a block and now. Keep a count of blocks to close */
7241   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7242     {
7243       tree b = enter_block ();
7244       BLOCK_IS_IMPLICIT (b) = 1;
7245     }
7246
7247   if (modifier)
7248     {
7249       size_t i;
7250       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7251         if (1 << i & modifier)
7252           break;
7253       if (modifier == ACC_FINAL)
7254         final_p = 1;
7255       else
7256         {
7257           parse_error_context
7258             (ctxp->modifier_ctx [i],
7259              "Only `final' is allowed as a local variables modifier");
7260           return;
7261         }
7262     }
7263
7264   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7265      hold the TYPE value if a new incomplete has to be created (as
7266      opposed to being found already existing and reused). */
7267   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7268
7269   /* If TYPE is fully resolved and we don't have a reference, make one */
7270   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7271
7272   /* Go through all the declared variables */
7273   for (current = vlist, saved_type = type; current;
7274        current = TREE_CHAIN (current), type = saved_type)
7275     {
7276       tree other, real_type;
7277       tree wfl  = TREE_PURPOSE (current);
7278       tree name = EXPR_WFL_NODE (wfl);
7279       tree init = TREE_VALUE (current);
7280
7281       /* Process NAME, as it may specify extra dimension(s) for it */
7282       type = build_array_from_name (type, type_wfl, name, &name);
7283
7284       /* Variable redefinition check */
7285       if ((other = lookup_name_in_blocks (name)))
7286         {
7287           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7288                                        DECL_SOURCE_LINE (other));
7289           continue;
7290         }
7291
7292       /* Type adjustment. We may have just readjusted TYPE because
7293          the variable specified more dimensions. Make sure we have
7294          a reference if we can and don't have one already. */
7295       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7296
7297       real_type = GET_REAL_TYPE (type);
7298       /* Never layout this decl. This will be done when its scope
7299          will be entered */
7300       decl = build_decl (VAR_DECL, name, real_type);
7301       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7302       DECL_FINAL (decl) = final_p;
7303       BLOCK_CHAIN_DECL (decl);
7304
7305       /* If doing xreferencing, replace the line number with the WFL
7306          compound value */
7307       if (flag_emit_xref)
7308         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7309
7310       /* Don't try to use an INIT statement when an error was found */
7311       if (init && java_error_count)
7312         init = NULL_TREE;
7313
7314       /* Add the initialization function to the current function's code */
7315       if (init)
7316         {
7317           /* Name might have been readjusted */
7318           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7319           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7320           java_method_add_stmt (current_function_decl,
7321                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7322                                                       init));
7323         }
7324
7325       /* Setup dependency the type of the decl */
7326       if (must_chain)
7327         {
7328           jdep *dep;
7329           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7330           dep = CLASSD_LAST (ctxp->classd_list);
7331           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7332         }
7333     }
7334   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7335 }
7336
7337 /* Called during parsing. Build decls from argument list.  */
7338
7339 static void
7340 source_start_java_method (fndecl)
7341      tree fndecl;
7342 {
7343   tree tem;
7344   tree parm_decl;
7345   int i;
7346
7347   if (!fndecl)
7348     return;
7349
7350   current_function_decl = fndecl;
7351
7352   /* New scope for the function */
7353   enter_block ();
7354   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7355        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7356     {
7357       tree type = TREE_VALUE (tem);
7358       tree name = TREE_PURPOSE (tem);
7359
7360       /* If type is incomplete. Create an incomplete decl and ask for
7361          the decl to be patched later */
7362       if (INCOMPLETE_TYPE_P (type))
7363         {
7364           jdep *jdep;
7365           tree real_type = GET_REAL_TYPE (type);
7366           parm_decl = build_decl (PARM_DECL, name, real_type);
7367           type = obtain_incomplete_type (type);
7368           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7369           jdep = CLASSD_LAST (ctxp->classd_list);
7370           JDEP_MISC (jdep) = name;
7371           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7372         }
7373       else
7374         parm_decl = build_decl (PARM_DECL, name, type);
7375
7376       /* Remember if a local variable was declared final (via its
7377          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7378       if (ARG_FINAL_P (tem))
7379         {
7380           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7381           DECL_FINAL (parm_decl) = 1;
7382         }
7383
7384       BLOCK_CHAIN_DECL (parm_decl);
7385     }
7386   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7387   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7388     nreverse (tem);
7389   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7390   DECL_MAX_LOCALS (current_function_decl) = i;
7391 }
7392
7393 /* Called during parsing. Creates an artificial method declaration.  */
7394
7395 static tree
7396 create_artificial_method (class, flags, type, name, args)
7397      tree class;
7398      int flags;
7399      tree type, name, args;
7400 {
7401   tree mdecl;
7402
7403   java_parser_context_save_global ();
7404   lineno = 0;
7405   mdecl = make_node (FUNCTION_TYPE);
7406   TREE_TYPE (mdecl) = type;
7407   TYPE_ARG_TYPES (mdecl) = args;
7408   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7409   java_parser_context_restore_global ();
7410   DECL_ARTIFICIAL (mdecl) = 1;
7411   return mdecl;
7412 }
7413
7414 /* Starts the body if an artificial method.  */
7415
7416 static void
7417 start_artificial_method_body (mdecl)
7418      tree mdecl;
7419 {
7420   DECL_SOURCE_LINE (mdecl) = 1;
7421   DECL_SOURCE_LINE_MERGE (mdecl, 1);
7422   source_start_java_method (mdecl);
7423   enter_block ();
7424 }
7425
7426 static void
7427 end_artificial_method_body (mdecl)
7428      tree mdecl;
7429 {
7430   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7431      It has to be evaluated first. (if mdecl is current_function_decl,
7432      we have an undefined behavior if no temporary variable is used.) */
7433   tree b = exit_block ();
7434   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7435   exit_block ();
7436 }
7437
7438 /* Dump a tree of some kind.  This is a convenience wrapper for the
7439    dump_* functions in tree-dump.c.  */
7440 static void
7441 dump_java_tree (phase, t)
7442      enum tree_dump_index phase;
7443      tree t;
7444 {
7445   FILE *stream;
7446   int flags;
7447
7448   stream = dump_begin (phase, &flags);
7449   flags |= TDF_SLIM;
7450   if (stream)
7451     {
7452       dump_node (t, flags, stream);
7453       dump_end (phase, stream);
7454     }
7455 }
7456
7457 /* Terminate a function and expand its body.  */
7458
7459 static void
7460 source_end_java_method ()
7461 {
7462   tree fndecl = current_function_decl;
7463
7464   if (!fndecl)
7465     return;
7466
7467   java_parser_context_save_global ();
7468   lineno = ctxp->last_ccb_indent1;
7469
7470   /* Turn function bodies with only a NOP expr null, so they don't get
7471      generated at all and we won't get warnings when using the -W
7472      -Wall flags. */
7473   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7474     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7475
7476   /* We've generated all the trees for this function, and it has been
7477      patched.  Dump it to a file if the user requested it.  */
7478   dump_java_tree (TDI_original, fndecl);
7479
7480   java_optimize_inline (fndecl);
7481
7482   /* Generate function's code */
7483   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7484       && ! flag_emit_class_files
7485       && ! flag_emit_xref)
7486     expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
7487
7488   /* pop out of its parameters */
7489   pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7490   poplevel (1, 0, 1);
7491   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7492
7493   /* Generate rtl for function exit.  */
7494   if (! flag_emit_class_files && ! flag_emit_xref)
7495     {
7496       lineno = DECL_SOURCE_LINE_LAST (fndecl);
7497       expand_function_end (input_filename, lineno, 0);
7498
7499       DECL_SOURCE_LINE (fndecl) = DECL_SOURCE_LINE_FIRST (fndecl);
7500
7501       /* Run the optimizers and output assembler code for this function. */
7502       rest_of_compilation (fndecl);
7503     }
7504
7505   current_function_decl = NULL_TREE;
7506   java_parser_context_restore_global ();
7507 }
7508
7509 /* Record EXPR in the current function block. Complements compound
7510    expression second operand if necessary.  */
7511
7512 tree
7513 java_method_add_stmt (fndecl, expr)
7514      tree fndecl, expr;
7515 {
7516   if (!GET_CURRENT_BLOCK (fndecl))
7517     return NULL_TREE;
7518   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7519 }
7520
7521 static tree
7522 add_stmt_to_block (b, type, stmt)
7523      tree b, type, stmt;
7524 {
7525   tree body = BLOCK_EXPR_BODY (b), c;
7526
7527   if (java_error_count)
7528     return body;
7529
7530   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7531     return body;
7532
7533   BLOCK_EXPR_BODY (b) = c;
7534   TREE_SIDE_EFFECTS (c) = 1;
7535   return c;
7536 }
7537
7538 /* Add STMT to EXISTING if possible, otherwise create a new
7539    COMPOUND_EXPR and add STMT to it. */
7540
7541 static tree
7542 add_stmt_to_compound (existing, type, stmt)
7543      tree existing, type, stmt;
7544 {
7545   /* Keep track of this for inlining.  */
7546   if (current_function_decl)
7547     ++DECL_NUM_STMTS (current_function_decl);
7548
7549   if (existing)
7550     return build (COMPOUND_EXPR, type, existing, stmt);
7551   else
7552     return stmt;
7553 }
7554
7555 void java_layout_seen_class_methods ()
7556 {
7557   tree previous_list = all_class_list;
7558   tree end = NULL_TREE;
7559   tree current;
7560
7561   while (1)
7562     {
7563       for (current = previous_list;
7564            current != end; current = TREE_CHAIN (current))
7565         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7566
7567       if (previous_list != all_class_list)
7568         {
7569           end = previous_list;
7570           previous_list = all_class_list;
7571         }
7572       else
7573         break;
7574     }
7575 }
7576
7577 static GTY(()) tree stop_reordering;
7578 void
7579 java_reorder_fields ()
7580 {
7581   tree current;
7582
7583   for (current = gclass_list; current; current = TREE_CHAIN (current))
7584     {
7585       current_class = TREE_TYPE (TREE_VALUE (current));
7586
7587       if (current_class == stop_reordering)
7588         break;
7589
7590       /* Reverse the fields, but leave the dummy field in front.
7591          Fields are already ordered for Object and Class */
7592       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7593           && current_class != class_type_node)
7594       {
7595         /* If the dummy field is there, reverse the right fields and
7596            just layout the type for proper fields offset */
7597         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7598           {
7599             tree fields = TYPE_FIELDS (current_class);
7600             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7601             TYPE_SIZE (current_class) = NULL_TREE;
7602           }
7603         /* We don't have a dummy field, we need to layout the class,
7604            after having reversed the fields */
7605         else
7606           {
7607             TYPE_FIELDS (current_class) =
7608               nreverse (TYPE_FIELDS (current_class));
7609             TYPE_SIZE (current_class) = NULL_TREE;
7610           }
7611       }
7612     }
7613   /* There are cases were gclass_list will be empty. */
7614   if (gclass_list)
7615     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7616 }
7617
7618 /* Layout the methods of all classes loaded in one way or another.
7619    Check methods of source parsed classes. Then reorder the
7620    fields and layout the classes or the type of all source parsed
7621    classes */
7622
7623 void
7624 java_layout_classes ()
7625 {
7626   tree current;
7627   int save_error_count = java_error_count;
7628
7629   /* Layout the methods of all classes seen so far */
7630   java_layout_seen_class_methods ();
7631   java_parse_abort_on_error ();
7632   all_class_list = NULL_TREE;
7633
7634   /* Then check the methods of all parsed classes */
7635   for (current = gclass_list; current; current = TREE_CHAIN (current))
7636     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7637       java_check_methods (TREE_VALUE (current));
7638   java_parse_abort_on_error ();
7639
7640   for (current = gclass_list; current; current = TREE_CHAIN (current))
7641     {
7642       current_class = TREE_TYPE (TREE_VALUE (current));
7643       layout_class (current_class);
7644
7645       /* Error reported by the caller */
7646       if (java_error_count)
7647         return;
7648     }
7649
7650   /* We might have reloaded classes durign the process of laying out
7651      classes for code generation. We must layout the methods of those
7652      late additions, as constructor checks might use them */
7653   java_layout_seen_class_methods ();
7654   java_parse_abort_on_error ();
7655 }
7656
7657 /* Expand methods in the current set of classes rememebered for
7658    generation.  */
7659
7660 static void
7661 java_complete_expand_classes ()
7662 {
7663   tree current;
7664
7665   do_not_fold = flag_emit_xref;
7666
7667   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7668     if (!INNER_CLASS_DECL_P (current))
7669       java_complete_expand_class (current);
7670 }
7671
7672 /* Expand the methods found in OUTER, starting first by OUTER's inner
7673    classes, if any.  */
7674
7675 static void
7676 java_complete_expand_class (outer)
7677      tree outer;
7678 {
7679   tree inner_list;
7680
7681   set_nested_class_simple_name_value (outer, 1); /* Set */
7682
7683   /* We need to go after all inner classes and start expanding them,
7684      starting with most nested ones. We have to do that because nested
7685      classes might add functions to outer classes */
7686
7687   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7688        inner_list; inner_list = TREE_CHAIN (inner_list))
7689     java_complete_expand_class (TREE_PURPOSE (inner_list));
7690
7691   java_complete_expand_methods (outer);
7692   set_nested_class_simple_name_value (outer, 0); /* Reset */
7693 }
7694
7695 /* Expand methods registered in CLASS_DECL. The general idea is that
7696    we expand regular methods first. This allows us get an estimate on
7697    how outer context local alias fields are really used so we can add
7698    to the constructor just enough code to initialize them properly (it
7699    also lets us generate finit$ correctly.) Then we expand the
7700    constructors and then <clinit>.  */
7701
7702 static void
7703 java_complete_expand_methods (class_decl)
7704      tree class_decl;
7705 {
7706   tree clinit, decl, first_decl;
7707
7708   current_class = TREE_TYPE (class_decl);
7709
7710   /* Initialize a new constant pool */
7711   init_outgoing_cpool ();
7712
7713   /* Pre-expand <clinit> to figure whether we really need it or
7714      not. If we do need it, we pre-expand the static fields so they're
7715      ready to be used somewhere else. <clinit> will be fully expanded
7716      after we processed the constructors. */
7717   first_decl = TYPE_METHODS (current_class);
7718   clinit = maybe_generate_pre_expand_clinit (current_class);
7719
7720   /* Then generate finit$ (if we need to) because constructors will
7721    try to use it.*/
7722   if (TYPE_FINIT_STMT_LIST (current_class))
7723     java_complete_expand_method (generate_finit (current_class));
7724
7725   /* Then generate instinit$ (if we need to) because constructors will
7726      try to use it. */
7727   if (TYPE_II_STMT_LIST (current_class))
7728     java_complete_expand_method (generate_instinit (current_class));
7729
7730   /* Now do the constructors */
7731   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7732     {
7733       int no_body;
7734
7735       if (!DECL_CONSTRUCTOR_P (decl))
7736         continue;
7737
7738       no_body = !DECL_FUNCTION_BODY (decl);
7739       /* Don't generate debug info on line zero when expanding a
7740          generated constructor. */
7741       if (no_body)
7742         restore_line_number_status (1);
7743
7744       java_complete_expand_method (decl);
7745
7746       if (no_body)
7747         restore_line_number_status (0);
7748     }
7749
7750   /* First, do the ordinary methods. */
7751   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7752     {
7753       /* Ctors aren't part of this batch. */
7754       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7755         continue;
7756
7757       /* Skip abstract or native methods -- but do handle native
7758          methods when generating JNI stubs.  */
7759       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7760         {
7761           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7762           continue;
7763         }
7764
7765       if (METHOD_NATIVE (decl))
7766         {
7767           tree body;
7768           current_function_decl = decl;
7769           body = build_jni_stub (decl);
7770           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7771         }
7772
7773       java_complete_expand_method (decl);
7774     }
7775
7776   /* If there is indeed a <clinit>, fully expand it now */
7777   if (clinit)
7778     {
7779       /* Prevent the use of `this' inside <clinit> */
7780       ctxp->explicit_constructor_p = 1;
7781       java_complete_expand_method (clinit);
7782       ctxp->explicit_constructor_p = 0;
7783     }
7784
7785   /* We might have generated a class$ that we now want to expand */
7786   if (TYPE_DOT_CLASS (current_class))
7787     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7788
7789   /* Now verify constructor circularity (stop after the first one we
7790      prove wrong.) */
7791   if (!CLASS_INTERFACE (class_decl))
7792     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7793       if (DECL_CONSTRUCTOR_P (decl)
7794           && verify_constructor_circularity (decl, decl))
7795         break;
7796
7797   /* Save the constant pool. We'll need to restore it later. */
7798   TYPE_CPOOL (current_class) = outgoing_cpool;
7799 }
7800
7801 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7802    safely used in some other methods/constructors.  */
7803
7804 static tree
7805 maybe_generate_pre_expand_clinit (class_type)
7806      tree class_type;
7807 {
7808   tree current, mdecl;
7809
7810   if (!TYPE_CLINIT_STMT_LIST (class_type))
7811     return NULL_TREE;
7812
7813   /* Go through all static fields and pre expand them */
7814   for (current = TYPE_FIELDS (class_type); current;
7815        current = TREE_CHAIN (current))
7816     if (FIELD_STATIC (current))
7817       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7818
7819   /* Then build the <clinit> method */
7820   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7821                                     clinit_identifier_node, end_params_node);
7822   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7823                        mdecl, NULL_TREE);
7824   start_artificial_method_body (mdecl);
7825
7826   /* We process the list of assignment we produced as the result of
7827      the declaration of initialized static field and add them as
7828      statement to the <clinit> method. */
7829   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7830        current = TREE_CHAIN (current))
7831     {
7832       tree stmt = current;
7833       /* We build the assignment expression that will initialize the
7834          field to its value. There are strict rules on static
7835          initializers (8.5). FIXME */
7836       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7837         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7838       java_method_add_stmt (mdecl, stmt);
7839     }
7840
7841   end_artificial_method_body (mdecl);
7842
7843   /* Now we want to place <clinit> as the last method (because we need
7844      it at least for interface so that it doesn't interfere with the
7845      dispatch table based lookup. */
7846   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7847     {
7848       current = TREE_CHAIN (TYPE_METHODS (class_type));
7849       TYPE_METHODS (class_type) = current;
7850
7851       while (TREE_CHAIN (current))
7852         current = TREE_CHAIN (current);
7853
7854       TREE_CHAIN (current) = mdecl;
7855       TREE_CHAIN (mdecl) = NULL_TREE;
7856     }
7857
7858   return mdecl;
7859 }
7860
7861 /* Analyzes a method body and look for something that isn't a
7862    MODIFY_EXPR with a constant value.  */
7863
7864 static int
7865 analyze_clinit_body (this_class, bbody)
7866      tree this_class, bbody;
7867 {
7868   while (bbody)
7869     switch (TREE_CODE (bbody))
7870       {
7871       case BLOCK:
7872         bbody = BLOCK_EXPR_BODY (bbody);
7873         break;
7874
7875       case EXPR_WITH_FILE_LOCATION:
7876         bbody = EXPR_WFL_NODE (bbody);
7877         break;
7878
7879       case COMPOUND_EXPR:
7880         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7881           return 1;
7882         bbody = TREE_OPERAND (bbody, 1);
7883         break;
7884
7885       case MODIFY_EXPR:
7886         /* If we're generating to class file and we're dealing with an
7887            array initialization, we return 1 to keep <clinit> */
7888         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7889             && flag_emit_class_files)
7890           return 1;
7891
7892         /* There are a few cases where we're required to keep
7893            <clinit>:
7894            - If this is an assignment whose operand is not constant,
7895            - If this is an assignment to a non-initialized field,
7896            - If this field is not a member of the current class.
7897         */
7898         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7899                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7900                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7901
7902       default:
7903         return 1;
7904       }
7905   return 0;
7906 }
7907
7908
7909 /* See whether we could get rid of <clinit>. Criteria are: all static
7910    final fields have constant initial values and the body of <clinit>
7911    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7912
7913 static int
7914 maybe_yank_clinit (mdecl)
7915      tree mdecl;
7916 {
7917   tree type, current;
7918   tree fbody, bbody;
7919
7920   if (!DECL_CLINIT_P (mdecl))
7921     return 0;
7922
7923   /* If the body isn't empty, then we keep <clinit>. Note that if
7924      we're emitting classfiles, this isn't enough not to rule it
7925      out. */
7926   fbody = DECL_FUNCTION_BODY (mdecl);
7927   bbody = BLOCK_EXPR_BODY (fbody);
7928   if (bbody && bbody != error_mark_node)
7929     bbody = BLOCK_EXPR_BODY (bbody);
7930   else
7931     return 0;
7932   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7933     return 0;
7934
7935   type = DECL_CONTEXT (mdecl);
7936   current = TYPE_FIELDS (type);
7937
7938   for (current = (current ? TREE_CHAIN (current) : current);
7939        current; current = TREE_CHAIN (current))
7940     {
7941       tree f_init;
7942
7943       /* We're not interested in non-static fields.  */
7944       if (!FIELD_STATIC (current))
7945         continue;
7946
7947       /* Nor in fields without initializers. */
7948       f_init = DECL_INITIAL (current);
7949       if (f_init == NULL_TREE)
7950         continue;
7951
7952       /* Anything that isn't String or a basic type is ruled out -- or
7953          if we know how to deal with it (when doing things natively) we
7954          should generated an empty <clinit> so that SUID are computed
7955          correctly. */
7956       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7957           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7958         return 0;
7959
7960       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7961         return 0;
7962     }
7963
7964   /* Now we analyze the method body and look for something that
7965      isn't a MODIFY_EXPR */
7966   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7967     return 0;
7968
7969   /* Get rid of <clinit> in the class' list of methods */
7970   if (TYPE_METHODS (type) == mdecl)
7971     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7972   else
7973     for (current = TYPE_METHODS (type); current;
7974          current = TREE_CHAIN (current))
7975       if (TREE_CHAIN (current) == mdecl)
7976         {
7977           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7978           break;
7979         }
7980
7981   return 1;
7982 }
7983
7984 /* Install the argument from MDECL. Suitable to completion and
7985    expansion of mdecl's body.  */
7986
7987 static void
7988 start_complete_expand_method (mdecl)
7989      tree mdecl;
7990 {
7991   tree tem;
7992
7993   pushlevel (1);                /* Prepare for a parameter push */
7994   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7995   DECL_ARGUMENTS (mdecl) = tem;
7996
7997   for (; tem; tem = TREE_CHAIN (tem))
7998     {
7999       /* TREE_CHAIN (tem) will change after pushdecl. */
8000       tree next = TREE_CHAIN (tem);
8001       tree type = TREE_TYPE (tem);
8002       if (PROMOTE_PROTOTYPES
8003           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8004           && INTEGRAL_TYPE_P (type))
8005         type = integer_type_node;
8006       DECL_ARG_TYPE (tem) = type;
8007       layout_decl (tem, 0);
8008       pushdecl (tem);
8009       /* Re-install the next so that the list is kept and the loop
8010          advances. */
8011       TREE_CHAIN (tem) = next;
8012     }
8013   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8014   lineno = DECL_SOURCE_LINE_FIRST (mdecl);
8015   build_result_decl (mdecl);
8016 }
8017
8018
8019 /* Complete and expand a method.  */
8020
8021 static void
8022 java_complete_expand_method (mdecl)
8023      tree mdecl;
8024 {
8025   tree fbody, block_body, exception_copy;
8026
8027   current_function_decl = mdecl;
8028   /* Fix constructors before expanding them */
8029   if (DECL_CONSTRUCTOR_P (mdecl))
8030     fix_constructors (mdecl);
8031
8032   /* Expand functions that have a body */
8033   if (!DECL_FUNCTION_BODY (mdecl))
8034     return;
8035
8036   fbody = DECL_FUNCTION_BODY (mdecl);
8037   block_body = BLOCK_EXPR_BODY (fbody);
8038   exception_copy = NULL_TREE;
8039
8040   current_function_decl = mdecl;
8041
8042   if (! quiet_flag)
8043     fprintf (stderr, " [%s.",
8044              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8045   announce_function (mdecl);
8046   if (! quiet_flag)
8047     fprintf (stderr, "]");
8048
8049   /* Prepare the function for tree completion */
8050   start_complete_expand_method (mdecl);
8051
8052   /* Install the current this */
8053   current_this = (!METHOD_STATIC (mdecl) ?
8054                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8055
8056   /* Purge the `throws' list of unchecked exceptions (we save a copy
8057      of the list and re-install it later.) */
8058   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8059   purge_unchecked_exceptions (mdecl);
8060
8061   /* Install exceptions thrown with `throws' */
8062   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8063
8064   if (block_body != NULL_TREE)
8065     {
8066       block_body = java_complete_tree (block_body);
8067
8068       /* Before we check initialization, attached all class initialization
8069          variable to the block_body */
8070       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8071                      attach_init_test_initialization_flags, block_body);
8072
8073       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8074         {
8075           check_for_initialization (block_body, mdecl);
8076
8077           /* Go through all the flags marking the initialization of
8078              static variables and see whether they're definitively
8079              assigned, in which case the type is remembered as
8080              definitively initialized in MDECL. */
8081           if (STATIC_CLASS_INIT_OPT_P ())
8082             {
8083               /* Always register the context as properly initialized in
8084                  MDECL. This used with caution helps removing extra
8085                  initialization of self. */
8086               if (METHOD_STATIC (mdecl))
8087                 {
8088                   *(htab_find_slot
8089                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8090                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8091                 }
8092             }
8093         }
8094       ctxp->explicit_constructor_p = 0;
8095     }
8096
8097   BLOCK_EXPR_BODY (fbody) = block_body;
8098
8099   /* If we saw a return but couldn't evaluate it properly, we'll have
8100      an error_mark_node here. */
8101   if (block_body != error_mark_node
8102       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8103       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8104       && !flag_emit_xref)
8105     missing_return_error (current_function_decl);
8106
8107   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8108   maybe_yank_clinit (mdecl);
8109
8110   /* Pop the current level, with special measures if we found errors. */
8111   if (java_error_count)
8112     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8113   poplevel (1, 0, 1);
8114
8115   /* Pop the exceptions and sanity check */
8116   POP_EXCEPTIONS();
8117   if (currently_caught_type_list)
8118     abort ();
8119
8120   /* Restore the copy of the list of exceptions if emitting xrefs. */
8121   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8122 }
8123
8124 /* For with each class for which there's code to generate. */
8125
8126 static void
8127 java_expand_method_bodies (class)
8128      tree class;
8129 {
8130   tree decl;
8131   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8132     {
8133       if (!DECL_FUNCTION_BODY (decl))
8134         continue;
8135
8136       current_function_decl = decl;
8137
8138       /* Save the function for inlining.  */
8139       if (flag_inline_trees)
8140         DECL_SAVED_TREE (decl) =
8141           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8142
8143       /* It's time to assign the variable flagging static class
8144          initialization based on which classes invoked static methods
8145          are definitely initializing. This should be flagged. */
8146       if (STATIC_CLASS_INIT_OPT_P ())
8147         {
8148           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8149           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8150             {
8151               /* Executed for each statement calling a static function.
8152                  LIST is a TREE_LIST whose PURPOSE is the called function
8153                  and VALUE is a compound whose second operand can be patched
8154                  with static class initialization flag assignments.  */
8155
8156               tree called_method = TREE_PURPOSE (list);
8157               tree compound = TREE_VALUE (list);
8158               tree assignment_compound_list
8159                 = build_tree_list (called_method, NULL);
8160
8161               /* For each class definitely initialized in
8162                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8163                  assignment to the class initialization flag. */
8164               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8165                              emit_test_initialization,
8166                              assignment_compound_list);
8167
8168               if (TREE_VALUE (assignment_compound_list))
8169                 TREE_OPERAND (compound, 1)
8170                   = TREE_VALUE (assignment_compound_list);
8171             }
8172         }
8173
8174       /* Prepare the function for RTL expansion */
8175       start_complete_expand_method (decl);
8176
8177       /* Expand function start, generate initialization flag
8178          assignment, and handle synchronized methods. */
8179       complete_start_java_method (decl);
8180
8181       /* Expand the rest of the function body and terminate
8182          expansion. */
8183       source_end_java_method ();
8184     }
8185 }
8186
8187 \f
8188
8189 /* This section of the code deals with accessing enclosing context
8190    fields either directly by using the relevant access to this$<n> or
8191    by invoking an access method crafted for that purpose.  */
8192
8193 /* Build the necessary access from an inner class to an outer
8194    class. This routine could be optimized to cache previous result
8195    (decl, current_class and returned access).  When an access method
8196    needs to be generated, it always takes the form of a read. It might
8197    be later turned into a write by calling outer_field_access_fix.  */
8198
8199 static tree
8200 build_outer_field_access (id, decl)
8201      tree id, decl;
8202 {
8203   tree access = NULL_TREE;
8204   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8205   tree decl_ctx = DECL_CONTEXT (decl);
8206
8207   /* If the immediate enclosing context of the current class is the
8208      field decl's class or inherits from it; build the access as
8209      `this$<n>.<field>'. Note that we will break the `private' barrier
8210      if we're not emitting bytecodes. */
8211   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8212       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8213     {
8214       tree thisn = build_current_thisn (current_class);
8215       access = make_qualified_primary (build_wfl_node (thisn),
8216                                        id, EXPR_WFL_LINECOL (id));
8217     }
8218   /* Otherwise, generate access methods to outer this and access the
8219      field (either using an access method or by direct access.) */
8220   else
8221     {
8222       int lc = EXPR_WFL_LINECOL (id);
8223
8224       /* Now we chain the required number of calls to the access$0 to
8225          get a hold to the enclosing instance we need, and then we
8226          build the field access. */
8227       access = build_access_to_thisn (current_class, decl_ctx, lc);
8228
8229       /* If the field is private and we're generating bytecode, then
8230          we generate an access method */
8231       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8232         {
8233           tree name = build_outer_field_access_methods (decl);
8234           access = build_outer_field_access_expr (lc, decl_ctx,
8235                                                   name, access, NULL_TREE);
8236         }
8237       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8238          Once again we break the `private' access rule from a foreign
8239          class. */
8240       else
8241         access = make_qualified_primary (access, id, lc);
8242     }
8243   return resolve_expression_name (access, NULL);
8244 }
8245
8246 /* Return a nonzero value if NODE describes an outer field inner
8247    access.  */
8248
8249 static int
8250 outer_field_access_p (type, decl)
8251     tree type, decl;
8252 {
8253   if (!INNER_CLASS_TYPE_P (type)
8254       || TREE_CODE (decl) != FIELD_DECL
8255       || DECL_CONTEXT (decl) == type)
8256     return 0;
8257
8258   /* If the inner class extends the declaration context of the field
8259      we're try to acces, then this isn't an outer field access */
8260   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8261     return 0;
8262
8263   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8264        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8265     {
8266       if (type == DECL_CONTEXT (decl))
8267         return 1;
8268
8269       if (!DECL_CONTEXT (TYPE_NAME (type)))
8270         {
8271           /* Before we give up, see whether the field is inherited from
8272              the enclosing context we're considering. */
8273           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8274             return 1;
8275           break;
8276         }
8277     }
8278
8279   return 0;
8280 }
8281
8282 /* Return a nonzero value if NODE represents an outer field inner
8283    access that was been already expanded. As a side effect, it returns
8284    the name of the field being accessed and the argument passed to the
8285    access function, suitable for a regeneration of the access method
8286    call if necessary. */
8287
8288 static int
8289 outer_field_expanded_access_p (node, name, arg_type, arg)
8290     tree node, *name, *arg_type, *arg;
8291 {
8292   int identified = 0;
8293
8294   if (TREE_CODE (node) != CALL_EXPR)
8295     return 0;
8296
8297   /* Well, gcj generates slightly different tree nodes when compiling
8298      to native or bytecodes. It's the case for function calls. */
8299
8300   if (flag_emit_class_files
8301       && TREE_CODE (node) == CALL_EXPR
8302       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8303     identified = 1;
8304   else if (!flag_emit_class_files)
8305     {
8306       node = TREE_OPERAND (node, 0);
8307
8308       if (node && TREE_OPERAND (node, 0)
8309           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8310         {
8311           node = TREE_OPERAND (node, 0);
8312           if (TREE_OPERAND (node, 0)
8313               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8314               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8315                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8316             identified = 1;
8317         }
8318     }
8319
8320   if (identified && name && arg_type && arg)
8321     {
8322       tree argument = TREE_OPERAND (node, 1);
8323       *name = DECL_NAME (TREE_OPERAND (node, 0));
8324       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8325       *arg = TREE_VALUE (argument);
8326     }
8327   return identified;
8328 }
8329
8330 /* Detect in NODE an outer field read access from an inner class and
8331    transform it into a write with RHS as an argument. This function is
8332    called from the java_complete_lhs when an assignment to a LHS can
8333    be identified. */
8334
8335 static tree
8336 outer_field_access_fix (wfl, node, rhs)
8337     tree wfl, node, rhs;
8338 {
8339   tree name, arg_type, arg;
8340
8341   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8342     {
8343       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8344                                             arg_type, name, arg, rhs);
8345       return java_complete_tree (node);
8346     }
8347   return NULL_TREE;
8348 }
8349
8350 /* Construct the expression that calls an access method:
8351      <type>.access$<n>(<arg1> [, <arg2>]);
8352
8353    ARG2 can be NULL and will be omitted in that case. It will denote a
8354    read access.  */
8355
8356 static tree
8357 build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
8358     int lc;
8359     tree type, access_method_name, arg1, arg2;
8360 {
8361   tree args, cn, access;
8362
8363   args = arg1 ? arg1 :
8364     build_wfl_node (build_current_thisn (current_class));
8365   args = build_tree_list (NULL_TREE, args);
8366
8367   if (arg2)
8368     args = tree_cons (NULL_TREE, arg2, args);
8369
8370   access = build_method_invocation (build_wfl_node (access_method_name), args);
8371   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8372   return make_qualified_primary (cn, access, lc);
8373 }
8374
8375 static tree
8376 build_new_access_id ()
8377 {
8378   static int access_n_counter = 1;
8379   char buffer [128];
8380
8381   sprintf (buffer, "access$%d", access_n_counter++);
8382   return get_identifier (buffer);
8383 }
8384
8385 /* Create the static access functions for the outer field DECL. We define a
8386    read:
8387      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8388        return inst$.field;
8389      }
8390    and a write access:
8391      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8392                                      TREE_TYPE (<field>) value$) {
8393        return inst$.field = value$;
8394      }
8395    We should have a usage flags on the DECL so we can lazily turn the ones
8396    we're using for code generation. FIXME.
8397 */
8398
8399 static tree
8400 build_outer_field_access_methods (decl)
8401     tree decl;
8402 {
8403   tree id, args, stmt, mdecl;
8404
8405   if (FIELD_INNER_ACCESS_P (decl))
8406     return FIELD_INNER_ACCESS (decl);
8407
8408   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8409
8410   /* Create the identifier and a function named after it. */
8411   id = build_new_access_id ();
8412
8413   /* The identifier is marked as bearing the name of a generated write
8414      access function for outer field accessed from inner classes. */
8415   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8416
8417   /* Create the read access */
8418   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8419   TREE_CHAIN (args) = end_params_node;
8420   stmt = make_qualified_primary (build_wfl_node (inst_id),
8421                                  build_wfl_node (DECL_NAME (decl)), 0);
8422   stmt = build_return (0, stmt);
8423   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8424                                            TREE_TYPE (decl), id, args, stmt);
8425   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8426
8427   /* Create the write access method. No write access for final variable */
8428   if (!FIELD_FINAL (decl))
8429     {
8430       args = build_tree_list (inst_id,
8431                               build_pointer_type (DECL_CONTEXT (decl)));
8432       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8433       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8434       stmt = make_qualified_primary (build_wfl_node (inst_id),
8435                                      build_wfl_node (DECL_NAME (decl)), 0);
8436       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8437                                                 build_wfl_node (wpv_id)));
8438       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8439                                                TREE_TYPE (decl), id,
8440                                                args, stmt);
8441     }
8442   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8443
8444   /* Return the access name */
8445   return FIELD_INNER_ACCESS (decl) = id;
8446 }
8447
8448 /* Build an field access method NAME.  */
8449
8450 static tree
8451 build_outer_field_access_method (class, type, name, args, body)
8452     tree class, type, name, args, body;
8453 {
8454   tree saved_current_function_decl, mdecl;
8455
8456   /* Create the method */
8457   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8458   fix_method_argument_names (args, mdecl);
8459   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8460
8461   /* Attach the method body. */
8462   saved_current_function_decl = current_function_decl;
8463   start_artificial_method_body (mdecl);
8464   java_method_add_stmt (mdecl, body);
8465   end_artificial_method_body (mdecl);
8466   current_function_decl = saved_current_function_decl;
8467
8468   return mdecl;
8469 }
8470
8471 \f
8472 /* This section deals with building access function necessary for
8473    certain kinds of method invocation from inner classes.  */
8474
8475 static tree
8476 build_outer_method_access_method (decl)
8477     tree decl;
8478 {
8479   tree saved_current_function_decl, mdecl;
8480   tree args = NULL_TREE, call_args = NULL_TREE;
8481   tree carg, id, body, class;
8482   char buffer [80];
8483   int parm_id_count = 0;
8484
8485   /* Test this abort with an access to a private field */
8486   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8487     abort ();
8488
8489   /* Check the cache first */
8490   if (DECL_FUNCTION_INNER_ACCESS (decl))
8491     return DECL_FUNCTION_INNER_ACCESS (decl);
8492
8493   class = DECL_CONTEXT (decl);
8494
8495   /* Obtain an access identifier and mark it */
8496   id = build_new_access_id ();
8497   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8498
8499   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8500   /* Create the arguments, as much as the original */
8501   for (; carg && carg != end_params_node;
8502        carg = TREE_CHAIN (carg))
8503     {
8504       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8505       args = chainon (args, build_tree_list (get_identifier (buffer),
8506                                              TREE_VALUE (carg)));
8507     }
8508   args = chainon (args, end_params_node);
8509
8510   /* Create the method */
8511   mdecl = create_artificial_method (class, ACC_STATIC,
8512                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8513   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8514   /* There is a potential bug here. We should be able to use
8515      fix_method_argument_names, but then arg names get mixed up and
8516      eventually a constructor will have its this$0 altered and the
8517      outer context won't be assignment properly. The test case is
8518      stub.java FIXME */
8519   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8520
8521   /* Attach the method body. */
8522   saved_current_function_decl = current_function_decl;
8523   start_artificial_method_body (mdecl);
8524
8525   /* The actual method invocation uses the same args. When invoking a
8526      static methods that way, we don't want to skip the first
8527      argument. */
8528   carg = args;
8529   if (!METHOD_STATIC (decl))
8530     carg = TREE_CHAIN (carg);
8531   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8532     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8533                            call_args);
8534
8535   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8536                                   call_args);
8537   if (!METHOD_STATIC (decl))
8538     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8539                                    body, 0);
8540   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8541     body = build_return (0, body);
8542   java_method_add_stmt (mdecl,body);
8543   end_artificial_method_body (mdecl);
8544   current_function_decl = saved_current_function_decl;
8545
8546   /* Back tag the access function so it know what it accesses */
8547   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8548
8549   /* Tag the current method so it knows it has an access generated */
8550   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8551 }
8552
8553 \f
8554 /* This section of the code deals with building expressions to access
8555    the enclosing instance of an inner class. The enclosing instance is
8556    kept in a generated field called this$<n>, with <n> being the
8557    inner class nesting level (starting from 0.)  */
8558
8559 /* Build an access to a given this$<n>, always chaining access call to
8560    others. Access methods to this$<n> are build on the fly if
8561    necessary. This CAN'T be used to solely access this$<n-1> from
8562    this$<n> (which alway yield to special cases and optimization, see
8563    for example build_outer_field_access).  */
8564
8565 static tree
8566 build_access_to_thisn (from, to, lc)
8567      tree from, to;
8568      int lc;
8569 {
8570   tree access = NULL_TREE;
8571
8572   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8573     {
8574       if (!access)
8575         {
8576           access = build_current_thisn (from);
8577           access = build_wfl_node (access);
8578         }
8579       else
8580         {
8581           tree access0_wfl, cn;
8582
8583           maybe_build_thisn_access_method (from);
8584           access0_wfl = build_wfl_node (access0_identifier_node);
8585           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8586           EXPR_WFL_LINECOL (access0_wfl) = lc;
8587           access = build_tree_list (NULL_TREE, access);
8588           access = build_method_invocation (access0_wfl, access);
8589           access = make_qualified_primary (cn, access, lc);
8590         }
8591
8592       /* If FROM isn't an inner class, that's fine, we've done enough.
8593          What we're looking for can be accessed from there.  */
8594       from = DECL_CONTEXT (TYPE_NAME (from));
8595       if (!from)
8596         break;
8597       from = TREE_TYPE (from);
8598     }
8599   return access;
8600 }
8601
8602 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8603    is returned if nothing needs to be generated. Otherwise, the method
8604    generated and a method decl is returned.
8605
8606    NOTE: These generated methods should be declared in a class file
8607    attribute so that they can't be referred to directly.  */
8608
8609 static tree
8610 maybe_build_thisn_access_method (type)
8611     tree type;
8612 {
8613   tree mdecl, args, stmt, rtype;
8614   tree saved_current_function_decl;
8615
8616   /* If TYPE is a top-level class, no access method is required.
8617      If there already is such an access method, bail out. */
8618   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8619     return NULL_TREE;
8620
8621   /* We generate the method. The method looks like:
8622      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8623   */
8624   args = build_tree_list (inst_id, build_pointer_type (type));
8625   TREE_CHAIN (args) = end_params_node;
8626   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8627   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8628                                     access0_identifier_node, args);
8629   fix_method_argument_names (args, mdecl);
8630   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8631   stmt = build_current_thisn (type);
8632   stmt = make_qualified_primary (build_wfl_node (inst_id),
8633                                  build_wfl_node (stmt), 0);
8634   stmt = build_return (0, stmt);
8635
8636   saved_current_function_decl = current_function_decl;
8637   start_artificial_method_body (mdecl);
8638   java_method_add_stmt (mdecl, stmt);
8639   end_artificial_method_body (mdecl);
8640   current_function_decl = saved_current_function_decl;
8641
8642   CLASS_ACCESS0_GENERATED_P (type) = 1;
8643
8644   return mdecl;
8645 }
8646
8647 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8648    the first level of innerclassing. this$1 for the next one, etc...
8649    This function can be invoked with TYPE to NULL, available and then
8650    has to count the parser context.  */
8651
8652 static GTY(()) tree saved_thisn;
8653 static GTY(()) tree saved_type;
8654
8655 static tree
8656 build_current_thisn (type)
8657     tree type;
8658 {
8659   static int saved_i = -1;
8660   static int saved_type_i = 0;
8661   tree decl;
8662   char buffer [24];
8663   int i = 0;
8664
8665   if (type)
8666     {
8667       if (type == saved_type)
8668         i = saved_type_i;
8669       else
8670         {
8671           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8672                decl; decl = DECL_CONTEXT (decl), i++)
8673             ;
8674
8675           saved_type = type;
8676           saved_type_i = i;
8677         }
8678     }
8679   else
8680     i = list_length (GET_CPC_LIST ())-2;
8681
8682   if (i == saved_i)
8683     return saved_thisn;
8684
8685   sprintf (buffer, "this$%d", i);
8686   saved_i = i;
8687   saved_thisn = get_identifier (buffer);
8688   return saved_thisn;
8689 }
8690
8691 /* Return the assignement to the hidden enclosing context `this$<n>'
8692    by the second incoming parameter to the innerclass constructor. The
8693    form used is `this.this$<n> = this$<n>;'.  */
8694
8695 static tree
8696 build_thisn_assign ()
8697 {
8698   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8699     {
8700       tree thisn = build_current_thisn (current_class);
8701       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8702                                          build_wfl_node (thisn), 0);
8703       tree rhs = build_wfl_node (thisn);
8704       EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
8705       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8706     }
8707   return NULL_TREE;
8708 }
8709
8710 \f
8711 /* Building the synthetic `class$' used to implement the `.class' 1.1
8712    extension for non primitive types. This method looks like:
8713
8714     static Class class$(String type) throws NoClassDefFoundError
8715     {
8716       try {return (java.lang.Class.forName (String));}
8717       catch (ClassNotFoundException e) {
8718         throw new NoClassDefFoundError(e.getMessage());}
8719     } */
8720
8721 static GTY(()) tree get_message_wfl;
8722 static GTY(()) tree type_parm_wfl;
8723
8724 static tree
8725 build_dot_class_method (class)
8726      tree class;
8727 {
8728 #define BWF(S) build_wfl_node (get_identifier ((S)))
8729 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8730   tree args, tmp, saved_current_function_decl, mdecl;
8731   tree stmt, throw_stmt;
8732
8733   if (!get_message_wfl)
8734     {
8735       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8736       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8737     }
8738
8739   /* Build the arguments */
8740   args = build_tree_list (get_identifier ("type$"),
8741                           build_pointer_type (string_type_node));
8742   TREE_CHAIN (args) = end_params_node;
8743
8744   /* Build the qualified name java.lang.Class.forName */
8745   tmp = MQN (MQN (MQN (BWF ("java"),
8746                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8747   load_class (class_not_found_type_node, 1);
8748   load_class (no_class_def_found_type_node, 1);
8749
8750   /* Create the "class$" function */
8751   mdecl = create_artificial_method (class, ACC_STATIC,
8752                                     build_pointer_type (class_type_node),
8753                                     classdollar_identifier_node, args);
8754   DECL_FUNCTION_THROWS (mdecl) =
8755     build_tree_list (NULL_TREE, no_class_def_found_type_node);
8756
8757   /* We start by building the try block. We need to build:
8758        return (java.lang.Class.forName (type)); */
8759   stmt = build_method_invocation (tmp,
8760                                   build_tree_list (NULL_TREE, type_parm_wfl));
8761   stmt = build_return (0, stmt);
8762
8763   /* Now onto the catch block. We start by building the expression
8764      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8765   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8766                                     get_message_wfl, 0);
8767   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8768
8769   /* Build new NoClassDefFoundError (_.getMessage) */
8770   throw_stmt = build_new_invocation
8771     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8772      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8773
8774   /* Build the throw, (it's too early to use BUILD_THROW) */
8775   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8776
8777   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8778   stmt = encapsulate_with_try_catch (0, class_not_found_type_node,
8779                                      stmt, throw_stmt);
8780
8781   fix_method_argument_names (args, mdecl);
8782   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8783   saved_current_function_decl = current_function_decl;
8784   start_artificial_method_body (mdecl);
8785   java_method_add_stmt (mdecl, stmt);
8786   end_artificial_method_body (mdecl);
8787   current_function_decl = saved_current_function_decl;
8788   TYPE_DOT_CLASS (class) = mdecl;
8789
8790   return mdecl;
8791 }
8792
8793 static tree
8794 build_dot_class_method_invocation (type)
8795      tree type;
8796 {
8797   tree sig_id, s;
8798
8799   if (TYPE_ARRAY_P (type))
8800     sig_id = build_java_signature (type);
8801   else
8802     sig_id = DECL_NAME (TYPE_NAME (type));
8803
8804   /* Ensure that the proper name separator is used */
8805   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8806                                IDENTIFIER_LENGTH (sig_id));
8807
8808   s = build_string (IDENTIFIER_LENGTH (sig_id),
8809                     IDENTIFIER_POINTER (sig_id));
8810   return build_method_invocation (build_wfl_node (classdollar_identifier_node),
8811                                   build_tree_list (NULL_TREE, s));
8812 }
8813
8814 /* This section of the code deals with constructor.  */
8815
8816 /* Craft a body for default constructor. Patch existing constructor
8817    bodies with call to super() and field initialization statements if
8818    necessary.  */
8819
8820 static void
8821 fix_constructors (mdecl)
8822      tree mdecl;
8823 {
8824   tree iii;                     /* Instance Initializer Invocation */
8825   tree body = DECL_FUNCTION_BODY (mdecl);
8826   tree thisn_assign, compound = NULL_TREE;
8827   tree class_type = DECL_CONTEXT (mdecl);
8828
8829   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8830     return;
8831   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8832
8833   if (!body)
8834     {
8835       /* It is an error for the compiler to generate a default
8836          constructor if the superclass doesn't have a constructor that
8837          takes no argument, or the same args for an anonymous class */
8838       if (verify_constructor_super (mdecl))
8839         {
8840           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8841           tree save = DECL_NAME (mdecl);
8842           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8843           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8844           parse_error_context
8845             (lookup_cl (TYPE_NAME (class_type)),
8846              "No constructor matching `%s' found in class `%s'",
8847              lang_printable_name (mdecl, 0), n);
8848           DECL_NAME (mdecl) = save;
8849         }
8850
8851       /* The constructor body must be crafted by hand. It's the
8852          constructor we defined when we realize we didn't have the
8853          CLASSNAME() constructor */
8854       start_artificial_method_body (mdecl);
8855
8856       /* Insert an assignment to the this$<n> hidden field, if
8857          necessary */
8858       if ((thisn_assign = build_thisn_assign ()))
8859         java_method_add_stmt (mdecl, thisn_assign);
8860
8861       /* We don't generate a super constructor invocation if we're
8862          compiling java.lang.Object. build_super_invocation takes care
8863          of that. */
8864       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8865
8866       /* FIXME */
8867       if ((iii = build_instinit_invocation (class_type)))
8868         java_method_add_stmt (mdecl, iii);
8869
8870       end_artificial_method_body (mdecl);
8871     }
8872   /* Search for an explicit constructor invocation */
8873   else
8874     {
8875       int found = 0;
8876       int invokes_this = 0;
8877       tree found_call = NULL_TREE;
8878       tree main_block = BLOCK_EXPR_BODY (body);
8879
8880       while (body)
8881         switch (TREE_CODE (body))
8882           {
8883           case CALL_EXPR:
8884             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8885             if (CALL_THIS_CONSTRUCTOR_P (body))
8886               invokes_this = 1;
8887             body = NULL_TREE;
8888             break;
8889           case COMPOUND_EXPR:
8890           case EXPR_WITH_FILE_LOCATION:
8891             found_call = body;
8892             body = TREE_OPERAND (body, 0);
8893             break;
8894           case BLOCK:
8895             found_call = body;
8896             body = BLOCK_EXPR_BODY (body);
8897             break;
8898           default:
8899             found = 0;
8900             body = NULL_TREE;
8901           }
8902
8903       /* Generate the assignment to this$<n>, if necessary */
8904       if ((thisn_assign = build_thisn_assign ()))
8905         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8906
8907       /* The constructor is missing an invocation of super() */
8908       if (!found)
8909         compound = add_stmt_to_compound (compound, NULL_TREE,
8910                                          build_super_invocation (mdecl));
8911       /* Explicit super() invokation should take place before the
8912          instance initializer blocks. */
8913       else
8914         {
8915           compound = add_stmt_to_compound (compound, NULL_TREE,
8916                                            TREE_OPERAND (found_call, 0));
8917           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8918         }
8919
8920       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8921
8922       /* Insert the instance initializer block right after. */
8923       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8924         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8925
8926       /* Fix the constructor main block if we're adding extra stmts */
8927       if (compound)
8928         {
8929           compound = add_stmt_to_compound (compound, NULL_TREE,
8930                                            BLOCK_EXPR_BODY (main_block));
8931           BLOCK_EXPR_BODY (main_block) = compound;
8932         }
8933     }
8934 }
8935
8936 /* Browse constructors in the super class, searching for a constructor
8937    that doesn't take any argument. Return 0 if one is found, 1
8938    otherwise.  If the current class is an anonymous inner class, look
8939    for something that has the same signature. */
8940
8941 static int
8942 verify_constructor_super (mdecl)
8943      tree mdecl;
8944 {
8945   tree class = CLASSTYPE_SUPER (current_class);
8946   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8947   tree sdecl;
8948
8949   if (!class)
8950     return 0;
8951
8952   if (ANONYMOUS_CLASS_P (current_class))
8953     {
8954       tree mdecl_arg_type;
8955       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8956       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8957         if (DECL_CONSTRUCTOR_P (sdecl))
8958           {
8959             tree m_arg_type;
8960             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8961             if (super_inner)
8962               arg_type = TREE_CHAIN (arg_type);
8963             for (m_arg_type = mdecl_arg_type;
8964                  (arg_type != end_params_node
8965                   && m_arg_type != end_params_node);
8966                  arg_type = TREE_CHAIN (arg_type),
8967                    m_arg_type = TREE_CHAIN (m_arg_type))
8968               if (!valid_method_invocation_conversion_p
8969                      (TREE_VALUE (arg_type),
8970                       TREE_VALUE (m_arg_type)))
8971                 break;
8972
8973             if (arg_type == end_params_node && m_arg_type == end_params_node)
8974               return 0;
8975           }
8976     }
8977   else
8978     {
8979       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8980         {
8981           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8982           if (super_inner)
8983             arg = TREE_CHAIN (arg);
8984           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8985             return 0;
8986         }
8987     }
8988   return 1;
8989 }
8990
8991 /* Generate code for all context remembered for code generation.  */
8992
8993 static GTY(()) tree reversed_class_list;
8994 void
8995 java_expand_classes ()
8996 {
8997   int save_error_count = 0;
8998   static struct parser_ctxt *cur_ctxp = NULL;
8999
9000   java_parse_abort_on_error ();
9001   if (!(ctxp = ctxp_for_generation))
9002     return;
9003   java_layout_classes ();
9004   java_parse_abort_on_error ();
9005
9006   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9007     {
9008       ctxp = cur_ctxp;
9009       input_filename = ctxp->filename;
9010       lang_init_source (2);            /* Error msgs have method prototypes */
9011       java_complete_expand_classes (); /* Complete and expand classes */
9012       java_parse_abort_on_error ();
9013     }
9014   input_filename = main_input_filename;
9015
9016
9017   /* Find anonymous classes and expand their constructor. This extra pass is
9018      neccessary because the constructor itself is only generated when the
9019      method in which it is defined is expanded. */
9020   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9021     {
9022       tree current;
9023       ctxp = cur_ctxp;
9024       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9025         {
9026           current_class = TREE_TYPE (current);
9027           if (ANONYMOUS_CLASS_P (current_class))
9028             {
9029               tree d;
9030               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9031                 {
9032                   if (DECL_CONSTRUCTOR_P (d))
9033                     {
9034                       restore_line_number_status (1);
9035                       java_complete_expand_method (d);
9036                       restore_line_number_status (0);
9037                       break;    /* There is only one constructor. */
9038                     }
9039                 }
9040             }
9041         }
9042     }
9043
9044   /* If we've found error at that stage, don't try to generate
9045      anything, unless we're emitting xrefs or checking the syntax only
9046      (but not using -fsyntax-only for the purpose of generating
9047      bytecode. */
9048   if (java_error_count && !flag_emit_xref
9049       && (!flag_syntax_only && !flag_emit_class_files))
9050     return;
9051
9052   /* Now things are stable, go for generation of the class data. */
9053
9054   /* We pessimistically marked all fields external until we knew
9055      what set of classes we were planning to compile.  Now mark
9056      those that will be generated locally as not external.  */
9057   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9058     {
9059       tree current;
9060       ctxp = cur_ctxp;
9061       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9062         {
9063           tree class = TREE_TYPE (current);
9064           tree field;
9065           for (field = TYPE_FIELDS (class); field ; field = TREE_CHAIN (field))
9066             if (FIELD_STATIC (field))
9067               DECL_EXTERNAL (field) = 0;
9068         }
9069     }
9070
9071   /* Compile the classes.  */
9072   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9073     {
9074       tree current;
9075       reversed_class_list = NULL;
9076
9077       ctxp = cur_ctxp;
9078
9079       /* We write out the classes in reverse order.  This ensures that
9080          inner classes are written before their containing classes,
9081          which is important for parallel builds.  Otherwise, the
9082          class file for the outer class may be found, but the class
9083          file for the inner class may not be present.  In that
9084          situation, the compiler cannot fall back to the original
9085          source, having already read the outer class, so we must
9086          prevent that situation.  */
9087       for (current = ctxp->class_list;
9088            current;
9089            current = TREE_CHAIN (current))
9090         reversed_class_list
9091           = tree_cons (NULL_TREE, current, reversed_class_list);
9092
9093       for (current = reversed_class_list;
9094            current;
9095            current = TREE_CHAIN (current))
9096         {
9097           current_class = TREE_TYPE (TREE_VALUE (current));
9098           outgoing_cpool = TYPE_CPOOL (current_class);
9099           if (flag_emit_class_files)
9100             write_classfile (current_class);
9101           if (flag_emit_xref)
9102             expand_xref (current_class);
9103           else if (! flag_syntax_only)
9104             {
9105               java_expand_method_bodies (current_class);
9106               finish_class ();
9107             }
9108         }
9109     }
9110 }
9111
9112 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9113    a tree list node containing RIGHT. Fore coming RIGHTs will be
9114    chained to this hook. LOCATION contains the location of the
9115    separating `.' operator.  */
9116
9117 static tree
9118 make_qualified_primary (primary, right, location)
9119      tree primary, right;
9120      int location;
9121 {
9122   tree wfl;
9123
9124   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9125     wfl = build_wfl_wrap (primary, location);
9126   else
9127     {
9128       wfl = primary;
9129       /* If wfl wasn't qualified, we build a first anchor */
9130       if (!EXPR_WFL_QUALIFICATION (wfl))
9131         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9132     }
9133
9134   /* And chain them */
9135   EXPR_WFL_LINECOL (right) = location;
9136   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9137   PRIMARY_P (wfl) =  1;
9138   return wfl;
9139 }
9140
9141 /* Simple merge of two name separated by a `.' */
9142
9143 static tree
9144 merge_qualified_name (left, right)
9145      tree left, right;
9146 {
9147   tree node;
9148   if (!left && !right)
9149     return NULL_TREE;
9150
9151   if (!left)
9152     return right;
9153
9154   if (!right)
9155     return left;
9156
9157   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9158                 IDENTIFIER_LENGTH (left));
9159   obstack_1grow (&temporary_obstack, '.');
9160   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9161                  IDENTIFIER_LENGTH (right));
9162   node =  get_identifier (obstack_base (&temporary_obstack));
9163   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9164   QUALIFIED_P (node) = 1;
9165   return node;
9166 }
9167
9168 /* Merge the two parts of a qualified name into LEFT.  Set the
9169    location information of the resulting node to LOCATION, usually
9170    inherited from the location information of the `.' operator. */
9171
9172 static tree
9173 make_qualified_name (left, right, location)
9174      tree left, right;
9175      int location;
9176 {
9177 #ifdef USE_COMPONENT_REF
9178   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9179   EXPR_WFL_LINECOL (node) = location;
9180   return node;
9181 #else
9182   tree left_id = EXPR_WFL_NODE (left);
9183   tree right_id = EXPR_WFL_NODE (right);
9184   tree wfl, merge;
9185
9186   merge = merge_qualified_name (left_id, right_id);
9187
9188   /* Left wasn't qualified and is now qualified */
9189   if (!QUALIFIED_P (left_id))
9190     {
9191       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9192       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9193       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9194     }
9195
9196   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9197   EXPR_WFL_LINECOL (wfl) = location;
9198   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9199
9200   EXPR_WFL_NODE (left) = merge;
9201   return left;
9202 #endif
9203 }
9204
9205 /* Extract the last identifier component of the qualified in WFL. The
9206    last identifier is removed from the linked list */
9207
9208 static tree
9209 cut_identifier_in_qualified (wfl)
9210      tree wfl;
9211 {
9212   tree q;
9213   tree previous = NULL_TREE;
9214   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9215     if (!TREE_CHAIN (q))
9216       {
9217         if (!previous)
9218           /* Operating on a non qualified qualified WFL.  */
9219           abort ();
9220
9221         TREE_CHAIN (previous) = NULL_TREE;
9222         return TREE_PURPOSE (q);
9223       }
9224 }
9225
9226 /* Resolve the expression name NAME. Return its decl.  */
9227
9228 static tree
9229 resolve_expression_name (id, orig)
9230      tree id;
9231      tree *orig;
9232 {
9233   tree name = EXPR_WFL_NODE (id);
9234   tree decl;
9235
9236   /* 6.5.5.1: Simple expression names */
9237   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9238     {
9239       /* 15.13.1: NAME can appear within the scope of a local variable
9240          declaration */
9241       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9242         return decl;
9243
9244       /* 15.13.1: NAME can appear within a class declaration */
9245       else
9246         {
9247           decl = lookup_field_wrapper (current_class, name);
9248           if (decl)
9249             {
9250               tree access = NULL_TREE;
9251               int fs = FIELD_STATIC (decl);
9252
9253               /* If we're accessing an outer scope local alias, make
9254                  sure we change the name of the field we're going to
9255                  build access to. */
9256               if (FIELD_LOCAL_ALIAS_USED (decl))
9257                 name = DECL_NAME (decl);
9258
9259               /* Instance variable (8.3.1.1) can't appear within
9260                  static method, static initializer or initializer for
9261                  a static variable. */
9262               if (!fs && METHOD_STATIC (current_function_decl))
9263                 {
9264                   static_ref_err (id, name, current_class);
9265                   return error_mark_node;
9266                 }
9267               /* Instance variables can't appear as an argument of
9268                  an explicit constructor invocation */
9269               if (!fs && ctxp->explicit_constructor_p
9270                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9271                 {
9272                   parse_error_context
9273                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9274                   return error_mark_node;
9275                 }
9276
9277               /* If we're processing an inner class and we're trying
9278                  to access a field belonging to an outer class, build
9279                  the access to the field */
9280               if (!fs && outer_field_access_p (current_class, decl))
9281                 {
9282                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9283                     {
9284                       static_ref_err (id, DECL_NAME (decl), current_class);
9285                       return error_mark_node;
9286                     }
9287                   access = build_outer_field_access (id, decl);
9288                   if (orig)
9289                     *orig = access;
9290                   return access;
9291                 }
9292
9293               /* Otherwise build what it takes to access the field */
9294               access = build_field_ref ((fs ? NULL_TREE : current_this),
9295                                         DECL_CONTEXT (decl), name);
9296               if (fs)
9297                 access = maybe_build_class_init_for_field (decl, access);
9298               /* We may be asked to save the real field access node */
9299               if (orig)
9300                 *orig = access;
9301               /* And we return what we got */
9302               return access;
9303             }
9304           /* Fall down to error report on undefined variable */
9305         }
9306     }
9307   /* 6.5.5.2 Qualified Expression Names */
9308   else
9309     {
9310       if (orig)
9311         *orig = NULL_TREE;
9312       qualify_ambiguous_name (id);
9313       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9314       /* 15.10.2: Accessing Superclass Members using super */
9315       return resolve_field_access (id, orig, NULL);
9316     }
9317
9318   /* We've got an error here */
9319   if (INNER_CLASS_TYPE_P (current_class))
9320     parse_error_context (id,
9321                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9322                          IDENTIFIER_POINTER (name),
9323                          IDENTIFIER_POINTER (DECL_NAME
9324                                              (TYPE_NAME (current_class))));
9325   else
9326     parse_error_context (id, "Undefined variable `%s'",
9327                          IDENTIFIER_POINTER (name));
9328
9329   return error_mark_node;
9330 }
9331
9332 static void
9333 static_ref_err (wfl, field_id, class_type)
9334     tree wfl, field_id, class_type;
9335 {
9336   parse_error_context
9337     (wfl,
9338      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9339      IDENTIFIER_POINTER (field_id),
9340      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9341 }
9342
9343 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9344    We return something suitable to generate the field access. We also
9345    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9346    recipient's address can be null. */
9347
9348 static tree
9349 resolve_field_access (qual_wfl, field_decl, field_type)
9350      tree qual_wfl;
9351      tree *field_decl, *field_type;
9352 {
9353   int is_static = 0;
9354   tree field_ref;
9355   tree decl, where_found, type_found;
9356
9357   if (resolve_qualified_expression_name (qual_wfl, &decl,
9358                                          &where_found, &type_found))
9359     return error_mark_node;
9360
9361   /* Resolve the LENGTH field of an array here */
9362   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9363       && type_found && TYPE_ARRAY_P (type_found)
9364       && ! flag_emit_class_files && ! flag_emit_xref)
9365     {
9366       tree length = build_java_array_length_access (where_found);
9367       field_ref = length;
9368
9369       /* In case we're dealing with a static array, we need to
9370          initialize its class before the array length can be fetched.
9371          It's also a good time to create a DECL_RTL for the field if
9372          none already exists, otherwise if the field was declared in a
9373          class found in an external file and hasn't been (and won't
9374          be) accessed for its value, none will be created. */
9375       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9376         {
9377           build_static_field_ref (where_found);
9378           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9379         }
9380     }
9381   /* We might have been trying to resolve field.method(). In which
9382      case, the resolution is over and decl is the answer */
9383   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9384     field_ref = decl;
9385   else if (JDECL_P (decl))
9386     {
9387       if (!type_found)
9388         type_found = DECL_CONTEXT (decl);
9389       is_static = FIELD_STATIC (decl);
9390       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9391                                     NULL_TREE : where_found),
9392                                    type_found, DECL_NAME (decl));
9393       if (field_ref == error_mark_node)
9394         return error_mark_node;
9395       if (is_static)
9396         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9397     }
9398   else
9399     field_ref = decl;
9400
9401   if (field_decl)
9402     *field_decl = decl;
9403   if (field_type)
9404     *field_type = (QUAL_DECL_TYPE (decl) ?
9405                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9406   return field_ref;
9407 }
9408
9409 /* If NODE is an access to f static field, strip out the class
9410    initialization part and return the field decl, otherwise, return
9411    NODE. */
9412
9413 static tree
9414 strip_out_static_field_access_decl (node)
9415     tree node;
9416 {
9417   if (TREE_CODE (node) == COMPOUND_EXPR)
9418     {
9419       tree op1 = TREE_OPERAND (node, 1);
9420       if (TREE_CODE (op1) == COMPOUND_EXPR)
9421          {
9422            tree call = TREE_OPERAND (op1, 0);
9423            if (TREE_CODE (call) == CALL_EXPR
9424                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9425                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9426                == soft_initclass_node)
9427              return TREE_OPERAND (op1, 1);
9428          }
9429       else if (JDECL_P (op1))
9430         return op1;
9431     }
9432   return node;
9433 }
9434
9435 /* 6.5.5.2: Qualified Expression Names */
9436
9437 static int
9438 resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
9439      tree wfl;
9440      tree *found_decl, *type_found, *where_found;
9441 {
9442   int from_type = 0;            /* Field search initiated from a type */
9443   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9444   int previous_call_static = 0;
9445   int is_static;
9446   tree decl = NULL_TREE, type = NULL_TREE, q;
9447   /* For certain for of inner class instantiation */
9448   tree saved_current, saved_this;
9449 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9450   { current_class = saved_current; current_this = saved_this;}
9451
9452   *type_found = *where_found = NULL_TREE;
9453
9454   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9455     {
9456       tree qual_wfl = QUAL_WFL (q);
9457       tree ret_decl;            /* for EH checking */
9458       int location;             /* for EH checking */
9459
9460       /* 15.10.1 Field Access Using a Primary */
9461       switch (TREE_CODE (qual_wfl))
9462         {
9463         case CALL_EXPR:
9464         case NEW_CLASS_EXPR:
9465           /* If the access to the function call is a non static field,
9466              build the code to access it. */
9467           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9468             {
9469               decl = maybe_access_field (decl, *where_found,
9470                                          DECL_CONTEXT (decl));
9471               if (decl == error_mark_node)
9472                 return 1;
9473             }
9474
9475           /* And code for the function call */
9476           if (complete_function_arguments (qual_wfl))
9477             return 1;
9478
9479           /* We might have to setup a new current class and a new this
9480              for the search of an inner class, relative to the type of
9481              a expression resolved as `decl'. The current values are
9482              saved and restored shortly after */
9483           saved_current = current_class;
9484           saved_this = current_this;
9485           if (decl
9486               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9487                   || from_qualified_this))
9488             {
9489               /* If we still have `from_qualified_this', we have the form
9490                  <T>.this.f() and we need to build <T>.this */
9491               if (from_qualified_this)
9492                 {
9493                   decl = build_access_to_thisn (current_class, type, 0);
9494                   decl = java_complete_tree (decl);
9495                   type = TREE_TYPE (TREE_TYPE (decl));
9496                 }
9497               current_class = type;
9498               current_this = decl;
9499               from_qualified_this = 0;
9500             }
9501
9502           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9503             CALL_USING_SUPER (qual_wfl) = 1;
9504           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9505                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9506           *where_found = patch_method_invocation (qual_wfl, decl, type,
9507                                                   from_super,
9508                                                   &is_static, &ret_decl);
9509           from_super = 0;
9510           if (*where_found == error_mark_node)
9511             {
9512               RESTORE_THIS_AND_CURRENT_CLASS;
9513               return 1;
9514             }
9515           *type_found = type = QUAL_DECL_TYPE (*where_found);
9516
9517           *where_found = force_evaluation_order (*where_found);
9518
9519           /* If we're creating an inner class instance, check for that
9520              an enclosing instance is in scope */
9521           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9522               && INNER_ENCLOSING_SCOPE_CHECK (type))
9523             {
9524               parse_error_context
9525                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9526                  lang_printable_name (type, 0),
9527                  (!current_this ? "" :
9528                   "; an explicit one must be provided when creating this inner class"));
9529               RESTORE_THIS_AND_CURRENT_CLASS;
9530               return 1;
9531             }
9532
9533           /* In case we had to change then to resolve a inner class
9534              instantiation using a primary qualified by a `new' */
9535           RESTORE_THIS_AND_CURRENT_CLASS;
9536
9537           /* EH check. No check on access$<n> functions */
9538           if (location
9539               && !OUTER_FIELD_ACCESS_IDENTIFIER_P
9540                     (DECL_NAME (current_function_decl)))
9541             check_thrown_exceptions (location, ret_decl);
9542
9543           /* If the previous call was static and this one is too,
9544              build a compound expression to hold the two (because in
9545              that case, previous function calls aren't transported as
9546              forcoming function's argument. */
9547           if (previous_call_static && is_static)
9548             {
9549               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9550                             decl, *where_found);
9551               TREE_SIDE_EFFECTS (decl) = 1;
9552             }
9553           else
9554             {
9555               previous_call_static = is_static;
9556               decl = *where_found;
9557             }
9558           from_type = 0;
9559           continue;
9560
9561         case NEW_ARRAY_EXPR:
9562         case NEW_ANONYMOUS_ARRAY_EXPR:
9563           *where_found = decl = java_complete_tree (qual_wfl);
9564           if (decl == error_mark_node)
9565             return 1;
9566           *type_found = type = QUAL_DECL_TYPE (decl);
9567           continue;
9568
9569         case CONVERT_EXPR:
9570           *where_found = decl = java_complete_tree (qual_wfl);
9571           if (decl == error_mark_node)
9572             return 1;
9573           *type_found = type = QUAL_DECL_TYPE (decl);
9574           from_cast = 1;
9575           continue;
9576
9577         case CONDITIONAL_EXPR:
9578         case STRING_CST:
9579         case MODIFY_EXPR:
9580           *where_found = decl = java_complete_tree (qual_wfl);
9581           if (decl == error_mark_node)
9582             return 1;
9583           *type_found = type = QUAL_DECL_TYPE (decl);
9584           continue;
9585
9586         case ARRAY_REF:
9587           /* If the access to the function call is a non static field,
9588              build the code to access it. */
9589           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9590             {
9591               decl = maybe_access_field (decl, *where_found, type);
9592               if (decl == error_mark_node)
9593                 return 1;
9594             }
9595           /* And code for the array reference expression */
9596           decl = java_complete_tree (qual_wfl);
9597           if (decl == error_mark_node)
9598             return 1;
9599           type = QUAL_DECL_TYPE (decl);
9600           continue;
9601
9602         case PLUS_EXPR:
9603           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9604             return 1;
9605           if ((type = patch_string (decl)))
9606             decl = type;
9607           *where_found = QUAL_RESOLUTION (q) = decl;
9608           *type_found = type = TREE_TYPE (decl);
9609           break;
9610
9611         case CLASS_LITERAL:
9612           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9613             return 1;
9614           *where_found = QUAL_RESOLUTION (q) = decl;
9615           *type_found = type = TREE_TYPE (decl);
9616           break;
9617
9618         default:
9619           /* Fix for -Wall Just go to the next statement. Don't
9620              continue */
9621           break;
9622         }
9623
9624       /* If we fall here, we weren't processing a (static) function call. */
9625       previous_call_static = 0;
9626
9627       /* It can be the keyword THIS */
9628       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9629           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9630         {
9631           if (!current_this)
9632             {
9633               parse_error_context
9634                 (wfl, "Keyword `this' used outside allowed context");
9635               return 1;
9636             }
9637           if (ctxp->explicit_constructor_p
9638               && type == current_class)
9639             {
9640               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9641               return 1;
9642             }
9643           /* We have to generate code for intermediate access */
9644           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9645             {
9646               *where_found = decl = current_this;
9647               *type_found = type = QUAL_DECL_TYPE (decl);
9648             }
9649           /* We're trying to access the this from somewhere else. Make sure
9650              it's allowed before doing so. */
9651           else
9652             {
9653               if (!enclosing_context_p (type, current_class))
9654                 {
9655                   char *p  = xstrdup (lang_printable_name (type, 0));
9656                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9657                                        p, p,
9658                                        lang_printable_name (current_class, 0));
9659                   free (p);
9660                   return 1;
9661                 }
9662               from_qualified_this = 1;
9663               /* If there's nothing else after that, we need to
9664                  produce something now, otherwise, the section of the
9665                  code that needs to produce <T>.this will generate
9666                  what is necessary. */
9667               if (!TREE_CHAIN (q))
9668                 {
9669                   decl = build_access_to_thisn (current_class, type, 0);
9670                   *where_found = decl = java_complete_tree (decl);
9671                   *type_found = type = TREE_TYPE (decl);
9672                 }
9673             }
9674
9675           from_type = 0;
9676           continue;
9677         }
9678
9679       /* 15.10.2 Accessing Superclass Members using SUPER */
9680       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9681           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9682         {
9683           tree node;
9684           /* Check on the restricted use of SUPER */
9685           if (METHOD_STATIC (current_function_decl)
9686               || current_class == object_type_node)
9687             {
9688               parse_error_context
9689                 (wfl, "Keyword `super' used outside allowed context");
9690               return 1;
9691             }
9692           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9693           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9694                              CLASSTYPE_SUPER (current_class),
9695                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9696           *where_found = decl = java_complete_tree (node);
9697           if (decl == error_mark_node)
9698             return 1;
9699           *type_found = type = QUAL_DECL_TYPE (decl);
9700           from_super = from_type = 1;
9701           continue;
9702         }
9703
9704       /* 15.13.1: Can't search for field name in packages, so we
9705          assume a variable/class name was meant. */
9706       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9707         {
9708           tree name;
9709           if ((decl = resolve_package (wfl, &q, &name)))
9710             {
9711               tree list;
9712               *where_found = decl;
9713
9714               /* We want to be absolutely sure that the class is laid
9715                  out. We're going to search something inside it. */
9716               *type_found = type = TREE_TYPE (decl);
9717               layout_class (type);
9718               from_type = 1;
9719
9720               /* Fix them all the way down, if any are left. */
9721               if (q)
9722                 {
9723                   list = TREE_CHAIN (q);
9724                   while (list)
9725                     {
9726                       RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9727                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9728                       list = TREE_CHAIN (list);
9729                     }
9730                 }
9731             }
9732           else
9733             {
9734               if (from_super || from_cast)
9735                 parse_error_context
9736                   ((from_cast ? qual_wfl : wfl),
9737                    "No variable `%s' defined in class `%s'",
9738                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9739                    lang_printable_name (type, 0));
9740               else
9741                 parse_error_context
9742                   (qual_wfl, "Undefined variable or class name: `%s'",
9743                    IDENTIFIER_POINTER (name));
9744               return 1;
9745             }
9746         }
9747
9748       /* We have a type name. It's been already resolved when the
9749          expression was qualified. */
9750       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9751         {
9752           decl = QUAL_RESOLUTION (q);
9753
9754           /* Sneak preview. If next we see a `new', we're facing a
9755              qualification with resulted in a type being selected
9756              instead of a field.  Report the error */
9757           if(TREE_CHAIN (q)
9758              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9759             {
9760               parse_error_context (qual_wfl, "Undefined variable `%s'",
9761                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9762               return 1;
9763             }
9764
9765           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9766             {
9767               parse_error_context
9768                 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
9769                  java_accstring_lookup (get_access_flags_from_decl (decl)),
9770                  GET_TYPE_NAME (type),
9771                  IDENTIFIER_POINTER (DECL_NAME (decl)),
9772                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9773               return 1;
9774             }
9775           check_deprecation (qual_wfl, decl);
9776
9777           type = TREE_TYPE (decl);
9778           from_type = 1;
9779         }
9780       /* We resolve an expression name */
9781       else
9782         {
9783           tree field_decl = NULL_TREE;
9784
9785           /* If there exists an early resolution, use it. That occurs
9786              only once and we know that there are more things to
9787              come. Don't do that when processing something after SUPER
9788              (we need more thing to be put in place below */
9789           if (!from_super && QUAL_RESOLUTION (q))
9790             {
9791               decl = QUAL_RESOLUTION (q);
9792               if (!type)
9793                 {
9794                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9795                     {
9796                       if (current_this)
9797                         *where_found = current_this;
9798                       else
9799                         {
9800                           static_ref_err (qual_wfl, DECL_NAME (decl),
9801                                           current_class);
9802                           return 1;
9803                         }
9804                       if (outer_field_access_p (current_class, decl))
9805                         decl = build_outer_field_access (qual_wfl, decl);
9806                     }
9807                   else
9808                     {
9809                       *where_found = TREE_TYPE (decl);
9810                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9811                         *where_found = TREE_TYPE (*where_found);
9812                     }
9813                 }
9814             }
9815
9816           /* Report and error if we're using a numerical litteral as a
9817              qualifier. It can only be an INTEGER_CST. */
9818           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9819             {
9820               parse_error_context
9821                 (wfl, "Can't use type `%s' as a qualifier",
9822                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9823               return 1;
9824             }
9825
9826           /* We have to search for a field, knowing the type of its
9827              container. The flag FROM_TYPE indicates that we resolved
9828              the last member of the expression as a type name, which
9829              means that for the resolution of this field, we'll look
9830              for other errors than if it was resolved as a member of
9831              an other field. */
9832           else
9833             {
9834               int is_static;
9835               tree field_decl_type; /* For layout */
9836
9837               if (!from_type && !JREFERENCE_TYPE_P (type))
9838                 {
9839                   parse_error_context
9840                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9841                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9842                      lang_printable_name (type, 0),
9843                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9844                   return 1;
9845                 }
9846
9847               field_decl = lookup_field_wrapper (type,
9848                                                  EXPR_WFL_NODE (qual_wfl));
9849
9850               /* Maybe what we're trying to access to is an inner
9851                  class, only if decl is a TYPE_DECL. */
9852               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9853                 {
9854                   tree ptr, inner_decl;
9855
9856                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9857                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9858                   if (inner_decl)
9859                     {
9860                       check_inner_class_access (inner_decl, decl, qual_wfl);
9861                       type = TREE_TYPE (inner_decl);
9862                       decl = inner_decl;
9863                       from_type = 1;
9864                       continue;
9865                     }
9866                 }
9867
9868               if (field_decl == NULL_TREE)
9869                 {
9870                   parse_error_context
9871                     (qual_wfl, "No variable `%s' defined in type `%s'",
9872                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9873                      GET_TYPE_NAME (type));
9874                   return 1;
9875                 }
9876               if (field_decl == error_mark_node)
9877                 return 1;
9878
9879               /* Layout the type of field_decl, since we may need
9880                  it. Don't do primitive types or loaded classes. The
9881                  situation of non primitive arrays may not handled
9882                  properly here. FIXME */
9883               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9884                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9885               else
9886                 field_decl_type = TREE_TYPE (field_decl);
9887               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9888                   && !CLASS_LOADED_P (field_decl_type)
9889                   && !TYPE_ARRAY_P (field_decl_type))
9890                 resolve_and_layout (field_decl_type, NULL_TREE);
9891
9892               /* Check on accessibility here */
9893               if (not_accessible_p (current_class, field_decl,
9894                                     DECL_CONTEXT (field_decl), from_super))
9895                 {
9896                   parse_error_context
9897                     (qual_wfl,
9898                      "Can't access %s field `%s.%s' from `%s'",
9899                      java_accstring_lookup
9900                        (get_access_flags_from_decl (field_decl)),
9901                      GET_TYPE_NAME (type),
9902                      IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9903                      IDENTIFIER_POINTER
9904                        (DECL_NAME (TYPE_NAME (current_class))));
9905                   return 1;
9906                 }
9907               check_deprecation (qual_wfl, field_decl);
9908
9909               /* There are things to check when fields are accessed
9910                  from type. There are no restrictions on a static
9911                  declaration of the field when it is accessed from an
9912                  interface */
9913               is_static = FIELD_STATIC (field_decl);
9914               if (!from_super && from_type
9915                   && !TYPE_INTERFACE_P (type)
9916                   && !is_static
9917                   && (current_function_decl
9918                       && METHOD_STATIC (current_function_decl)))
9919                 {
9920                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9921                   return 1;
9922                 }
9923               from_cast = from_super = 0;
9924
9925               /* It's an access from a type but it isn't static, we
9926                  make it relative to `this'. */
9927               if (!is_static && from_type)
9928                 decl = current_this;
9929
9930               /* If we need to generate something to get a proper
9931                  handle on what this field is accessed from, do it
9932                  now. */
9933               if (!is_static)
9934                 {
9935                   decl = maybe_access_field (decl, *where_found, *type_found);
9936                   if (decl == error_mark_node)
9937                     return 1;
9938                 }
9939
9940               /* We want to keep the location were found it, and the type
9941                  we found. */
9942               *where_found = decl;
9943               *type_found = type;
9944
9945               /* Generate the correct expression for field access from
9946                  qualified this */
9947               if (from_qualified_this)
9948                 {
9949                   field_decl = build_outer_field_access (qual_wfl, field_decl);
9950                   from_qualified_this = 0;
9951                 }
9952
9953               /* This is the decl found and eventually the next one to
9954                  search from */
9955               decl = field_decl;
9956             }
9957           from_type = 0;
9958           type = QUAL_DECL_TYPE (decl);
9959
9960           /* Sneak preview. If decl is qualified by a `new', report
9961              the error here to be accurate on the peculiar construct */
9962           if (TREE_CHAIN (q)
9963               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9964               && !JREFERENCE_TYPE_P (type))
9965             {
9966               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9967                                    lang_printable_name (type, 0));
9968               return 1;
9969             }
9970         }
9971       /* `q' might have changed due to a after package resolution
9972          re-qualification */
9973       if (!q)
9974         break;
9975     }
9976   *found_decl = decl;
9977   return 0;
9978 }
9979
9980 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9981    can't be accessed from REFERENCE (a record type). If MEMBER
9982    features a protected access, we then use WHERE which, if non null,
9983    holds the type of MEMBER's access that is checked against
9984    6.6.2.1. This function should be used when decl is a field or a
9985    method.  */
9986
9987 static int
9988 not_accessible_p (reference, member, where, from_super)
9989      tree reference, member;
9990      tree where;
9991      int from_super;
9992 {
9993   int access_flag = get_access_flags_from_decl (member);
9994
9995   /* Inner classes are processed by check_inner_class_access */
9996   if (INNER_CLASS_TYPE_P (reference))
9997     return 0;
9998
9999   /* Access always granted for members declared public */
10000   if (access_flag & ACC_PUBLIC)
10001     return 0;
10002
10003   /* Check access on protected members */
10004   if (access_flag & ACC_PROTECTED)
10005     {
10006       /* Access granted if it occurs from within the package
10007          containing the class in which the protected member is
10008          declared */
10009       if (class_in_current_package (DECL_CONTEXT (member)))
10010         return 0;
10011
10012       /* If accessed with the form `super.member', then access is granted */
10013       if (from_super)
10014         return 0;
10015
10016       /* If where is active, access was made through a
10017          qualifier. Access is granted if the type of the qualifier is
10018          or is a sublass of the type the access made from (6.6.2.1.)  */
10019       if (where && !inherits_from_p (reference, where))
10020         return 1;
10021
10022       /* Otherwise, access is granted if occurring from the class where
10023          member is declared or a subclass of it. Find the right
10024          context to perform the check */
10025       if (PURE_INNER_CLASS_TYPE_P (reference))
10026         {
10027           while (INNER_CLASS_TYPE_P (reference))
10028             {
10029               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10030                 return 0;
10031               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10032             }
10033         }
10034       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10035         return 0;
10036       return 1;
10037     }
10038
10039   /* Check access on private members. Access is granted only if it
10040      occurs from within the class in which it is declared -- that does
10041      it for innerclasses too. */
10042   if (access_flag & ACC_PRIVATE)
10043     {
10044       if (reference == DECL_CONTEXT (member))
10045         return 0;
10046       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10047         return 0;
10048       return 1;
10049     }
10050
10051   /* Default access are permitted only when occurring within the
10052      package in which the type (REFERENCE) is declared. In other words,
10053      REFERENCE is defined in the current package */
10054   if (ctxp->package)
10055     return !class_in_current_package (reference);
10056
10057   /* Otherwise, access is granted */
10058   return 0;
10059 }
10060
10061 /* Test deprecated decl access.  */
10062 static void
10063 check_deprecation (wfl, decl)
10064      tree wfl, decl;
10065 {
10066   const char *file = DECL_SOURCE_FILE (decl);
10067   /* Complain if the field is deprecated and the file it was defined
10068      in isn't compiled at the same time the file which contains its
10069      use is */
10070   if (DECL_DEPRECATED (decl)
10071       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10072     {
10073       char the [20];
10074       switch (TREE_CODE (decl))
10075         {
10076         case FUNCTION_DECL:
10077           strcpy (the, "method");
10078           break;
10079         case FIELD_DECL:
10080         case VAR_DECL:
10081           strcpy (the, "field");
10082           break;
10083         case TYPE_DECL:
10084           parse_warning_context (wfl, "The class `%s' has been deprecated",
10085                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10086           return;
10087         default:
10088           abort ();
10089         }
10090       /* Don't issue a message if the context as been deprecated as a
10091          whole. */
10092       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10093         parse_warning_context
10094           (wfl, "The %s `%s' in class `%s' has been deprecated",
10095            the, lang_printable_name (decl, 0),
10096            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10097     }
10098 }
10099
10100 /* Returns 1 if class was declared in the current package, 0 otherwise */
10101
10102 static GTY(()) tree cicp_cache;
10103 static int
10104 class_in_current_package (class)
10105      tree class;
10106 {
10107   int qualified_flag;
10108   tree left;
10109
10110   if (cicp_cache == class)
10111     return 1;
10112
10113   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10114
10115   /* If the current package is empty and the name of CLASS is
10116      qualified, class isn't in the current package.  If there is a
10117      current package and the name of the CLASS is not qualified, class
10118      isn't in the current package */
10119   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10120     return 0;
10121
10122   /* If there is not package and the name of CLASS isn't qualified,
10123      they belong to the same unnamed package */
10124   if (!ctxp->package && !qualified_flag)
10125     return 1;
10126
10127   /* Compare the left part of the name of CLASS with the package name */
10128   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10129   if (ctxp->package == left)
10130     {
10131       cicp_cache = class;
10132       return 1;
10133     }
10134   return 0;
10135 }
10136
10137 /* This function may generate code to access DECL from WHERE. This is
10138    done only if certain conditions meet.  */
10139
10140 static tree
10141 maybe_access_field (decl, where, type)
10142   tree decl, where, type;
10143 {
10144   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10145       && !FIELD_STATIC (decl))
10146     decl = build_field_ref (where ? where : current_this,
10147                             (type ? type : DECL_CONTEXT (decl)),
10148                             DECL_NAME (decl));
10149   return decl;
10150 }
10151
10152 /* Build a method invocation, by patching PATCH. If non NULL
10153    and according to the situation, PRIMARY and WHERE may be
10154    used. IS_STATIC is set to 1 if the invoked function is static. */
10155
10156 static tree
10157 patch_method_invocation (patch, primary, where, from_super,
10158                         is_static, ret_decl)
10159      tree patch, primary, where;
10160      int from_super;
10161      int *is_static;
10162      tree *ret_decl;
10163 {
10164   tree wfl = TREE_OPERAND (patch, 0);
10165   tree args = TREE_OPERAND (patch, 1);
10166   tree name = EXPR_WFL_NODE (wfl);
10167   tree list;
10168   int is_static_flag = 0;
10169   int is_super_init = 0;
10170   tree this_arg = NULL_TREE;
10171   int is_array_clone_call = 0;
10172
10173   /* Should be overriden if everything goes well. Otherwise, if
10174      something fails, it should keep this value. It stop the
10175      evaluation of a bogus assignment. See java_complete_tree,
10176      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10177      evaluating an assignment */
10178   TREE_TYPE (patch) = error_mark_node;
10179
10180   /* Since lookup functions are messing with line numbers, save the
10181      context now.  */
10182   java_parser_context_save_global ();
10183
10184   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10185
10186   /* Resolution of qualified name, excluding constructors */
10187   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10188     {
10189       tree identifier, identifier_wfl, type, resolved;
10190       /* Extract the last IDENTIFIER of the qualified
10191          expression. This is a wfl and we will use it's location
10192          data during error report. */
10193       identifier_wfl = cut_identifier_in_qualified (wfl);
10194       identifier = EXPR_WFL_NODE (identifier_wfl);
10195
10196       /* Given the context, IDENTIFIER is syntactically qualified
10197          as a MethodName. We need to qualify what's before */
10198       qualify_ambiguous_name (wfl);
10199       resolved = resolve_field_access (wfl, NULL, NULL);
10200
10201       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10202          && FIELD_FINAL (resolved)
10203          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10204          && !flag_emit_class_files && !flag_emit_xref)
10205        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10206
10207       if (resolved == error_mark_node)
10208         PATCH_METHOD_RETURN_ERROR ();
10209
10210       type = GET_SKIP_TYPE (resolved);
10211       resolve_and_layout (type, NULL_TREE);
10212
10213       if (JPRIMITIVE_TYPE_P (type))
10214         {
10215           parse_error_context
10216             (identifier_wfl,
10217              "Can't invoke a method on primitive type `%s'",
10218              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10219           PATCH_METHOD_RETURN_ERROR ();
10220         }
10221
10222       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10223       args = nreverse (args);
10224
10225       /* We're resolving a call from a type */
10226       if (TREE_CODE (resolved) == TYPE_DECL)
10227         {
10228           if (CLASS_INTERFACE (resolved))
10229             {
10230               parse_error_context
10231                 (identifier_wfl,
10232                 "Can't make static reference to method `%s' in interface `%s'",
10233                  IDENTIFIER_POINTER (identifier),
10234                  IDENTIFIER_POINTER (name));
10235               PATCH_METHOD_RETURN_ERROR ();
10236             }
10237           if (list && !METHOD_STATIC (list))
10238             {
10239               char *fct_name = xstrdup (lang_printable_name (list, 0));
10240               parse_error_context
10241                 (identifier_wfl,
10242                  "Can't make static reference to method `%s %s' in class `%s'",
10243                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10244                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10245               free (fct_name);
10246               PATCH_METHOD_RETURN_ERROR ();
10247             }
10248         }
10249       else
10250         this_arg = primary = resolved;
10251
10252       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10253         is_array_clone_call = 1;
10254
10255       /* IDENTIFIER_WFL will be used to report any problem further */
10256       wfl = identifier_wfl;
10257     }
10258   /* Resolution of simple names, names generated after a primary: or
10259      constructors */
10260   else
10261     {
10262       tree class_to_search = NULL_TREE;
10263       int lc;                   /* Looking for Constructor */
10264
10265       /* We search constructor in their target class */
10266       if (CALL_CONSTRUCTOR_P (patch))
10267         {
10268           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10269             class_to_search = EXPR_WFL_NODE (wfl);
10270           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10271                    this_identifier_node)
10272             class_to_search = NULL_TREE;
10273           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10274                    super_identifier_node)
10275             {
10276               is_super_init = 1;
10277               if (CLASSTYPE_SUPER (current_class))
10278                 class_to_search =
10279                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10280               else
10281                 {
10282                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10283                   PATCH_METHOD_RETURN_ERROR ();
10284                 }
10285             }
10286
10287           /* Class to search is NULL if we're searching the current one */
10288           if (class_to_search)
10289             {
10290               class_to_search = resolve_and_layout (class_to_search, wfl);
10291
10292               if (!class_to_search)
10293                 {
10294                   parse_error_context
10295                     (wfl, "Class `%s' not found in type declaration",
10296                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10297                   PATCH_METHOD_RETURN_ERROR ();
10298                 }
10299
10300               /* Can't instantiate an abstract class, but we can
10301                  invoke it's constructor. It's use within the `new'
10302                  context is denied here. */
10303               if (CLASS_ABSTRACT (class_to_search)
10304                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10305                 {
10306                   parse_error_context
10307                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10308                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10309                   PATCH_METHOD_RETURN_ERROR ();
10310                 }
10311
10312               class_to_search = TREE_TYPE (class_to_search);
10313             }
10314           else
10315             class_to_search = current_class;
10316           lc = 1;
10317         }
10318       /* This is a regular search in the local class, unless an
10319          alternate class is specified. */
10320       else
10321         {
10322           if (where != NULL_TREE)
10323             class_to_search = where;
10324           else if (QUALIFIED_P (name))
10325             class_to_search = current_class;
10326           else
10327             {
10328               class_to_search = current_class;
10329
10330               for (;;)
10331                 {
10332                   if (has_method (class_to_search, name))
10333                     break;
10334                   if (! INNER_CLASS_TYPE_P (class_to_search))
10335                     {
10336                       parse_error_context (wfl,
10337                                            "No method named `%s' in scope",
10338                                            IDENTIFIER_POINTER (name));
10339                       PATCH_METHOD_RETURN_ERROR ();
10340                     }
10341                   class_to_search
10342                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10343                 }
10344             }
10345           lc = 0;
10346         }
10347
10348       /* NAME is a simple identifier or comes from a primary. Search
10349          in the class whose declaration contain the method being
10350          invoked. */
10351       resolve_and_layout (class_to_search, NULL_TREE);
10352
10353       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10354       /* Don't continue if no method were found, as the next statement
10355          can't be executed then. */
10356       if (!list)
10357         PATCH_METHOD_RETURN_ERROR ();
10358
10359       if (TYPE_ARRAY_P (class_to_search)
10360           && DECL_NAME (list) == get_identifier ("clone"))
10361         is_array_clone_call = 1;
10362
10363       /* Check for static reference if non static methods */
10364       if (check_for_static_method_reference (wfl, patch, list,
10365                                              class_to_search, primary))
10366         PATCH_METHOD_RETURN_ERROR ();
10367
10368       /* Check for inner classes creation from illegal contexts */
10369       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10370                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10371           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10372           && !DECL_INIT_P (current_function_decl))
10373         {
10374           parse_error_context
10375             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10376              lang_printable_name (class_to_search, 0),
10377              (!current_this ? "" :
10378               "; an explicit one must be provided when creating this inner class"));
10379           PATCH_METHOD_RETURN_ERROR ();
10380         }
10381
10382       /* Non static methods are called with the current object extra
10383          argument. If patch a `new TYPE()', the argument is the value
10384          returned by the object allocator. If method is resolved as a
10385          primary, use the primary otherwise use the current THIS. */
10386       args = nreverse (args);
10387       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10388         {
10389           this_arg = primary ? primary : current_this;
10390
10391           /* If we're using an access method, things are different.
10392              There are two familly of cases:
10393
10394              1) We're not generating bytecodes:
10395
10396              - LIST is non static. It's invocation is transformed from
10397                x(a1,...,an) into this$<n>.x(a1,....an).
10398              - LIST is static. It's invocation is transformed from
10399                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10400
10401              2) We're generating bytecodes:
10402
10403              - LIST is non static. It's invocation is transformed from
10404                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10405              - LIST is static. It's invocation is transformed from
10406                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10407
10408              Of course, this$<n> can be abitrary complex, ranging from
10409              this$0 (the immediate outer context) to
10410              access$0(access$0(...(this$0))).
10411
10412              maybe_use_access_method returns a nonzero value if the
10413              this_arg has to be moved into the (then generated) stub
10414              argument list. In the meantime, the selected function
10415              might have be replaced by a generated stub. */
10416           if (!primary &&
10417               maybe_use_access_method (is_super_init, &list, &this_arg))
10418             {
10419               args = tree_cons (NULL_TREE, this_arg, args);
10420               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10421             }
10422         }
10423     }
10424
10425   /* Merge point of all resolution schemes. If we have nothing, this
10426      is an error, already signaled */
10427   if (!list)
10428     PATCH_METHOD_RETURN_ERROR ();
10429
10430   /* Check accessibility, position the is_static flag, build and
10431      return the call */
10432   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10433                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10434                          NULL_TREE), from_super)
10435       /* Calls to clone() on array types are permitted as a special-case. */
10436       && !is_array_clone_call)
10437     {
10438       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10439       const char *const access =
10440         java_accstring_lookup (get_access_flags_from_decl (list));
10441       const char *const klass =
10442         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10443       const char *const refklass =
10444         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10445       const char *const what = (DECL_CONSTRUCTOR_P (list)
10446                                 ? "constructor" : "method");
10447       /* FIXME: WFL yields the wrong message here but I don't know
10448          what else to use.  */
10449       parse_error_context (wfl,
10450                            "Can't access %s %s `%s.%s' from `%s'",
10451                            access, what, klass, fct_name, refklass);
10452       PATCH_METHOD_RETURN_ERROR ();
10453     }
10454
10455   /* Deprecation check: check whether the method being invoked or the
10456      instance-being-created's type are deprecated. */
10457   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10458     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10459   else
10460     check_deprecation (wfl, list);
10461
10462   /* If invoking a innerclass constructor, there are hidden parameters
10463      to pass */
10464   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10465       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10466     {
10467       /* And make sure we add the accessed local variables to be saved
10468          in field aliases. */
10469       args = build_alias_initializer_parameter_list
10470         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10471
10472       /* Secretly pass the current_this/primary as a second argument */
10473       if (primary || current_this)
10474         {
10475           tree extra_arg;
10476           tree this_type = (current_this ?
10477                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10478           /* Method's (list) enclosing context */
10479           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10480           /* If we have a primary, use it. */
10481           if (primary)
10482             extra_arg = primary;
10483           /* The current `this' is an inner class but isn't a direct
10484              enclosing context for the inner class we're trying to
10485              create. Build an access to the proper enclosing context
10486              and use it. */
10487           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10488                    && this_type != TREE_TYPE (mec))
10489             {
10490
10491               extra_arg = build_access_to_thisn (current_class,
10492                                                  TREE_TYPE (mec), 0);
10493               extra_arg = java_complete_tree (extra_arg);
10494             }
10495           /* Otherwise, just use the current `this' as an enclosing
10496              context. */
10497           else
10498             extra_arg = current_this;
10499           args = tree_cons (NULL_TREE, extra_arg, args);
10500         }
10501       else
10502         args = tree_cons (NULL_TREE, integer_zero_node, args);
10503     }
10504
10505   /* This handles the situation where a constructor invocation needs
10506      to have an enclosing context passed as a second parameter (the
10507      constructor is one of an inner class). */
10508   if ((is_super_init ||
10509        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10510       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10511     {
10512       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10513       tree extra_arg =
10514         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10515       extra_arg = java_complete_tree (extra_arg);
10516       args = tree_cons (NULL_TREE, extra_arg, args);
10517     }
10518
10519   is_static_flag = METHOD_STATIC (list);
10520   if (! is_static_flag && this_arg != NULL_TREE)
10521     args = tree_cons (NULL_TREE, this_arg, args);
10522
10523   /* In the context of an explicit constructor invocation, we can't
10524      invoke any method relying on `this'. Exceptions are: we're
10525      invoking a static function, primary exists and is not the current
10526      this, we're creating a new object. */
10527   if (ctxp->explicit_constructor_p
10528       && !is_static_flag
10529       && (!primary || primary == current_this)
10530       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10531     {
10532       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10533       PATCH_METHOD_RETURN_ERROR ();
10534     }
10535   java_parser_context_restore_global ();
10536   if (is_static)
10537     *is_static = is_static_flag;
10538   /* Sometimes, we want the decl of the selected method. Such as for
10539      EH checking */
10540   if (ret_decl)
10541     *ret_decl = list;
10542   patch = patch_invoke (patch, list, args);
10543
10544   /* Now is a good time to insert the call to finit$ */
10545   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10546     {
10547       tree finit_parms, finit_call;
10548
10549       /* Prepare to pass hidden parameters to finit$, if any. */
10550       finit_parms = build_alias_initializer_parameter_list
10551         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10552
10553       finit_call =
10554         build_method_invocation (build_wfl_node (finit_identifier_node),
10555                                  finit_parms);
10556
10557       /* Generate the code used to initialize fields declared with an
10558          initialization statement and build a compound statement along
10559          with the super constructor invocation. */
10560       CAN_COMPLETE_NORMALLY (patch) = 1;
10561       patch = build (COMPOUND_EXPR, void_type_node, patch,
10562                      java_complete_tree (finit_call));
10563     }
10564   return patch;
10565 }
10566
10567 /* Check that we're not trying to do a static reference to a method in
10568    non static method. Return 1 if it's the case, 0 otherwise. */
10569
10570 static int
10571 check_for_static_method_reference (wfl, node, method, where, primary)
10572      tree wfl, node, method, where, primary;
10573 {
10574   if (METHOD_STATIC (current_function_decl)
10575       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10576     {
10577       char *fct_name = xstrdup (lang_printable_name (method, 0));
10578       parse_error_context
10579         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10580          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10581          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10582       free (fct_name);
10583       return 1;
10584     }
10585   return 0;
10586 }
10587
10588 /* Fix the invocation of *MDECL if necessary in the case of a
10589    invocation from an inner class. *THIS_ARG might be modified
10590    appropriately and an alternative access to *MDECL might be
10591    returned.  */
10592
10593 static int
10594 maybe_use_access_method (is_super_init, mdecl, this_arg)
10595      int is_super_init;
10596      tree *mdecl, *this_arg;
10597 {
10598   tree ctx;
10599   tree md = *mdecl, ta = *this_arg;
10600   int to_return = 0;
10601   int non_static_context = !METHOD_STATIC (md);
10602
10603   if (is_super_init
10604       || DECL_CONTEXT (md) == current_class
10605       || !PURE_INNER_CLASS_TYPE_P (current_class)
10606       || DECL_FINIT_P (md)
10607       || DECL_INSTINIT_P (md))
10608     return 0;
10609
10610   /* If we're calling a method found in an enclosing class, generate
10611      what it takes to retrieve the right this. Don't do that if we're
10612      invoking a static method. Note that if MD's type is unrelated to
10613      CURRENT_CLASS, then the current this can be used. */
10614
10615   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10616     {
10617       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10618       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10619         {
10620           ta = build_current_thisn (current_class);
10621           ta = build_wfl_node (ta);
10622         }
10623       else
10624         {
10625           tree type = ctx;
10626           while (type)
10627             {
10628               maybe_build_thisn_access_method (type);
10629               if (inherits_from_p (type, DECL_CONTEXT (md)))
10630                 {
10631                   ta = build_access_to_thisn (ctx, type, 0);
10632                   break;
10633                 }
10634               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10635                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10636             }
10637         }
10638       ta = java_complete_tree (ta);
10639     }
10640
10641   /* We might have to use an access method to get to MD. We can
10642      break the method access rule as far as we're not generating
10643      bytecode */
10644   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10645     {
10646       md = build_outer_method_access_method (md);
10647       to_return = 1;
10648     }
10649
10650   *mdecl = md;
10651   *this_arg = ta;
10652
10653   /* Returnin a nonzero value indicates we were doing a non static
10654      method invokation that is now a static invocation. It will have
10655      callee displace `this' to insert it in the regular argument
10656      list. */
10657   return (non_static_context && to_return);
10658 }
10659
10660 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10661    mode.  */
10662
10663 static tree
10664 patch_invoke (patch, method, args)
10665      tree patch, method, args;
10666 {
10667   tree dtable, func;
10668   tree original_call, t, ta;
10669   tree check = NULL_TREE;
10670
10671   /* Last step for args: convert build-in types. If we're dealing with
10672      a new TYPE() type call, the first argument to the constructor
10673      isn't found in the incoming argument list, but delivered by
10674      `new' */
10675   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10676   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10677     t = TREE_CHAIN (t);
10678   for (ta = args; t != end_params_node && ta;
10679        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10680     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10681         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10682       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10683
10684   /* Resolve unresolved returned type isses */
10685   t = TREE_TYPE (TREE_TYPE (method));
10686   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10687     resolve_and_layout (TREE_TYPE (t), NULL);
10688
10689   if (flag_emit_class_files || flag_emit_xref)
10690     func = method;
10691   else
10692     {
10693       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10694         {
10695         case INVOKE_VIRTUAL:
10696           dtable = invoke_build_dtable (0, args);
10697           func = build_invokevirtual (dtable, method);
10698           break;
10699
10700         case INVOKE_NONVIRTUAL:
10701           /* If the object for the method call is null, we throw an
10702              exception.  We don't do this if the object is the current
10703              method's `this'.  In other cases we just rely on an
10704              optimization pass to eliminate redundant checks.  */
10705           if (TREE_VALUE (args) != current_this)
10706             {
10707               /* We use a save_expr here to make sure we only evaluate
10708                  the new `self' expression once.  */
10709               tree save_arg = save_expr (TREE_VALUE (args));
10710               TREE_VALUE (args) = save_arg;
10711               check = java_check_reference (save_arg, 1);
10712             }
10713           /* Fall through.  */
10714
10715         case INVOKE_SUPER:
10716         case INVOKE_STATIC:
10717           {
10718             tree signature = build_java_signature (TREE_TYPE (method));
10719             func = build_known_method_ref (method, TREE_TYPE (method),
10720                                            DECL_CONTEXT (method),
10721                                            signature, args);
10722           }
10723           break;
10724
10725         case INVOKE_INTERFACE:
10726           dtable = invoke_build_dtable (1, args);
10727           func = build_invokeinterface (dtable, method);
10728           break;
10729
10730         default:
10731           abort ();
10732         }
10733
10734       /* Ensure self_type is initialized, (invokestatic). FIXME */
10735       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10736     }
10737
10738   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10739   TREE_OPERAND (patch, 0) = func;
10740   TREE_OPERAND (patch, 1) = args;
10741   patch = check_for_builtin (method, patch);
10742   original_call = patch;
10743
10744   /* We're processing a `new TYPE ()' form. New is called and its
10745      returned value is the first argument to the constructor. We build
10746      a COMPOUND_EXPR and use saved expression so that the overall NEW
10747      expression value is a pointer to a newly created and initialized
10748      class. */
10749   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10750     {
10751       tree class = DECL_CONTEXT (method);
10752       tree c1, saved_new, size, new;
10753       tree alloc_node;
10754
10755       if (flag_emit_class_files || flag_emit_xref)
10756         {
10757           TREE_TYPE (patch) = build_pointer_type (class);
10758           return patch;
10759         }
10760       if (!TYPE_SIZE (class))
10761         safe_layout_class (class);
10762       size = size_in_bytes (class);
10763       alloc_node =
10764         (class_has_finalize_method (class) ? alloc_object_node
10765                                            : alloc_no_finalizer_node);
10766       new = build (CALL_EXPR, promote_type (class),
10767                    build_address_of (alloc_node),
10768                    tree_cons (NULL_TREE, build_class_ref (class),
10769                               build_tree_list (NULL_TREE,
10770                                                size_in_bytes (class))),
10771                    NULL_TREE);
10772       saved_new = save_expr (new);
10773       c1 = build_tree_list (NULL_TREE, saved_new);
10774       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10775       TREE_OPERAND (original_call, 1) = c1;
10776       TREE_SET_CODE (original_call, CALL_EXPR);
10777       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10778     }
10779
10780   /* If CHECK is set, then we are building a check to see if the object
10781      is NULL.  */
10782   if (check != NULL_TREE)
10783     {
10784       /* We have to call force_evaluation_order now because creating a
10785          COMPOUND_EXPR wraps the arg list in a way that makes it
10786          unrecognizable by force_evaluation_order later.  Yuk.  */
10787       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10788                      force_evaluation_order (patch));
10789       TREE_SIDE_EFFECTS (patch) = 1;
10790     }
10791
10792   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10793      put it as the first expression of a COMPOUND_EXPR. The second
10794      expression being an empty statement to be later patched if
10795      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10796      the VALUE is the compound) in a hashtable and return a
10797      COMPOUND_EXPR built so that the result of the evaluation of the
10798      original PATCH node is returned. */
10799   if (STATIC_CLASS_INIT_OPT_P ()
10800       && current_function_decl && METHOD_STATIC (method))
10801     {
10802       tree list;
10803       tree fndecl = current_function_decl;
10804       /* We have to call force_evaluation_order now because creating a
10805          COMPOUND_EXPR wraps the arg list in a way that makes it
10806          unrecognizable by force_evaluation_order later.  Yuk.  */
10807       tree save = save_expr (force_evaluation_order (patch));
10808       tree type = TREE_TYPE (patch);
10809
10810       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10811       list = tree_cons (method, patch,
10812                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10813
10814       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10815
10816       patch = build (COMPOUND_EXPR, type, patch, save);
10817     }
10818
10819   return patch;
10820 }
10821
10822 static int
10823 invocation_mode (method, super)
10824      tree method;
10825      int super;
10826 {
10827   int access = get_access_flags_from_decl (method);
10828
10829   if (super)
10830     return INVOKE_SUPER;
10831
10832   if (access & ACC_STATIC)
10833     return INVOKE_STATIC;
10834
10835   /* We have to look for a constructor before we handle nonvirtual
10836      calls; otherwise the constructor will look nonvirtual.  */
10837   if (DECL_CONSTRUCTOR_P (method))
10838     return INVOKE_STATIC;
10839
10840   if (access & ACC_FINAL || access & ACC_PRIVATE)
10841     return INVOKE_NONVIRTUAL;
10842
10843   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10844     return INVOKE_NONVIRTUAL;
10845
10846   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10847     return INVOKE_INTERFACE;
10848
10849   return INVOKE_VIRTUAL;
10850 }
10851
10852 /* Retrieve a refined list of matching methods. It covers the step
10853    15.11.2 (Compile-Time Step 2) */
10854
10855 static tree
10856 lookup_method_invoke (lc, cl, class, name, arg_list)
10857      int lc;
10858      tree cl;
10859      tree class, name, arg_list;
10860 {
10861   tree atl = end_params_node;           /* Arg Type List */
10862   tree method, signature, list, node;
10863   const char *candidates;               /* Used for error report */
10864   char *dup;
10865
10866   /* Fix the arguments */
10867   for (node = arg_list; node; node = TREE_CHAIN (node))
10868     {
10869       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10870       /* Non primitive type may have to be resolved */
10871       if (!JPRIMITIVE_TYPE_P (current_arg))
10872         resolve_and_layout (current_arg, NULL_TREE);
10873       /* And promoted */
10874       if (TREE_CODE (current_arg) == RECORD_TYPE)
10875         current_arg = promote_type (current_arg);
10876       atl = tree_cons (NULL_TREE, current_arg, atl);
10877     }
10878
10879   /* Presto. If we're dealing with an anonymous class and a
10880      constructor call, generate the right constructor now, since we
10881      know the arguments' types. */
10882
10883   if (lc && ANONYMOUS_CLASS_P (class))
10884     {
10885       tree saved_current_class;
10886       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10887       saved_current_class = current_class;
10888       current_class = class;
10889       fix_constructors (mdecl);
10890       current_class = saved_current_class;
10891     }
10892
10893   /* Find all candidates and then refine the list, searching for the
10894      most specific method. */
10895   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10896   list = find_most_specific_methods_list (list);
10897   if (list && !TREE_CHAIN (list))
10898     return TREE_VALUE (list);
10899
10900   /* Issue an error. List candidates if any. Candidates are listed
10901      only if accessible (non accessible methods may end-up here for
10902      the sake of a better error report). */
10903   candidates = NULL;
10904   if (list)
10905     {
10906       tree current;
10907       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10908       for (current = list; current; current = TREE_CHAIN (current))
10909         {
10910           tree cm = TREE_VALUE (current);
10911           char string [4096];
10912           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10913             continue;
10914           sprintf
10915             (string, "  `%s' in `%s'%s",
10916              get_printable_method_name (cm),
10917              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10918              (TREE_CHAIN (current) ? "\n" : ""));
10919           obstack_grow (&temporary_obstack, string, strlen (string));
10920         }
10921       obstack_1grow (&temporary_obstack, '\0');
10922       candidates = obstack_finish (&temporary_obstack);
10923     }
10924   /* Issue the error message */
10925   method = make_node (FUNCTION_TYPE);
10926   TYPE_ARG_TYPES (method) = atl;
10927   signature = build_java_argument_signature (method);
10928   dup = xstrdup (lang_printable_name (class, 0));
10929   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10930                        (lc ? "constructor" : "method"),
10931                        (lc ? dup : IDENTIFIER_POINTER (name)),
10932                        IDENTIFIER_POINTER (signature), dup,
10933                        (candidates ? candidates : ""));
10934   free (dup);
10935   return NULL_TREE;
10936 }
10937
10938 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10939    when we're looking for a constructor. */
10940
10941 static tree
10942 find_applicable_accessible_methods_list (lc, class, name, arglist)
10943      int lc;
10944      tree class, name, arglist;
10945 {
10946   static htab_t searched_classes;
10947   static int search_not_done = 0;
10948   tree list = NULL_TREE, all_list = NULL_TREE;
10949
10950   /* Check the hash table to determine if this class has been searched
10951      already. */
10952   if (searched_classes)
10953     {
10954       if (htab_find (searched_classes, class) != NULL)
10955         return NULL;
10956     }
10957   else
10958     {
10959       searched_classes = htab_create (10, htab_hash_pointer,
10960                                       htab_eq_pointer, NULL);
10961     }
10962
10963   search_not_done++;
10964   *htab_find_slot (searched_classes, class, INSERT) = class;
10965
10966   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
10967     {
10968       load_class (class, 1);
10969       safe_layout_class (class);
10970     }
10971
10972   /* Search interfaces */
10973   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
10974       && CLASS_INTERFACE (TYPE_NAME (class)))
10975     {
10976       int i, n;
10977       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
10978       search_applicable_methods_list (lc, TYPE_METHODS (class),
10979                                       name, arglist, &list, &all_list);
10980       n = TREE_VEC_LENGTH (basetype_vec);
10981       for (i = 1; i < n; i++)
10982         {
10983           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10984           tree rlist;
10985
10986           rlist = find_applicable_accessible_methods_list (lc,  t, name,
10987                                                            arglist);
10988           list = chainon (rlist, list);
10989         }
10990     }
10991   /* Search classes */
10992   else
10993     {
10994       search_applicable_methods_list (lc, TYPE_METHODS (class),
10995                                       name, arglist, &list, &all_list);
10996
10997       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
10998          that we only search in class. Note that we should have found
10999          something at this point. */
11000       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11001         {
11002           lc = 1;
11003           if (!list)
11004             abort ();
11005         }
11006
11007       /* We must search all interfaces of this class */
11008       if (!lc)
11009       {
11010         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11011         int n = TREE_VEC_LENGTH (basetype_vec), i;
11012         for (i = 1; i < n; i++)
11013           {
11014             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11015             if (t != object_type_node)
11016               {
11017                 tree rlist
11018                   = find_applicable_accessible_methods_list (lc, t,
11019                                                              name, arglist);
11020                 list = chainon (rlist, list);
11021               }
11022           }
11023       }
11024
11025       /* Search superclass */
11026       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11027         {
11028           tree rlist;
11029           class = CLASSTYPE_SUPER (class);
11030           rlist = find_applicable_accessible_methods_list (lc, class,
11031                                                            name, arglist);
11032           list = chainon (rlist, list);
11033         }
11034     }
11035
11036   search_not_done--;
11037
11038   /* We're done. Reset the searched classes list and finally search
11039      java.lang.Object if it wasn't searched already. */
11040   if (!search_not_done)
11041     {
11042       if (!lc
11043           && TYPE_METHODS (object_type_node)
11044           && htab_find (searched_classes, object_type_node) == NULL)
11045         {
11046           search_applicable_methods_list (lc,
11047                                           TYPE_METHODS (object_type_node),
11048                                           name, arglist, &list, &all_list);
11049         }
11050       htab_delete (searched_classes);
11051       searched_classes = NULL;
11052     }
11053
11054   /* Either return the list obtained or all selected (but
11055      inaccessible) methods for better error report. */
11056   return (!list ? all_list : list);
11057 }
11058
11059 /* Effectively search for the appropriate method in method */
11060
11061 static void
11062 search_applicable_methods_list (lc, method, name, arglist, list, all_list)
11063      int lc;
11064      tree method, name, arglist;
11065      tree *list, *all_list;
11066 {
11067   for (; method; method = TREE_CHAIN (method))
11068     {
11069       /* When dealing with constructor, stop here, otherwise search
11070          other classes */
11071       if (lc && !DECL_CONSTRUCTOR_P (method))
11072         continue;
11073       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11074                        || (DECL_NAME (method) != name)))
11075         continue;
11076
11077       if (argument_types_convertible (method, arglist))
11078         {
11079           /* Retain accessible methods only */
11080           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11081                                  method, NULL_TREE, 0))
11082             *list = tree_cons (NULL_TREE, method, *list);
11083           else
11084             /* Also retain all selected method here */
11085             *all_list = tree_cons (NULL_TREE, method, *list);
11086         }
11087     }
11088 }
11089
11090 /* 15.11.2.2 Choose the Most Specific Method */
11091
11092 static tree
11093 find_most_specific_methods_list (list)
11094      tree list;
11095 {
11096   int max = 0;
11097   int abstract, candidates;
11098   tree current, new_list = NULL_TREE;
11099   for (current = list; current; current = TREE_CHAIN (current))
11100     {
11101       tree method;
11102       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11103
11104       for (method = list; method; method = TREE_CHAIN (method))
11105         {
11106           tree method_v, current_v;
11107           /* Don't test a method against itself */
11108           if (method == current)
11109             continue;
11110
11111           method_v = TREE_VALUE (method);
11112           current_v = TREE_VALUE (current);
11113
11114           /* Compare arguments and location where methods where declared */
11115           if (argument_types_convertible (method_v, current_v))
11116             {
11117               if (valid_method_invocation_conversion_p
11118                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11119                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11120                       && enclosing_context_p (DECL_CONTEXT (method_v),
11121                                               DECL_CONTEXT (current_v))))
11122                 {
11123                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11124                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11125                   max = (v > max ? v : max);
11126                 }
11127             }
11128         }
11129     }
11130
11131   /* Review the list and select the maximally specific methods */
11132   for (current = list, abstract = -1, candidates = -1;
11133        current; current = TREE_CHAIN (current))
11134     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11135       {
11136         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11137         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11138         candidates++;
11139       }
11140
11141   /* If we have several and they're all abstract, just pick the
11142      closest one. */
11143   if (candidates > 0 && (candidates == abstract))
11144     {
11145       new_list = nreverse (new_list);
11146       TREE_CHAIN (new_list) = NULL_TREE;
11147     }
11148
11149   /* We have several (we couldn't find a most specific), all but one
11150      are abstract, we pick the only non abstract one. */
11151   if (candidates > 0 && (candidates == abstract+1))
11152     {
11153       for (current = new_list; current; current = TREE_CHAIN (current))
11154         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11155           {
11156             TREE_CHAIN (current) = NULL_TREE;
11157             new_list = current;
11158           }
11159     }
11160
11161   /* If we can't find one, lower expectations and try to gather multiple
11162      maximally specific methods */
11163   while (!new_list && max)
11164     {
11165       while (--max > 0)
11166         {
11167           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11168             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11169         }
11170     }
11171
11172   return new_list;
11173 }
11174
11175 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11176    converted by method invocation conversion (5.3) to the type of the
11177    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11178    to change less often than M1. */
11179
11180 static GTY(()) tree m2_arg_value;
11181 static GTY(()) tree m2_arg_cache;
11182
11183 static int
11184 argument_types_convertible (m1, m2_or_arglist)
11185     tree m1, m2_or_arglist;
11186 {
11187   register tree m1_arg, m2_arg;
11188
11189   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11190
11191   if (m2_arg_value == m2_or_arglist)
11192     m2_arg = m2_arg_cache;
11193   else
11194     {
11195       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11196          argument types */
11197       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11198         {
11199           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11200           if (!METHOD_STATIC (m2_or_arglist))
11201             m2_arg = TREE_CHAIN (m2_arg);
11202         }
11203       else
11204         m2_arg = m2_or_arglist;
11205
11206       m2_arg_value = m2_or_arglist;
11207       m2_arg_cache = m2_arg;
11208     }
11209
11210   while (m1_arg != end_params_node && m2_arg != end_params_node)
11211     {
11212       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11213       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11214                                                  TREE_VALUE (m2_arg)))
11215         break;
11216       m1_arg = TREE_CHAIN (m1_arg);
11217       m2_arg = TREE_CHAIN (m2_arg);
11218     }
11219   return m1_arg == end_params_node && m2_arg == end_params_node;
11220 }
11221
11222 /* Qualification routines */
11223
11224 static void
11225 qualify_ambiguous_name (id)
11226      tree id;
11227 {
11228   tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
11229     saved_current_class;
11230   int again, super_found = 0, this_found = 0, new_array_found = 0;
11231   int code;
11232
11233   /* We first qualify the first element, then derive qualification of
11234      others based on the first one. If the first element is qualified
11235      by a resolution (field or type), this resolution is stored in the
11236      QUAL_RESOLUTION of the qual element being examined. We need to
11237      save the current_class since the use of SUPER might change the
11238      its value. */
11239   saved_current_class = current_class;
11240   qual = EXPR_WFL_QUALIFICATION (id);
11241   do {
11242
11243     /* Simple qualified expression feature a qual_wfl that is a
11244        WFL. Expression derived from a primary feature more complicated
11245        things like a CALL_EXPR. Expression from primary need to be
11246        worked out to extract the part on which the qualification will
11247        take place. */
11248     qual_wfl = QUAL_WFL (qual);
11249     switch (TREE_CODE (qual_wfl))
11250       {
11251       case CALL_EXPR:
11252         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11253         if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION
11254             || (EXPR_WFL_QUALIFICATION (qual_wfl)
11255                 && TREE_CODE (EXPR_WFL_QUALIFICATION (qual_wfl)) == TREE_LIST))
11256           {
11257             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11258             qual_wfl = QUAL_WFL (qual);
11259           }
11260         break;
11261       case NEW_ARRAY_EXPR:
11262       case NEW_ANONYMOUS_ARRAY_EXPR:
11263         qual = TREE_CHAIN (qual);
11264         again = new_array_found = 1;
11265         continue;
11266       case CONVERT_EXPR:
11267         break;
11268       case NEW_CLASS_EXPR:
11269         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11270         break;
11271       case ARRAY_REF:
11272         while (TREE_CODE (qual_wfl) == ARRAY_REF)
11273           qual_wfl = TREE_OPERAND (qual_wfl, 0);
11274         break;
11275       case STRING_CST:
11276         qual = TREE_CHAIN (qual);
11277         qual_wfl = QUAL_WFL (qual);
11278         break;
11279       case CLASS_LITERAL:
11280         qual = TREE_CHAIN (qual);
11281         qual_wfl = QUAL_WFL (qual);
11282       break;
11283       default:
11284         /* Fix for -Wall. Just break doing nothing */
11285         break;
11286       }
11287
11288     ptr_type = current_class;
11289     again = 0;
11290     code = TREE_CODE (qual_wfl);
11291
11292     /* Pos evaluation: non WFL leading expression nodes */
11293     if (code == CONVERT_EXPR
11294         && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
11295       name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
11296
11297     else if (code == INTEGER_CST)
11298       name = qual_wfl;
11299
11300     else if (code == CONVERT_EXPR &&
11301              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11302       name = TREE_OPERAND (qual_wfl, 0);
11303
11304     else if (code == CONVERT_EXPR
11305              && TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == CALL_EXPR
11306              && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0))
11307                  == EXPR_WITH_FILE_LOCATION))
11308       name = TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0);
11309
11310     else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
11311              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11312       name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
11313
11314     else if (code == TREE_LIST)
11315       name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
11316
11317     else if (code == STRING_CST || code == CONDITIONAL_EXPR
11318              || code == PLUS_EXPR)
11319       {
11320         qual = TREE_CHAIN (qual);
11321         qual_wfl = QUAL_WFL (qual);
11322         again = 1;
11323       }
11324     else
11325       {
11326         name = EXPR_WFL_NODE (qual_wfl);
11327         if (!name)
11328           {
11329             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11330             again = 1;
11331           }
11332       }
11333
11334     /* If we have a THIS (from a primary), we set the context accordingly */
11335     if (name == this_identifier_node)
11336       {
11337         /* This isn't really elegant. One more added irregularity
11338            before I start using COMPONENT_REF (hopefully very soon.)  */
11339         if (TREE_CODE (TREE_PURPOSE (qual)) == ARRAY_REF
11340             && TREE_CODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11341                EXPR_WITH_FILE_LOCATION
11342             && EXPR_WFL_NODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11343                this_identifier_node)
11344             {
11345               qual = TREE_OPERAND (TREE_PURPOSE (qual), 0);
11346               qual = EXPR_WFL_QUALIFICATION (qual);
11347             }
11348         qual = TREE_CHAIN (qual);
11349         qual_wfl = QUAL_WFL (qual);
11350         if (TREE_CODE (qual_wfl) == CALL_EXPR)
11351           again = 1;
11352         else if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION)
11353           name = EXPR_WFL_NODE (qual_wfl);
11354         else if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
11355           name = TREE_OPERAND (qual_wfl, 0);
11356         this_found = 1;
11357       }
11358     /* If we have a SUPER, we set the context accordingly */
11359     if (name == super_identifier_node)
11360       {
11361         current_class = CLASSTYPE_SUPER (ptr_type);
11362         /* Check that there is such a thing as a super class. If not,
11363            return.  The error will be caught later on, during the
11364            resolution */
11365         if (!current_class)
11366           {
11367             current_class = saved_current_class;
11368             return;
11369           }
11370         qual = TREE_CHAIN (qual);
11371         /* Do one more interation to set things up */
11372         super_found = again = 1;
11373       }
11374   } while (again);
11375
11376   /* If name appears within the scope of a local variable declaration
11377      or parameter declaration, then it is an expression name. We don't
11378      carry this test out if we're in the context of the use of SUPER
11379      or THIS */
11380   if (!this_found && !super_found
11381       && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
11382       && (decl = IDENTIFIER_LOCAL_VALUE (name)))
11383     {
11384       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11385       QUAL_RESOLUTION (qual) = decl;
11386     }
11387
11388   /* If within the class/interface NAME was found to be used there
11389      exists a (possibly inherited) field named NAME, then this is an
11390      expression name. If we saw a NEW_ARRAY_EXPR before and want to
11391      address length, it is OK. */
11392   else if ((decl = lookup_field_wrapper (ptr_type, name))
11393            || name == length_identifier_node)
11394     {
11395       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11396       QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
11397     }
11398
11399   /* We reclassify NAME as yielding to a type name resolution if:
11400      - NAME is a class/interface declared within the compilation
11401        unit containing NAME,
11402      - NAME is imported via a single-type-import declaration,
11403      - NAME is declared in an another compilation unit of the package
11404        of the compilation unit containing NAME,
11405      - NAME is declared by exactly on type-import-on-demand declaration
11406      of the compilation unit containing NAME.
11407      - NAME is actually a STRING_CST.
11408      This can't happen if the expression was qualified by `this.' */
11409   else if (! this_found &&
11410            (TREE_CODE (name) == STRING_CST ||
11411             TREE_CODE (name) == INTEGER_CST ||
11412             (decl = resolve_and_layout (name, NULL_TREE))))
11413     {
11414       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11415       QUAL_RESOLUTION (qual) = decl;
11416     }
11417
11418   /* Method call, array references and cast are expression name */
11419   else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
11420            || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
11421            || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR
11422            || TREE_CODE (QUAL_WFL (qual)) == MODIFY_EXPR)
11423     RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11424
11425   /* Check here that NAME isn't declared by more than one
11426      type-import-on-demand declaration of the compilation unit
11427      containing NAME. FIXME */
11428
11429   /* Otherwise, NAME is reclassified as a package name */
11430   else
11431     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11432
11433   /* Propagate the qualification accross other components of the
11434      qualified name */
11435   for (qual = TREE_CHAIN (qual); qual;
11436        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11437     {
11438       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11439         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11440       else
11441         RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
11442     }
11443
11444   /* Store the global qualification for the ambiguous part of ID back
11445      into ID fields */
11446   if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
11447     RESOLVE_EXPRESSION_NAME_P (id) = 1;
11448   else if (RESOLVE_TYPE_NAME_P (qual_wfl))
11449     RESOLVE_TYPE_NAME_P (id) = 1;
11450   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11451     RESOLVE_PACKAGE_NAME_P (id) = 1;
11452
11453   /* Restore the current class */
11454   current_class = saved_current_class;
11455 }
11456
11457 static int
11458 breakdown_qualified (left, right, source)
11459     tree *left, *right, source;
11460 {
11461   char *p, *base;
11462   int l = IDENTIFIER_LENGTH (source);
11463
11464   base = alloca (l + 1);
11465   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11466
11467   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11468   p = base + l - 1;
11469   while (*p != '.' && p != base)
11470     p--;
11471
11472   /* We didn't find a '.'. Return an error.  */
11473   if (p == base)
11474     return 1;
11475
11476   *p = '\0';
11477   if (right)
11478     *right = get_identifier (p+1);
11479   *left = get_identifier (base);
11480
11481   return 0;
11482 }
11483
11484 /* Return TRUE if two classes are from the same package. */
11485
11486 static int
11487 in_same_package (name1, name2)
11488   tree name1, name2;
11489 {
11490   tree tmp;
11491   tree pkg1;
11492   tree pkg2;
11493
11494   if (TREE_CODE (name1) == TYPE_DECL)
11495     name1 = DECL_NAME (name1);
11496   if (TREE_CODE (name2) == TYPE_DECL)
11497     name2 = DECL_NAME (name2);
11498
11499   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11500     /* One in empty package. */
11501     return 0;
11502
11503   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11504     /* Both in empty package. */
11505     return 1;
11506
11507   breakdown_qualified (&pkg1, &tmp, name1);
11508   breakdown_qualified (&pkg2, &tmp, name2);
11509
11510   return (pkg1 == pkg2);
11511 }
11512
11513 /* Patch tree nodes in a function body. When a BLOCK is found, push
11514    local variable decls if present.
11515    Same as java_complete_lhs, but does resolve static finals to values. */
11516
11517 static tree
11518 java_complete_tree (node)
11519      tree node;
11520 {
11521   node = java_complete_lhs (node);
11522   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11523       && DECL_INITIAL (node) != NULL_TREE
11524       && !flag_emit_xref)
11525     {
11526       tree value = fold_constant_for_init (node, node);
11527       if (value != NULL_TREE)
11528         return value;
11529     }
11530   return node;
11531 }
11532
11533 static tree
11534 java_stabilize_reference (node)
11535      tree node;
11536 {
11537   if (TREE_CODE (node) == COMPOUND_EXPR)
11538     {
11539       tree op0 = TREE_OPERAND (node, 0);
11540       tree op1 = TREE_OPERAND (node, 1);
11541       TREE_OPERAND (node, 0) = save_expr (op0);
11542       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11543       return node;
11544     }
11545   return stabilize_reference (node);
11546 }
11547
11548 /* Patch tree nodes in a function body. When a BLOCK is found, push
11549    local variable decls if present.
11550    Same as java_complete_tree, but does not resolve static finals to values. */
11551
11552 static tree
11553 java_complete_lhs (node)
11554      tree node;
11555 {
11556   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11557   int flag;
11558
11559   /* CONVERT_EXPR always has its type set, even though it needs to be
11560      worked out. */
11561   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11562     return node;
11563
11564   /* The switch block implements cases processing container nodes
11565      first.  Contained nodes are always written back. Leaves come
11566      next and return a value. */
11567   switch (TREE_CODE (node))
11568     {
11569     case BLOCK:
11570
11571       /* 1- Block section.
11572          Set the local values on decl names so we can identify them
11573          faster when they're referenced. At that stage, identifiers
11574          are legal so we don't check for declaration errors. */
11575       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11576         {
11577           DECL_CONTEXT (cn) = current_function_decl;
11578           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11579         }
11580       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11581           CAN_COMPLETE_NORMALLY (node) = 1;
11582       else
11583         {
11584           tree stmt = BLOCK_EXPR_BODY (node);
11585           tree *ptr;
11586           int error_seen = 0;
11587           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11588             {
11589               /* Re-order from (((A; B); C); ...; Z) to
11590                  (A; (B; (C ; (...; Z)))).
11591                  This makes it easier to scan the statements left-to-right
11592                  without using recursion (which might overflow the stack
11593                  if the block has many statements. */
11594               for (;;)
11595                 {
11596                   tree left = TREE_OPERAND (stmt, 0);
11597                   if (TREE_CODE (left) != COMPOUND_EXPR)
11598                     break;
11599                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11600                   TREE_OPERAND (left, 1) = stmt;
11601                   stmt = left;
11602                 }
11603               BLOCK_EXPR_BODY (node) = stmt;
11604             }
11605
11606           /* Now do the actual complete, without deep recursion for
11607              long blocks. */
11608           ptr = &BLOCK_EXPR_BODY (node);
11609           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11610                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11611             {
11612               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11613               tree *next = &TREE_OPERAND (*ptr, 1);
11614               TREE_OPERAND (*ptr, 0) = cur;
11615               if (cur == empty_stmt_node)
11616                 {
11617                   /* Optimization;  makes it easier to detect empty bodies.
11618                      Most useful for <clinit> with all-constant initializer. */
11619                   *ptr = *next;
11620                   continue;
11621                 }
11622               if (TREE_CODE (cur) == ERROR_MARK)
11623                 error_seen++;
11624               else if (! CAN_COMPLETE_NORMALLY (cur))
11625                 {
11626                   wfl_op2 = *next;
11627                   for (;;)
11628                     {
11629                       if (TREE_CODE (wfl_op2) == BLOCK)
11630                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11631                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11632                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11633                       else
11634                         break;
11635                     }
11636                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11637                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11638                     unreachable_stmt_error (*ptr);
11639                 }
11640               ptr = next;
11641             }
11642           *ptr = java_complete_tree (*ptr);
11643
11644           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11645             return error_mark_node;
11646           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11647         }
11648       /* Turn local bindings to null */
11649       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11650         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11651
11652       TREE_TYPE (node) = void_type_node;
11653       break;
11654
11655       /* 2- They are expressions but ultimately deal with statements */
11656
11657     case THROW_EXPR:
11658       wfl_op1 = TREE_OPERAND (node, 0);
11659       COMPLETE_CHECK_OP_0 (node);
11660       /* 14.19 A throw statement cannot complete normally. */
11661       CAN_COMPLETE_NORMALLY (node) = 0;
11662       return patch_throw_statement (node, wfl_op1);
11663
11664     case SYNCHRONIZED_EXPR:
11665       wfl_op1 = TREE_OPERAND (node, 0);
11666       return patch_synchronized_statement (node, wfl_op1);
11667
11668     case TRY_EXPR:
11669       return patch_try_statement (node);
11670
11671     case TRY_FINALLY_EXPR:
11672       COMPLETE_CHECK_OP_0 (node);
11673       COMPLETE_CHECK_OP_1 (node);
11674       if (TREE_OPERAND (node, 0) == empty_stmt_node)
11675         return TREE_OPERAND (node, 1);
11676       if (TREE_OPERAND (node, 1) == empty_stmt_node)
11677         return TREE_OPERAND (node, 0);
11678       CAN_COMPLETE_NORMALLY (node)
11679         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11680            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11681       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11682       return node;
11683
11684     case LABELED_BLOCK_EXPR:
11685       PUSH_LABELED_BLOCK (node);
11686       if (LABELED_BLOCK_BODY (node))
11687         COMPLETE_CHECK_OP_1 (node);
11688       TREE_TYPE (node) = void_type_node;
11689       POP_LABELED_BLOCK ();
11690
11691       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11692         {
11693           LABELED_BLOCK_BODY (node) = NULL_TREE;
11694           CAN_COMPLETE_NORMALLY (node) = 1;
11695         }
11696       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11697         CAN_COMPLETE_NORMALLY (node) = 1;
11698       return node;
11699
11700     case EXIT_BLOCK_EXPR:
11701       /* We don't complete operand 1, because it's the return value of
11702          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11703       return patch_bc_statement (node);
11704
11705     case CASE_EXPR:
11706       cn = java_complete_tree (TREE_OPERAND (node, 0));
11707       if (cn == error_mark_node)
11708         return cn;
11709
11710       /* First, the case expression must be constant. Values of final
11711          fields are accepted. */
11712       cn = fold (cn);
11713       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11714           && JDECL_P (TREE_OPERAND (cn, 1))
11715           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11716           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11717         {
11718           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11719                                        TREE_OPERAND (cn, 1));
11720         }
11721       /* Accept final locals too. */
11722       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11723         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11724
11725       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11726         {
11727           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11728           parse_error_context (node, "Constant expression required");
11729           return error_mark_node;
11730         }
11731
11732       nn = ctxp->current_loop;
11733
11734       /* It must be assignable to the type of the switch expression. */
11735       if (!try_builtin_assignconv (NULL_TREE,
11736                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11737         {
11738           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11739           parse_error_context
11740             (wfl_operator,
11741              "Incompatible type for case. Can't convert `%s' to `int'",
11742              lang_printable_name (TREE_TYPE (cn), 0));
11743           return error_mark_node;
11744         }
11745
11746       cn = fold (convert (int_type_node, cn));
11747       TREE_CONSTANT_OVERFLOW (cn) = 0;
11748       CAN_COMPLETE_NORMALLY (cn) = 1;
11749
11750       /* Save the label on a list so that we can later check for
11751          duplicates.  */
11752       case_label_list = tree_cons (node, cn, case_label_list);
11753
11754       /* Multiple instance of a case label bearing the same value is
11755          checked later. The case expression is all right so far. */
11756       if (TREE_CODE (cn) == VAR_DECL)
11757         cn = DECL_INITIAL (cn);
11758       TREE_OPERAND (node, 0) = cn;
11759       TREE_TYPE (node) = void_type_node;
11760       CAN_COMPLETE_NORMALLY (node) = 1;
11761       TREE_SIDE_EFFECTS (node) = 1;
11762       break;
11763
11764     case DEFAULT_EXPR:
11765       nn = ctxp->current_loop;
11766       /* Only one default label is allowed per switch statement */
11767       if (SWITCH_HAS_DEFAULT (nn))
11768         {
11769           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11770           parse_error_context (wfl_operator,
11771                                "Duplicate case label: `default'");
11772           return error_mark_node;
11773         }
11774       else
11775         SWITCH_HAS_DEFAULT (nn) = 1;
11776       TREE_TYPE (node) = void_type_node;
11777       TREE_SIDE_EFFECTS (node) = 1;
11778       CAN_COMPLETE_NORMALLY (node) = 1;
11779       break;
11780
11781     case SWITCH_EXPR:
11782     case LOOP_EXPR:
11783       PUSH_LOOP (node);
11784       /* Check whether the loop was enclosed in a labeled
11785          statement. If not, create one, insert the loop in it and
11786          return the node */
11787       nn = patch_loop_statement (node);
11788
11789       /* Anyways, walk the body of the loop */
11790       if (TREE_CODE (node) == LOOP_EXPR)
11791         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11792       /* Switch statement: walk the switch expression and the cases */
11793       else
11794         node = patch_switch_statement (node);
11795
11796       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11797         nn = error_mark_node;
11798       else
11799         {
11800           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11801           /* If we returned something different, that's because we
11802              inserted a label. Pop the label too. */
11803           if (nn != node)
11804             {
11805               if (CAN_COMPLETE_NORMALLY (node))
11806                 CAN_COMPLETE_NORMALLY (nn) = 1;
11807               POP_LABELED_BLOCK ();
11808             }
11809         }
11810       POP_LOOP ();
11811       return nn;
11812
11813     case EXIT_EXPR:
11814       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11815       return patch_exit_expr (node);
11816
11817     case COND_EXPR:
11818       /* Condition */
11819       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11820       if (TREE_OPERAND (node, 0) == error_mark_node)
11821         return error_mark_node;
11822       /* then-else branches */
11823       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11824       if (TREE_OPERAND (node, 1) == error_mark_node)
11825         return error_mark_node;
11826       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11827       if (TREE_OPERAND (node, 2) == error_mark_node)
11828         return error_mark_node;
11829       return patch_if_else_statement (node);
11830       break;
11831
11832     case CONDITIONAL_EXPR:
11833       /* Condition */
11834       wfl_op1 = TREE_OPERAND (node, 0);
11835       COMPLETE_CHECK_OP_0 (node);
11836       wfl_op2 = TREE_OPERAND (node, 1);
11837       COMPLETE_CHECK_OP_1 (node);
11838       wfl_op3 = TREE_OPERAND (node, 2);
11839       COMPLETE_CHECK_OP_2 (node);
11840       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11841
11842       /* 3- Expression section */
11843     case COMPOUND_EXPR:
11844       wfl_op2 = TREE_OPERAND (node, 1);
11845       TREE_OPERAND (node, 0) = nn =
11846         java_complete_tree (TREE_OPERAND (node, 0));
11847       if (wfl_op2 == empty_stmt_node)
11848         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11849       else
11850         {
11851           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11852             {
11853               /* An unreachable condition in a do-while statement
11854                  is *not* (technically) an unreachable statement. */
11855               nn = wfl_op2;
11856               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11857                 nn = EXPR_WFL_NODE (nn);
11858               if (TREE_CODE (nn) != EXIT_EXPR)
11859                 {
11860                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11861                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11862                     {
11863                       /* Perhaps this warning should have an
11864                          associated flag.  The code being compiled is
11865                          pedantically correct, but useless.  */
11866                       parse_warning_context (wfl_operator,
11867                                              "Unreachable statement");
11868                     }
11869                   else
11870                     parse_error_context (wfl_operator,
11871                                          "Unreachable statement");
11872                 }
11873             }
11874           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11875           if (TREE_OPERAND (node, 1) == error_mark_node)
11876             return error_mark_node;
11877           /* Even though we might allow the case where the first
11878              operand doesn't return normally, we still should compute
11879              CAN_COMPLETE_NORMALLY correctly.  */
11880           CAN_COMPLETE_NORMALLY (node)
11881             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11882                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11883         }
11884       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11885       break;
11886
11887     case RETURN_EXPR:
11888       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11889       return patch_return (node);
11890
11891     case EXPR_WITH_FILE_LOCATION:
11892       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11893           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11894         {
11895           tree wfl = node;
11896           node = resolve_expression_name (node, NULL);
11897           if (node == error_mark_node)
11898             return node;
11899           /* Keep line number information somewhere were it doesn't
11900              disrupt the completion process. */
11901           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11902             {
11903               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11904               TREE_OPERAND (node, 1) = wfl;
11905             }
11906           CAN_COMPLETE_NORMALLY (node) = 1;
11907         }
11908       else
11909         {
11910           tree body;
11911           int save_lineno = lineno;
11912           lineno = EXPR_WFL_LINENO (node);
11913           body = java_complete_tree (EXPR_WFL_NODE (node));
11914           lineno = save_lineno;
11915           EXPR_WFL_NODE (node) = body;
11916           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11917           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11918           if (body == empty_stmt_node || TREE_CONSTANT (body))
11919             {
11920               /* Makes it easier to constant fold, detect empty bodies. */
11921               return body;
11922             }
11923           if (body == error_mark_node)
11924             {
11925               /* Its important for the evaluation of assignment that
11926                  this mark on the TREE_TYPE is propagated. */
11927               TREE_TYPE (node) = error_mark_node;
11928               return error_mark_node;
11929             }
11930           else
11931             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11932
11933         }
11934       break;
11935
11936     case NEW_ARRAY_EXPR:
11937       /* Patch all the dimensions */
11938       flag = 0;
11939       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11940         {
11941           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11942           tree dim = convert (int_type_node,
11943                               java_complete_tree (TREE_VALUE (cn)));
11944           if (dim == error_mark_node)
11945             {
11946               flag = 1;
11947               continue;
11948             }
11949           else
11950             {
11951               TREE_VALUE (cn) = dim;
11952               /* Setup the location of the current dimension, for
11953                  later error report. */
11954               TREE_PURPOSE (cn) =
11955                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11956               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11957             }
11958         }
11959       /* They complete the array creation expression, if no errors
11960          were found. */
11961       CAN_COMPLETE_NORMALLY (node) = 1;
11962       return (flag ? error_mark_node
11963               : force_evaluation_order (patch_newarray (node)));
11964
11965     case NEW_ANONYMOUS_ARRAY_EXPR:
11966       /* Create the array type if necessary. */
11967       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11968         {
11969           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11970           if (!(type = resolve_type_during_patch (type)))
11971             return error_mark_node;
11972           type = build_array_from_name (type, NULL_TREE,
11973                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11974           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11975         }
11976       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11977                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11978       if (node == error_mark_node)
11979         return error_mark_node;
11980       CAN_COMPLETE_NORMALLY (node) = 1;
11981       return node;
11982
11983     case NEW_CLASS_EXPR:
11984     case CALL_EXPR:
11985       /* Complete function's argument(s) first */
11986       if (complete_function_arguments (node))
11987         return error_mark_node;
11988       else
11989         {
11990           tree decl, wfl = TREE_OPERAND (node, 0);
11991           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11992           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11993                            super_identifier_node);
11994
11995           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11996                                           from_super, 0, &decl);
11997           if (node == error_mark_node)
11998             return error_mark_node;
11999
12000           check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
12001           /* If we call this(...), register signature and positions */
12002           if (in_this)
12003             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
12004               tree_cons (wfl, decl,
12005                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
12006           CAN_COMPLETE_NORMALLY (node) = 1;
12007           return force_evaluation_order (node);
12008         }
12009
12010     case MODIFY_EXPR:
12011       /* Save potential wfls */
12012       wfl_op1 = TREE_OPERAND (node, 0);
12013       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
12014
12015       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
12016           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
12017           && DECL_INITIAL (nn) != NULL_TREE)
12018         {
12019           tree value;
12020
12021           value = fold_constant_for_init (nn, nn);
12022
12023           /* When we have a primitype type, or a string and we're not
12024              emitting a class file, we actually don't want to generate
12025              anything for the assignment. */
12026           if (value != NULL_TREE &&
12027               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12028                (TREE_TYPE (value) == string_ptr_type_node &&
12029                 ! flag_emit_class_files)))
12030             {
12031               /* Prepare node for patch_assignment */
12032               TREE_OPERAND (node, 1) = value;
12033               /* Call patch assignment to verify the assignment */
12034               if (patch_assignment (node, wfl_op1) == error_mark_node)
12035                 return error_mark_node;
12036               /* Set DECL_INITIAL properly (a conversion might have
12037                  been decided by patch_assignment) and return the
12038                  empty statement. */
12039               else
12040                 {
12041                   tree patched = patch_string (TREE_OPERAND (node, 1));
12042                   if (patched)
12043                     DECL_INITIAL (nn) = patched;
12044                   else
12045                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12046                   DECL_FIELD_FINAL_IUD (nn) = 1;
12047                   return empty_stmt_node;
12048                 }
12049             }
12050           if (! flag_emit_class_files)
12051             DECL_INITIAL (nn) = NULL_TREE;
12052         }
12053       wfl_op2 = TREE_OPERAND (node, 1);
12054
12055       if (TREE_OPERAND (node, 0) == error_mark_node)
12056         return error_mark_node;
12057
12058       flag = COMPOUND_ASSIGN_P (wfl_op2);
12059       if (flag)
12060         {
12061           /* This might break when accessing outer field from inner
12062              class. TESTME, FIXME */
12063           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12064
12065           /* Hand stabilize the lhs on both places */
12066           TREE_OPERAND (node, 0) = lvalue;
12067           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12068             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12069
12070           /* 15.25.2.a: Left hand is not an array access. FIXME */
12071           /* Now complete the RHS. We write it back later on. */
12072           nn = java_complete_tree (TREE_OPERAND (node, 1));
12073
12074           if ((cn = patch_string (nn)))
12075             nn = cn;
12076
12077           /* The last part of the rewrite for E1 op= E2 is to have
12078              E1 = (T)(E1 op E2), with T being the type of E1. */
12079           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12080                                                TREE_TYPE (lvalue), nn));
12081
12082           /* If the assignment is compound and has reference type,
12083              then ensure the LHS has type String and nothing else.  */
12084           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12085               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12086             parse_error_context (wfl_op2,
12087                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12088                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12089
12090           /* 15.25.2.b: Left hand is an array access. FIXME */
12091         }
12092
12093       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12094          function to complete this RHS. Note that a NEW_ARRAY_INIT
12095          might have been already fully expanded if created as a result
12096          of processing an anonymous array initializer. We avoid doing
12097          the operation twice by testing whether the node already bears
12098          a type. */
12099       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12100         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12101                                    TREE_OPERAND (node, 1));
12102       /* Otherwise we simply complete the RHS */
12103       else
12104         nn = java_complete_tree (TREE_OPERAND (node, 1));
12105
12106       if (nn == error_mark_node)
12107         return error_mark_node;
12108
12109       /* Write back the RHS as we evaluated it. */
12110       TREE_OPERAND (node, 1) = nn;
12111
12112       /* In case we're handling = with a String as a RHS, we need to
12113          produce a String out of the RHS (it might still be a
12114          STRING_CST or a StringBuffer at this stage */
12115       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12116         TREE_OPERAND (node, 1) = nn;
12117
12118       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12119                                         TREE_OPERAND (node, 1))))
12120         {
12121           /* We return error_mark_node if outer_field_access_fix
12122              detects we write into a final. */
12123           if (nn == error_mark_node)
12124             return error_mark_node;
12125           node = nn;
12126         }
12127       else
12128         {
12129           node = patch_assignment (node, wfl_op1);
12130           if (node == error_mark_node)
12131             return error_mark_node;
12132           /* Reorganize the tree if necessary. */
12133           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12134                        || JSTRING_P (TREE_TYPE (node))))
12135             node = java_refold (node);
12136         }
12137
12138       /* Seek to set DECL_INITIAL to a proper value, since it might have
12139          undergone a conversion in patch_assignment. We do that only when
12140          it's necessary to have DECL_INITIAL properly set. */
12141       nn = TREE_OPERAND (node, 0);
12142       if (TREE_CODE (nn) == VAR_DECL
12143           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12144           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12145           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12146               || TREE_TYPE (nn) == string_ptr_type_node))
12147         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12148
12149       CAN_COMPLETE_NORMALLY (node) = 1;
12150       return node;
12151
12152     case MULT_EXPR:
12153     case PLUS_EXPR:
12154     case MINUS_EXPR:
12155     case LSHIFT_EXPR:
12156     case RSHIFT_EXPR:
12157     case URSHIFT_EXPR:
12158     case BIT_AND_EXPR:
12159     case BIT_XOR_EXPR:
12160     case BIT_IOR_EXPR:
12161     case TRUNC_MOD_EXPR:
12162     case TRUNC_DIV_EXPR:
12163     case RDIV_EXPR:
12164     case TRUTH_ANDIF_EXPR:
12165     case TRUTH_ORIF_EXPR:
12166     case EQ_EXPR:
12167     case NE_EXPR:
12168     case GT_EXPR:
12169     case GE_EXPR:
12170     case LT_EXPR:
12171     case LE_EXPR:
12172       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12173          knows how to handle those cases. */
12174       wfl_op1 = TREE_OPERAND (node, 0);
12175       wfl_op2 = TREE_OPERAND (node, 1);
12176
12177       CAN_COMPLETE_NORMALLY (node) = 1;
12178       /* Don't complete string nodes if dealing with the PLUS operand. */
12179       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12180         {
12181           nn = java_complete_tree (wfl_op1);
12182           if (nn == error_mark_node)
12183             return error_mark_node;
12184
12185           TREE_OPERAND (node, 0) = nn;
12186         }
12187       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12188         {
12189           nn = java_complete_tree (wfl_op2);
12190           if (nn == error_mark_node)
12191             return error_mark_node;
12192
12193           TREE_OPERAND (node, 1) = nn;
12194         }
12195       return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
12196
12197     case INSTANCEOF_EXPR:
12198       wfl_op1 = TREE_OPERAND (node, 0);
12199       COMPLETE_CHECK_OP_0 (node);
12200       if (flag_emit_xref)
12201         {
12202           TREE_TYPE (node) = boolean_type_node;
12203           return node;
12204         }
12205       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12206
12207     case UNARY_PLUS_EXPR:
12208     case NEGATE_EXPR:
12209     case TRUTH_NOT_EXPR:
12210     case BIT_NOT_EXPR:
12211     case PREDECREMENT_EXPR:
12212     case PREINCREMENT_EXPR:
12213     case POSTDECREMENT_EXPR:
12214     case POSTINCREMENT_EXPR:
12215     case CONVERT_EXPR:
12216       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12217          how to handle those cases. */
12218       wfl_op1 = TREE_OPERAND (node, 0);
12219       CAN_COMPLETE_NORMALLY (node) = 1;
12220       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12221       if (TREE_OPERAND (node, 0) == error_mark_node)
12222         return error_mark_node;
12223       node = patch_unaryop (node, wfl_op1);
12224       CAN_COMPLETE_NORMALLY (node) = 1;
12225       break;
12226
12227     case ARRAY_REF:
12228       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12229          how to handle those cases. */
12230       wfl_op1 = TREE_OPERAND (node, 0);
12231       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12232       if (TREE_OPERAND (node, 0) == error_mark_node)
12233         return error_mark_node;
12234       if (!flag_emit_class_files && !flag_emit_xref)
12235         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12236       /* The same applies to wfl_op2 */
12237       wfl_op2 = TREE_OPERAND (node, 1);
12238       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12239       if (TREE_OPERAND (node, 1) == error_mark_node)
12240         return error_mark_node;
12241       if (!flag_emit_class_files && !flag_emit_xref)
12242         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12243       return patch_array_ref (node);
12244
12245     case RECORD_TYPE:
12246       return node;;
12247
12248     case COMPONENT_REF:
12249       /* The first step in the re-write of qualified name handling.  FIXME.
12250          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12251       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12252       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12253         {
12254           tree name = TREE_OPERAND (node, 1);
12255           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12256           if (field == NULL_TREE)
12257             {
12258               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12259               return error_mark_node;
12260             }
12261           if (! FIELD_STATIC (field))
12262             {
12263               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12264               return error_mark_node;
12265             }
12266           return field;
12267         }
12268       else
12269         abort ();
12270       break;
12271
12272     case THIS_EXPR:
12273       /* Can't use THIS in a static environment */
12274       if (!current_this)
12275         {
12276           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12277           parse_error_context (wfl_operator,
12278                                "Keyword `this' used outside allowed context");
12279           TREE_TYPE (node) = error_mark_node;
12280           return error_mark_node;
12281         }
12282       if (ctxp->explicit_constructor_p)
12283         {
12284           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12285           parse_error_context
12286             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12287           TREE_TYPE (node) = error_mark_node;
12288           return error_mark_node;
12289         }
12290       return current_this;
12291
12292     case CLASS_LITERAL:
12293       CAN_COMPLETE_NORMALLY (node) = 1;
12294       node = patch_incomplete_class_ref (node);
12295       if (node == error_mark_node)
12296         return error_mark_node;
12297       break;
12298
12299     default:
12300       CAN_COMPLETE_NORMALLY (node) = 1;
12301       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12302          and it's time to turn it into the appropriate String object */
12303       if ((nn = patch_string (node)))
12304         node = nn;
12305       else
12306         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12307     }
12308   return node;
12309 }
12310
12311 /* Complete function call's argument. Return a nonzero value is an
12312    error was found.  */
12313
12314 static int
12315 complete_function_arguments (node)
12316      tree node;
12317 {
12318   int flag = 0;
12319   tree cn;
12320
12321   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12322   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12323     {
12324       tree wfl = TREE_VALUE (cn), parm, temp;
12325       parm = java_complete_tree (wfl);
12326
12327       if (parm == error_mark_node)
12328         {
12329           flag = 1;
12330           continue;
12331         }
12332       /* If have a string literal that we haven't transformed yet or a
12333          crafted string buffer, as a result of use of the the String
12334          `+' operator. Build `parm.toString()' and expand it. */
12335       if ((temp = patch_string (parm)))
12336         parm = temp;
12337
12338       TREE_VALUE (cn) = parm;
12339     }
12340   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12341   return flag;
12342 }
12343
12344 /* Sometimes (for loops and variable initialized during their
12345    declaration), we want to wrap a statement around a WFL and turn it
12346    debugable.  */
12347
12348 static tree
12349 build_debugable_stmt (location, stmt)
12350     int location;
12351     tree stmt;
12352 {
12353   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12354     {
12355       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12356       EXPR_WFL_LINECOL (stmt) = location;
12357     }
12358   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12359   return stmt;
12360 }
12361
12362 static tree
12363 build_expr_block (body, decls)
12364      tree body, decls;
12365 {
12366   tree node = make_node (BLOCK);
12367   BLOCK_EXPR_DECLS (node) = decls;
12368   BLOCK_EXPR_BODY (node) = body;
12369   if (body)
12370     TREE_TYPE (node) = TREE_TYPE (body);
12371   TREE_SIDE_EFFECTS (node) = 1;
12372   return node;
12373 }
12374
12375 /* Create a new function block and link it appropriately to current
12376    function block chain */
12377
12378 static tree
12379 enter_block ()
12380 {
12381   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12382
12383   /* Link block B supercontext to the previous block. The current
12384      function DECL is used as supercontext when enter_a_block is called
12385      for the first time for a given function. The current function body
12386      (DECL_FUNCTION_BODY) is set to be block B.  */
12387
12388   tree fndecl = current_function_decl;
12389
12390   if (!fndecl) {
12391     BLOCK_SUPERCONTEXT (b) = current_static_block;
12392     current_static_block = b;
12393   }
12394
12395   else if (!DECL_FUNCTION_BODY (fndecl))
12396     {
12397       BLOCK_SUPERCONTEXT (b) = fndecl;
12398       DECL_FUNCTION_BODY (fndecl) = b;
12399     }
12400   else
12401     {
12402       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12403       DECL_FUNCTION_BODY (fndecl) = b;
12404     }
12405   return b;
12406 }
12407
12408 /* Exit a block by changing the current function body
12409    (DECL_FUNCTION_BODY) to the current block super context, only if
12410    the block being exited isn't the method's top level one.  */
12411
12412 static tree
12413 exit_block ()
12414 {
12415   tree b;
12416   if (current_function_decl)
12417     {
12418       b = DECL_FUNCTION_BODY (current_function_decl);
12419       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12420         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12421     }
12422   else
12423     {
12424       b = current_static_block;
12425
12426       if (BLOCK_SUPERCONTEXT (b))
12427         current_static_block = BLOCK_SUPERCONTEXT (b);
12428     }
12429   return b;
12430 }
12431
12432 /* Lookup for NAME in the nested function's blocks, all the way up to
12433    the current toplevel one. It complies with Java's local variable
12434    scoping rules.  */
12435
12436 static tree
12437 lookup_name_in_blocks (name)
12438      tree name;
12439 {
12440   tree b = GET_CURRENT_BLOCK (current_function_decl);
12441
12442   while (b != current_function_decl)
12443     {
12444       tree current;
12445
12446       /* Paranoid sanity check. To be removed */
12447       if (TREE_CODE (b) != BLOCK)
12448         abort ();
12449
12450       for (current = BLOCK_EXPR_DECLS (b); current;
12451            current = TREE_CHAIN (current))
12452         if (DECL_NAME (current) == name)
12453           return current;
12454       b = BLOCK_SUPERCONTEXT (b);
12455     }
12456   return NULL_TREE;
12457 }
12458
12459 static void
12460 maybe_absorb_scoping_blocks ()
12461 {
12462   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12463     {
12464       tree b = exit_block ();
12465       java_method_add_stmt (current_function_decl, b);
12466       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
12467     }
12468 }
12469
12470 \f
12471 /* This section of the source is reserved to build_* functions that
12472    are building incomplete tree nodes and the patch_* functions that
12473    are completing them.  */
12474
12475 /* Wrap a non WFL node around a WFL.  */
12476
12477 static tree
12478 build_wfl_wrap (node, location)
12479     tree node;
12480     int location;
12481 {
12482   tree wfl, node_to_insert = node;
12483
12484   /* We want to process THIS . xxx symbolicaly, to keep it consistent
12485      with the way we're processing SUPER. A THIS from a primary as a
12486      different form than a SUPER. Turn THIS into something symbolic */
12487   if (TREE_CODE (node) == THIS_EXPR)
12488     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12489   else
12490     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12491
12492   EXPR_WFL_LINECOL (wfl) = location;
12493   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12494   return wfl;
12495 }
12496
12497 /* Build a super() constructor invocation. Returns empty_stmt_node if
12498    we're currently dealing with the class java.lang.Object. */
12499
12500 static tree
12501 build_super_invocation (mdecl)
12502      tree mdecl;
12503 {
12504   if (DECL_CONTEXT (mdecl) == object_type_node)
12505     return empty_stmt_node;
12506   else
12507     {
12508       tree super_wfl = build_wfl_node (super_identifier_node);
12509       tree a = NULL_TREE, t;
12510       /* If we're dealing with an anonymous class, pass the arguments
12511          of the crafted constructor along. */
12512       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12513         {
12514           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12515           for (; t != end_params_node; t = TREE_CHAIN (t))
12516             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12517         }
12518       return build_method_invocation (super_wfl, a);
12519     }
12520 }
12521
12522 /* Build a SUPER/THIS qualified method invocation.  */
12523
12524 static tree
12525 build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
12526      int use_this;
12527      tree name, args;
12528      int lloc, rloc;
12529 {
12530   tree invok;
12531   tree wfl =
12532     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12533   EXPR_WFL_LINECOL (wfl) = lloc;
12534   invok = build_method_invocation (name, args);
12535   return make_qualified_primary (wfl, invok, rloc);
12536 }
12537
12538 /* Build an incomplete CALL_EXPR node. */
12539
12540 static tree
12541 build_method_invocation (name, args)
12542     tree name;
12543     tree args;
12544 {
12545   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12546   TREE_SIDE_EFFECTS (call) = 1;
12547   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12548   return call;
12549 }
12550
12551 /* Build an incomplete new xxx(...) node. */
12552
12553 static tree
12554 build_new_invocation (name, args)
12555     tree name, args;
12556 {
12557   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12558   TREE_SIDE_EFFECTS (call) = 1;
12559   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12560   return call;
12561 }
12562
12563 /* Build an incomplete assignment expression. */
12564
12565 static tree
12566 build_assignment (op, op_location, lhs, rhs)
12567      int op, op_location;
12568      tree lhs, rhs;
12569 {
12570   tree assignment;
12571   /* Build the corresponding binop if we deal with a Compound
12572      Assignment operator. Mark the binop sub-tree as part of a
12573      Compound Assignment expression */
12574   if (op != ASSIGN_TK)
12575     {
12576       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12577       COMPOUND_ASSIGN_P (rhs) = 1;
12578     }
12579   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12580   TREE_SIDE_EFFECTS (assignment) = 1;
12581   EXPR_WFL_LINECOL (assignment) = op_location;
12582   return assignment;
12583 }
12584
12585 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12586    the buffer.  This is used only for string conversion.  */
12587 static char *
12588 string_convert_int_cst (node)
12589      tree node;
12590 {
12591   static char buffer[80];
12592
12593   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12594   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12595   char *p = buffer + sizeof (buffer) - 1;
12596   int neg = 0;
12597
12598   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12599                                   << (HOST_BITS_PER_WIDE_INT - 1));
12600
12601   *p-- = '\0';
12602
12603   /* If negative, note the fact and negate the value.  */
12604   if ((hi & hibit))
12605     {
12606       lo = ~lo;
12607       hi = ~hi;
12608       if (++lo == 0)
12609         ++hi;
12610       neg = 1;
12611     }
12612
12613   /* Divide by 10 until there are no bits left.  */
12614   while (hi || lo)
12615     {
12616       unsigned HOST_WIDE_INT acc = 0;
12617       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12618       unsigned int i;
12619
12620       /* Use long division to compute the result and the remainder.  */
12621       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12622         {
12623           /* Shift a bit into accumulator.  */
12624           acc <<= 1;
12625           if ((hi & hibit))
12626             acc |= 1;
12627
12628           /* Shift the value.  */
12629           hi <<= 1;
12630           if ((lo & hibit))
12631             hi |= 1;
12632           lo <<= 1;
12633
12634           /* Shift the correct bit into the result.  */
12635           outhi <<= 1;
12636           if ((outlo & hibit))
12637             outhi |= 1;
12638           outlo <<= 1;
12639           if (acc >= 10)
12640             {
12641               acc -= 10;
12642               outlo |= 1;
12643             }
12644         }
12645
12646       /* FIXME: ASCII assumption.  */
12647       *p-- = '0' + acc;
12648
12649       hi = outhi;
12650       lo = outlo;
12651     }
12652
12653   if (neg)
12654     *p-- = '-';
12655
12656   return p + 1;
12657 }
12658
12659 /* Print an INTEGER_CST node in a static buffer, and return the
12660    buffer.  This is used only for error handling.  */
12661 char *
12662 print_int_node (node)
12663     tree node;
12664 {
12665   static char buffer [80];
12666   if (TREE_CONSTANT_OVERFLOW (node))
12667     sprintf (buffer, "<overflow>");
12668
12669   if (TREE_INT_CST_HIGH (node) == 0)
12670     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12671              TREE_INT_CST_LOW (node));
12672   else if (TREE_INT_CST_HIGH (node) == -1
12673            && TREE_INT_CST_LOW (node) != 0)
12674     {
12675       buffer [0] = '-';
12676       sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
12677                -TREE_INT_CST_LOW (node));
12678     }
12679   else
12680     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12681              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12682
12683   return buffer;
12684 }
12685
12686 \f
12687 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12688    context.  */
12689
12690 /* 15.25 Assignment operators. */
12691
12692 static tree
12693 patch_assignment (node, wfl_op1)
12694      tree node;
12695      tree wfl_op1;
12696 {
12697   tree rhs = TREE_OPERAND (node, 1);
12698   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12699   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12700   int error_found = 0;
12701   int lvalue_from_array = 0;
12702   int is_return = 0;
12703
12704   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12705
12706   /* Lhs can be a named variable */
12707   if (JDECL_P (lvalue))
12708     {
12709       lhs_type = TREE_TYPE (lvalue);
12710     }
12711   /* Or Lhs can be an array access. */
12712   else if (TREE_CODE (lvalue) == ARRAY_REF)
12713     {
12714       lhs_type = TREE_TYPE (lvalue);
12715       lvalue_from_array = 1;
12716     }
12717   /* Or a field access */
12718   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12719     lhs_type = TREE_TYPE (lvalue);
12720   /* Or a function return slot */
12721   else if (TREE_CODE (lvalue) == RESULT_DECL)
12722     {
12723       /* If the return type is an integral type, then we create the
12724          RESULT_DECL with a promoted type, but we need to do these
12725          checks against the unpromoted type to ensure type safety.  So
12726          here we look at the real type, not the type of the decl we
12727          are modifying.  */
12728       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12729       is_return = 1;
12730     }
12731   /* Otherwise, we might want to try to write into an optimized static
12732      final, this is an of a different nature, reported further on. */
12733   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12734            && resolve_expression_name (wfl_op1, &llvalue))
12735     {
12736       lhs_type = TREE_TYPE (lvalue);
12737     }
12738   else
12739     {
12740       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12741       error_found = 1;
12742     }
12743
12744   rhs_type = TREE_TYPE (rhs);
12745
12746   /* 5.1 Try the assignment conversion for builtin type. */
12747   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12748
12749   /* 5.2 If it failed, try a reference conversion */
12750   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
12751     lhs_type = promote_type (rhs_type);
12752
12753   /* 15.25.2 If we have a compound assignment, convert RHS into the
12754      type of the LHS */
12755   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12756     new_rhs = convert (lhs_type, rhs);
12757
12758   /* Explicit cast required. This is an error */
12759   if (!new_rhs)
12760     {
12761       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12762       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12763       tree wfl;
12764       char operation [32];      /* Max size known */
12765
12766       /* If the assignment is part of a declaration, we use the WFL of
12767          the declared variable to point out the error and call it a
12768          declaration problem. If the assignment is a genuine =
12769          operator, we call is a operator `=' problem, otherwise we
12770          call it an assignment problem. In both of these last cases,
12771          we use the WFL of the operator to indicate the error. */
12772
12773       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12774         {
12775           wfl = wfl_op1;
12776           strcpy (operation, "declaration");
12777         }
12778       else
12779         {
12780           wfl = wfl_operator;
12781           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12782             strcpy (operation, "assignment");
12783           else if (is_return)
12784             strcpy (operation, "`return'");
12785           else
12786             strcpy (operation, "`='");
12787         }
12788
12789       if (!valid_cast_to_p (rhs_type, lhs_type))
12790         parse_error_context
12791           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12792            operation, t1, t2);
12793       else
12794         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12795                              operation, t1, t2);
12796       free (t1); free (t2);
12797       error_found = 1;
12798     }
12799
12800   if (error_found)
12801     return error_mark_node;
12802
12803   /* If we're processing a `return' statement, promote the actual type
12804      to the promoted type.  */
12805   if (is_return)
12806     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12807
12808   /* 10.10: Array Store Exception runtime check */
12809   if (!flag_emit_class_files
12810       && !flag_emit_xref
12811       && lvalue_from_array
12812       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12813     {
12814       tree array, store_check, base, index_expr;
12815
12816       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12817       new_rhs = save_expr (new_rhs);
12818
12819       /* Get the INDIRECT_REF. */
12820       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12821       /* Get the array pointer expr. */
12822       array = TREE_OPERAND (array, 0);
12823       store_check = build_java_arraystore_check (array, new_rhs);
12824
12825       index_expr = TREE_OPERAND (lvalue, 1);
12826
12827       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12828         {
12829           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12830              happen before the store check, so prepare to insert the store
12831              check within the second operand of the existing COMPOUND_EXPR. */
12832           base = index_expr;
12833         }
12834       else
12835         base = lvalue;
12836
12837       index_expr = TREE_OPERAND (base, 1);
12838       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12839                                       store_check, index_expr);
12840     }
12841
12842   /* Final locals can be used as case values in switch
12843      statement. Prepare them for this eventuality. */
12844   if (TREE_CODE (lvalue) == VAR_DECL
12845       && DECL_FINAL (lvalue)
12846       && TREE_CONSTANT (new_rhs)
12847       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12848       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12849       )
12850     {
12851       TREE_CONSTANT (lvalue) = 1;
12852       DECL_INITIAL (lvalue) = new_rhs;
12853     }
12854
12855   TREE_OPERAND (node, 0) = lvalue;
12856   TREE_OPERAND (node, 1) = new_rhs;
12857   TREE_TYPE (node) = lhs_type;
12858   return node;
12859 }
12860
12861 /* Check that type SOURCE can be cast into type DEST. If the cast
12862    can't occur at all, return NULL; otherwise, return a possibly
12863    modified rhs.  */
12864
12865 static tree
12866 try_reference_assignconv (lhs_type, rhs)
12867      tree lhs_type, rhs;
12868 {
12869   tree new_rhs = NULL_TREE;
12870   tree rhs_type = TREE_TYPE (rhs);
12871
12872   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12873     {
12874       /* `null' may be assigned to any reference type */
12875       if (rhs == null_pointer_node)
12876         new_rhs = null_pointer_node;
12877       /* Try the reference assignment conversion */
12878       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12879         new_rhs = rhs;
12880       /* This is a magic assignment that we process differently */
12881       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12882         new_rhs = rhs;
12883     }
12884   return new_rhs;
12885 }
12886
12887 /* Check that RHS can be converted into LHS_TYPE by the assignment
12888    conversion (5.2), for the cases of RHS being a builtin type. Return
12889    NULL_TREE if the conversion fails or if because RHS isn't of a
12890    builtin type. Return a converted RHS if the conversion is possible.  */
12891
12892 static tree
12893 try_builtin_assignconv (wfl_op1, lhs_type, rhs)
12894      tree wfl_op1, lhs_type, rhs;
12895 {
12896   tree new_rhs = NULL_TREE;
12897   tree rhs_type = TREE_TYPE (rhs);
12898
12899   /* Handle boolean specially.  */
12900   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12901       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12902     {
12903       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12904           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12905         new_rhs = rhs;
12906     }
12907
12908   /* 5.1.1 Try Identity Conversion,
12909      5.1.2 Try Widening Primitive Conversion */
12910   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12911     new_rhs = convert (lhs_type, rhs);
12912
12913   /* Try a narrowing primitive conversion (5.1.3):
12914        - expression is a constant expression of type byte, short, char,
12915          or int, AND
12916        - variable is byte, short or char AND
12917        - The value of the expression is representable in the type of the
12918          variable */
12919   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12920             || rhs_type == char_type_node || rhs_type == int_type_node)
12921             && TREE_CONSTANT (rhs)
12922            && (lhs_type == byte_type_node || lhs_type == char_type_node
12923                || lhs_type == short_type_node))
12924     {
12925       if (int_fits_type_p (rhs, lhs_type))
12926         new_rhs = convert (lhs_type, rhs);
12927       else if (wfl_op1)         /* Might be called with a NULL */
12928         parse_warning_context
12929           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12930            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12931       /* Reported a warning that will turn into an error further
12932          down, so we don't return */
12933     }
12934
12935   return new_rhs;
12936 }
12937
12938 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12939    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12940    0 is the conversion test fails.  This implements parts the method
12941    invocation convertion (5.3).  */
12942
12943 static int
12944 valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
12945      tree lhs_type, rhs_type;
12946 {
12947   /* 5.1.1: This is the identity conversion part. */
12948   if (lhs_type == rhs_type)
12949     return 1;
12950
12951   /* Reject non primitive types and boolean conversions.  */
12952   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12953     return 0;
12954
12955   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12956      than a char can't be converted into a char. Short can't too, but
12957      the < test below takes care of that */
12958   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12959     return 0;
12960
12961   /* Accept all promoted type here. Note, we can't use <= in the test
12962      below, because we still need to bounce out assignments of short
12963      to char and the likes */
12964   if (lhs_type == int_type_node
12965       && (rhs_type == promoted_byte_type_node
12966           || rhs_type == promoted_short_type_node
12967           || rhs_type == promoted_char_type_node
12968           || rhs_type == promoted_boolean_type_node))
12969     return 1;
12970
12971   /* From here, an integral is widened if its precision is smaller
12972      than the precision of the LHS or if the LHS is a floating point
12973      type, or the RHS is a float and the RHS a double. */
12974   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12975        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12976       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12977       || (rhs_type == float_type_node && lhs_type == double_type_node))
12978     return 1;
12979
12980   return 0;
12981 }
12982
12983 /* Check that something of SOURCE type can be assigned or cast to
12984    something of DEST type at runtime. Return 1 if the operation is
12985    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12986    were SOURCE is cast into DEST, which borrows a lot of the
12987    assignment check. */
12988
12989 static int
12990 valid_ref_assignconv_cast_p (source, dest, cast)
12991      tree source;
12992      tree dest;
12993      int cast;
12994 {
12995   /* SOURCE or DEST might be null if not from a declared entity. */
12996   if (!source || !dest)
12997     return 0;
12998   if (JNULLP_TYPE_P (source))
12999     return 1;
13000   if (TREE_CODE (source) == POINTER_TYPE)
13001     source = TREE_TYPE (source);
13002   if (TREE_CODE (dest) == POINTER_TYPE)
13003     dest = TREE_TYPE (dest);
13004
13005   /* If source and dest are being compiled from bytecode, they may need to
13006      be loaded. */
13007   if (CLASS_P (source) && !CLASS_LOADED_P (source))
13008     {
13009       load_class (source, 1);
13010       safe_layout_class (source);
13011     }
13012   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
13013     {
13014       load_class (dest, 1);
13015       safe_layout_class (dest);
13016     }
13017
13018   /* Case where SOURCE is a class type */
13019   if (TYPE_CLASS_P (source))
13020     {
13021       if (TYPE_CLASS_P (dest))
13022         return  (source == dest
13023                  || inherits_from_p (source, dest)
13024                  || (cast && inherits_from_p (dest, source)));
13025       if (TYPE_INTERFACE_P (dest))
13026         {
13027           /* If doing a cast and SOURCE is final, the operation is
13028              always correct a compile time (because even if SOURCE
13029              does not implement DEST, a subclass of SOURCE might). */
13030           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13031             return 1;
13032           /* Otherwise, SOURCE must implement DEST */
13033           return interface_of_p (dest, source);
13034         }
13035       /* DEST is an array, cast permited if SOURCE is of Object type */
13036       return (cast && source == object_type_node ? 1 : 0);
13037     }
13038   if (TYPE_INTERFACE_P (source))
13039     {
13040       if (TYPE_CLASS_P (dest))
13041         {
13042           /* If not casting, DEST must be the Object type */
13043           if (!cast)
13044             return dest == object_type_node;
13045           /* We're doing a cast. The cast is always valid is class
13046              DEST is not final, otherwise, DEST must implement SOURCE */
13047           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13048             return 1;
13049           else
13050             return interface_of_p (source, dest);
13051         }
13052       if (TYPE_INTERFACE_P (dest))
13053         {
13054           /* If doing a cast, then if SOURCE and DEST contain method
13055              with the same signature but different return type, then
13056              this is a (compile time) error */
13057           if (cast)
13058             {
13059               tree method_source, method_dest;
13060               tree source_type;
13061               tree source_sig;
13062               tree source_name;
13063               for (method_source = TYPE_METHODS (source); method_source;
13064                    method_source = TREE_CHAIN (method_source))
13065                 {
13066                   source_sig =
13067                     build_java_argument_signature (TREE_TYPE (method_source));
13068                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13069                   source_name = DECL_NAME (method_source);
13070                   for (method_dest = TYPE_METHODS (dest);
13071                        method_dest; method_dest = TREE_CHAIN (method_dest))
13072                     if (source_sig ==
13073                         build_java_argument_signature (TREE_TYPE (method_dest))
13074                         && source_name == DECL_NAME (method_dest)
13075                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13076                       return 0;
13077                 }
13078               return 1;
13079             }
13080           else
13081             return source == dest || interface_of_p (dest, source);
13082         }
13083       else
13084         {
13085           /* Array */
13086           return (cast
13087                   && (DECL_NAME (TYPE_NAME (source))
13088                       == java_lang_cloneable_identifier_node
13089                       || (DECL_NAME (TYPE_NAME (source))
13090                           == java_io_serializable_identifier_node)));
13091         }
13092     }
13093   if (TYPE_ARRAY_P (source))
13094     {
13095       if (TYPE_CLASS_P (dest))
13096         return dest == object_type_node;
13097       /* Can't cast an array to an interface unless the interface is
13098          java.lang.Cloneable or java.io.Serializable.  */
13099       if (TYPE_INTERFACE_P (dest))
13100         return (DECL_NAME (TYPE_NAME (dest))
13101                 == java_lang_cloneable_identifier_node
13102                 || (DECL_NAME (TYPE_NAME (dest))
13103                     == java_io_serializable_identifier_node));
13104       else                      /* Arrays */
13105         {
13106           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13107           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13108
13109           /* In case of severe errors, they turn out null */
13110           if (!dest_element_type || !source_element_type)
13111             return 0;
13112           if (source_element_type == dest_element_type)
13113             return 1;
13114           return valid_ref_assignconv_cast_p (source_element_type,
13115                                               dest_element_type, cast);
13116         }
13117       return 0;
13118     }
13119   return 0;
13120 }
13121
13122 static int
13123 valid_cast_to_p (source, dest)
13124      tree source;
13125      tree dest;
13126 {
13127   if (TREE_CODE (source) == POINTER_TYPE)
13128     source = TREE_TYPE (source);
13129   if (TREE_CODE (dest) == POINTER_TYPE)
13130     dest = TREE_TYPE (dest);
13131
13132   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13133     return valid_ref_assignconv_cast_p (source, dest, 1);
13134
13135   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13136     return 1;
13137
13138   else if (TREE_CODE (source) == BOOLEAN_TYPE
13139            && TREE_CODE (dest) == BOOLEAN_TYPE)
13140     return 1;
13141
13142   return 0;
13143 }
13144
13145 static tree
13146 do_unary_numeric_promotion (arg)
13147      tree arg;
13148 {
13149   tree type = TREE_TYPE (arg);
13150   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13151       || TREE_CODE (type) == CHAR_TYPE)
13152     arg = convert (int_type_node, arg);
13153   return arg;
13154 }
13155
13156 /* Return a nonzero value if SOURCE can be converted into DEST using
13157    the method invocation conversion rule (5.3).  */
13158 static int
13159 valid_method_invocation_conversion_p (dest, source)
13160      tree dest, source;
13161 {
13162   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13163            && valid_builtin_assignconv_identity_widening_p (dest, source))
13164           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13165               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13166               && valid_ref_assignconv_cast_p (source, dest, 0)));
13167 }
13168
13169 /* Build an incomplete binop expression. */
13170
13171 static tree
13172 build_binop (op, op_location, op1, op2)
13173      enum tree_code op;
13174      int op_location;
13175      tree op1, op2;
13176 {
13177   tree binop = build (op, NULL_TREE, op1, op2);
13178   TREE_SIDE_EFFECTS (binop) = 1;
13179   /* Store the location of the operator, for better error report. The
13180      string of the operator will be rebuild based on the OP value. */
13181   EXPR_WFL_LINECOL (binop) = op_location;
13182   return binop;
13183 }
13184
13185 /* Build the string of the operator retained by NODE. If NODE is part
13186    of a compound expression, add an '=' at the end of the string. This
13187    function is called when an error needs to be reported on an
13188    operator. The string is returned as a pointer to a static character
13189    buffer. */
13190
13191 static char *
13192 operator_string (node)
13193      tree node;
13194 {
13195 #define BUILD_OPERATOR_STRING(S)                                        \
13196   {                                                                     \
13197     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13198     return buffer;                                                      \
13199   }
13200
13201   static char buffer [10];
13202   switch (TREE_CODE (node))
13203     {
13204     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13205     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13206     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13207     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13208     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13209     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13210     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13211     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13212     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13213     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13214     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13215     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13216     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13217     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13218     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13219     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13220     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13221     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13222     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13223     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13224     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13225     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13226     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13227     case PREINCREMENT_EXPR:     /* Fall through */
13228     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13229     case PREDECREMENT_EXPR:     /* Fall through */
13230     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13231     default:
13232       internal_error ("unregistered operator %s",
13233                       tree_code_name [TREE_CODE (node)]);
13234     }
13235   return NULL;
13236 #undef BUILD_OPERATOR_STRING
13237 }
13238
13239 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13240
13241 static int
13242 java_decl_equiv (var_acc1, var_acc2)
13243      tree var_acc1, var_acc2;
13244 {
13245   if (JDECL_P (var_acc1))
13246     return (var_acc1 == var_acc2);
13247
13248   return (TREE_CODE (var_acc1) == COMPONENT_REF
13249           && TREE_CODE (var_acc2) == COMPONENT_REF
13250           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13251              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13252           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13253 }
13254
13255 /* Return a nonzero value if CODE is one of the operators that can be
13256    used in conjunction with the `=' operator in a compound assignment.  */
13257
13258 static int
13259 binop_compound_p (code)
13260     enum tree_code code;
13261 {
13262   int i;
13263   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13264     if (binop_lookup [i] == code)
13265       break;
13266
13267   return i < BINOP_COMPOUND_CANDIDATES;
13268 }
13269
13270 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13271
13272 static tree
13273 java_refold (t)
13274      tree t;
13275 {
13276   tree c, b, ns, decl;
13277
13278   if (TREE_CODE (t) != MODIFY_EXPR)
13279     return t;
13280
13281   c = TREE_OPERAND (t, 1);
13282   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13283          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13284          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13285     return t;
13286
13287   /* Now the left branch of the binary operator. */
13288   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13289   if (! (b && TREE_CODE (b) == NOP_EXPR
13290          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13291     return t;
13292
13293   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13294   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13295          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13296     return t;
13297
13298   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13299   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13300       /* It's got to be the an equivalent decl */
13301       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13302     {
13303       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13304       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13305       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13306       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13307       /* Change the right part of the BINOP_EXPR */
13308       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13309     }
13310
13311   return t;
13312 }
13313
13314 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13315    errors but we modify NODE so that it contains the type computed
13316    according to the expression, when it's fixed. Otherwise, we write
13317    error_mark_node as the type. It allows us to further the analysis
13318    of remaining nodes and detects more errors in certain cases.  */
13319
13320 static tree
13321 patch_binop (node, wfl_op1, wfl_op2)
13322      tree node;
13323      tree wfl_op1;
13324      tree wfl_op2;
13325 {
13326   tree op1 = TREE_OPERAND (node, 0);
13327   tree op2 = TREE_OPERAND (node, 1);
13328   tree op1_type = TREE_TYPE (op1);
13329   tree op2_type = TREE_TYPE (op2);
13330   tree prom_type = NULL_TREE, cn;
13331   enum tree_code code = TREE_CODE (node);
13332
13333   /* If 1, tell the routine that we have to return error_mark_node
13334      after checking for the initialization of the RHS */
13335   int error_found = 0;
13336
13337   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13338
13339   /* If either op<n>_type are NULL, this might be early signs of an
13340      error situation, unless it's too early to tell (in case we're
13341      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13342      correctly so the error can be later on reported accurately. */
13343   if (! (code == PLUS_EXPR || code == NE_EXPR
13344          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13345     {
13346       tree n;
13347       if (! op1_type)
13348         {
13349           n = java_complete_tree (op1);
13350           op1_type = TREE_TYPE (n);
13351         }
13352       if (! op2_type)
13353         {
13354           n = java_complete_tree (op2);
13355           op2_type = TREE_TYPE (n);
13356         }
13357     }
13358
13359   switch (code)
13360     {
13361     /* 15.16 Multiplicative operators */
13362     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13363     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13364     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13365     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13366       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13367         {
13368           if (!JNUMERIC_TYPE_P (op1_type))
13369             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13370           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13371             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13372           TREE_TYPE (node) = error_mark_node;
13373           error_found = 1;
13374           break;
13375         }
13376       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13377
13378       /* Detect integral division by zero */
13379       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13380           && TREE_CODE (prom_type) == INTEGER_TYPE
13381           && (op2 == integer_zero_node || op2 == long_zero_node ||
13382               (TREE_CODE (op2) == INTEGER_CST &&
13383                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13384         {
13385           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13386           TREE_CONSTANT (node) = 0;
13387         }
13388
13389       /* Change the division operator if necessary */
13390       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13391         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13392
13393       /* Before divisions as is disapear, try to simplify and bail if
13394          applicable, otherwise we won't perform even simple
13395          simplifications like (1-1)/3. We can't do that with floating
13396          point number, folds can't handle them at this stage. */
13397       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13398           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13399         {
13400           TREE_TYPE (node) = prom_type;
13401           node = fold (node);
13402           if (TREE_CODE (node) != code)
13403             return node;
13404         }
13405
13406       if (TREE_CODE (prom_type) == INTEGER_TYPE
13407           && flag_use_divide_subroutine
13408           && ! flag_emit_class_files
13409           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13410         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13411
13412       /* This one is more complicated. FLOATs are processed by a
13413          function call to soft_fmod. Duplicate the value of the
13414          COMPOUND_ASSIGN_P flag. */
13415       if (code == TRUNC_MOD_EXPR)
13416         {
13417           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13418           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13419           TREE_SIDE_EFFECTS (mod)
13420             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13421           return mod;
13422         }
13423       break;
13424
13425     /* 15.17 Additive Operators */
13426     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13427
13428       /* Operation is valid if either one argument is a string
13429          constant, a String object or a StringBuffer crafted for the
13430          purpose of the a previous usage of the String concatenation
13431          operator */
13432
13433       if (TREE_CODE (op1) == STRING_CST
13434           || TREE_CODE (op2) == STRING_CST
13435           || JSTRING_TYPE_P (op1_type)
13436           || JSTRING_TYPE_P (op2_type)
13437           || IS_CRAFTED_STRING_BUFFER_P (op1)
13438           || IS_CRAFTED_STRING_BUFFER_P (op2))
13439         return build_string_concatenation (op1, op2);
13440
13441     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13442                                    Numeric Types */
13443       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13444         {
13445           if (!JNUMERIC_TYPE_P (op1_type))
13446             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13447           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13448             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13449           TREE_TYPE (node) = error_mark_node;
13450           error_found = 1;
13451           break;
13452         }
13453       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13454       break;
13455
13456     /* 15.18 Shift Operators */
13457     case LSHIFT_EXPR:
13458     case RSHIFT_EXPR:
13459     case URSHIFT_EXPR:
13460       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13461         {
13462           if (!JINTEGRAL_TYPE_P (op1_type))
13463             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13464           else
13465             {
13466               if (JNUMERIC_TYPE_P (op2_type))
13467                 parse_error_context (wfl_operator,
13468                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13469                                      operator_string (node),
13470                                      lang_printable_name (op2_type, 0));
13471               else
13472                 parse_error_context (wfl_operator,
13473                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13474                                      operator_string (node),
13475                                      lang_printable_name (op2_type, 0));
13476             }
13477           TREE_TYPE (node) = error_mark_node;
13478           error_found = 1;
13479           break;
13480         }
13481
13482       /* Unary numeric promotion (5.6.1) is performed on each operand
13483          separately */
13484       op1 = do_unary_numeric_promotion (op1);
13485       op2 = do_unary_numeric_promotion (op2);
13486
13487       /* If the right hand side is of type `long', first cast it to
13488          `int'.  */
13489       if (TREE_TYPE (op2) == long_type_node)
13490         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13491
13492       /* The type of the shift expression is the type of the promoted
13493          type of the left-hand operand */
13494       prom_type = TREE_TYPE (op1);
13495
13496       /* Shift int only up to 0x1f and long up to 0x3f */
13497       if (prom_type == int_type_node)
13498         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13499                            build_int_2 (0x1f, 0)));
13500       else
13501         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13502                            build_int_2 (0x3f, 0)));
13503
13504       /* The >>> operator is a >> operating on unsigned quantities */
13505       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13506         {
13507           tree to_return;
13508           tree utype = java_unsigned_type (prom_type);
13509           op1 = convert (utype, op1);
13510           TREE_SET_CODE (node, RSHIFT_EXPR);
13511           TREE_OPERAND (node, 0) = op1;
13512           TREE_OPERAND (node, 1) = op2;
13513           TREE_TYPE (node) = utype;
13514           to_return = convert (prom_type, node);
13515           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13516           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13517           TREE_SIDE_EFFECTS (to_return)
13518             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13519           return to_return;
13520         }
13521       break;
13522
13523       /* 15.19.1 Type Comparison Operator instaceof */
13524     case INSTANCEOF_EXPR:
13525
13526       TREE_TYPE (node) = boolean_type_node;
13527
13528       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13529       if ((cn = patch_string (op1)))
13530         {
13531           op1 = cn;
13532           op1_type = TREE_TYPE (op1);
13533         }
13534       if (op1_type == NULL_TREE)
13535         abort ();
13536
13537       if (!(op2_type = resolve_type_during_patch (op2)))
13538         return error_mark_node;
13539
13540       /* The first operand must be a reference type or the null type */
13541       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13542         error_found = 1;        /* Error reported further below */
13543
13544       /* The second operand must be a reference type */
13545       if (!JREFERENCE_TYPE_P (op2_type))
13546         {
13547           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13548           parse_error_context
13549             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13550              lang_printable_name (op2_type, 0));
13551           error_found = 1;
13552         }
13553
13554       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13555         {
13556           /* If the first operand is null, the result is always false */
13557           if (op1 == null_pointer_node)
13558             return boolean_false_node;
13559           else if (flag_emit_class_files)
13560             {
13561               TREE_OPERAND (node, 1) = op2_type;
13562               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13563               return node;
13564             }
13565           /* Otherwise we have to invoke instance of to figure it out */
13566           else
13567             return build_instanceof (op1, op2_type);
13568         }
13569       /* There is no way the expression operand can be an instance of
13570          the type operand. This is a compile time error. */
13571       else
13572         {
13573           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13574           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13575           parse_error_context
13576             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13577              t1, lang_printable_name (op2_type, 0));
13578           free (t1);
13579           error_found = 1;
13580         }
13581
13582       break;
13583
13584       /* 15.21 Bitwise and Logical Operators */
13585     case BIT_AND_EXPR:
13586     case BIT_XOR_EXPR:
13587     case BIT_IOR_EXPR:
13588       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13589         /* Binary numeric promotion is performed on both operand and the
13590            expression retain that type */
13591         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13592
13593       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13594                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13595         /* The type of the bitwise operator expression is BOOLEAN */
13596         prom_type = boolean_type_node;
13597       else
13598         {
13599           if (!JINTEGRAL_TYPE_P (op1_type))
13600             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13601           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13602             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13603           TREE_TYPE (node) = error_mark_node;
13604           error_found = 1;
13605           /* Insert a break here if adding thing before the switch's
13606              break for this case */
13607         }
13608       break;
13609
13610       /* 15.22 Conditional-And Operator */
13611     case TRUTH_ANDIF_EXPR:
13612       /* 15.23 Conditional-Or Operator */
13613     case TRUTH_ORIF_EXPR:
13614       /* Operands must be of BOOLEAN type */
13615       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13616           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13617         {
13618           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13619             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13620           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13621             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13622           TREE_TYPE (node) = boolean_type_node;
13623           error_found = 1;
13624           break;
13625         }
13626       else if (integer_zerop (op1))
13627         {
13628           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13629         }
13630       else if (integer_onep (op1))
13631         {
13632           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13633         }
13634       /* The type of the conditional operators is BOOLEAN */
13635       prom_type = boolean_type_node;
13636       break;
13637
13638       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13639     case LT_EXPR:
13640     case GT_EXPR:
13641     case LE_EXPR:
13642     case GE_EXPR:
13643       /* The type of each of the operands must be a primitive numeric
13644          type */
13645       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13646         {
13647           if (!JNUMERIC_TYPE_P (op1_type))
13648             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13649           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13650             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13651           TREE_TYPE (node) = boolean_type_node;
13652           error_found = 1;
13653           break;
13654         }
13655       /* Binary numeric promotion is performed on the operands */
13656       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13657       /* The type of the relation expression is always BOOLEAN */
13658       prom_type = boolean_type_node;
13659       break;
13660
13661       /* 15.20 Equality Operator */
13662     case EQ_EXPR:
13663     case NE_EXPR:
13664       /* It's time for us to patch the strings. */
13665       if ((cn = patch_string (op1)))
13666        {
13667          op1 = cn;
13668          op1_type = TREE_TYPE (op1);
13669        }
13670       if ((cn = patch_string (op2)))
13671        {
13672          op2 = cn;
13673          op2_type = TREE_TYPE (op2);
13674        }
13675
13676       /* 15.20.1 Numerical Equality Operators == and != */
13677       /* Binary numeric promotion is performed on the operands */
13678       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13679         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13680
13681       /* 15.20.2 Boolean Equality Operators == and != */
13682       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13683           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13684         ;                       /* Nothing to do here */
13685
13686       /* 15.20.3 Reference Equality Operators == and != */
13687       /* Types have to be either references or the null type. If
13688          they're references, it must be possible to convert either
13689          type to the other by casting conversion. */
13690       else if (op1 == null_pointer_node || op2 == null_pointer_node
13691                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13692                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13693                        || valid_ref_assignconv_cast_p (op2_type,
13694                                                        op1_type, 1))))
13695         ;                       /* Nothing to do here */
13696
13697       /* Else we have an error figure what can't be converted into
13698          what and report the error */
13699       else
13700         {
13701           char *t1;
13702           t1 = xstrdup (lang_printable_name (op1_type, 0));
13703           parse_error_context
13704             (wfl_operator,
13705              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13706              operator_string (node), t1,
13707              lang_printable_name (op2_type, 0));
13708           free (t1);
13709           TREE_TYPE (node) = boolean_type_node;
13710           error_found = 1;
13711           break;
13712         }
13713       prom_type = boolean_type_node;
13714       break;
13715     default:
13716       abort ();
13717     }
13718
13719   if (error_found)
13720     return error_mark_node;
13721
13722   TREE_OPERAND (node, 0) = op1;
13723   TREE_OPERAND (node, 1) = op2;
13724   TREE_TYPE (node) = prom_type;
13725   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13726
13727   if (flag_emit_xref)
13728     return node;
13729
13730   /* fold does not respect side-effect order as required for Java but not C.
13731    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13732    * bytecode.
13733    */
13734   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13735       : ! TREE_SIDE_EFFECTS (node))
13736     node = fold (node);
13737   return node;
13738 }
13739
13740 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13741    zero value, the value of CSTE comes after the valude of STRING */
13742
13743 static tree
13744 do_merge_string_cste (cste, string, string_len, after)
13745      tree cste;
13746      const char *string;
13747      int string_len, after;
13748 {
13749   const char *old = TREE_STRING_POINTER (cste);
13750   int old_len = TREE_STRING_LENGTH (cste);
13751   int len = old_len + string_len;
13752   char *new = alloca (len+1);
13753
13754   if (after)
13755     {
13756       memcpy (new, string, string_len);
13757       memcpy (&new [string_len], old, old_len);
13758     }
13759   else
13760     {
13761       memcpy (new, old, old_len);
13762       memcpy (&new [old_len], string, string_len);
13763     }
13764   new [len] = '\0';
13765   return build_string (len, new);
13766 }
13767
13768 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13769    new STRING_CST on success, NULL_TREE on failure */
13770
13771 static tree
13772 merge_string_cste (op1, op2, after)
13773      tree op1, op2;
13774      int after;
13775 {
13776   /* Handle two string constants right away */
13777   if (TREE_CODE (op2) == STRING_CST)
13778     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13779                                  TREE_STRING_LENGTH (op2), after);
13780
13781   /* Reasonable integer constant can be treated right away */
13782   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13783     {
13784       static const char *const boolean_true = "true";
13785       static const char *const boolean_false = "false";
13786       static const char *const null_pointer = "null";
13787       char ch[3];
13788       const char *string;
13789
13790       if (op2 == boolean_true_node)
13791         string = boolean_true;
13792       else if (op2 == boolean_false_node)
13793         string = boolean_false;
13794       else if (op2 == null_pointer_node)
13795         string = null_pointer;
13796       else if (TREE_TYPE (op2) == char_type_node)
13797         {
13798           /* Convert the character into UTF-8.  */
13799           unsigned char c = (unsigned char) TREE_INT_CST_LOW (op2);
13800           unsigned char *p = (unsigned char *) ch;
13801           if (0x01 <= c
13802               && c <= 0x7f)
13803             *p++ = c;
13804           else
13805             {
13806               *p++ = c >> 6 | 0xc0;
13807               *p++ = (c & 0x3f) | 0x80;
13808             }
13809           *p = '\0';
13810
13811           string = ch;
13812         }
13813       else
13814         string = string_convert_int_cst (op2);
13815
13816       return do_merge_string_cste (op1, string, strlen (string), after);
13817     }
13818   return NULL_TREE;
13819 }
13820
13821 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13822    has to be a STRING_CST and the other part must be a STRING_CST or a
13823    INTEGRAL constant. Return a new STRING_CST if the operation
13824    succeed, NULL_TREE otherwise.
13825
13826    If the case we want to optimize for space, we might want to return
13827    NULL_TREE for each invocation of this routine. FIXME */
13828
13829 static tree
13830 string_constant_concatenation (op1, op2)
13831      tree op1, op2;
13832 {
13833   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13834     {
13835       tree string, rest;
13836       int invert;
13837
13838       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13839       rest   = (string == op1 ? op2 : op1);
13840       invert = (string == op1 ? 0 : 1 );
13841
13842       /* Walk REST, only if it looks reasonable */
13843       if (TREE_CODE (rest) != STRING_CST
13844           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13845           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13846           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13847         {
13848           rest = java_complete_tree (rest);
13849           if (rest == error_mark_node)
13850             return error_mark_node;
13851           rest = fold (rest);
13852         }
13853       return merge_string_cste (string, rest, invert);
13854     }
13855   return NULL_TREE;
13856 }
13857
13858 /* Implement the `+' operator. Does static optimization if possible,
13859    otherwise create (if necessary) and append elements to a
13860    StringBuffer. The StringBuffer will be carried around until it is
13861    used for a function call or an assignment. Then toString() will be
13862    called on it to turn it into a String object. */
13863
13864 static tree
13865 build_string_concatenation (op1, op2)
13866      tree op1, op2;
13867 {
13868   tree result;
13869   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13870
13871   if (flag_emit_xref)
13872     return build (PLUS_EXPR, string_type_node, op1, op2);
13873
13874   /* Try to do some static optimization */
13875   if ((result = string_constant_concatenation (op1, op2)))
13876     return result;
13877
13878   /* Discard empty strings on either side of the expression */
13879   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13880     {
13881       op1 = op2;
13882       op2 = NULL_TREE;
13883     }
13884   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13885     op2 = NULL_TREE;
13886
13887   /* If operands are string constant, turn then into object references */
13888   if (TREE_CODE (op1) == STRING_CST)
13889     op1 = patch_string_cst (op1);
13890   if (op2 && TREE_CODE (op2) == STRING_CST)
13891     op2 = patch_string_cst (op2);
13892
13893   /* If either one of the constant is null and the other non null
13894      operand is a String constant, return it. */
13895   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13896     return op1;
13897
13898   /* If OP1 isn't already a StringBuffer, create and
13899      initialize a new one */
13900   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13901     {
13902       /* Two solutions here:
13903          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13904          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13905       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13906         op1 = BUILD_STRING_BUFFER (op1);
13907       else
13908         {
13909           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13910           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13911         }
13912     }
13913
13914   if (op2)
13915     {
13916       /* OP1 is no longer the last node holding a crafted StringBuffer */
13917       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13918       /* Create a node for `{new...,xxx}.append (op2)' */
13919       if (op2)
13920         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13921     }
13922
13923   /* Mark the last node holding a crafted StringBuffer */
13924   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13925
13926   TREE_SIDE_EFFECTS (op1) = side_effects;
13927   return op1;
13928 }
13929
13930 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13931    StringBuffer. If no string were found to be patched, return
13932    NULL. */
13933
13934 static tree
13935 patch_string (node)
13936     tree node;
13937 {
13938   if (node == error_mark_node)
13939     return error_mark_node;
13940   if (TREE_CODE (node) == STRING_CST)
13941     return patch_string_cst (node);
13942   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13943     {
13944       int saved = ctxp->explicit_constructor_p;
13945       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13946       tree ret;
13947       /* Temporary disable forbid the use of `this'. */
13948       ctxp->explicit_constructor_p = 0;
13949       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13950       /* String concatenation arguments must be evaluated in order too. */
13951       ret = force_evaluation_order (ret);
13952       /* Restore it at its previous value */
13953       ctxp->explicit_constructor_p = saved;
13954       return ret;
13955     }
13956   return NULL_TREE;
13957 }
13958
13959 /* Build the internal representation of a string constant.  */
13960
13961 static tree
13962 patch_string_cst (node)
13963      tree node;
13964 {
13965   int location;
13966   if (! flag_emit_class_files)
13967     {
13968       node = get_identifier (TREE_STRING_POINTER (node));
13969       location = alloc_name_constant (CONSTANT_String, node);
13970       node = build_ref_from_constant_pool (location);
13971     }
13972   TREE_TYPE (node) = string_ptr_type_node;
13973   TREE_CONSTANT (node) = 1;
13974   return node;
13975 }
13976
13977 /* Build an incomplete unary operator expression. */
13978
13979 static tree
13980 build_unaryop (op_token, op_location, op1)
13981      int op_token, op_location;
13982      tree op1;
13983 {
13984   enum tree_code op;
13985   tree unaryop;
13986   switch (op_token)
13987     {
13988     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13989     case MINUS_TK: op = NEGATE_EXPR; break;
13990     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13991     case NOT_TK: op = BIT_NOT_EXPR; break;
13992     default: abort ();
13993     }
13994
13995   unaryop = build1 (op, NULL_TREE, op1);
13996   TREE_SIDE_EFFECTS (unaryop) = 1;
13997   /* Store the location of the operator, for better error report. The
13998      string of the operator will be rebuild based on the OP value. */
13999   EXPR_WFL_LINECOL (unaryop) = op_location;
14000   return unaryop;
14001 }
14002
14003 /* Special case for the ++/-- operators, since they require an extra
14004    argument to build, which is set to NULL and patched
14005    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
14006
14007 static tree
14008 build_incdec (op_token, op_location, op1, is_post_p)
14009      int op_token, op_location;
14010      tree op1;
14011      int is_post_p;
14012 {
14013   static const enum tree_code lookup [2][2] =
14014     {
14015       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
14016       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
14017     };
14018   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
14019                      NULL_TREE, op1, NULL_TREE);
14020   TREE_SIDE_EFFECTS (node) = 1;
14021   /* Store the location of the operator, for better error report. The
14022      string of the operator will be rebuild based on the OP value. */
14023   EXPR_WFL_LINECOL (node) = op_location;
14024   return node;
14025 }
14026
14027 /* Build an incomplete cast operator, based on the use of the
14028    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14029    set. java_complete_tree is trained to walk a CONVERT_EXPR even
14030    though its type is already set.  */
14031
14032 static tree
14033 build_cast (location, type, exp)
14034      int location;
14035      tree type, exp;
14036 {
14037   tree node = build1 (CONVERT_EXPR, type, exp);
14038   EXPR_WFL_LINECOL (node) = location;
14039   return node;
14040 }
14041
14042 /* Build an incomplete class reference operator.  */
14043 static tree
14044 build_incomplete_class_ref (location, class_name)
14045     int location;
14046     tree class_name;
14047 {
14048   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
14049   EXPR_WFL_LINECOL (node) = location;
14050   return node;
14051 }
14052
14053 /* Complete an incomplete class reference operator.  */
14054 static tree
14055 patch_incomplete_class_ref (node)
14056     tree node;
14057 {
14058   tree type = TREE_OPERAND (node, 0);
14059   tree ref_type;
14060
14061   if (!(ref_type = resolve_type_during_patch (type)))
14062     return error_mark_node;
14063
14064   /* Generate the synthetic static method `class$'.  (Previously we
14065      deferred this, causing different method tables to be emitted
14066      for native code and bytecode.)  */
14067   if (!TYPE_DOT_CLASS (current_class))
14068       build_dot_class_method (current_class);
14069
14070   /* If we're not emitting class files and we know ref_type is a
14071      compiled class, build a direct reference.  */
14072   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14073       || JPRIMITIVE_TYPE_P (ref_type)
14074       || TREE_CODE (ref_type) == VOID_TYPE)
14075     {
14076       tree dot = build_class_ref (ref_type);
14077       /* A class referenced by `foo.class' is initialized.  */
14078       if (!flag_emit_class_files)
14079        dot = build_class_init (ref_type, dot);
14080       return java_complete_tree (dot);
14081     }
14082
14083   /* If we're emitting class files and we have to deal with non
14084      primitive types, we invoke the synthetic static method `class$'.  */
14085   ref_type = build_dot_class_method_invocation (ref_type);
14086   return java_complete_tree (ref_type);
14087 }
14088
14089 /* 15.14 Unary operators. We return error_mark_node in case of error,
14090    but preserve the type of NODE if the type is fixed.  */
14091
14092 static tree
14093 patch_unaryop (node, wfl_op)
14094      tree node;
14095      tree wfl_op;
14096 {
14097   tree op = TREE_OPERAND (node, 0);
14098   tree op_type = TREE_TYPE (op);
14099   tree prom_type = NULL_TREE, value, decl;
14100   int outer_field_flag = 0;
14101   int code = TREE_CODE (node);
14102   int error_found = 0;
14103
14104   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14105
14106   switch (code)
14107     {
14108       /* 15.13.2 Postfix Increment Operator ++ */
14109     case POSTINCREMENT_EXPR:
14110       /* 15.13.3 Postfix Increment Operator -- */
14111     case POSTDECREMENT_EXPR:
14112       /* 15.14.1 Prefix Increment Operator ++ */
14113     case PREINCREMENT_EXPR:
14114       /* 15.14.2 Prefix Decrement Operator -- */
14115     case PREDECREMENT_EXPR:
14116       op = decl = strip_out_static_field_access_decl (op);
14117       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14118       /* We might be trying to change an outer field accessed using
14119          access method. */
14120       if (outer_field_flag)
14121         {
14122           /* Retrieve the decl of the field we're trying to access. We
14123              do that by first retrieving the function we would call to
14124              access the field. It has been already verified that this
14125              field isn't final */
14126           if (flag_emit_class_files)
14127             decl = TREE_OPERAND (op, 0);
14128           else
14129             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14130           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14131         }
14132       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14133       else if (!JDECL_P (decl)
14134           && TREE_CODE (decl) != COMPONENT_REF
14135           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14136           && TREE_CODE (decl) != INDIRECT_REF
14137           && !(TREE_CODE (decl) == COMPOUND_EXPR
14138                && TREE_OPERAND (decl, 1)
14139                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14140         {
14141           TREE_TYPE (node) = error_mark_node;
14142           error_found = 1;
14143         }
14144
14145       /* From now on, we know that op if a variable and that it has a
14146          valid wfl. We use wfl_op to locate errors related to the
14147          ++/-- operand. */
14148       if (!JNUMERIC_TYPE_P (op_type))
14149         {
14150           parse_error_context
14151             (wfl_op, "Invalid argument type `%s' to `%s'",
14152              lang_printable_name (op_type, 0), operator_string (node));
14153           TREE_TYPE (node) = error_mark_node;
14154           error_found = 1;
14155         }
14156       else
14157         {
14158           /* Before the addition, binary numeric promotion is performed on
14159              both operands, if really necessary */
14160           if (JINTEGRAL_TYPE_P (op_type))
14161             {
14162               value = build_int_2 (1, 0);
14163               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14164             }
14165           else
14166             {
14167               value = build_int_2 (1, 0);
14168               TREE_TYPE (node) =
14169                 binary_numeric_promotion (op_type,
14170                                           TREE_TYPE (value), &op, &value);
14171             }
14172
14173           /* We remember we might be accessing an outer field */
14174           if (outer_field_flag)
14175             {
14176               /* We re-generate an access to the field */
14177               value = build (PLUS_EXPR, TREE_TYPE (op),
14178                              build_outer_field_access (wfl_op, decl), value);
14179
14180               /* And we patch the original access$() into a write
14181                  with plus_op as a rhs */
14182               return outer_field_access_fix (node, op, value);
14183             }
14184
14185           /* And write back into the node. */
14186           TREE_OPERAND (node, 0) = op;
14187           TREE_OPERAND (node, 1) = value;
14188           /* Convert the overall back into its original type, if
14189              necessary, and return */
14190           if (JINTEGRAL_TYPE_P (op_type))
14191             return fold (node);
14192           else
14193             return fold (convert (op_type, node));
14194         }
14195       break;
14196
14197       /* 15.14.3 Unary Plus Operator + */
14198     case UNARY_PLUS_EXPR:
14199       /* 15.14.4 Unary Minus Operator - */
14200     case NEGATE_EXPR:
14201       if (!JNUMERIC_TYPE_P (op_type))
14202         {
14203           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14204           TREE_TYPE (node) = error_mark_node;
14205           error_found = 1;
14206         }
14207       /* Unary numeric promotion is performed on operand */
14208       else
14209         {
14210           op = do_unary_numeric_promotion (op);
14211           prom_type = TREE_TYPE (op);
14212           if (code == UNARY_PLUS_EXPR)
14213             return fold (op);
14214         }
14215       break;
14216
14217       /* 15.14.5 Bitwise Complement Operator ~ */
14218     case BIT_NOT_EXPR:
14219       if (!JINTEGRAL_TYPE_P (op_type))
14220         {
14221           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14222           TREE_TYPE (node) = error_mark_node;
14223           error_found = 1;
14224         }
14225       else
14226         {
14227           op = do_unary_numeric_promotion (op);
14228           prom_type = TREE_TYPE (op);
14229         }
14230       break;
14231
14232       /* 15.14.6 Logical Complement Operator ! */
14233     case TRUTH_NOT_EXPR:
14234       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14235         {
14236           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14237           /* But the type is known. We will report an error if further
14238              attempt of a assignment is made with this rhs */
14239           TREE_TYPE (node) = boolean_type_node;
14240           error_found = 1;
14241         }
14242       else
14243         prom_type = boolean_type_node;
14244       break;
14245
14246       /* 15.15 Cast Expression */
14247     case CONVERT_EXPR:
14248       value = patch_cast (node, wfl_operator);
14249       if (value == error_mark_node)
14250         {
14251           /* If this cast is part of an assignment, we tell the code
14252              that deals with it not to complain about a mismatch,
14253              because things have been cast, anyways */
14254           TREE_TYPE (node) = error_mark_node;
14255           error_found = 1;
14256         }
14257       else
14258         {
14259           value = fold (value);
14260           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14261           return value;
14262         }
14263       break;
14264     }
14265
14266   if (error_found)
14267     return error_mark_node;
14268
14269   /* There are cases where node has been replaced by something else
14270      and we don't end up returning here: UNARY_PLUS_EXPR,
14271      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14272   TREE_OPERAND (node, 0) = fold (op);
14273   TREE_TYPE (node) = prom_type;
14274   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14275   return fold (node);
14276 }
14277
14278 /* Generic type resolution that sometimes takes place during node
14279    patching. Returned the resolved type or generate an error
14280    message. Return the resolved type or NULL_TREE.  */
14281
14282 static tree
14283 resolve_type_during_patch (type)
14284      tree type;
14285 {
14286   if (unresolved_type_p (type, NULL))
14287     {
14288       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14289       if (!type_decl)
14290         {
14291           parse_error_context (type,
14292                                "Class `%s' not found in type declaration",
14293                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14294           return NULL_TREE;
14295         }
14296       return TREE_TYPE (type_decl);
14297     }
14298   return type;
14299 }
14300 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14301    found. Otherwise NODE or something meant to replace it is returned.  */
14302
14303 static tree
14304 patch_cast (node, wfl_op)
14305      tree node;
14306      tree wfl_op;
14307 {
14308   tree op = TREE_OPERAND (node, 0);
14309   tree cast_type = TREE_TYPE (node);
14310   tree patched, op_type;
14311   char *t1;
14312
14313   /* Some string patching might be necessary at this stage */
14314   if ((patched = patch_string (op)))
14315     TREE_OPERAND (node, 0) = op = patched;
14316   op_type = TREE_TYPE (op);
14317
14318   /* First resolve OP_TYPE if unresolved */
14319   if (!(cast_type = resolve_type_during_patch (cast_type)))
14320     return error_mark_node;
14321
14322   /* Check on cast that are proven correct at compile time */
14323   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14324     {
14325       /* Same type */
14326       if (cast_type == op_type)
14327         return node;
14328
14329       /* float and double type are converted to the original type main
14330          variant and then to the target type. */
14331       if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
14332         op = convert (integer_type_node, op);
14333
14334       /* Try widening/narowwing convertion. Potentially, things need
14335          to be worked out in gcc so we implement the extreme cases
14336          correctly. fold_convert() needs to be fixed. */
14337       return convert (cast_type, op);
14338     }
14339
14340   /* It's also valid to cast a boolean into a boolean */
14341   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14342     return node;
14343
14344   /* null can be casted to references */
14345   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14346     return build_null_of_type (cast_type);
14347
14348   /* The remaining legal casts involve conversion between reference
14349      types. Check for their compile time correctness. */
14350   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14351       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14352     {
14353       TREE_TYPE (node) = promote_type (cast_type);
14354       /* Now, the case can be determined correct at compile time if
14355          OP_TYPE can be converted into CAST_TYPE by assignment
14356          conversion (5.2) */
14357
14358       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14359         {
14360           TREE_SET_CODE (node, NOP_EXPR);
14361           return node;
14362         }
14363
14364       if (flag_emit_class_files)
14365         {
14366           TREE_SET_CODE (node, CONVERT_EXPR);
14367           return node;
14368         }
14369
14370       /* The cast requires a run-time check */
14371       return build (CALL_EXPR, promote_type (cast_type),
14372                     build_address_of (soft_checkcast_node),
14373                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14374                                build_tree_list (NULL_TREE, op)),
14375                     NULL_TREE);
14376     }
14377
14378   /* Any other casts are proven incorrect at compile time */
14379   t1 = xstrdup (lang_printable_name (op_type, 0));
14380   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14381                        t1, lang_printable_name (cast_type, 0));
14382   free (t1);
14383   return error_mark_node;
14384 }
14385
14386 /* Build a null constant and give it the type TYPE.  */
14387
14388 static tree
14389 build_null_of_type (type)
14390      tree type;
14391 {
14392   tree node = build_int_2 (0, 0);
14393   TREE_TYPE (node) = promote_type (type);
14394   return node;
14395 }
14396
14397 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14398    a list of indices. */
14399 static tree
14400 build_array_ref (location, array, index)
14401      int location;
14402      tree array, index;
14403 {
14404   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14405   EXPR_WFL_LINECOL (node) = location;
14406   return node;
14407 }
14408
14409 /* 15.12 Array Access Expression */
14410
14411 static tree
14412 patch_array_ref (node)
14413      tree node;
14414 {
14415   tree array = TREE_OPERAND (node, 0);
14416   tree array_type  = TREE_TYPE (array);
14417   tree index = TREE_OPERAND (node, 1);
14418   tree index_type = TREE_TYPE (index);
14419   int error_found = 0;
14420
14421   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14422
14423   if (TREE_CODE (array_type) == POINTER_TYPE)
14424     array_type = TREE_TYPE (array_type);
14425
14426   /* The array reference must be an array */
14427   if (!TYPE_ARRAY_P (array_type))
14428     {
14429       parse_error_context
14430         (wfl_operator,
14431          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14432          lang_printable_name (array_type, 0));
14433       TREE_TYPE (node) = error_mark_node;
14434       error_found = 1;
14435     }
14436
14437   /* The array index undergoes unary numeric promotion. The promoted
14438      type must be int */
14439   index = do_unary_numeric_promotion (index);
14440   if (TREE_TYPE (index) != int_type_node)
14441     {
14442       if (valid_cast_to_p (index_type, int_type_node))
14443         parse_error_context (wfl_operator,
14444    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14445                              lang_printable_name (index_type, 0));
14446       else
14447         parse_error_context (wfl_operator,
14448           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14449                              lang_printable_name (index_type, 0));
14450       TREE_TYPE (node) = error_mark_node;
14451       error_found = 1;
14452     }
14453
14454   if (error_found)
14455     return error_mark_node;
14456
14457   array_type = TYPE_ARRAY_ELEMENT (array_type);
14458
14459   if (flag_emit_class_files || flag_emit_xref)
14460     {
14461       TREE_OPERAND (node, 0) = array;
14462       TREE_OPERAND (node, 1) = index;
14463     }
14464   else
14465     node = build_java_arrayaccess (array, array_type, index);
14466   TREE_TYPE (node) = array_type;
14467   return node;
14468 }
14469
14470 /* 15.9 Array Creation Expressions */
14471
14472 static tree
14473 build_newarray_node (type, dims, extra_dims)
14474      tree type;
14475      tree dims;
14476      int extra_dims;
14477 {
14478   tree node =
14479     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14480            build_int_2 (extra_dims, 0));
14481   return node;
14482 }
14483
14484 static tree
14485 patch_newarray (node)
14486      tree node;
14487 {
14488   tree type = TREE_OPERAND (node, 0);
14489   tree dims = TREE_OPERAND (node, 1);
14490   tree cdim, array_type;
14491   int error_found = 0;
14492   int ndims = 0;
14493   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14494
14495   /* Dimension types are verified. It's better for the types to be
14496      verified in order. */
14497   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14498     {
14499       int dim_error = 0;
14500       tree dim = TREE_VALUE (cdim);
14501
14502       /* Dim might have been saved during its evaluation */
14503       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14504
14505       /* The type of each specified dimension must be an integral type. */
14506       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14507         dim_error = 1;
14508
14509       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14510          promoted type must be int. */
14511       else
14512         {
14513           dim = do_unary_numeric_promotion (dim);
14514           if (TREE_TYPE (dim) != int_type_node)
14515             dim_error = 1;
14516         }
14517
14518       /* Report errors on types here */
14519       if (dim_error)
14520         {
14521           parse_error_context
14522             (TREE_PURPOSE (cdim),
14523              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14524              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14525               "Explicit cast needed to" : "Can't"),
14526              lang_printable_name (TREE_TYPE (dim), 0));
14527           error_found = 1;
14528         }
14529
14530       TREE_PURPOSE (cdim) = NULL_TREE;
14531     }
14532
14533   /* Resolve array base type if unresolved */
14534   if (!(type = resolve_type_during_patch (type)))
14535     error_found = 1;
14536
14537   if (error_found)
14538     {
14539       /* We don't want further evaluation of this bogus array creation
14540          operation */
14541       TREE_TYPE (node) = error_mark_node;
14542       return error_mark_node;
14543     }
14544
14545   /* Set array_type to the actual (promoted) array type of the result. */
14546   if (TREE_CODE (type) == RECORD_TYPE)
14547     type = build_pointer_type (type);
14548   while (--xdims >= 0)
14549     {
14550       type = promote_type (build_java_array_type (type, -1));
14551     }
14552   dims = nreverse (dims);
14553   array_type = type;
14554   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14555     {
14556       type = array_type;
14557       array_type
14558         = build_java_array_type (type,
14559                                  TREE_CODE (cdim) == INTEGER_CST
14560                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14561                                  : -1);
14562       array_type = promote_type (array_type);
14563     }
14564   dims = nreverse (dims);
14565
14566   /* The node is transformed into a function call. Things are done
14567      differently according to the number of dimensions. If the number
14568      of dimension is equal to 1, then the nature of the base type
14569      (primitive or not) matters. */
14570   if (ndims == 1)
14571     return build_new_array (type, TREE_VALUE (dims));
14572
14573   /* Can't reuse what's already written in expr.c because it uses the
14574      JVM stack representation. Provide a build_multianewarray. FIXME */
14575   return build (CALL_EXPR, array_type,
14576                 build_address_of (soft_multianewarray_node),
14577                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14578                            tree_cons (NULL_TREE,
14579                                       build_int_2 (ndims, 0), dims )),
14580                 NULL_TREE);
14581 }
14582
14583 /* 10.6 Array initializer.  */
14584
14585 /* Build a wfl for array element that don't have one, so we can
14586    pin-point errors.  */
14587
14588 static tree
14589 maybe_build_array_element_wfl (node)
14590      tree node;
14591 {
14592   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14593     return build_expr_wfl (NULL_TREE, ctxp->filename,
14594                            ctxp->elc.line, ctxp->elc.prev_col);
14595   else
14596     return NULL_TREE;
14597 }
14598
14599 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14600    identification of initialized arrays easier to detect during walk
14601    and expansion.  */
14602
14603 static tree
14604 build_new_array_init (location, values)
14605      int location;
14606      tree values;
14607 {
14608   tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
14609   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14610   EXPR_WFL_LINECOL (to_return) = location;
14611   return to_return;
14612 }
14613
14614 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14615    occurred.  Otherwise return NODE after having set its type
14616    appropriately.  */
14617
14618 static tree
14619 patch_new_array_init (type, node)
14620      tree type, node;
14621 {
14622   int error_seen = 0;
14623   tree current, element_type;
14624   HOST_WIDE_INT length;
14625   int all_constant = 1;
14626   tree init = TREE_OPERAND (node, 0);
14627
14628   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14629     {
14630       parse_error_context (node,
14631                            "Invalid array initializer for non-array type `%s'",
14632                            lang_printable_name (type, 1));
14633       return error_mark_node;
14634     }
14635   type = TREE_TYPE (type);
14636   element_type = TYPE_ARRAY_ELEMENT (type);
14637
14638   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14639
14640   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14641        current;  length++, current = TREE_CHAIN (current))
14642     {
14643       tree elt = TREE_VALUE (current);
14644       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14645         {
14646           error_seen |= array_constructor_check_entry (element_type, current);
14647           elt = TREE_VALUE (current);
14648           /* When compiling to native code, STRING_CST is converted to
14649              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14650           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14651             all_constant = 0;
14652         }
14653       else
14654         {
14655           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14656           TREE_PURPOSE (current) = NULL_TREE;
14657           all_constant = 0;
14658         }
14659       if (elt && TREE_CODE (elt) == TREE_LIST
14660           && TREE_VALUE (elt) == error_mark_node)
14661         error_seen = 1;
14662     }
14663
14664   if (error_seen)
14665     return error_mark_node;
14666
14667   /* Create a new type. We can't reuse the one we have here by
14668      patching its dimension because it originally is of dimension -1
14669      hence reused by gcc. This would prevent triangular arrays. */
14670   type = build_java_array_type (element_type, length);
14671   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14672   TREE_TYPE (node) = promote_type (type);
14673   TREE_CONSTANT (init) = all_constant;
14674   TREE_CONSTANT (node) = all_constant;
14675   return node;
14676 }
14677
14678 /* Verify that one entry of the initializer element list can be
14679    assigned to the array base type. Report 1 if an error occurred, 0
14680    otherwise.  */
14681
14682 static int
14683 array_constructor_check_entry (type, entry)
14684      tree type, entry;
14685 {
14686   char *array_type_string = NULL;       /* For error reports */
14687   tree value, type_value, new_value, wfl_value, patched;
14688   int error_seen = 0;
14689
14690   new_value = NULL_TREE;
14691   wfl_value = TREE_VALUE (entry);
14692
14693   value = java_complete_tree (TREE_VALUE (entry));
14694   /* patch_string return error_mark_node if arg is error_mark_node */
14695   if ((patched = patch_string (value)))
14696     value = patched;
14697   if (value == error_mark_node)
14698     return 1;
14699
14700   type_value = TREE_TYPE (value);
14701
14702   /* At anytime, try_builtin_assignconv can report a warning on
14703      constant overflow during narrowing. */
14704   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14705   new_value = try_builtin_assignconv (wfl_operator, type, value);
14706   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14707     type_value = promote_type (type);
14708
14709   /* Check and report errors */
14710   if (!new_value)
14711     {
14712       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14713                    "Can't" : "Explicit cast needed to");
14714       if (!array_type_string)
14715         array_type_string = xstrdup (lang_printable_name (type, 1));
14716       parse_error_context
14717         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14718          msg, lang_printable_name (type_value, 1), array_type_string);
14719       error_seen = 1;
14720     }
14721
14722   if (new_value)
14723     TREE_VALUE (entry) = new_value;
14724
14725   if (array_type_string)
14726     free (array_type_string);
14727
14728   TREE_PURPOSE (entry) = NULL_TREE;
14729   return error_seen;
14730 }
14731
14732 static tree
14733 build_this (location)
14734      int location;
14735 {
14736   tree node = build_wfl_node (this_identifier_node);
14737   TREE_SET_CODE (node, THIS_EXPR);
14738   EXPR_WFL_LINECOL (node) = location;
14739   return node;
14740 }
14741
14742 /* 14.15 The return statement. It builds a modify expression that
14743    assigns the returned value to the RESULT_DECL that hold the value
14744    to be returned. */
14745
14746 static tree
14747 build_return (location, op)
14748      int location;
14749      tree op;
14750 {
14751   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14752   EXPR_WFL_LINECOL (node) = location;
14753   node = build_debugable_stmt (location, node);
14754   return node;
14755 }
14756
14757 static tree
14758 patch_return (node)
14759      tree node;
14760 {
14761   tree return_exp = TREE_OPERAND (node, 0);
14762   tree meth = current_function_decl;
14763   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14764   int error_found = 0;
14765
14766   TREE_TYPE (node) = error_mark_node;
14767   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14768
14769   /* It's invalid to have a return value within a function that is
14770      declared with the keyword void or that is a constructor */
14771   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14772     error_found = 1;
14773
14774   /* It's invalid to use a return statement in a static block */
14775   if (DECL_CLINIT_P (current_function_decl))
14776     error_found = 1;
14777
14778   /* It's invalid to have a no return value within a function that
14779      isn't declared with the keyword `void' */
14780   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14781     error_found = 2;
14782
14783   if (DECL_INSTINIT_P (current_function_decl))
14784     error_found = 1;
14785
14786   if (error_found)
14787     {
14788       if (DECL_INSTINIT_P (current_function_decl))
14789         parse_error_context (wfl_operator,
14790                              "`return' inside instance initializer");
14791
14792       else if (DECL_CLINIT_P (current_function_decl))
14793         parse_error_context (wfl_operator,
14794                              "`return' inside static initializer");
14795
14796       else if (!DECL_CONSTRUCTOR_P (meth))
14797         {
14798           char *t = xstrdup (lang_printable_name (mtype, 0));
14799           parse_error_context (wfl_operator,
14800                                "`return' with%s value from `%s %s'",
14801                                (error_found == 1 ? "" : "out"),
14802                                t, lang_printable_name (meth, 0));
14803           free (t);
14804         }
14805       else
14806         parse_error_context (wfl_operator,
14807                              "`return' with value from constructor `%s'",
14808                              lang_printable_name (meth, 0));
14809       return error_mark_node;
14810     }
14811
14812   /* If we have a return_exp, build a modify expression and expand
14813      it. Note: at that point, the assignment is declared valid, but we
14814      may want to carry some more hacks */
14815   if (return_exp)
14816     {
14817       tree exp = java_complete_tree (return_exp);
14818       tree modify, patched;
14819
14820       if ((patched = patch_string (exp)))
14821         exp = patched;
14822
14823       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14824       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14825       modify = java_complete_tree (modify);
14826
14827       if (modify != error_mark_node)
14828         {
14829           TREE_SIDE_EFFECTS (modify) = 1;
14830           TREE_OPERAND (node, 0) = modify;
14831         }
14832       else
14833         return error_mark_node;
14834     }
14835   TREE_TYPE (node) = void_type_node;
14836   TREE_SIDE_EFFECTS (node) = 1;
14837   return node;
14838 }
14839
14840 /* 14.8 The if Statement */
14841
14842 static tree
14843 build_if_else_statement (location, expression, if_body, else_body)
14844      int location;
14845      tree expression, if_body, else_body;
14846 {
14847   tree node;
14848   if (!else_body)
14849     else_body = empty_stmt_node;
14850   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14851   EXPR_WFL_LINECOL (node) = location;
14852   node = build_debugable_stmt (location, node);
14853   return node;
14854 }
14855
14856 static tree
14857 patch_if_else_statement (node)
14858      tree node;
14859 {
14860   tree expression = TREE_OPERAND (node, 0);
14861   int can_complete_normally
14862     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14863        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14864
14865   TREE_TYPE (node) = error_mark_node;
14866   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14867
14868   /* The type of expression must be boolean */
14869   if (TREE_TYPE (expression) != boolean_type_node
14870       && TREE_TYPE (expression) != promoted_boolean_type_node)
14871     {
14872       parse_error_context
14873         (wfl_operator,
14874          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14875          lang_printable_name (TREE_TYPE (expression), 0));
14876       return error_mark_node;
14877     }
14878
14879   if (TREE_CODE (expression) == INTEGER_CST)
14880     {
14881       if (integer_zerop (expression))
14882         node = TREE_OPERAND (node, 2);
14883       else
14884         node = TREE_OPERAND (node, 1);
14885       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14886         {
14887           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14888           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14889         }
14890       return node;
14891     }
14892   TREE_TYPE (node) = void_type_node;
14893   TREE_SIDE_EFFECTS (node) = 1;
14894   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14895   return node;
14896 }
14897
14898 /* 14.6 Labeled Statements */
14899
14900 /* Action taken when a lableled statement is parsed. a new
14901    LABELED_BLOCK_EXPR is created. No statement is attached to the
14902    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14903
14904 static tree
14905 build_labeled_block (location, label)
14906      int location;
14907      tree label;
14908 {
14909   tree label_name ;
14910   tree label_decl, node;
14911   if (label == NULL_TREE || label == continue_identifier_node)
14912     label_name = label;
14913   else
14914     {
14915       label_name = merge_qualified_name (label_id, label);
14916       /* Issue an error if we try to reuse a label that was previously
14917          declared */
14918       if (IDENTIFIER_LOCAL_VALUE (label_name))
14919         {
14920           EXPR_WFL_LINECOL (wfl_operator) = location;
14921           parse_error_context (wfl_operator,
14922             "Declaration of `%s' shadows a previous label declaration",
14923                                IDENTIFIER_POINTER (label));
14924           EXPR_WFL_LINECOL (wfl_operator) =
14925             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14926           parse_error_context (wfl_operator,
14927             "This is the location of the previous declaration of label `%s'",
14928                                IDENTIFIER_POINTER (label));
14929           java_error_count--;
14930         }
14931     }
14932
14933   label_decl = create_label_decl (label_name);
14934   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14935   EXPR_WFL_LINECOL (node) = location;
14936   TREE_SIDE_EFFECTS (node) = 1;
14937   return node;
14938 }
14939
14940 /* A labeled statement LBE is attached a statement.  */
14941
14942 static tree
14943 finish_labeled_statement (lbe, statement)
14944      tree lbe;                  /* Labeled block expr */
14945      tree statement;
14946 {
14947   /* In anyways, tie the loop to its statement */
14948   LABELED_BLOCK_BODY (lbe) = statement;
14949   pop_labeled_block ();
14950   POP_LABELED_BLOCK ();
14951   return lbe;
14952 }
14953
14954 /* 14.10, 14.11, 14.12 Loop Statements */
14955
14956 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14957    list. */
14958
14959 static tree
14960 build_new_loop (loop_body)
14961      tree loop_body;
14962 {
14963   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14964   TREE_SIDE_EFFECTS (loop) = 1;
14965   PUSH_LOOP (loop);
14966   return loop;
14967 }
14968
14969 /* Create a loop body according to the following structure:
14970      COMPOUND_EXPR
14971        COMPOUND_EXPR            (loop main body)
14972          EXIT_EXPR              (this order is for while/for loops.
14973          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14974            LABEL_DECL           (a continue occurring here branches at the
14975            BODY                  end of this labeled block)
14976        INCREMENT                (if any)
14977
14978   REVERSED, if nonzero, tells that the loop condition expr comes
14979   after the body, like in the do-while loop.
14980
14981   To obtain a loop, the loop body structure described above is
14982   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14983
14984    LABELED_BLOCK_EXPR
14985      LABEL_DECL                   (use this label to exit the loop)
14986      LOOP_EXPR
14987        <structure described above> */
14988
14989 static tree
14990 build_loop_body (location, condition, reversed)
14991      int location;
14992      tree condition;
14993      int reversed;
14994 {
14995   tree first, second, body;
14996
14997   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14998   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14999   condition = build_debugable_stmt (location, condition);
15000   TREE_SIDE_EFFECTS (condition) = 1;
15001
15002   body = build_labeled_block (0, continue_identifier_node);
15003   first = (reversed ? body : condition);
15004   second = (reversed ? condition : body);
15005   return
15006     build (COMPOUND_EXPR, NULL_TREE,
15007            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
15008 }
15009
15010 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15011    their order) on the current loop. Unlink the current loop from the
15012    loop list.  */
15013
15014 static tree
15015 finish_loop_body (location, condition, body, reversed)
15016      int location;
15017      tree condition, body;
15018      int reversed;
15019 {
15020   tree to_return = ctxp->current_loop;
15021   tree loop_body = LOOP_EXPR_BODY (to_return);
15022   if (condition)
15023     {
15024       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
15025       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15026          The real EXIT_EXPR is one operand further. */
15027       EXPR_WFL_LINECOL (cnode) = location;
15028       /* This one is for accurate error reports */
15029       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
15030       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
15031     }
15032   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
15033   POP_LOOP ();
15034   return to_return;
15035 }
15036
15037 /* Tailored version of finish_loop_body for FOR loops, when FOR
15038    loops feature the condition part */
15039
15040 static tree
15041 finish_for_loop (location, condition, update, body)
15042     int location;
15043     tree condition, update, body;
15044 {
15045   /* Put the condition and the loop body in place */
15046   tree loop = finish_loop_body (location, condition, body, 0);
15047   /* LOOP is the current loop which has been now popped of the loop
15048      stack.  Mark the update block as reachable and install it.  We do
15049      this because the (current interpretation of the) JLS requires
15050      that the update expression be considered reachable even if the
15051      for loop's body doesn't complete normally.  */
15052   if (update != NULL_TREE && update != empty_stmt_node)
15053     {
15054       tree up2 = update;
15055       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15056         up2 = EXPR_WFL_NODE (up2);
15057       /* Try to detect constraint violations.  These would be
15058          programming errors somewhere.  */
15059       if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
15060           || TREE_CODE (up2) == LOOP_EXPR)
15061         abort ();
15062       SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15063     }
15064   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15065   return loop;
15066 }
15067
15068 /* Try to find the loop a block might be related to. This comprises
15069    the case where the LOOP_EXPR is found as the second operand of a
15070    COMPOUND_EXPR, because the loop happens to have an initialization
15071    part, then expressed as the first operand of the COMPOUND_EXPR. If
15072    the search finds something, 1 is returned. Otherwise, 0 is
15073    returned. The search is assumed to start from a
15074    LABELED_BLOCK_EXPR's block.  */
15075
15076 static tree
15077 search_loop (statement)
15078     tree statement;
15079 {
15080   if (TREE_CODE (statement) == LOOP_EXPR)
15081     return statement;
15082
15083   if (TREE_CODE (statement) == BLOCK)
15084     statement = BLOCK_SUBBLOCKS (statement);
15085   else
15086     return NULL_TREE;
15087
15088   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15089     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15090       statement = TREE_OPERAND (statement, 1);
15091
15092   return (TREE_CODE (statement) == LOOP_EXPR
15093           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15094 }
15095
15096 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15097    returned otherwise.  */
15098
15099 static int
15100 labeled_block_contains_loop_p (block, loop)
15101     tree block, loop;
15102 {
15103   if (!block)
15104     return 0;
15105
15106   if (LABELED_BLOCK_BODY (block) == loop)
15107     return 1;
15108
15109   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15110     return 1;
15111
15112   return 0;
15113 }
15114
15115 /* If the loop isn't surrounded by a labeled statement, create one and
15116    insert LOOP as its body.  */
15117
15118 static tree
15119 patch_loop_statement (loop)
15120      tree loop;
15121 {
15122   tree loop_label;
15123
15124   TREE_TYPE (loop) = void_type_node;
15125   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15126     return loop;
15127
15128   loop_label = build_labeled_block (0, NULL_TREE);
15129   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15130      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15131   LABELED_BLOCK_BODY (loop_label) = loop;
15132   PUSH_LABELED_BLOCK (loop_label);
15133   return loop_label;
15134 }
15135
15136 /* 14.13, 14.14: break and continue Statements */
15137
15138 /* Build a break or a continue statement. a null NAME indicates an
15139    unlabeled break/continue statement.  */
15140
15141 static tree
15142 build_bc_statement (location, is_break, name)
15143      int location, is_break;
15144      tree name;
15145 {
15146   tree break_continue, label_block_expr = NULL_TREE;
15147
15148   if (name)
15149     {
15150       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15151             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15152         /* Null means that we don't have a target for this named
15153            break/continue. In this case, we make the target to be the
15154            label name, so that the error can be reported accuratly in
15155            patch_bc_statement. */
15156         label_block_expr = EXPR_WFL_NODE (name);
15157     }
15158   /* Unlabeled break/continue will be handled during the
15159      break/continue patch operation */
15160   break_continue
15161     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15162
15163   IS_BREAK_STMT_P (break_continue) = is_break;
15164   TREE_SIDE_EFFECTS (break_continue) = 1;
15165   EXPR_WFL_LINECOL (break_continue) = location;
15166   break_continue = build_debugable_stmt (location, break_continue);
15167   return break_continue;
15168 }
15169
15170 /* Verification of a break/continue statement. */
15171
15172 static tree
15173 patch_bc_statement (node)
15174      tree node;
15175 {
15176   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15177   tree labeled_block = ctxp->current_labeled_block;
15178   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15179
15180   /* Having an identifier here means that the target is unknown. */
15181   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15182     {
15183       parse_error_context (wfl_operator, "No label definition found for `%s'",
15184                            IDENTIFIER_POINTER (bc_label));
15185       return error_mark_node;
15186     }
15187   if (! IS_BREAK_STMT_P (node))
15188     {
15189       /* It's a continue statement. */
15190       for (;; labeled_block = TREE_CHAIN (labeled_block))
15191         {
15192           if (labeled_block == NULL_TREE)
15193             {
15194               if (bc_label == NULL_TREE)
15195                 parse_error_context (wfl_operator,
15196                                      "`continue' must be in loop");
15197               else
15198                 parse_error_context
15199                   (wfl_operator, "continue label `%s' does not name a loop",
15200                    IDENTIFIER_POINTER (bc_label));
15201               return error_mark_node;
15202             }
15203           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15204                == continue_identifier_node)
15205               && (bc_label == NULL_TREE
15206                   || TREE_CHAIN (labeled_block) == bc_label))
15207             {
15208               bc_label = labeled_block;
15209               break;
15210             }
15211         }
15212     }
15213   else if (!bc_label)
15214     {
15215       for (;; labeled_block = TREE_CHAIN (labeled_block))
15216         {
15217           if (labeled_block == NULL_TREE)
15218             {
15219               parse_error_context (wfl_operator,
15220                                      "`break' must be in loop or switch");
15221               return error_mark_node;
15222             }
15223           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15224           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15225               || search_loop (target_stmt))
15226             {
15227               bc_label = labeled_block;
15228               break;
15229             }
15230         }
15231     }
15232
15233   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15234   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15235
15236   /* Our break/continue don't return values. */
15237   TREE_TYPE (node) = void_type_node;
15238   /* Encapsulate the break within a compound statement so that it's
15239      expanded all the times by expand_expr (and not clobbered
15240      sometimes, like after a if statement) */
15241   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15242   TREE_SIDE_EFFECTS (node) = 1;
15243   return node;
15244 }
15245
15246 /* Process the exit expression belonging to a loop. Its type must be
15247    boolean.  */
15248
15249 static tree
15250 patch_exit_expr (node)
15251      tree node;
15252 {
15253   tree expression = TREE_OPERAND (node, 0);
15254   TREE_TYPE (node) = error_mark_node;
15255   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15256
15257   /* The type of expression must be boolean */
15258   if (TREE_TYPE (expression) != boolean_type_node)
15259     {
15260       parse_error_context
15261         (wfl_operator,
15262     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15263          lang_printable_name (TREE_TYPE (expression), 0));
15264       return error_mark_node;
15265     }
15266   /* Now we know things are allright, invert the condition, fold and
15267      return */
15268   TREE_OPERAND (node, 0) =
15269     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15270
15271   if (! integer_zerop (TREE_OPERAND (node, 0))
15272       && ctxp->current_loop != NULL_TREE
15273       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15274     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15275   if (! integer_onep (TREE_OPERAND (node, 0)))
15276     CAN_COMPLETE_NORMALLY (node) = 1;
15277
15278
15279   TREE_TYPE (node) = void_type_node;
15280   return node;
15281 }
15282
15283 /* 14.9 Switch statement */
15284
15285 static tree
15286 patch_switch_statement (node)
15287      tree node;
15288 {
15289   tree se = TREE_OPERAND (node, 0), se_type;
15290   tree save, iter;
15291
15292   /* Complete the switch expression */
15293   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15294   se_type = TREE_TYPE (se);
15295   /* The type of the switch expression must be char, byte, short or
15296      int */
15297   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15298     {
15299       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15300       parse_error_context (wfl_operator,
15301           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15302                            lang_printable_name (se_type, 0));
15303       /* This is what java_complete_tree will check */
15304       TREE_OPERAND (node, 0) = error_mark_node;
15305       return error_mark_node;
15306     }
15307
15308   /* Save and restore the outer case label list.  */
15309   save = case_label_list;
15310   case_label_list = NULL_TREE;
15311
15312   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15313
15314   /* See if we've found a duplicate label.  We can't leave this until
15315      code generation, because in `--syntax-only' and `-C' modes we
15316      don't do ordinary code generation.  */
15317   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15318     {
15319       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15320       tree subiter;
15321       for (subiter = TREE_CHAIN (iter);
15322            subiter != NULL_TREE;
15323            subiter = TREE_CHAIN (subiter))
15324         {
15325           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15326           if (val == subval)
15327             {
15328               EXPR_WFL_LINECOL (wfl_operator)
15329                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15330               /* The case_label_list is in reverse order, so print the
15331                  outer label first.  */
15332               parse_error_context (wfl_operator, "duplicate case label: `"
15333                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15334               EXPR_WFL_LINECOL (wfl_operator)
15335                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15336               parse_error_context (wfl_operator, "original label is here");
15337
15338               break;
15339             }
15340         }
15341     }
15342
15343   case_label_list = save;
15344
15345   /* Ready to return */
15346   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15347     {
15348       TREE_TYPE (node) = error_mark_node;
15349       return error_mark_node;
15350     }
15351   TREE_TYPE (node) = void_type_node;
15352   TREE_SIDE_EFFECTS (node) = 1;
15353   CAN_COMPLETE_NORMALLY (node)
15354     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15355       || ! SWITCH_HAS_DEFAULT (node);
15356   return node;
15357 }
15358
15359 /* Assertions.  */
15360
15361 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15362    might be NULL_TREE.  */
15363 static tree
15364 build_assertion (location, condition, value)
15365      int location;
15366      tree condition, value;
15367 {
15368   tree node;
15369   tree klass = GET_CPC ();
15370
15371   if (! CLASS_USES_ASSERTIONS (klass))
15372     {
15373       tree field, classdollar, id, call;
15374       tree class_type = TREE_TYPE (klass);
15375
15376       field = add_field (class_type,
15377                          get_identifier ("$assertionsDisabled"),
15378                          boolean_type_node,
15379                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15380       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15381       FIELD_SYNTHETIC (field) = 1;
15382
15383       if (!TYPE_DOT_CLASS (class_type))
15384         build_dot_class_method (class_type);
15385       classdollar = build_dot_class_method_invocation (class_type);
15386
15387       /* Call CLASS.desiredAssertionStatus().  */
15388       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15389       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15390       call = make_qualified_primary (classdollar, call, location);
15391       TREE_SIDE_EFFECTS (call) = 1;
15392
15393       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15394          seem odd, but we do it to generate code identical to that of
15395          the JDK.  */
15396       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15397       TREE_SIDE_EFFECTS (call) = 1;
15398       DECL_INITIAL (field) = call;
15399
15400       /* Record the initializer in the initializer statement list.  */
15401       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15402       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15403       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15404       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15405
15406       CLASS_USES_ASSERTIONS (klass) = 1;
15407     }
15408
15409   if (value != NULL_TREE)
15410     value = tree_cons (NULL_TREE, value, NULL_TREE);
15411
15412   node = build_wfl_node (get_identifier ("java"));
15413   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15414                               location);
15415   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15416                               location);
15417
15418   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15419   TREE_SIDE_EFFECTS (node) = 1;
15420   /* It is too early to use BUILD_THROW.  */
15421   node = build1 (THROW_EXPR, NULL_TREE, node);
15422   TREE_SIDE_EFFECTS (node) = 1;
15423
15424   /* We invert the condition; if we just put NODE as the `else' part
15425      then we generate weird-looking bytecode.  */
15426   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15427   /* Check $assertionsDisabled.  */
15428   condition
15429     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15430              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15431                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15432              condition);
15433   node = build_if_else_statement (location, condition, node, NULL_TREE);
15434   return node;
15435 }
15436
15437 /* 14.18 The try/catch statements */
15438
15439 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15440    catches TYPE and executes CATCH_STMTS.  */
15441
15442 static tree
15443 encapsulate_with_try_catch (location, type, try_stmts, catch_stmts)
15444      int location;
15445      tree type, try_stmts, catch_stmts;
15446 {
15447   tree try_block, catch_clause_param, catch_block, catch;
15448
15449   /* First build a try block */
15450   try_block = build_expr_block (try_stmts, NULL_TREE);
15451
15452   /* Build a catch block: we need a catch clause parameter */
15453   catch_clause_param = build_decl (VAR_DECL,
15454                                    wpv_id, build_pointer_type (type));
15455   /* And a block */
15456   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15457
15458   /* Initialize the variable and store in the block */
15459   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15460                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15461   add_stmt_to_block (catch_block, NULL_TREE, catch);
15462
15463   /* Add the catch statements */
15464   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15465
15466   /* Now we can build a CATCH_EXPR */
15467   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15468
15469   return build_try_statement (location, try_block, catch_block);
15470 }
15471
15472 static tree
15473 build_try_statement (location, try_block, catches)
15474      int location;
15475      tree try_block, catches;
15476 {
15477   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15478   EXPR_WFL_LINECOL (node) = location;
15479   return node;
15480 }
15481
15482 static tree
15483 build_try_finally_statement (location, try_block, finally)
15484      int location;
15485      tree try_block, finally;
15486 {
15487   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15488   EXPR_WFL_LINECOL (node) = location;
15489   return node;
15490 }
15491
15492 static tree
15493 patch_try_statement (node)
15494      tree node;
15495 {
15496   int error_found = 0;
15497   tree try = TREE_OPERAND (node, 0);
15498   /* Exception handlers are considered in left to right order */
15499   tree catch = nreverse (TREE_OPERAND (node, 1));
15500   tree current, caught_type_list = NULL_TREE;
15501
15502   /* Check catch clauses, if any. Every time we find an error, we try
15503      to process the next catch clause. We process the catch clause before
15504      the try block so that when processing the try block we can check thrown
15505      exceptions againts the caught type list. */
15506   for (current = catch; current; current = TREE_CHAIN (current))
15507     {
15508       tree carg_decl, carg_type;
15509       tree sub_current, catch_block, catch_clause;
15510       int unreachable;
15511
15512       /* At this point, the structure of the catch clause is
15513            CATCH_EXPR           (catch node)
15514              BLOCK              (with the decl of the parameter)
15515                COMPOUND_EXPR
15516                  MODIFY_EXPR   (assignment of the catch parameter)
15517                  BLOCK          (catch clause block)
15518        */
15519       catch_clause = TREE_OPERAND (current, 0);
15520       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15521       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15522
15523       /* Catch clauses can't have more than one parameter declared,
15524          but it's already enforced by the grammar. Make sure that the
15525          only parameter of the clause statement in of class Throwable
15526          or a subclass of Throwable, but that was done earlier. The
15527          catch clause parameter type has also been resolved. */
15528
15529       /* Just make sure that the catch clause parameter type inherits
15530          from java.lang.Throwable */
15531       if (!inherits_from_p (carg_type, throwable_type_node))
15532         {
15533           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15534           parse_error_context (wfl_operator,
15535                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15536                                lang_printable_name (carg_type, 0));
15537           error_found = 1;
15538           continue;
15539         }
15540
15541       /* Partial check for unreachable catch statement: The catch
15542          clause is reachable iff is no earlier catch block A in
15543          the try statement such that the type of the catch
15544          clause's parameter is the same as or a subclass of the
15545          type of A's parameter */
15546       unreachable = 0;
15547       for (sub_current = catch;
15548            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15549         {
15550           tree sub_catch_clause, decl;
15551           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15552           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15553
15554           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15555             {
15556               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15557               parse_error_context
15558                 (wfl_operator,
15559                  "`catch' not reached because of the catch clause at line %d",
15560                  EXPR_WFL_LINENO (sub_current));
15561               unreachable = error_found = 1;
15562               break;
15563             }
15564         }
15565       /* Complete the catch clause block */
15566       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15567       if (catch_block == error_mark_node)
15568         {
15569           error_found = 1;
15570           continue;
15571         }
15572       if (CAN_COMPLETE_NORMALLY (catch_block))
15573         CAN_COMPLETE_NORMALLY (node) = 1;
15574       TREE_OPERAND (current, 0) = catch_block;
15575
15576       if (unreachable)
15577         continue;
15578
15579       /* Things to do here: the exception must be thrown */
15580
15581       /* Link this type to the caught type list */
15582       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15583     }
15584
15585   PUSH_EXCEPTIONS (caught_type_list);
15586   if ((try = java_complete_tree (try)) == error_mark_node)
15587     error_found = 1;
15588   if (CAN_COMPLETE_NORMALLY (try))
15589     CAN_COMPLETE_NORMALLY (node) = 1;
15590   POP_EXCEPTIONS ();
15591
15592   /* Verification ends here */
15593   if (error_found)
15594     return error_mark_node;
15595
15596   TREE_OPERAND (node, 0) = try;
15597   TREE_OPERAND (node, 1) = catch;
15598   TREE_TYPE (node) = void_type_node;
15599   return node;
15600 }
15601
15602 /* 14.17 The synchronized Statement */
15603
15604 static tree
15605 patch_synchronized_statement (node, wfl_op1)
15606     tree node, wfl_op1;
15607 {
15608   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15609   tree block = TREE_OPERAND (node, 1);
15610
15611   tree tmp, enter, exit, expr_decl, assignment;
15612
15613   if (expr == error_mark_node)
15614     {
15615       block = java_complete_tree (block);
15616       return expr;
15617     }
15618
15619   /* We might be trying to synchronize on a STRING_CST */
15620   if ((tmp = patch_string (expr)))
15621     expr = tmp;
15622
15623   /* The TYPE of expr must be a reference type */
15624   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15625     {
15626       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15627       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15628                            lang_printable_name (TREE_TYPE (expr), 0));
15629       return error_mark_node;
15630     }
15631
15632   if (flag_emit_xref)
15633     {
15634       TREE_OPERAND (node, 0) = expr;
15635       TREE_OPERAND (node, 1) = java_complete_tree (block);
15636       CAN_COMPLETE_NORMALLY (node) = 1;
15637       return node;
15638     }
15639
15640   /* Generate a try-finally for the synchronized statement, except
15641      that the handler that catches all throw exception calls
15642      _Jv_MonitorExit and then rethrow the exception.
15643      The synchronized statement is then implemented as:
15644      TRY
15645        {
15646          _Jv_MonitorEnter (expression)
15647          synchronized_block
15648          _Jv_MonitorExit (expression)
15649        }
15650      CATCH_ALL
15651        {
15652          e = _Jv_exception_info ();
15653          _Jv_MonitorExit (expression)
15654          Throw (e);
15655        } */
15656
15657   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15658   BUILD_MONITOR_ENTER (enter, expr_decl);
15659   BUILD_MONITOR_EXIT (exit, expr_decl);
15660   CAN_COMPLETE_NORMALLY (enter) = 1;
15661   CAN_COMPLETE_NORMALLY (exit) = 1;
15662   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15663   TREE_SIDE_EFFECTS (assignment) = 1;
15664   node = build (COMPOUND_EXPR, NULL_TREE,
15665                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15666                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15667   node = build_expr_block (node, expr_decl);
15668
15669   return java_complete_tree (node);
15670 }
15671
15672 /* 14.16 The throw Statement */
15673
15674 static tree
15675 patch_throw_statement (node, wfl_op1)
15676     tree node, wfl_op1;
15677 {
15678   tree expr = TREE_OPERAND (node, 0);
15679   tree type = TREE_TYPE (expr);
15680   int unchecked_ok = 0, tryblock_throws_ok = 0;
15681
15682   /* Thrown expression must be assignable to java.lang.Throwable */
15683   if (!try_reference_assignconv (throwable_type_node, expr))
15684     {
15685       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15686       parse_error_context (wfl_operator,
15687     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15688                            lang_printable_name (type, 0));
15689       /* If the thrown expression was a reference, we further the
15690          compile-time check. */
15691       if (!JREFERENCE_TYPE_P (type))
15692         return error_mark_node;
15693     }
15694
15695   /* At least one of the following must be true */
15696
15697   /* The type of the throw expression is a not checked exception,
15698      i.e. is a unchecked expression. */
15699   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15700
15701   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15702   /* An instance can't throw a checked exception unless that exception
15703      is explicitly declared in the `throws' clause of each
15704      constructor. This doesn't apply to anonymous classes, since they
15705      don't have declared constructors. */
15706   if (!unchecked_ok
15707       && DECL_INSTINIT_P (current_function_decl)
15708       && !ANONYMOUS_CLASS_P (current_class))
15709     {
15710       tree current;
15711       for (current = TYPE_METHODS (current_class); current;
15712            current = TREE_CHAIN (current))
15713         if (DECL_CONSTRUCTOR_P (current)
15714             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15715           {
15716             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)",
15717                                  lang_printable_name (TREE_TYPE (expr), 0));
15718             return error_mark_node;
15719           }
15720     }
15721
15722   /* Throw is contained in a try statement and at least one catch
15723      clause can receive the thrown expression or the current method is
15724      declared to throw such an exception. Or, the throw statement is
15725      contained in a method or constructor declaration and the type of
15726      the Expression is assignable to at least one type listed in the
15727      throws clause the declaration. */
15728   if (!unchecked_ok)
15729     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15730   if (!(unchecked_ok || tryblock_throws_ok))
15731     {
15732       /* If there is a surrounding try block that has no matching
15733          clatch clause, report it first. A surrounding try block exits
15734          only if there is something after the list of checked
15735          exception thrown by the current function (if any). */
15736       if (IN_TRY_BLOCK_P ())
15737         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15738                              lang_printable_name (type, 0));
15739       /* If we have no surrounding try statement and the method doesn't have
15740          any throws, report it now. FIXME */
15741
15742       /* We report that the exception can't be throw from a try block
15743          in all circumstances but when the `throw' is inside a static
15744          block. */
15745       else if (!EXCEPTIONS_P (currently_caught_type_list)
15746                && !tryblock_throws_ok)
15747         {
15748           if (DECL_CLINIT_P (current_function_decl))
15749             parse_error_context (wfl_operator,
15750                    "Checked exception `%s' can't be thrown in initializer",
15751                                  lang_printable_name (type, 0));
15752           else
15753             parse_error_context (wfl_operator,
15754                    "Checked exception `%s' isn't thrown from a `try' block",
15755                                  lang_printable_name (type, 0));
15756         }
15757       /* Otherwise, the current method doesn't have the appropriate
15758          throws declaration */
15759       else
15760         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15761                              lang_printable_name (type, 0));
15762       return error_mark_node;
15763     }
15764
15765   if (! flag_emit_class_files && ! flag_emit_xref)
15766     BUILD_THROW (node, expr);
15767
15768   /* If doing xrefs, keep the location where the `throw' was seen. */
15769   if (flag_emit_xref)
15770     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15771   return node;
15772 }
15773
15774 /* Check that exception said to be thrown by method DECL can be
15775    effectively caught from where DECL is invoked.  */
15776
15777 static void
15778 check_thrown_exceptions (location, decl)
15779      int location;
15780      tree decl;
15781 {
15782   tree throws;
15783   /* For all the unchecked exceptions thrown by DECL */
15784   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15785        throws = TREE_CHAIN (throws))
15786     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15787       {
15788 #if 1
15789         /* Temporary hack to suppresses errors about cloning arrays. FIXME */
15790         if (DECL_NAME (decl) == get_identifier ("clone"))
15791           continue;
15792 #endif
15793         EXPR_WFL_LINECOL (wfl_operator) = location;
15794         if (DECL_FINIT_P (current_function_decl))
15795           parse_error_context
15796             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15797              lang_printable_name (TREE_VALUE (throws), 0));
15798         else
15799           {
15800             parse_error_context
15801               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15802                lang_printable_name (TREE_VALUE (throws), 0),
15803                (DECL_INIT_P (current_function_decl) ?
15804                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15805                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15806           }
15807       }
15808 }
15809
15810 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15811    try-catch blocks, OR is listed in the `throws' clause of the
15812    current method.  */
15813
15814 static int
15815 check_thrown_exceptions_do (exception)
15816      tree exception;
15817 {
15818   tree list = currently_caught_type_list;
15819   resolve_and_layout (exception, NULL_TREE);
15820   /* First, all the nested try-catch-finally at that stage. The
15821      last element contains `throws' clause exceptions, if any. */
15822   if (IS_UNCHECKED_EXCEPTION_P (exception))
15823     return 1;
15824   while (list)
15825     {
15826       tree caught;
15827       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15828         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15829           return 1;
15830       list = TREE_CHAIN (list);
15831     }
15832   return 0;
15833 }
15834
15835 static void
15836 purge_unchecked_exceptions (mdecl)
15837      tree mdecl;
15838 {
15839   tree throws = DECL_FUNCTION_THROWS (mdecl);
15840   tree new = NULL_TREE;
15841
15842   while (throws)
15843     {
15844       tree next = TREE_CHAIN (throws);
15845       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15846         {
15847           TREE_CHAIN (throws) = new;
15848           new = throws;
15849         }
15850       throws = next;
15851     }
15852   /* List is inverted here, but it doesn't matter */
15853   DECL_FUNCTION_THROWS (mdecl) = new;
15854 }
15855
15856 /* This function goes over all of CLASS_TYPE ctors and checks whether
15857    each of them features at least one unchecked exception in its
15858    `throws' clause. If it's the case, it returns `true', `false'
15859    otherwise.  */
15860
15861 static bool
15862 ctors_unchecked_throws_clause_p (class_type)
15863      tree class_type;
15864 {
15865   tree current;
15866
15867   for (current = TYPE_METHODS (class_type); current;
15868        current = TREE_CHAIN (current))
15869     {
15870       bool ctu = false; /* Ctor Throws Unchecked */
15871       if (DECL_CONSTRUCTOR_P (current))
15872         {
15873           tree throws;
15874           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15875                throws = TREE_CHAIN (throws))
15876             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15877               ctu = true;
15878         }
15879       /* We return false as we found one ctor that is unfit. */
15880       if (!ctu && DECL_CONSTRUCTOR_P (current))
15881         return false;
15882     }
15883   /* All ctors feature at least one unchecked exception in their
15884      `throws' clause. */
15885   return true;
15886 }
15887
15888 /* 15.24 Conditional Operator ?: */
15889
15890 static tree
15891 patch_conditional_expr (node, wfl_cond, wfl_op1)
15892      tree node, wfl_cond, wfl_op1;
15893 {
15894   tree cond = TREE_OPERAND (node, 0);
15895   tree op1 = TREE_OPERAND (node, 1);
15896   tree op2 = TREE_OPERAND (node, 2);
15897   tree resulting_type = NULL_TREE;
15898   tree t1, t2, patched;
15899   int error_found = 0;
15900
15901   /* Operands of ?: might be StringBuffers crafted as a result of a
15902      string concatenation. Obtain a descent operand here.  */
15903   if ((patched = patch_string (op1)))
15904     TREE_OPERAND (node, 1) = op1 = patched;
15905   if ((patched = patch_string (op2)))
15906     TREE_OPERAND (node, 2) = op2 = patched;
15907
15908   t1 = TREE_TYPE (op1);
15909   t2 = TREE_TYPE (op2);
15910
15911   /* The first expression must be a boolean */
15912   if (TREE_TYPE (cond) != boolean_type_node)
15913     {
15914       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15915       parse_error_context (wfl_operator,
15916                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15917                            lang_printable_name (TREE_TYPE (cond), 0));
15918       error_found = 1;
15919     }
15920
15921   /* Second and third can be numeric, boolean (i.e. primitive),
15922      references or null. Anything else results in an error */
15923   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15924         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15925             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15926         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15927     error_found = 1;
15928
15929   /* Determine the type of the conditional expression. Same types are
15930      easy to deal with */
15931   else if (t1 == t2)
15932     resulting_type = t1;
15933
15934   /* There are different rules for numeric types */
15935   else if (JNUMERIC_TYPE_P (t1))
15936     {
15937       /* if byte/short found, the resulting type is short */
15938       if ((t1 == byte_type_node && t2 == short_type_node)
15939           || (t1 == short_type_node && t2 == byte_type_node))
15940         resulting_type = short_type_node;
15941
15942       /* If t1 is a constant int and t2 is of type byte, short or char
15943          and t1's value fits in t2, then the resulting type is t2 */
15944       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15945           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15946         resulting_type = t2;
15947
15948       /* If t2 is a constant int and t1 is of type byte, short or char
15949          and t2's value fits in t1, then the resulting type is t1 */
15950       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15951           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15952         resulting_type = t1;
15953
15954       /* Otherwise, binary numeric promotion is applied and the
15955          resulting type is the promoted type of operand 1 and 2 */
15956       else
15957         resulting_type = binary_numeric_promotion (t1, t2,
15958                                                    &TREE_OPERAND (node, 1),
15959                                                    &TREE_OPERAND (node, 2));
15960     }
15961
15962   /* Cases of a reference and a null type */
15963   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15964     resulting_type = t1;
15965
15966   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15967     resulting_type = t2;
15968
15969   /* Last case: different reference types. If a type can be converted
15970      into the other one by assignment conversion, the latter
15971      determines the type of the expression */
15972   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15973     resulting_type = promote_type (t1);
15974
15975   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15976     resulting_type = promote_type (t2);
15977
15978   /* If we don't have any resulting type, we're in trouble */
15979   if (!resulting_type)
15980     {
15981       char *t = xstrdup (lang_printable_name (t1, 0));
15982       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15983       parse_error_context (wfl_operator,
15984                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15985                            t, lang_printable_name (t2, 0));
15986       free (t);
15987       error_found = 1;
15988     }
15989
15990   if (error_found)
15991     {
15992       TREE_TYPE (node) = error_mark_node;
15993       return error_mark_node;
15994     }
15995
15996   TREE_TYPE (node) = resulting_type;
15997   TREE_SET_CODE (node, COND_EXPR);
15998   CAN_COMPLETE_NORMALLY (node) = 1;
15999   return node;
16000 }
16001
16002 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16003
16004 static tree
16005 maybe_build_class_init_for_field (decl, expr)
16006     tree decl, expr;
16007 {
16008   tree clas = DECL_CONTEXT (decl);
16009   if (flag_emit_class_files || flag_emit_xref)
16010     return expr;
16011
16012   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
16013       && FIELD_FINAL (decl))
16014     {
16015       tree init = DECL_INITIAL (decl);
16016       if (init != NULL_TREE)
16017         init = fold_constant_for_init (init, decl);
16018       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
16019         return expr;
16020     }
16021
16022   return build_class_init (clas, expr);
16023 }
16024
16025 /* Try to constant fold NODE.
16026    If NODE is not a constant expression, return NULL_EXPR.
16027    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16028
16029 static tree
16030 fold_constant_for_init (node, context)
16031      tree node;
16032      tree context;
16033 {
16034   tree op0, op1, val;
16035   enum tree_code code = TREE_CODE (node);
16036
16037   switch (code)
16038     {
16039     case INTEGER_CST:
16040       if (node == null_pointer_node)
16041         return NULL_TREE;
16042     case STRING_CST:
16043     case REAL_CST:
16044       return node;
16045
16046     case PLUS_EXPR:
16047     case MINUS_EXPR:
16048     case MULT_EXPR:
16049     case TRUNC_MOD_EXPR:
16050     case RDIV_EXPR:
16051     case LSHIFT_EXPR:
16052     case RSHIFT_EXPR:
16053     case URSHIFT_EXPR:
16054     case BIT_AND_EXPR:
16055     case BIT_XOR_EXPR:
16056     case BIT_IOR_EXPR:
16057     case TRUTH_ANDIF_EXPR:
16058     case TRUTH_ORIF_EXPR:
16059     case EQ_EXPR:
16060     case NE_EXPR:
16061     case GT_EXPR:
16062     case GE_EXPR:
16063     case LT_EXPR:
16064     case LE_EXPR:
16065       op0 = TREE_OPERAND (node, 0);
16066       op1 = TREE_OPERAND (node, 1);
16067       val = fold_constant_for_init (op0, context);
16068       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16069         return NULL_TREE;
16070       TREE_OPERAND (node, 0) = val;
16071       val = fold_constant_for_init (op1, context);
16072       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16073         return NULL_TREE;
16074       TREE_OPERAND (node, 1) = val;
16075       return patch_binop (node, op0, op1);
16076
16077     case UNARY_PLUS_EXPR:
16078     case NEGATE_EXPR:
16079     case TRUTH_NOT_EXPR:
16080     case BIT_NOT_EXPR:
16081     case CONVERT_EXPR:
16082       op0 = TREE_OPERAND (node, 0);
16083       val = fold_constant_for_init (op0, context);
16084       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16085         return NULL_TREE;
16086       TREE_OPERAND (node, 0) = val;
16087       return patch_unaryop (node, op0);
16088       break;
16089
16090     case COND_EXPR:
16091       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16092       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16093         return NULL_TREE;
16094       TREE_OPERAND (node, 0) = val;
16095       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16096       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16097         return NULL_TREE;
16098       TREE_OPERAND (node, 1) = val;
16099       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16100       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16101         return NULL_TREE;
16102       TREE_OPERAND (node, 2) = val;
16103       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16104         : TREE_OPERAND (node, 2);
16105
16106     case VAR_DECL:
16107     case FIELD_DECL:
16108       if (! FIELD_FINAL (node)
16109           || DECL_INITIAL (node) == NULL_TREE)
16110         return NULL_TREE;
16111       val = DECL_INITIAL (node);
16112       /* Guard against infinite recursion. */
16113       DECL_INITIAL (node) = NULL_TREE;
16114       val = fold_constant_for_init (val, node);
16115       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16116         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16117       DECL_INITIAL (node) = val;
16118       return val;
16119
16120     case EXPR_WITH_FILE_LOCATION:
16121       /* Compare java_complete_tree and resolve_expression_name. */
16122       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16123           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16124         {
16125           tree name = EXPR_WFL_NODE (node);
16126           tree decl;
16127           if (PRIMARY_P (node))
16128             return NULL_TREE;
16129           else if (! QUALIFIED_P (name))
16130             {
16131               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16132               if (decl == NULL_TREE
16133                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16134                 return NULL_TREE;
16135               return fold_constant_for_init (decl, decl);
16136             }
16137           else
16138             {
16139               /* Install the proper context for the field resolution.
16140                  The prior context is restored once the name is
16141                  properly qualified. */
16142               tree saved_current_class = current_class;
16143               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16144               current_class = DECL_CONTEXT (context);
16145               qualify_ambiguous_name (node);
16146               current_class = saved_current_class;
16147               if (resolve_field_access (node, &decl, NULL)
16148                   && decl != NULL_TREE)
16149                 return fold_constant_for_init (decl, decl);
16150               return NULL_TREE;
16151             }
16152         }
16153       else
16154         {
16155           op0 = TREE_OPERAND (node, 0);
16156           val = fold_constant_for_init (op0, context);
16157           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16158             return NULL_TREE;
16159           TREE_OPERAND (node, 0) = val;
16160           return val;
16161         }
16162
16163 #ifdef USE_COMPONENT_REF
16164     case IDENTIFIER:
16165     case COMPONENT_REF:
16166       ?;
16167 #endif
16168
16169     default:
16170       return NULL_TREE;
16171     }
16172 }
16173
16174 #ifdef USE_COMPONENT_REF
16175 /* Context is 'T' for TypeName, 'P' for PackageName,
16176    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16177
16178 tree
16179 resolve_simple_name (name, context)
16180      tree name;
16181      int context;
16182 {
16183 }
16184
16185 tree
16186 resolve_qualified_name (name, context)
16187      tree name;
16188      int context;
16189 {
16190 }
16191 #endif
16192
16193 /* Mark P, which is really a `struct parser_ctxt **' for GC.  */
16194
16195 static void
16196 mark_parser_ctxt (p)
16197      void *p;
16198 {
16199   struct parser_ctxt *pc = *((struct parser_ctxt **) p);
16200 #ifndef JC1_LITE
16201   size_t i;
16202 #endif
16203
16204   if (!pc)
16205     return;
16206
16207 #ifndef JC1_LITE
16208   for (i = 0; i < ARRAY_SIZE (pc->modifier_ctx); ++i)
16209     ggc_mark_tree (pc->modifier_ctx[i]);
16210   ggc_mark_tree (pc->class_type);
16211   ggc_mark_tree (pc->function_decl);
16212   ggc_mark_tree (pc->package);
16213   ggc_mark_tree (pc->class_list);
16214   ggc_mark_tree (pc->current_parsed_class);
16215   ggc_mark_tree (pc->current_parsed_class_un);
16216   ggc_mark_tree (pc->non_static_initialized);
16217   ggc_mark_tree (pc->static_initialized);
16218   ggc_mark_tree (pc->instance_initializers);
16219   ggc_mark_tree (pc->import_list);
16220   ggc_mark_tree (pc->import_demand_list);
16221   ggc_mark_tree (pc->current_loop);
16222   ggc_mark_tree (pc->current_labeled_block);
16223 #endif /* JC1_LITE */
16224
16225   if (pc->next)
16226     mark_parser_ctxt (&pc->next);
16227 }
16228
16229 void
16230 init_src_parse ()
16231 {
16232   /* Sanity check; we've been bit by this before.  */
16233   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16234     abort ();
16235 }
16236
16237 \f
16238
16239 /* This section deals with the functions that are called when tables
16240    recording class initialization information are traversed.  */
16241
16242 /* Attach to PTR (a block) the declaration found in ENTRY. */
16243
16244 static int
16245 attach_init_test_initialization_flags (entry, ptr)
16246      PTR *entry;
16247      PTR ptr;
16248 {
16249   tree block = (tree)ptr;
16250   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16251
16252   if (block != error_mark_node)
16253     {
16254       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16255       BLOCK_EXPR_DECLS (block) = ite->value;
16256     }
16257   return true;
16258 }
16259
16260 /* This function is called for each classes that is known definitely
16261    assigned when a given static method was called. This function
16262    augments a compound expression (INFO) storing all assignment to
16263    initialized static class flags if a flag already existed, otherwise
16264    a new one is created.  */
16265
16266 static int
16267 emit_test_initialization (entry_p, info)
16268      PTR *entry_p;
16269      PTR info;
16270 {
16271   tree l = (tree) info;
16272   tree decl, init;
16273   tree key = (tree) *entry_p;
16274   tree *ite;
16275   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16276
16277   /* If we haven't found a flag and we're dealing with self registered
16278      with current_function_decl, then don't do anything. Self is
16279      always added as definitely initialized but this information is
16280      valid only if used outside the current function. */
16281   if (current_function_decl == TREE_PURPOSE (l)
16282       && java_treetreehash_find (cf_ht, key) == NULL)
16283     return true;
16284
16285   ite = java_treetreehash_new (cf_ht, key);
16286
16287   /* If we don't have a variable, create one and install it. */
16288   if (*ite == NULL)
16289     {
16290       tree block;
16291
16292       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16293       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16294       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16295       DECL_CONTEXT (decl) = current_function_decl;
16296       DECL_INITIAL (decl) = boolean_true_node;
16297
16298       /* The trick is to find the right context for it. */
16299       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16300       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16301       BLOCK_EXPR_DECLS (block) = decl;
16302       *ite = decl;
16303     }
16304   else
16305     decl = *ite;
16306
16307   /* Now simply augment the compound that holds all the assignments
16308      pertaining to this method invocation. */
16309   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16310   TREE_SIDE_EFFECTS (init) = 1;
16311   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16312   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16313
16314   return true;
16315 }
16316
16317 #include "gt-java-parse.h"
16318 #include "gtype-java.h"