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 Free Software Foundation, Inc.
   4    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.
  22
  23 Java and all Java-based marks are trademarks or registered trademarks
  24 of Sun Microsystems, Inc. in the United States and other countries.
  25 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  26
  27 /* This file parses java source code and issues a tree node image
  28 suitable for code generation (byte code and targeted CPU assembly
  29 language).
  30
  31 The grammar conforms to the Java grammar described in "The Java(TM)
  32 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  33 1996, ISBN 0-201-63451-1"
  34
  35 The following modifications were brought to the original grammar:
  36
  37 method_body: added the rule '| block SC_TK'
  38 static_initializer: added the rule 'static block SC_TK'.
  39
  40 Note: All the extra rules described above should go away when the
  41       empty_statement rule will work.
  42
  43 statement_nsi: 'nsi' should be read no_short_if.
  44
  45 Some rules have been modified to support JDK1.1 inner classes
  46 definitions and other extensions.  */
  47
  48 %{
  49 #include "config.h"
  50 #include "system.h"
  51 #include <dirent.h>
  52 #include "tree.h"
  53 #include "rtl.h"
  54 #include "obstack.h"
  55 #include "toplev.h"
  56 #include "flags.h"
  57 #include "java-tree.h"
  58 #include "jcf.h"
  59 #include "lex.h"
  60 #include "parse.h"
  61 #include "zipfile.h"
  62 #include "convert.h"
  63 #include "buffer.h"
  64
  65 #ifndef DIR_SEPARATOR
  66 #define DIR_SEPARATOR '/'
  67 #endif
  68
  69 /* Local function prototypes */
  70 static char *java_accstring_lookup PROTO ((int));
  71 static void  classitf_redefinition_error PROTO ((char *,tree, tree, tree));
  72 static void  variable_redefinition_error PROTO ((tree, tree, tree, int));
  73 static void  check_modifiers PROTO ((char *, int, int));
  74 static tree  create_class PROTO ((int, tree, tree, tree));
  75 static tree  create_interface PROTO ((int, tree, tree));
  76 static tree  find_field PROTO ((tree, tree));
  77 static tree lookup_field_wrapper PROTO ((tree, tree));
  78 static int   duplicate_declaration_error_p PROTO ((tree, tree, tree));
  79 static void  register_fields PROTO ((int, tree, tree));
  80 static tree parser_qualified_classname PROTO ((tree));
  81 static int  parser_check_super PROTO ((tree, tree, tree));
  82 static int  parser_check_super_interface PROTO ((tree, tree, tree));
  83 static void check_modifiers_consistency PROTO ((int));
  84 static tree lookup_cl PROTO ((tree));
  85 static tree lookup_java_method2 PROTO ((tree, tree, int));
  86 static tree method_header PROTO ((int, tree, tree, tree));
  87 static void fix_method_argument_names PROTO ((tree ,tree));
  88 static tree method_declarator PROTO ((tree, tree));
  89 static void parse_warning_context PVPROTO ((tree cl, const char *msg, ...))
  90   ATTRIBUTE_PRINTF_2;
  91 static void issue_warning_error_from_context PROTO ((tree, const char *msg, va_list));
  92 static tree parse_jdk1_1_error PROTO ((char *));
  93 static void complete_class_report_errors PROTO ((jdep *));
  94 static int process_imports PROTO ((void));
  95 static void read_import_dir PROTO ((tree));
  96 static int find_in_imports_on_demand PROTO ((tree));
  97 static int find_in_imports PROTO ((tree));
  98 static int check_pkg_class_access PROTO ((tree, tree));
  99 static tree resolve_package PROTO ((tree, tree *));
 100 static tree lookup_package_type PROTO ((char *, int));
 101 static tree resolve_class PROTO ((tree, tree, tree));
 102 static void declare_local_variables PROTO ((int, tree, tree));
 103 static void source_start_java_method PROTO ((tree));
 104 static void source_end_java_method PROTO ((void));
 105 static void expand_start_java_method PROTO ((tree));
 106 static tree find_name_in_single_imports PROTO ((tree));
 107 static void check_abstract_method_header PROTO ((tree));
 108 static tree lookup_java_interface_method2 PROTO ((tree, tree));
 109 static tree resolve_expression_name PROTO ((tree, tree *));
 110 static tree maybe_create_class_interface_decl PROTO ((tree, tree, tree));
 111 static int check_class_interface_creation PROTO ((int, int, tree,
 112                                                   tree, tree, tree));
 113 static tree patch_method_invocation PROTO ((tree, tree, tree,
 114                                             int *, tree *));
 115 static int breakdown_qualified PROTO ((tree *, tree *, tree));
 116 static tree resolve_and_layout PROTO ((tree, tree));
 117 static tree resolve_no_layout PROTO ((tree, tree));
 118 static int invocation_mode PROTO ((tree, int));
 119 static tree find_applicable_accessible_methods_list PROTO ((int, tree,
 120                                                             tree, tree));
 121 static tree find_most_specific_methods_list PROTO ((tree));
 122 static int argument_types_convertible PROTO ((tree, tree));
 123 static tree patch_invoke PROTO ((tree, tree, tree));
 124 static tree lookup_method_invoke PROTO ((int, tree, tree, tree, tree));
 125 static tree register_incomplete_type PROTO ((int, tree, tree, tree));
 126 static tree obtain_incomplete_type PROTO ((tree));
 127 static tree java_complete_lhs PROTO ((tree));
 128 static tree java_complete_tree PROTO ((tree));
 129 static void java_complete_expand_method PROTO ((tree));
 130 static int  unresolved_type_p PROTO ((tree, tree *));
 131 static void create_jdep_list PROTO ((struct parser_ctxt *));
 132 static tree build_expr_block PROTO ((tree, tree));
 133 static tree enter_block PROTO ((void));
 134 static tree enter_a_block PROTO ((tree));
 135 static tree exit_block PROTO ((void));
 136 static tree lookup_name_in_blocks PROTO ((tree));
 137 static void maybe_absorb_scoping_blocks PROTO ((void));
 138 static tree build_method_invocation PROTO ((tree, tree));
 139 static tree build_new_invocation PROTO ((tree, tree));
 140 static tree build_assignment PROTO ((int, int, tree, tree));
 141 static tree build_binop PROTO ((enum tree_code, int, tree, tree));
 142 static int check_final_assignment PROTO ((tree ,tree));
 143 static tree patch_assignment PROTO ((tree, tree, tree ));
 144 static tree patch_binop PROTO ((tree, tree, tree));
 145 static tree build_unaryop PROTO ((int, int, tree));
 146 static tree build_incdec PROTO ((int, int, tree, int));
 147 static tree patch_unaryop PROTO ((tree, tree));
 148 static tree build_cast PROTO ((int, tree, tree));
 149 static tree build_null_of_type PROTO ((tree));
 150 static tree patch_cast PROTO ((tree, tree));
 151 static int valid_ref_assignconv_cast_p PROTO ((tree, tree, int));
 152 static int valid_builtin_assignconv_identity_widening_p PROTO ((tree, tree));
 153 static int valid_cast_to_p PROTO ((tree, tree));
 154 static int valid_method_invocation_conversion_p PROTO ((tree, tree));
 155 static tree try_builtin_assignconv PROTO ((tree, tree, tree));
 156 static tree try_reference_assignconv PROTO ((tree, tree));
 157 static tree build_unresolved_array_type PROTO ((tree));
 158 static tree build_array_from_name PROTO ((tree, tree, tree, tree *));
 159 static tree build_array_ref PROTO ((int, tree, tree));
 160 static tree patch_array_ref PROTO ((tree));
 161 static tree make_qualified_name PROTO ((tree, tree, int));
 162 static tree merge_qualified_name PROTO ((tree, tree));
 163 static tree make_qualified_primary PROTO ((tree, tree, int));
 164 static int resolve_qualified_expression_name PROTO ((tree, tree *,
 165                                                      tree *, tree *));
 166 static void qualify_ambiguous_name PROTO ((tree));
 167 static void maybe_generate_clinit PROTO ((void));
 168 static tree resolve_field_access PROTO ((tree, tree *, tree *));
 169 static tree build_newarray_node PROTO ((tree, tree, int));
 170 static tree patch_newarray PROTO ((tree));
 171 static tree resolve_type_during_patch PROTO ((tree));
 172 static tree build_this PROTO ((int));
 173 static tree build_return PROTO ((int, tree));
 174 static tree patch_return PROTO ((tree));
 175 static tree maybe_access_field PROTO ((tree, tree, tree));
 176 static int complete_function_arguments PROTO ((tree));
 177 static int check_for_static_method_reference PROTO ((tree, tree, tree, tree, tree));
 178 static int not_accessible_p PROTO ((tree, tree, int));
 179 static void check_deprecation PROTO ((tree, tree));
 180 static int class_in_current_package PROTO ((tree));
 181 static tree build_if_else_statement PROTO ((int, tree, tree, tree));
 182 static tree patch_if_else_statement PROTO ((tree));
 183 static tree add_stmt_to_compound PROTO ((tree, tree, tree));
 184 static tree add_stmt_to_block PROTO ((tree, tree, tree));
 185 static tree patch_exit_expr PROTO ((tree));
 186 static tree build_labeled_block PROTO ((int, tree));
 187 static tree generate_labeled_block PROTO (());
 188 static tree complete_labeled_statement PROTO ((tree, tree));
 189 static tree build_bc_statement PROTO ((int, int, tree));
 190 static tree patch_bc_statement PROTO ((tree));
 191 static tree patch_loop_statement PROTO ((tree));
 192 static tree build_new_loop PROTO ((tree));
 193 static tree build_loop_body PROTO ((int, tree, int));
 194 static tree complete_loop_body PROTO ((int, tree, tree, int));
 195 static tree build_debugable_stmt PROTO ((int, tree));
 196 static tree complete_for_loop PROTO ((int, tree, tree, tree));
 197 static tree patch_switch_statement PROTO ((tree));
 198 static tree string_constant_concatenation PROTO ((tree, tree));
 199 static tree build_string_concatenation PROTO ((tree, tree));
 200 static tree patch_string_cst PROTO ((tree));
 201 static tree patch_string PROTO ((tree));
 202 static tree build_jump_to_finally PROTO ((tree, tree, tree, tree));
 203 static tree build_try_statement PROTO ((int, tree, tree));
 204 static tree build_try_finally_statement PROTO ((int, tree, tree));
 205 static tree patch_try_statement PROTO ((tree));
 206 static tree patch_synchronized_statement PROTO ((tree, tree));
 207 static tree patch_throw_statement PROTO ((tree, tree));
 208 static void check_thrown_exceptions PROTO ((int, tree));
 209 static int check_thrown_exceptions_do PROTO ((tree));
 210 static void purge_unchecked_exceptions PROTO ((tree));
 211 static void check_throws_clauses PROTO ((tree, tree, tree));
 212 static void complete_method_declaration PROTO ((tree));
 213 static tree build_super_invocation PROTO (());
 214 static int verify_constructor_circularity PROTO ((tree, tree));
 215 static char *constructor_circularity_msg PROTO ((tree, tree));
 216 static tree build_this_super_qualified_invocation PROTO ((int, tree, tree,
 217                                                           int, int));
 218 static char *get_printable_method_name PROTO ((tree));
 219 static tree patch_conditional_expr PROTO ((tree, tree, tree));
 220 static void maybe_generate_finit PROTO (());
 221 static void fix_constructors PROTO ((tree));
 222 static int verify_constructor_super PROTO (());
 223 static tree create_artificial_method PROTO ((tree, int, tree, tree, tree));
 224 static void start_artificial_method_body PROTO ((tree));
 225 static void end_artificial_method_body PROTO ((tree));
 226 static int check_method_redefinition PROTO ((tree, tree));
 227 static int reset_method_name PROTO ((tree));
 228 static void java_check_regular_methods PROTO ((tree));
 229 static void java_check_abstract_methods PROTO ((tree));
 230 static tree maybe_build_primttype_type_ref PROTO ((tree, tree));
 231 static void unreachable_stmt_error PROTO ((tree));
 232 static tree find_expr_with_wfl PROTO ((tree));
 233 static void missing_return_error PROTO ((tree));
 234 static tree build_new_array_init PROTO ((int, tree));
 235 static tree patch_new_array_init PROTO ((tree, tree));
 236 static tree maybe_build_array_element_wfl PROTO ((tree));
 237 static int array_constructor_check_entry PROTO ((tree, tree));
 238 static char *purify_type_name PROTO ((char *));
 239 static tree patch_initialized_static_field PROTO ((tree));
 240 static tree fold_constant_for_init PROTO ((tree, tree));
 241 static tree strip_out_static_field_access_decl PROTO ((tree));
 242
 243 /* Number of error found so far. */
 244 int java_error_count;
 245 /* Number of warning found so far. */
 246 int java_warning_count;
 247
 248 /* The current parser context */
 249 static struct parser_ctxt *ctxp;
 250
 251 /* List of things that were anlyzed for which code will be generated */
 252 static struct parser_ctxt *ctxp_for_generation = NULL;
 253
 254 /* binop_lookup maps token to tree_code. It is used where binary
 255    operations are involved and required by the parser. RDIV_EXPR
 256    covers both integral/floating point division. The code is changed
 257    once the type of both operator is worked out.  */
 258
 259 static enum tree_code binop_lookup[19] =
 260   {
 261     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 262     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 263     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 264     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 265     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 266    };
 267 #define BINOP_LOOKUP(VALUE)                                             \
 268   binop_lookup [((VALUE) - PLUS_TK)%                                    \
 269                 (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
 270
 271 /* Fake WFL used to report error message. It is initialized once if
 272    needed and reused with it's location information is overriden.  */
 273 tree wfl_operator = NULL_TREE;
 274
 275 /* The "$L" identifier we use to create labels.  */
 276 static tree label_id = NULL_TREE;
 277
 278 /* The "StringBuffer" identifier used for the String `+' operator. */
 279 static tree wfl_string_buffer = NULL_TREE;
 280
 281 /* The "append" identifier used for String `+' operator.  */
 282 static tree wfl_append = NULL_TREE;
 283
 284 /* The "toString" identifier used for String `+' operator. */
 285 static tree wfl_to_string = NULL_TREE;
 286
 287 /* The "java.lang" import qualified name.  */
 288 static tree java_lang_id = NULL_TREE;
 289
 290 /* The "java.lang.Cloneable" qualified name.  */
 291 static tree java_lang_cloneable = NULL_TREE;
 292 %}
 293
 294 %union {
 295   tree node;
 296   int sub_token;
 297   struct {
 298     int token;
 299     int location;
 300   } operator;
 301   int value;
 302 }
 303
 304 %pure_parser
 305
 306 /* Things defined here have to match the order of what's in the
 307    binop_lookup table.  */
 308
 309 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 310 %token   LS_TK           SRS_TK          ZRS_TK
 311 %token   AND_TK          XOR_TK          OR_TK
 312 %token   BOOL_AND_TK BOOL_OR_TK
 313 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 314
 315 /* This maps to the same binop_lookup entry than the token above */
 316
 317 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 318 %token   REM_ASSIGN_TK
 319 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 320 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 321
 322
 323 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 324
 325 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 326 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 327 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 328 %token   PAD_TK          ABSTRACT_TK        MODIFIER_TK
 329
 330 /* Keep those two in order, too */
 331 %token   DECR_TK INCR_TK
 332
 333 /* From now one, things can be in any order */
 334
 335 %token   DEFAULT_TK      IF_TK              THROW_TK
 336 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 337 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 338 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 339 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 340 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 341 %token   SUPER_TK        WHILE_TK           CLASS_TK
 342 %token   SWITCH_TK       CONST_TK           TRY_TK
 343 %token   FOR_TK          NEW_TK             CONTINUE_TK
 344 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 345
 346 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 347 %token   CHAR_TK         INTEGRAL_TK
 348
 349 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 350
 351 %token   ID_TK
 352
 353 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 354
 355 %token   ASSIGN_ANY_TK   ASSIGN_TK
 356 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 357
 358 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 359 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 360
 361 %type    <value>        modifiers MODIFIER_TK
 362
 363 %type    <node>         super ID_TK identifier
 364 %type    <node>         name simple_name qualified_name
 365 %type    <node>         class_declaration type_declaration compilation_unit
 366                         field_declaration method_declaration extends_interfaces
 367                         interfaces interface_type_list
 368                         interface_declaration class_member_declaration
 369                         import_declarations package_declaration
 370                         type_declarations interface_body
 371                         interface_member_declaration constant_declaration
 372                         interface_member_declarations interface_type
 373                         abstract_method_declaration interface_type_list
 374 %type    <node>         class_body_declaration class_member_declaration
 375                         static_initializer constructor_declaration block
 376 %type    <node>         class_body_declarations constructor_header
 377 %type    <node>         class_or_interface_type class_type class_type_list
 378                         constructor_declarator explicit_constructor_invocation
 379 %type    <node>         dim_expr dim_exprs this_or_super throws
 380
 381 %type    <node>         variable_declarator_id variable_declarator
 382                         variable_declarators variable_initializer
 383                         variable_initializers constructor_body
 384                         array_initializer
 385
 386 %type    <node>         class_body block_end
 387 %type    <node>         statement statement_without_trailing_substatement
 388                         labeled_statement if_then_statement label_decl
 389                         if_then_else_statement while_statement for_statement
 390                         statement_nsi labeled_statement_nsi do_statement
 391                         if_then_else_statement_nsi while_statement_nsi
 392                         for_statement_nsi statement_expression_list for_init
 393                         for_update statement_expression expression_statement
 394                         primary_no_new_array expression primary
 395                         array_creation_expression array_type
 396                         class_instance_creation_expression field_access
 397                         method_invocation array_access something_dot_new
 398                         argument_list postfix_expression while_expression
 399                         post_increment_expression post_decrement_expression
 400                         unary_expression_not_plus_minus unary_expression
 401                         pre_increment_expression pre_decrement_expression
 402                         unary_expression_not_plus_minus cast_expression
 403                         multiplicative_expression additive_expression
 404                         shift_expression relational_expression
 405                         equality_expression and_expression
 406                         exclusive_or_expression inclusive_or_expression
 407                         conditional_and_expression conditional_or_expression
 408                         conditional_expression assignment_expression
 409                         left_hand_side assignment for_header for_begin
 410                         constant_expression do_statement_begin empty_statement
 411                         switch_statement synchronized_statement throw_statement
 412                         try_statement switch_expression switch_block
 413                         catches catch_clause catch_clause_parameter finally
 414 %type    <node>         return_statement break_statement continue_statement
 415
 416 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 417 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 418 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 419 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 420 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 421 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 422 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 423 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 424 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK
 425 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 426 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 427 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 428
 429 %type    <node>         method_body
 430
 431 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 432                         STRING_LIT_TK NULL_TK VOID_TK
 433
 434 %type    <node>         IF_TK WHILE_TK FOR_TK
 435
 436 %type    <node>         formal_parameter_list formal_parameter
 437                         method_declarator method_header
 438
 439 %type    <node>         primitive_type reference_type type
 440                         BOOLEAN_TK INTEGRAL_TK FP_TK
 441
 442 %%
 443 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 444 goal:
 445         compilation_unit
 446                 {}
 447 ;
 448
 449 /* 19.3 Productions from 3: Lexical structure  */
 450 literal:
 451         INT_LIT_TK
 452 |       FP_LIT_TK
 453 |       BOOL_LIT_TK
 454 |       CHAR_LIT_TK
 455 |       STRING_LIT_TK
 456 |       NULL_TK
 457 ;
 458
 459 /* 19.4 Productions from 4: Types, Values and Variables  */
 460 type:
 461         primitive_type
 462 |       reference_type
 463 ;
 464
 465 primitive_type:
 466         INTEGRAL_TK
 467 |       FP_TK
 468 |       BOOLEAN_TK
 469 ;
 470
 471 reference_type:
 472         class_or_interface_type
 473 |       array_type
 474 ;
 475
 476 class_or_interface_type:
 477         name
 478 ;
 479
 480 class_type:
 481         class_or_interface_type /* Default rule */
 482 ;
 483
 484 interface_type:
 485          class_or_interface_type
 486 ;
 487
 488 array_type:
 489         primitive_type OSB_TK CSB_TK
 490                 {
 491                   $$ = build_java_array_type ($1, -1);
 492                   CLASS_LOADED_P ($$) = 1;
 493                 }
 494 |       name OSB_TK CSB_TK
 495                 { $$ = build_unresolved_array_type ($1); }
 496 |       array_type OSB_TK CSB_TK
 497                 { $$ = build_unresolved_array_type ($1); }
 498 |       primitive_type OSB_TK error
 499                 {RULE ("']' expected"); RECOVER;}
 500 |       array_type OSB_TK error
 501                 {RULE ("']' expected"); RECOVER;}
 502 ;
 503
 504 /* 19.5 Productions from 6: Names  */
 505 name:
 506         simple_name             /* Default rule */
 507 |       qualified_name          /* Default rule */
 508 ;
 509
 510 simple_name:
 511         identifier              /* Default rule */
 512 ;
 513
 514 qualified_name:
 515         name DOT_TK identifier
 516                 { $$ = make_qualified_name ($1, $3, $2.location); }
 517 ;
 518
 519 identifier:
 520         ID_TK
 521 ;
 522
 523 /* 19.6: Production from 7: Packages  */
 524 compilation_unit:
 525                 {$$ = NULL;}
 526 |       package_declaration
 527 |       import_declarations
 528 |       type_declarations
 529 |       package_declaration import_declarations
 530 |       package_declaration type_declarations
 531 |       import_declarations type_declarations
 532 |       package_declaration import_declarations type_declarations
 533 ;
 534
 535 import_declarations:
 536         import_declaration
 537                 {
 538                   $$ = NULL;
 539                 }
 540 |       import_declarations import_declaration
 541                 {
 542                   $$ = NULL;
 543                 }
 544 ;
 545
 546 type_declarations:
 547         type_declaration
 548 |       type_declarations type_declaration
 549 ;
 550
 551 package_declaration:
 552         PACKAGE_TK name SC_TK
 553                 { ctxp->package = EXPR_WFL_NODE ($2); }
 554 |       PACKAGE_TK error
 555                 {yyerror ("Missing name"); RECOVER;}
 556 |       PACKAGE_TK name error
 557                 {yyerror ("';' expected"); RECOVER;}
 558 ;
 559
 560 import_declaration:
 561         single_type_import_declaration
 562 |       type_import_on_demand_declaration
 563 ;
 564
 565 single_type_import_declaration:
 566         IMPORT_TK name SC_TK
 567                 {
 568                   tree name = EXPR_WFL_NODE ($2), node, last_name;
 569                   int   i = IDENTIFIER_LENGTH (name)-1;
 570                   char *last = &IDENTIFIER_POINTER (name)[i];
 571                   while (last != IDENTIFIER_POINTER (name))
 572                     {
 573                       if (last [0] == '.')
 574                         break;
 575                       last--;
 576                     }
 577                   last_name = get_identifier (++last);
 578                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 579                     {
 580                       tree err = find_name_in_single_imports (last_name);
 581                       if (err && err != name)
 582                         parse_error_context
 583                           ($2, "Ambiguous class: `%s' and `%s'",
 584                            IDENTIFIER_POINTER (name),
 585                            IDENTIFIER_POINTER (err));
 586                       else
 587                         REGISTER_IMPORT ($2, last_name)
 588                     }
 589                   else
 590                     REGISTER_IMPORT ($2, last_name);
 591                 }
 592 |       IMPORT_TK error
 593                 {yyerror ("Missing name"); RECOVER;}
 594 |       IMPORT_TK name error
 595                 {yyerror ("';' expected"); RECOVER;}
 596 ;
 597
 598 type_import_on_demand_declaration:
 599         IMPORT_TK name DOT_TK MULT_TK SC_TK
 600                 {
 601                   tree name = EXPR_WFL_NODE ($2);
 602                   /* Don't import java.lang.* twice. */
 603                   if (name != java_lang_id)
 604                     {
 605                       tree node = build_tree_list ($2, NULL_TREE);
 606                       read_import_dir ($2);
 607                       TREE_CHAIN (node) = ctxp->import_demand_list;
 608                       ctxp->import_demand_list = node;
 609                     }
 610                 }
 611 |       IMPORT_TK name DOT_TK error
 612                 {yyerror ("'*' expected"); RECOVER;}
 613 |       IMPORT_TK name DOT_TK MULT_TK error
 614                 {yyerror ("';' expected"); RECOVER;}
 615 ;
 616
 617 type_declaration:
 618         class_declaration
 619                 {
 620                   maybe_generate_finit ();
 621                   maybe_generate_clinit ();
 622                   $$ = $1;
 623                 }
 624 |       interface_declaration
 625 |       SC_TK
 626                 { $$ = NULL; }
 627 |       error
 628                 {
 629                   YYERROR_NOW;
 630                   yyerror ("Class or interface declaration expected");
 631                 }
 632 ;
 633
 634 /* 19.7 Shortened from the original:
 635    modifiers: modifier | modifiers modifier
 636    modifier: any of public...  */
 637 modifiers:
 638         MODIFIER_TK
 639                 {
 640                   $$ = (1 << $1);
 641                 }
 642 |       modifiers MODIFIER_TK
 643                 {
 644                   int acc = (1 << $2);
 645                   if ($$ & acc)
 646                     parse_error_context
 647                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 648                        java_accstring_lookup (acc));
 649                   else
 650                     {
 651                       $$ |= acc;
 652                     }
 653                 }
 654 ;
 655
 656 /* 19.8.1 Production from $8.1: Class Declaration */
 657 class_declaration:
 658         modifiers CLASS_TK identifier super interfaces
 659                 { create_class ($1, $3, $4, $5); }
 660         class_body
 661                 {
 662                   $$ = $7;
 663                 }
 664 |       CLASS_TK identifier super interfaces
 665                 { create_class (0, $2, $3, $4); }
 666         class_body
 667                 {
 668                   $$ = $6;
 669                 }
 670 |       modifiers CLASS_TK error
 671                 {yyerror ("Missing class name"); RECOVER;}
 672 |       CLASS_TK error
 673                 {yyerror ("Missing class name"); RECOVER;}
 674 |       CLASS_TK identifier error
 675                 {
 676                   if (!ctxp->class_err) yyerror ("'{' expected");
 677                   DRECOVER(class1);
 678                 }
 679 |       modifiers CLASS_TK identifier error
 680                 {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
 681 ;
 682
 683 super:
 684                 { $$ = NULL; }
 685 |       EXTENDS_TK class_type
 686                 { $$ = $2; }
 687 |       EXTENDS_TK class_type error
 688                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 689 |       EXTENDS_TK error
 690                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 691 ;
 692
 693 interfaces:
 694                 { $$ = NULL_TREE; }
 695 |       IMPLEMENTS_TK interface_type_list
 696                 { $$ = $2; }
 697 |       IMPLEMENTS_TK error
 698                 {
 699                   ctxp->class_err=1;
 700                   yyerror ("Missing interface name");
 701                 }
 702 ;
 703
 704 interface_type_list:
 705         interface_type
 706                 {
 707                   ctxp->interface_number = 1;
 708                   $$ = build_tree_list ($1, NULL_TREE);
 709                 }
 710 |       interface_type_list C_TK interface_type
 711                 {
 712                   ctxp->interface_number++;
 713                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 714                 }
 715 |       interface_type_list C_TK error
 716                 {yyerror ("Missing interface name"); RECOVER;}
 717 ;
 718
 719 class_body:
 720         OCB_TK CCB_TK
 721                 { $$ = ctxp->current_parsed_class; }
 722 |       OCB_TK class_body_declarations CCB_TK
 723                 { $$ = ctxp->current_parsed_class; }
 724 ;
 725
 726 class_body_declarations:
 727         class_body_declaration
 728 |       class_body_declarations class_body_declaration
 729 ;
 730
 731 class_body_declaration:
 732         class_member_declaration
 733 |       static_initializer
 734 |       constructor_declaration
 735 |       block                   /* Added, JDK1.1, instance initializer */
 736                 { $$ = parse_jdk1_1_error ("instance initializer"); }
 737 ;
 738
 739 class_member_declaration:
 740         field_declaration
 741 |       field_declaration SC_TK
 742                 { $$ = $1; }
 743 |       method_declaration
 744 |       class_declaration       /* Added, JDK1.1 inner classes */
 745                 { $$ = parse_jdk1_1_error ("inner classe declaration"); }
 746 |       interface_declaration   /* Added, JDK1.1 inner classes */
 747                 { $$ = parse_jdk1_1_error ("inner interface declaration"); }
 748 ;
 749
 750 /* 19.8.2 Productions from 8.3: Field Declarations  */
 751 field_declaration:
 752         type variable_declarators SC_TK
 753                 { register_fields (0, $1, $2); }
 754 |       modifiers type variable_declarators SC_TK
 755                 {
 756                   check_modifiers
 757                     ("Illegal modifier `%s' for field declaration",
 758                      $1, FIELD_MODIFIERS);
 759                   check_modifiers_consistency ($1);
 760                   register_fields ($1, $2, $3);
 761                 }
 762 ;
 763
 764 variable_declarators:
 765         /* Should we use build_decl_list () instead ? FIXME */
 766         variable_declarator     /* Default rule */
 767 |       variable_declarators C_TK variable_declarator
 768                 { $$ = chainon ($1, $3); }
 769 |       variable_declarators C_TK error
 770                 {yyerror ("Missing term"); RECOVER;}
 771 ;
 772
 773 variable_declarator:
 774         variable_declarator_id
 775                 { $$ = build_tree_list ($1, NULL_TREE); }
 776 |       variable_declarator_id ASSIGN_TK variable_initializer
 777                 {
 778                   if (java_error_count)
 779                     $3 = NULL_TREE;
 780                   $$ = build_tree_list
 781                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 782                 }
 783 |       variable_declarator_id ASSIGN_TK error
 784                 {
 785                   yyerror ("Missing variable initializer");
 786                   $$ = build_tree_list ($1, NULL_TREE);
 787                   RECOVER;
 788                 }
 789 |       variable_declarator_id ASSIGN_TK variable_initializer error
 790                 {
 791                   yyerror ("';' expected");
 792                   $$ = build_tree_list ($1, NULL_TREE);
 793                   RECOVER;
 794                 }
 795 ;
 796
 797 variable_declarator_id:
 798         identifier
 799 |       variable_declarator_id OSB_TK CSB_TK
 800                 { $$ = build_unresolved_array_type ($1); }
 801 |       identifier error
 802                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 803 |       variable_declarator_id OSB_TK error
 804                 {yyerror ("']' expected"); DRECOVER(vdi);}
 805 |       variable_declarator_id CSB_TK error
 806                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 807 ;
 808
 809 variable_initializer:
 810         expression
 811 |       array_initializer
 812 ;
 813
 814 /* 19.8.3 Productions from 8.4: Method Declarations  */
 815 method_declaration:
 816         method_header
 817                 {
 818                   current_function_decl = $1;
 819                   source_start_java_method (current_function_decl);
 820                 }
 821         method_body
 822                 { complete_method_declaration ($3); }
 823 |       method_header error
 824                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
 825 ;
 826
 827 method_header:
 828         type method_declarator throws
 829                 { $$ = method_header (0, $1, $2, $3); }
 830 |       VOID_TK method_declarator throws
 831                 { $$ = method_header (0, void_type_node, $2, $3); }
 832 |       modifiers type method_declarator throws
 833                 { $$ = method_header ($1, $2, $3, $4); }
 834 |       modifiers VOID_TK method_declarator throws
 835                 { $$ = method_header ($1, void_type_node, $3, $4); }
 836 |       type error
 837                 {RECOVER;}
 838 |       modifiers type error
 839                 {RECOVER;}
 840 |       VOID_TK error
 841                 {yyerror ("Identifier expected"); RECOVER;}
 842 |       modifiers VOID_TK error
 843                 {yyerror ("Identifier expected"); RECOVER;}
 844 |       modifiers error
 845                 {
 846                   yyerror ("Invalid method declaration, return type required");
 847                   RECOVER;
 848                 }
 849 ;
 850
 851 method_declarator:
 852         identifier OP_TK CP_TK
 853                 { $$ = method_declarator ($1, NULL_TREE); }
 854 |       identifier OP_TK formal_parameter_list CP_TK
 855                 { $$ = method_declarator ($1, $3); }
 856 |       method_declarator OSB_TK CSB_TK
 857                 {
 858                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
 859                   TREE_PURPOSE ($1) =
 860                     build_unresolved_array_type (TREE_PURPOSE ($1));
 861                   parse_warning_context
 862                     (wfl_operator,
 863                      "Discouraged form of returned type specification");
 864                 }
 865 |       identifier OP_TK error
 866                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
 867 |       method_declarator OSB_TK error
 868                 {yyerror ("']' expected"); RECOVER;}
 869 ;
 870
 871 formal_parameter_list:
 872         formal_parameter
 873                 {
 874                   ctxp->formal_parameter_number = 1;
 875                 }
 876 |       formal_parameter_list C_TK formal_parameter
 877                 {
 878                   ctxp->formal_parameter_number += 1;
 879                   $$ = chainon ($1, $3);
 880                 }
 881 |       formal_parameter_list C_TK error
 882                 {yyerror ("Missing formal parameter term"); RECOVER;}
 883 ;
 884
 885 formal_parameter:
 886         type variable_declarator_id
 887                 {
 888                   $$ = build_tree_list ($2, $1);
 889                 }
 890 |       modifiers type variable_declarator_id /* Added, JDK1.1 final parms */
 891                 { $$ = parse_jdk1_1_error ("final parameters"); }
 892 |       type error
 893                 {yyerror ("Missing identifier"); RECOVER;}
 894 |       modifiers type error
 895                 {
 896                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
 897                   yyerror ("Missing identifier"); RECOVER;
 898                 }
 899 ;
 900
 901 throws:
 902                 { $$ = NULL_TREE; }
 903 |       THROWS_TK class_type_list
 904                 { $$ = $2; }
 905 |       THROWS_TK error
 906                 {yyerror ("Missing class type term"); RECOVER;}
 907 ;
 908
 909 class_type_list:
 910         class_type
 911                 { $$ = build_tree_list ($1, $1); }
 912 |       class_type_list C_TK class_type
 913                 { $$ = tree_cons ($3, $3, $1); }
 914 |       class_type_list C_TK error
 915                 {yyerror ("Missing class type term"); RECOVER;}
 916 ;
 917
 918 method_body:
 919         block
 920 |       block SC_TK
 921 |       SC_TK
 922                 { $$ = NULL_TREE; } /* Probably not the right thing to do. */
 923 ;
 924
 925 /* 19.8.4 Productions from 8.5: Static Initializers  */
 926 static_initializer:
 927         static block
 928                 {
 929                   RULE ("STATIC_INITIALIZER");
 930                 }
 931 |       static block SC_TK      /* Shouldn't be here. FIXME */
 932                 {
 933                   RULE ("STATIC_INITIALIZER");
 934                 }
 935 ;
 936
 937 static:                         /* Test lval.sub_token here */
 938         MODIFIER_TK
 939                 {
 940                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
 941                 }
 942 ;
 943
 944 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
 945 constructor_declaration:
 946         constructor_header
 947                 {
 948                   current_function_decl = $1;
 949                   source_start_java_method (current_function_decl);
 950                 }
 951         constructor_body
 952                 { complete_method_declaration ($3); }
 953 ;
 954
 955 constructor_header:
 956         constructor_declarator throws
 957                 { $$ = method_header (0, NULL_TREE, $1, $2); }
 958 |       modifiers constructor_declarator throws
 959                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
 960 ;
 961
 962 constructor_declarator:
 963         simple_name OP_TK CP_TK
 964                 { $$ = method_declarator ($1, NULL_TREE); }
 965 |       simple_name OP_TK formal_parameter_list CP_TK
 966                 { $$ = method_declarator ($1, $3); }
 967 ;
 968
 969 constructor_body:
 970         /* Unlike regular method, we always need a complete (empty)
 971            body so we can safely perform all the required code
 972            addition (super invocation and field initialization) */
 973         block_begin block_end
 974                 {
 975                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
 976                   $$ = $2;
 977                 }
 978 |       block_begin explicit_constructor_invocation block_end
 979                 { $$ = $3; }
 980 |       block_begin block_statements block_end
 981                 { $$ = $3; }
 982 |       block_begin explicit_constructor_invocation block_statements block_end
 983                 { $$ = $4; }
 984 ;
 985
 986 /* Error recovery for that rule moved down expression_statement: rule.  */
 987 explicit_constructor_invocation:
 988         this_or_super OP_TK CP_TK SC_TK
 989                 {
 990                   $$ = build_method_invocation ($1, NULL_TREE);
 991                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
 992                   $$ = java_method_add_stmt (current_function_decl, $$);
 993                 }
 994 |       this_or_super OP_TK argument_list CP_TK SC_TK
 995                 {
 996                   $$ = build_method_invocation ($1, $3);
 997                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
 998                   $$ = java_method_add_stmt (current_function_decl, $$);
 999                 }
1000         /* Added, JDK1.1 inner classes. Modified because the rule
1001            'primary' couldn't work.  */
1002 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1003                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1004 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1005                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1006 ;
1007
1008 this_or_super:                  /* Added, simplifies error diagnostics */
1009         THIS_TK
1010                 {
1011                   tree wfl = build_wfl_node (this_identifier_node,
1012                                              input_filename, 0, 0);
1013                   EXPR_WFL_LINECOL (wfl) = $1.location;
1014                   $$ = wfl;
1015                 }
1016 |       SUPER_TK
1017                 {
1018                   tree wfl = build_wfl_node (super_identifier_node,
1019                                              input_filename, 0, 0);
1020                   EXPR_WFL_LINECOL (wfl) = $1.location;
1021                   $$ = wfl;
1022                 }
1023 ;
1024
1025 /* 19.9 Productions from 9: Interfaces  */
1026 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1027 interface_declaration:
1028         INTERFACE_TK identifier
1029                 { create_interface (0, $2, NULL_TREE); }
1030         interface_body
1031                 {
1032                   $$ = $4;
1033                 }
1034 |       modifiers INTERFACE_TK identifier
1035                 { create_interface ($1, $3, NULL_TREE); }
1036         interface_body
1037                 {
1038                   $$ = $5;
1039                 }
1040 |       INTERFACE_TK identifier extends_interfaces
1041                 { create_interface (0, $2, $3); }
1042         interface_body
1043                 {
1044                   $$ = $5;
1045                 }
1046 |       modifiers INTERFACE_TK identifier extends_interfaces
1047                 { create_interface ($1, $3, $4); }
1048         interface_body
1049                 {
1050                   $$ = $6;
1051                 }
1052 |       INTERFACE_TK identifier error
1053                 {yyerror ("'{' expected"); RECOVER;}
1054 |       modifiers INTERFACE_TK identifier error
1055                 {yyerror ("'{' expected"); RECOVER;}
1056 ;
1057
1058 extends_interfaces:
1059         EXTENDS_TK interface_type
1060                 {
1061                   ctxp->interface_number = 1;
1062                   $$ = build_tree_list ($2, NULL_TREE);
1063                 }
1064 |       extends_interfaces C_TK interface_type
1065                 {
1066                   ctxp->interface_number++;
1067                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1068                 }
1069 |       EXTENDS_TK error
1070                 {yyerror ("Invalid interface type"); RECOVER;}
1071 |       extends_interfaces C_TK error
1072                 {yyerror ("Missing term"); RECOVER;}
1073 ;
1074
1075 interface_body:
1076         OCB_TK CCB_TK
1077                 { $$ = NULL_TREE; }
1078 |       OCB_TK interface_member_declarations CCB_TK
1079                 { $$ = NULL_TREE; }
1080 ;
1081
1082 interface_member_declarations:
1083         interface_member_declaration
1084 |       interface_member_declarations interface_member_declaration
1085 ;
1086
1087 interface_member_declaration:
1088         constant_declaration
1089 |       abstract_method_declaration
1090 |       class_declaration       /* Added, JDK1.1 inner classes */
1091                 { $$ = parse_jdk1_1_error ("inner class declaration"); }
1092 |       interface_declaration   /* Added, JDK1.1 inner classes */
1093                 { $$ = parse_jdk1_1_error ("inner interface declaration"); }
1094 ;
1095
1096 constant_declaration:
1097         field_declaration
1098 ;
1099
1100 abstract_method_declaration:
1101         method_header SC_TK
1102                 {
1103                   check_abstract_method_header ($1);
1104                   current_function_decl = NULL_TREE; /* FIXME ? */
1105                 }
1106 |       method_header error
1107                 {yyerror ("';' expected"); RECOVER;}
1108 ;
1109
1110 /* 19.10 Productions from 10: Arrays  */
1111 array_initializer:
1112         OCB_TK CCB_TK
1113                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1114 |       OCB_TK variable_initializers CCB_TK
1115                 { $$ = build_new_array_init ($1.location, $2); }
1116 |       OCB_TK variable_initializers C_TK CCB_TK
1117                 { $$ = build_new_array_init ($1.location, $2); }
1118 ;
1119
1120 variable_initializers:
1121         variable_initializer
1122                 {
1123                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1124                                   $1, NULL_TREE);
1125                 }
1126 |       variable_initializers C_TK variable_initializer
1127                 {
1128                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1129                 }
1130 |       variable_initializers C_TK error
1131                 {yyerror ("Missing term"); RECOVER;}
1132 ;
1133
1134 /* 19.11 Production from 14: Blocks and Statements  */
1135 block:
1136         OCB_TK CCB_TK
1137                 { $$ = empty_stmt_node; }
1138 |       block_begin block_statements block_end
1139                 { $$ = $3; }
1140 ;
1141
1142 block_begin:
1143         OCB_TK
1144                 { enter_block (); }
1145 ;
1146
1147 block_end:
1148         CCB_TK
1149                 {
1150                   maybe_absorb_scoping_blocks ();
1151                   $$ = exit_block ();
1152                 }
1153 ;
1154
1155 block_statements:
1156         block_statement
1157 |       block_statements block_statement
1158 ;
1159
1160 block_statement:
1161         local_variable_declaration_statement
1162 |       statement
1163                 { java_method_add_stmt (current_function_decl, $1); }
1164 |       class_declaration       /* Added, JDK1.1 inner classes */
1165                 { parse_jdk1_1_error ("inner class declaration"); }
1166 ;
1167
1168 local_variable_declaration_statement:
1169         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1170 ;
1171
1172 local_variable_declaration:
1173         type variable_declarators
1174                 { declare_local_variables (0, $1, $2); }
1175 |       modifiers type variable_declarators /* Added, JDK1.1 final locals */
1176                 { declare_local_variables ($1, $2, $3); }
1177 ;
1178
1179 statement:
1180         statement_without_trailing_substatement
1181 |       labeled_statement
1182 |       if_then_statement
1183 |       if_then_else_statement
1184 |       while_statement
1185 |       for_statement
1186                 {
1187                   /* If the for loop is unlabeled, we must return the
1188                      block it was defined it. It our last chance to
1189                      get a hold on it. */
1190                   if (!LOOP_HAS_LABEL_P ($$))
1191                     $$ = exit_block ();
1192                 }
1193 ;
1194
1195 statement_nsi:
1196         statement_without_trailing_substatement
1197 |       labeled_statement_nsi
1198 |       if_then_else_statement_nsi
1199 |       while_statement_nsi
1200 |       for_statement_nsi
1201 ;
1202
1203 statement_without_trailing_substatement:
1204         block
1205 |       empty_statement
1206 |       expression_statement
1207 |       switch_statement
1208 |       do_statement
1209 |       break_statement
1210 |       continue_statement
1211 |       return_statement
1212 |       synchronized_statement
1213 |       throw_statement
1214 |       try_statement
1215 ;
1216
1217 empty_statement:
1218         SC_TK
1219                 { $$ = empty_stmt_node; }
1220 ;
1221
1222 label_decl:
1223         identifier REL_CL_TK
1224                 {
1225                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1226                                             EXPR_WFL_NODE ($1));
1227                   pushlevel (2);
1228                   push_labeled_block ($$);
1229                   PUSH_LABELED_BLOCK ($$);
1230                 }
1231 ;
1232
1233 labeled_statement:
1234         label_decl statement
1235                 {
1236                   $$ = complete_labeled_statement ($1, $2);
1237                   pop_labeled_block ();
1238                   POP_LABELED_BLOCK ();
1239                 }
1240 |       identifier error
1241                 {yyerror ("':' expected"); RECOVER;}
1242 ;
1243
1244 labeled_statement_nsi:
1245         label_decl statement_nsi
1246                 {
1247                   $$ = complete_labeled_statement ($1, $2);
1248                   pop_labeled_block ();
1249                   POP_LABELED_BLOCK ();
1250                 }
1251 ;
1252
1253 /* We concentrate here a bunch of error handling rules that we couldn't write
1254    earlier, because expression_statement catches a missing ';'.  */
1255 expression_statement:
1256         statement_expression SC_TK
1257                 {
1258                   /* We have a statement. Generate a WFL around it so
1259                      we can debug it */
1260                   $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1261                   /* We know we have a statement, so set the debug
1262                      info to be eventually generate here. */
1263                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1264                 }
1265 |       error SC_TK
1266                 {
1267                   if (ctxp->prevent_ese != lineno)
1268                     yyerror ("Invalid expression statement");
1269                   DRECOVER (expr_stmt);
1270                 }
1271 |       error OCB_TK
1272                 {
1273                   if (ctxp->prevent_ese != lineno)
1274                     yyerror ("Invalid expression statement");
1275                   DRECOVER (expr_stmt);
1276                 }
1277 |       error CCB_TK
1278                 {
1279                   if (ctxp->prevent_ese != lineno)
1280                     yyerror ("Invalid expression statement");
1281                   DRECOVER (expr_stmt);
1282                 }
1283 |       this_or_super OP_TK error
1284                 {yyerror ("')' expected"); RECOVER;}
1285 |       this_or_super OP_TK CP_TK error
1286                 {
1287                   yyerror ("Constructor invocation must be first "
1288                            "thing in a constructor");
1289                   RECOVER;
1290                 }
1291 |       this_or_super OP_TK argument_list error
1292                 {yyerror ("')' expected"); RECOVER;}
1293 |       this_or_super OP_TK argument_list CP_TK error
1294                 {
1295                   yyerror ("Constructor invocation must be first "
1296                            "thing in a constructor");
1297                   RECOVER;
1298                 }
1299 |       name DOT_TK SUPER_TK error
1300                 {yyerror ("'(' expected"); RECOVER;}
1301 |       name DOT_TK SUPER_TK OP_TK error
1302                 {yyerror ("')' expected"); RECOVER;}
1303 |       name DOT_TK SUPER_TK OP_TK argument_list error
1304                 {yyerror ("')' expected"); RECOVER;}
1305 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1306                 {yyerror ("';' expected"); RECOVER;}
1307 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1308                 {yyerror ("';' expected"); RECOVER;}
1309 ;
1310
1311 statement_expression:
1312         assignment
1313 |       pre_increment_expression
1314 |       pre_decrement_expression
1315 |       post_increment_expression
1316 |       post_decrement_expression
1317 |       method_invocation
1318 |       class_instance_creation_expression
1319 ;
1320
1321 if_then_statement:
1322         IF_TK OP_TK expression CP_TK statement
1323         { $$ = build_if_else_statement ($2.location, $3, $5, NULL_TREE); }
1324 |       IF_TK error
1325                 {yyerror ("'(' expected"); RECOVER;}
1326 |       IF_TK OP_TK error
1327                 {yyerror ("Missing term"); RECOVER;}
1328 |       IF_TK OP_TK expression error
1329                 {yyerror ("')' expected"); RECOVER;}
1330 ;
1331
1332 if_then_else_statement:
1333         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1334         { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1335 ;
1336
1337 if_then_else_statement_nsi:
1338         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1339         { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1340 ;
1341
1342 switch_statement:
1343         switch_expression
1344                 {
1345                   enter_block ();
1346                 }
1347         switch_block
1348                 {
1349                   /* Make into "proper list" of COMPOUND_EXPRs.
1350                      I.e. make the last statment also have its own
1351                      COMPOUND_EXPR. */
1352                   maybe_absorb_scoping_blocks ();
1353                   TREE_OPERAND ($1, 1) = exit_block ();
1354                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1355                 }
1356 ;
1357
1358 switch_expression:
1359         SWITCH_TK OP_TK expression CP_TK
1360                 {
1361                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1362                   EXPR_WFL_LINECOL ($$) = $2.location;
1363                 }
1364 |       SWITCH_TK error
1365                 {yyerror ("'(' expected"); RECOVER;}
1366 |       SWITCH_TK OP_TK error
1367                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1368 |       SWITCH_TK OP_TK expression CP_TK error
1369                 {yyerror ("'{' expected"); RECOVER;}
1370 ;
1371
1372 /* Default assignment is there to avoid type node on switch_block
1373    node. */
1374
1375 switch_block:
1376         OCB_TK CCB_TK
1377                 { $$ = NULL_TREE; }
1378 |       OCB_TK switch_labels CCB_TK
1379                 { $$ = NULL_TREE; }
1380 |       OCB_TK switch_block_statement_groups CCB_TK
1381                 { $$ = NULL_TREE; }
1382 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1383                 { $$ = NULL_TREE; }
1384 ;
1385
1386 switch_block_statement_groups:
1387         switch_block_statement_group
1388 |       switch_block_statement_groups switch_block_statement_group
1389 ;
1390
1391 switch_block_statement_group:
1392         switch_labels block_statements
1393 ;
1394
1395 switch_labels:
1396         switch_label
1397 |       switch_labels switch_label
1398 ;
1399
1400 switch_label:
1401         CASE_TK constant_expression REL_CL_TK
1402                 {
1403                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1404                   EXPR_WFL_LINECOL (lab) = $1.location;
1405                   java_method_add_stmt (current_function_decl, lab);
1406                 }
1407 |       DEFAULT_TK REL_CL_TK
1408                 {
1409                   tree lab = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1410                   EXPR_WFL_LINECOL (lab) = $1.location;
1411                   java_method_add_stmt (current_function_decl, lab);
1412                 }
1413 |       CASE_TK error
1414                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1415 |       CASE_TK constant_expression error
1416                 {yyerror ("':' expected"); RECOVER;}
1417 |       DEFAULT_TK error
1418                 {yyerror ("':' expected"); RECOVER;}
1419 ;
1420
1421 while_expression:
1422         WHILE_TK OP_TK expression CP_TK
1423                 {
1424                   tree body = build_loop_body ($2.location, $3, 0);
1425                   $$ = build_new_loop (body);
1426                 }
1427 ;
1428
1429 while_statement:
1430         while_expression statement
1431                 { $$ = complete_loop_body (0, NULL_TREE, $2, 0); }
1432 |       WHILE_TK error
1433                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1434 |       WHILE_TK OP_TK error
1435                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1436 |       WHILE_TK OP_TK expression error
1437                 {yyerror ("')' expected"); RECOVER;}
1438 ;
1439
1440 while_statement_nsi:
1441         while_expression statement_nsi
1442                 { $$ = complete_loop_body (0, NULL_TREE, $2, 0); }
1443 ;
1444
1445 do_statement_begin:
1446         DO_TK
1447                 {
1448                   tree body = build_loop_body (0, NULL_TREE, 1);
1449                   $$ = build_new_loop (body);
1450                 }
1451         /* Need error handing here. FIXME */
1452 ;
1453
1454 do_statement:
1455         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1456                 { $$ = complete_loop_body ($4.location, $5, $2, 1); }
1457 ;
1458
1459 for_statement:
1460         for_begin SC_TK expression SC_TK for_update CP_TK statement
1461                 { $$ = complete_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1462 |       for_begin SC_TK SC_TK for_update CP_TK statement
1463                 {
1464                   $$ = complete_for_loop (0, NULL_TREE, $4, $6);
1465                   /* We have not condition, so we get rid of the EXIT_EXPR */
1466                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1467                     empty_stmt_node;
1468                 }
1469 |       for_begin SC_TK error
1470                 {yyerror ("Invalid control expression"); RECOVER;}
1471 |       for_begin SC_TK expression SC_TK error
1472                 {yyerror ("Invalid update expression"); RECOVER;}
1473 |       for_begin SC_TK SC_TK error
1474                 {yyerror ("Invalid update expression"); RECOVER;}
1475 ;
1476
1477 for_statement_nsi:
1478         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1479                 { $$ = complete_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1480 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1481                 {
1482                   $$ = complete_for_loop (0, NULL_TREE, $4, $6);
1483                   /* We have not condition, so we get rid of the EXIT_EXPR */
1484                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1485                     empty_stmt_node;
1486                 }
1487 ;
1488
1489 for_header:
1490         FOR_TK OP_TK
1491                 {
1492                   /* This scope defined for local variable that may be
1493                      defined within the scope of the for loop */
1494                   enter_block ();
1495                 }
1496 |       FOR_TK error
1497                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1498 |       FOR_TK OP_TK error
1499                 {yyerror ("Invalid init statement"); RECOVER;}
1500 ;
1501
1502 for_begin:
1503         for_header for_init
1504                 {
1505                   /* We now declare the loop body. The loop is
1506                      declared as a for loop. */
1507                   tree body = build_loop_body (0, NULL_TREE, 0);
1508                   $$ =  build_new_loop (body);
1509                   IS_FOR_LOOP_P ($$) = 1;
1510                   /* The loop is added to the current block the for
1511                      statement is defined within */
1512                   java_method_add_stmt (current_function_decl, $$);
1513                 }
1514 ;
1515 for_init:                       /* Can be empty */
1516                 { $$ = empty_stmt_node; }
1517 |       statement_expression_list
1518                 {
1519                   /* Init statement recorded within the previously
1520                      defined block scope */
1521                   $$ = java_method_add_stmt (current_function_decl, $1);
1522                 }
1523 |       local_variable_declaration
1524                 {
1525                   /* Local variable are recorded within the previously
1526                      defined block scope */
1527                   $$ = NULL_TREE;
1528                 }
1529 |       statement_expression_list error
1530                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1531 ;
1532
1533 for_update:                     /* Can be empty */
1534                 {$$ = empty_stmt_node;}
1535 |       statement_expression_list
1536                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1537 ;
1538
1539 statement_expression_list:
1540         statement_expression
1541                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1542 |       statement_expression_list C_TK statement_expression
1543                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1544 |       statement_expression_list C_TK error
1545                 {yyerror ("Missing term"); RECOVER;}
1546 ;
1547
1548 break_statement:
1549         BREAK_TK SC_TK
1550                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1551 |       BREAK_TK identifier SC_TK
1552                 { $$ = build_bc_statement ($1.location, 1, $2); }
1553 |       BREAK_TK error
1554                 {yyerror ("Missing term"); RECOVER;}
1555 |       BREAK_TK identifier error
1556                 {yyerror ("';' expected"); RECOVER;}
1557 ;
1558
1559 continue_statement:
1560         CONTINUE_TK SC_TK
1561                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1562 |       CONTINUE_TK identifier SC_TK
1563                 { $$ = build_bc_statement ($1.location, 0, $2); }
1564 |       CONTINUE_TK error
1565                 {yyerror ("Missing term"); RECOVER;}
1566 |       CONTINUE_TK identifier error
1567                 {yyerror ("';' expected"); RECOVER;}
1568 ;
1569
1570 return_statement:
1571         RETURN_TK SC_TK
1572                 { $$ = build_return ($1.location, NULL_TREE); }
1573 |       RETURN_TK expression SC_TK
1574                 { $$ = build_return ($1.location, $2); }
1575 |       RETURN_TK error
1576                 {yyerror ("Missing term"); RECOVER;}
1577 |       RETURN_TK expression error
1578                 {yyerror ("';' expected"); RECOVER;}
1579 ;
1580
1581 throw_statement:
1582         THROW_TK expression SC_TK
1583                 {
1584                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1585                   EXPR_WFL_LINECOL ($$) = $1.location;
1586                 }
1587 |       THROW_TK error
1588                 {yyerror ("Missing term"); RECOVER;}
1589 |       THROW_TK expression error
1590                 {yyerror ("';' expected"); RECOVER;}
1591 ;
1592
1593 synchronized_statement:
1594         synchronized OP_TK expression CP_TK block
1595                 {
1596                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1597                   EXPR_WFL_LINECOL ($$) =
1598                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1599                 }
1600 |       synchronized OP_TK expression CP_TK error
1601                 {yyerror ("'{' expected"); RECOVER;}
1602 |       synchronized error
1603                 {yyerror ("'(' expected"); RECOVER;}
1604 |       synchronized OP_TK error CP_TK
1605                 {yyerror ("Missing term"); RECOVER;}
1606 |       synchronized OP_TK error
1607                 {yyerror ("Missing term"); RECOVER;}
1608 ;
1609
1610 synchronized:
1611         MODIFIER_TK
1612                 {
1613                   if ((1 << $1) != ACC_SYNCHRONIZED)
1614                     fatal ("synchronized was '%d' - yyparse", (1 << $1));
1615                 }
1616 ;
1617
1618 try_statement:
1619         TRY_TK block catches
1620                 { $$ = build_try_statement ($1.location, $2, $3); }
1621 |       TRY_TK block finally
1622                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1623 |       TRY_TK block catches finally
1624                 { $$ = build_try_finally_statement ($1.location,
1625                                                     build_try_statement ($1.location,
1626                                                                          $2, $3),
1627                                                     $4); }
1628 |       TRY_TK error
1629                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1630 ;
1631
1632 catches:
1633         catch_clause
1634 |       catches catch_clause
1635                 {
1636                   TREE_CHAIN ($2) = $1;
1637                   $$ = $2;
1638                 }
1639 ;
1640
1641 catch_clause:
1642         catch_clause_parameter block
1643                 {
1644                   java_method_add_stmt (current_function_decl, $2);
1645                   exit_block ();
1646                   $$ = $1;
1647                 }
1648
1649 catch_clause_parameter:
1650         CATCH_TK OP_TK formal_parameter CP_TK
1651                 {
1652                   /* We add a block to define a scope for
1653                      formal_parameter (CCBP). The formal parameter is
1654                      declared initialized by the appropriate function
1655                      call */
1656                   tree ccpb = enter_block ();
1657                   tree init = build_assignment (ASSIGN_TK, $2.location,
1658                                                 TREE_PURPOSE ($3),
1659                                                 soft_exceptioninfo_call_node);
1660                   declare_local_variables (0, TREE_VALUE ($3),
1661                                            build_tree_list (TREE_PURPOSE ($3),
1662                                                             init));
1663                   $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1664                   EXPR_WFL_LINECOL ($$) = $1.location;
1665                 }
1666 |       CATCH_TK error
1667                 {yyerror ("'(' expected"); RECOVER;}
1668 |       CATCH_TK OP_TK error
1669                 {yyerror ("Missing term or ')' expected"); DRECOVER (2);}
1670 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1671                 {yyerror ("')' expected"); DRECOVER (1);}
1672 ;
1673
1674 finally:
1675         FINALLY_TK block
1676                 { $$ = $2; }
1677 |       FINALLY_TK error
1678                 {yyerror ("'{' expected"); RECOVER; }
1679 ;
1680
1681 /* 19.12 Production from 15: Expressions  */
1682 primary:
1683         primary_no_new_array
1684 |       array_creation_expression
1685 ;
1686
1687 primary_no_new_array:
1688         literal
1689 |       THIS_TK
1690                 { $$ = build_this ($1.location); }
1691 |       OP_TK expression CP_TK
1692                 {$$ = $2;}
1693 |       class_instance_creation_expression
1694 |       field_access
1695 |       method_invocation
1696 |       array_access
1697         /* type DOT_TK CLASS_TK doens't work. So we split the rule
1698            'type' into its components. Missing is something for array,
1699            which will complete the reference_type part. FIXME */
1700 |       name DOT_TK CLASS_TK           /* Added, JDK1.1 class literals */
1701                 { $$ = parse_jdk1_1_error ("named class literals"); }
1702 |       primitive_type DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
1703                 { $$ = build_class_ref ($1); }
1704 |       VOID_TK DOT_TK CLASS_TK        /* Added, JDK1.1 class literals */
1705                 { $$ = build_class_ref (void_type_node); }
1706         /* Added, JDK1.1 inner classes. Documentation is wrong
1707            refering to a 'ClassName' (class_name) rule that doesn't
1708            exist. Used name instead.  */
1709 |       name DOT_TK THIS_TK
1710                 { $$ = parse_jdk1_1_error ("class literals"); }
1711 |       OP_TK expression error
1712                 {yyerror ("')' expected"); RECOVER;}
1713 |       name DOT_TK error
1714                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1715 |       primitive_type DOT_TK error
1716                 {yyerror ("'class' expected" ); RECOVER;}
1717 |       VOID_TK DOT_TK error
1718                 {yyerror ("'class' expected" ); RECOVER;}
1719 ;
1720
1721 class_instance_creation_expression:
1722         NEW_TK class_type OP_TK argument_list CP_TK
1723                 { $$ = build_new_invocation ($2, $4); }
1724 |       NEW_TK class_type OP_TK CP_TK
1725                 { $$ = build_new_invocation ($2, NULL_TREE); }
1726         /* Added, JDK1.1 inner classes but modified to use
1727            'class_type' instead of 'TypeName' (type_name) mentionned
1728            in the documentation but doesn't exist. */
1729 |       NEW_TK class_type OP_TK argument_list CP_TK class_body
1730                 { $$ = parse_jdk1_1_error ("inner class instance creation"); }
1731 |       NEW_TK class_type OP_TK CP_TK class_body
1732                 { $$ = parse_jdk1_1_error ("inner class instance creation"); }
1733         /* Added, JDK1.1 inner classes, modified to use name or
1734            primary instead of primary solely which couldn't work in
1735            all situations.  */
1736 |       something_dot_new identifier OP_TK CP_TK
1737 |       something_dot_new identifier OP_TK CP_TK class_body
1738 |       something_dot_new identifier OP_TK argument_list CP_TK
1739 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
1740 |       NEW_TK error SC_TK
1741                 {yyerror ("'(' expected"); DRECOVER(new_1);}
1742 |       NEW_TK class_type error
1743                 {yyerror ("'(' expected"); RECOVER;}
1744 |       NEW_TK class_type OP_TK error
1745                 {yyerror ("')' or term expected"); RECOVER;}
1746 |       NEW_TK class_type OP_TK argument_list error
1747                 {yyerror ("')' expected"); RECOVER;}
1748 |       something_dot_new error
1749                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
1750 |       something_dot_new identifier error
1751                 {yyerror ("'(' expected"); RECOVER;}
1752 ;
1753
1754 something_dot_new:              /* Added, not part of the specs. */
1755         name DOT_TK NEW_TK
1756 |       primary DOT_TK NEW_TK
1757 ;
1758
1759 argument_list:
1760         expression
1761                 {
1762                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
1763                   ctxp->formal_parameter_number = 1;
1764                 }
1765 |       argument_list C_TK expression
1766                 {
1767                   ctxp->formal_parameter_number += 1;
1768                   $$ = tree_cons (NULL_TREE, $3, $1);
1769                 }
1770 |       argument_list C_TK error
1771                 {yyerror ("Missing term"); RECOVER;}
1772 ;
1773
1774 array_creation_expression:
1775         NEW_TK primitive_type dim_exprs
1776                 { $$ = build_newarray_node ($2, $3, 0); }
1777 |       NEW_TK class_or_interface_type dim_exprs
1778                 { $$ = build_newarray_node ($2, $3, 0); }
1779 |       NEW_TK primitive_type dim_exprs dims
1780                 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
1781 |       NEW_TK class_or_interface_type dim_exprs dims
1782                 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
1783         /* Added, JDK1.1 anonymous array. Initial documentation rule
1784            modified */
1785 |       NEW_TK class_or_interface_type dims array_initializer
1786                 { $$ = parse_jdk1_1_error ("anonymous array"); }
1787 |       NEW_TK primitive_type dims array_initializer
1788                 { $$ = parse_jdk1_1_error ("anonymous array"); }
1789 |       NEW_TK error CSB_TK
1790                 {yyerror ("'[' expected"); DRECOVER ("]");}
1791 |       NEW_TK error OSB_TK
1792                 {yyerror ("']' expected"); RECOVER;}
1793 ;
1794
1795 dim_exprs:
1796         dim_expr
1797                 { $$ = build_tree_list (NULL_TREE, $1); }
1798 |       dim_exprs dim_expr
1799                 { $$ = tree_cons (NULL_TREE, $2, $$); }
1800 ;
1801
1802 dim_expr:
1803         OSB_TK expression CSB_TK
1804                 {
1805                   EXPR_WFL_LINECOL ($2) = $1.location;
1806                   $$ = $2;
1807                 }
1808 |       OSB_TK expression error
1809                 {yyerror ("']' expected"); RECOVER;}
1810 |       OSB_TK error
1811                 {
1812                   yyerror ("Missing term");
1813                   yyerror ("']' expected");
1814                   RECOVER;
1815                 }
1816 ;
1817
1818 dims:
1819         OSB_TK CSB_TK
1820                 {
1821                   int allocate = 0;
1822                   /* If not initialized, allocate memory for the osb
1823                      numbers stack */
1824                   if (!ctxp->osb_limit)
1825                     {
1826                       allocate = ctxp->osb_limit = 32;
1827                       ctxp->osb_depth = -1;
1828                     }
1829                   /* If capacity overflown, reallocate a bigger chuck */
1830                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
1831                     allocate = ctxp->osb_limit << 1;
1832
1833                   if (allocate)
1834                     {
1835                       allocate *= sizeof (int);
1836                       if (ctxp->osb_number)
1837                         ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
1838                                                             allocate);
1839                       else
1840                         ctxp->osb_number = (int *)xmalloc (allocate);
1841                     }
1842                   ctxp->osb_depth++;
1843                   CURRENT_OSB (ctxp) = 1;
1844                 }
1845 |       dims OSB_TK CSB_TK
1846                 { CURRENT_OSB (ctxp)++; }
1847 |       dims OSB_TK error
1848                 { yyerror ("']' expected"); RECOVER;}
1849 ;
1850
1851 field_access:
1852         primary DOT_TK identifier
1853                 { $$ = make_qualified_primary ($1, $3, $2.location); }
1854                 /*  FIXME - REWRITE TO:
1855                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
1856 |       SUPER_TK DOT_TK identifier
1857                 {
1858                   tree super_wfl =
1859                     build_wfl_node (super_identifier_node,
1860                                     input_filename, 0, 0);
1861                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
1862                   $$ = make_qualified_name (super_wfl, $3, $2.location);
1863                 }
1864 |       SUPER_TK error
1865                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
1866 ;
1867
1868 method_invocation:
1869         name OP_TK CP_TK
1870                 { $$ = build_method_invocation ($1, NULL_TREE); }
1871 |       name OP_TK argument_list CP_TK
1872                 { $$ = build_method_invocation ($1, $3); }
1873 |       primary DOT_TK identifier OP_TK CP_TK
1874                 {
1875                   if (TREE_CODE ($1) == THIS_EXPR)
1876                     $$ = build_this_super_qualified_invocation
1877                       (1, $3, NULL_TREE, 0, $2.location);
1878                   else
1879                     {
1880                       tree invok = build_method_invocation ($3, NULL_TREE);
1881                       $$ = make_qualified_primary ($1, invok, $2.location);
1882                     }
1883                 }
1884 |       primary DOT_TK identifier OP_TK argument_list CP_TK
1885                 {
1886                   if (TREE_CODE ($1) == THIS_EXPR)
1887                     $$ = build_this_super_qualified_invocation
1888                       (1, $3, $5, 0, $2.location);
1889                   else
1890                     {
1891                       tree invok = build_method_invocation ($3, $5);
1892                       $$ = make_qualified_primary ($1, invok, $2.location);
1893                     }
1894                 }
1895 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
1896                 {
1897                   $$ = build_this_super_qualified_invocation
1898                     (0, $3, NULL_TREE, $1.location, $2.location);
1899                 }
1900 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
1901                 {
1902                   $$ = build_this_super_qualified_invocation
1903                     (0, $3, $5, $1.location, $2.location);
1904                 }
1905         /* Screws up thing. I let it here until I'm convinced it can
1906            be removed. FIXME
1907 |       primary DOT_TK error
1908                 {yyerror ("'(' expected"); DRECOVER(bad);} */
1909 |       SUPER_TK DOT_TK error CP_TK
1910                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
1911 |       SUPER_TK DOT_TK error DOT_TK
1912                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
1913 ;
1914
1915 array_access:
1916         name OSB_TK expression CSB_TK
1917                 { $$ = build_array_ref ($2.location, $1, $3); }
1918 |       primary_no_new_array OSB_TK expression CSB_TK
1919                 { $$ = build_array_ref ($2.location, $1, $3); }
1920 |       name OSB_TK error
1921                 {
1922                   yyerror ("Missing term and ']' expected");
1923                   DRECOVER(array_access);
1924                 }
1925 |       name OSB_TK expression error
1926                 {
1927                   yyerror ("']' expected");
1928                   DRECOVER(array_access);
1929                 }
1930 |       primary_no_new_array OSB_TK error
1931                 {
1932                   yyerror ("Missing term and ']' expected");
1933                   DRECOVER(array_access);
1934                 }
1935 |       primary_no_new_array OSB_TK expression error
1936                 {
1937                   yyerror ("']' expected");
1938                   DRECOVER(array_access);
1939                 }
1940 ;
1941
1942 postfix_expression:
1943         primary
1944 |       name
1945 |       post_increment_expression
1946 |       post_decrement_expression
1947 ;
1948
1949 post_increment_expression:
1950         postfix_expression INCR_TK
1951                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
1952 ;
1953
1954 post_decrement_expression:
1955         postfix_expression DECR_TK
1956                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
1957 ;
1958
1959 unary_expression:
1960         pre_increment_expression
1961 |       pre_decrement_expression
1962 |       PLUS_TK unary_expression
1963                 {$$ = build_unaryop ($1.token, $1.location, $2); }
1964 |       MINUS_TK unary_expression
1965                 {$$ = build_unaryop ($1.token, $1.location, $2); }
1966 |       unary_expression_not_plus_minus
1967 |       PLUS_TK error
1968                 {yyerror ("Missing term"); RECOVER}
1969 |       MINUS_TK error
1970                 {yyerror ("Missing term"); RECOVER}
1971 ;
1972
1973 pre_increment_expression:
1974         INCR_TK unary_expression
1975                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
1976 |       INCR_TK error
1977                 {yyerror ("Missing term"); RECOVER}
1978 ;
1979
1980 pre_decrement_expression:
1981         DECR_TK unary_expression
1982                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
1983 |       DECR_TK error
1984                 {yyerror ("Missing term"); RECOVER}
1985 ;
1986
1987 unary_expression_not_plus_minus:
1988         postfix_expression
1989 |       NOT_TK unary_expression
1990                 {$$ = build_unaryop ($1.token, $1.location, $2); }
1991 |       NEG_TK unary_expression
1992                 {$$ = build_unaryop ($1.token, $1.location, $2); }
1993 |       cast_expression
1994 |       NOT_TK error
1995                 {yyerror ("Missing term"); RECOVER}
1996 |       NEG_TK error
1997                 {yyerror ("Missing term"); RECOVER}
1998 ;
1999
2000 cast_expression:                /* Error handling here is potentially weak */
2001         OP_TK primitive_type dims CP_TK unary_expression
2002                 {
2003                   tree type = $2;
2004                   while (CURRENT_OSB (ctxp)--)
2005                     type = build_java_array_type (type, -1);
2006                   ctxp->osb_depth--;
2007                   $$ = build_cast ($1.location, type, $5);
2008                 }
2009 |       OP_TK primitive_type CP_TK unary_expression
2010                 { $$ = build_cast ($1.location, $2, $4); }
2011 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2012                 { $$ = build_cast ($1.location, $2, $4); }
2013 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2014                 {
2015                   char *ptr;
2016                   while (CURRENT_OSB (ctxp)--)
2017                     obstack_1grow (&temporary_obstack, '[');
2018                   ctxp->osb_depth--;
2019                   obstack_grow0 (&temporary_obstack,
2020                                  IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2021                                  IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2022                   ptr = obstack_finish (&temporary_obstack);
2023                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2024                   $$ = build_cast ($1.location, $2, $5);
2025                 }
2026 |       OP_TK primitive_type OSB_TK error
2027                 {yyerror ("']' expected, invalid type expression");}
2028 |       OP_TK error
2029                 {
2030                   if (ctxp->prevent_ese != lineno)
2031                     yyerror ("Invalid type expression"); RECOVER;
2032                   RECOVER;
2033                 }
2034 |       OP_TK primitive_type dims CP_TK error
2035                 {yyerror ("Missing term"); RECOVER;}
2036 |       OP_TK primitive_type CP_TK error
2037                 {yyerror ("Missing term"); RECOVER;}
2038 |       OP_TK name dims CP_TK error
2039                 {yyerror ("Missing term"); RECOVER;}
2040 ;
2041
2042 multiplicative_expression:
2043         unary_expression
2044 |       multiplicative_expression MULT_TK unary_expression
2045                 {
2046                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2047                                     $2.location, $1, $3);
2048                 }
2049 |       multiplicative_expression DIV_TK unary_expression
2050                 {
2051                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2052                                     $1, $3);
2053                 }
2054 |       multiplicative_expression REM_TK unary_expression
2055                 {
2056                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2057                                     $1, $3);
2058                 }
2059 |       multiplicative_expression MULT_TK error
2060                 {yyerror ("Missing term"); RECOVER;}
2061 |       multiplicative_expression DIV_TK error
2062                 {yyerror ("Missing term"); RECOVER;}
2063 |       multiplicative_expression REM_TK error
2064                 {yyerror ("Missing term"); RECOVER;}
2065 ;
2066
2067 additive_expression:
2068         multiplicative_expression
2069 |       additive_expression PLUS_TK multiplicative_expression
2070                 {
2071                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2072                                     $1, $3);
2073                 }
2074 |       additive_expression MINUS_TK multiplicative_expression
2075                 {
2076                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2077                                     $1, $3);
2078                 }
2079 |       additive_expression PLUS_TK error
2080                 {yyerror ("Missing term"); RECOVER;}
2081 |       additive_expression MINUS_TK error
2082                 {yyerror ("Missing term"); RECOVER;}
2083 ;
2084
2085 shift_expression:
2086         additive_expression
2087 |       shift_expression LS_TK additive_expression
2088                 {
2089                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2090                                     $1, $3);
2091                 }
2092 |       shift_expression SRS_TK additive_expression
2093                 {
2094                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2095                                     $1, $3);
2096                 }
2097 |       shift_expression ZRS_TK additive_expression
2098                 {
2099                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2100                                     $1, $3);
2101                 }
2102 |       shift_expression LS_TK error
2103                 {yyerror ("Missing term"); RECOVER;}
2104 |       shift_expression SRS_TK error
2105                 {yyerror ("Missing term"); RECOVER;}
2106 |       shift_expression ZRS_TK error
2107                 {yyerror ("Missing term"); RECOVER;}
2108 ;
2109
2110 relational_expression:
2111         shift_expression
2112 |       relational_expression LT_TK shift_expression
2113                 {
2114                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2115                                     $1, $3);
2116                 }
2117 |       relational_expression GT_TK shift_expression
2118                 {
2119                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2120                                     $1, $3);
2121                 }
2122 |       relational_expression LTE_TK shift_expression
2123                 {
2124                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2125                                     $1, $3);
2126                 }
2127 |       relational_expression GTE_TK shift_expression
2128                 {
2129                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2130                                     $1, $3);
2131                 }
2132 |       relational_expression INSTANCEOF_TK reference_type
2133                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2134 |       relational_expression LT_TK error
2135                 {yyerror ("Missing term"); RECOVER;}
2136 |       relational_expression GT_TK error
2137                 {yyerror ("Missing term"); RECOVER;}
2138 |       relational_expression LTE_TK error
2139                 {yyerror ("Missing term"); RECOVER;}
2140 |       relational_expression GTE_TK error
2141                 {yyerror ("Missing term"); RECOVER;}
2142 |       relational_expression INSTANCEOF_TK error
2143                 {yyerror ("Invalid reference type"); RECOVER;}
2144 ;
2145
2146 equality_expression:
2147         relational_expression
2148 |       equality_expression EQ_TK relational_expression
2149                 {
2150                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2151                                     $1, $3);
2152                 }
2153 |       equality_expression NEQ_TK relational_expression
2154                 {
2155                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2156                                     $1, $3);
2157                 }
2158 |       equality_expression EQ_TK error
2159                 {yyerror ("Missing term"); RECOVER;}
2160 |       equality_expression NEQ_TK error
2161                 {yyerror ("Missing term"); RECOVER;}
2162 ;
2163
2164 and_expression:
2165         equality_expression
2166 |       and_expression AND_TK equality_expression
2167                 {
2168                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2169                                     $1, $3);
2170                 }
2171 |       and_expression AND_TK error
2172                 {yyerror ("Missing term"); RECOVER;}
2173 ;
2174
2175 exclusive_or_expression:
2176         and_expression
2177 |       exclusive_or_expression XOR_TK and_expression
2178                 {
2179                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2180                                     $1, $3);
2181                 }
2182 |       exclusive_or_expression XOR_TK error
2183                 {yyerror ("Missing term"); RECOVER;}
2184 ;
2185
2186 inclusive_or_expression:
2187         exclusive_or_expression
2188 |       inclusive_or_expression OR_TK exclusive_or_expression
2189                 {
2190                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2191                                     $1, $3);
2192                 }
2193 |       inclusive_or_expression OR_TK error
2194                 {yyerror ("Missing term"); RECOVER;}
2195 ;
2196
2197 conditional_and_expression:
2198         inclusive_or_expression
2199 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2200                 {
2201                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2202                                     $1, $3);
2203                 }
2204 |       conditional_and_expression BOOL_AND_TK error
2205                 {yyerror ("Missing term"); RECOVER;}
2206 ;
2207
2208 conditional_or_expression:
2209         conditional_and_expression
2210 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2211                 {
2212                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2213                                     $1, $3);
2214                 }
2215 |       conditional_or_expression BOOL_OR_TK error
2216                 {yyerror ("Missing term"); RECOVER;}
2217 ;
2218
2219 conditional_expression:         /* Error handling here is weak */
2220         conditional_or_expression
2221 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2222                 {
2223                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2224                   EXPR_WFL_LINECOL ($$) = $2.location;
2225                 }
2226 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2227                 {
2228                   YYERROR_NOW;
2229                   yyerror ("Missing term");
2230                   DRECOVER (1);
2231                 }
2232 |       conditional_or_expression REL_QM_TK error
2233                 {yyerror ("Missing term"); DRECOVER (2);}
2234 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2235                 {yyerror ("Missing term"); DRECOVER (3);}
2236 ;
2237
2238 assignment_expression:
2239         conditional_expression
2240 |       assignment
2241 ;
2242
2243 assignment:
2244         left_hand_side assignment_operator assignment_expression
2245                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2246 |       left_hand_side assignment_operator error
2247                 {
2248                   if (ctxp->prevent_ese != lineno)
2249                     yyerror ("Missing term");
2250                   DRECOVER (assign);
2251                 }
2252 ;
2253
2254 left_hand_side:
2255         name
2256 |       field_access
2257 |       array_access
2258 ;
2259
2260 assignment_operator:
2261         ASSIGN_ANY_TK
2262 |       ASSIGN_TK
2263 ;
2264
2265 expression:
2266         assignment_expression
2267 ;
2268
2269 constant_expression:
2270         expression
2271 ;
2272
2273 %%
2274 \f
2275
2276 #include "lex.c"
2277
2278 /* Flag for the error report routine to issue the error the first time
2279    it's called (overriding the default behavior which is to drop the
2280    first invocation and honor the second one, taking advantage of a
2281    richer context.  */
2282 static int force_error = 0;
2283
2284 /* Create a new parser context and make it the current one. */
2285
2286 void
2287 java_push_parser_context ()
2288 {
2289   struct parser_ctxt *new =
2290     (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2291
2292   bzero (new, sizeof (struct parser_ctxt));
2293   new->next = ctxp;
2294   ctxp = new;
2295   if (ctxp->next)
2296     {
2297       ctxp->incomplete_class = ctxp->next->incomplete_class;
2298       ctxp->gclass_list = ctxp->next->gclass_list;
2299     }
2300 }
2301
2302 /* If the first file of a file list was a class file, no context
2303    exists for a source file to be parsed. This boolean remembers that
2304    java_parser_context_save_global might have created a dummy one, so
2305    that java_parser_context_restore_global can pop it.  */
2306 static int extra_ctxp_pushed_p = 0;
2307
2308 void
2309 java_parser_context_save_global ()
2310 {
2311   if (!ctxp)
2312     {
2313       java_push_parser_context ();
2314       extra_ctxp_pushed_p = 1;
2315     }
2316   ctxp->finput = finput;
2317   ctxp->lineno = lineno;
2318   ctxp->current_class = current_class;
2319   ctxp->filename = input_filename;
2320   ctxp->current_function_decl = current_function_decl;
2321 }
2322
2323 void
2324 java_parser_context_restore_global ()
2325 {
2326   finput = ctxp->finput;
2327   lineno = ctxp->lineno;
2328   current_class = ctxp->current_class;
2329   input_filename = ctxp->filename;
2330   current_function_decl = ctxp->current_function_decl;
2331   if (!ctxp->next && extra_ctxp_pushed_p)
2332     {
2333       java_pop_parser_context (0);
2334       extra_ctxp_pushed_p = 0;
2335     }
2336 }
2337
2338 void
2339 java_pop_parser_context (generate)
2340      int generate;
2341 {
2342   tree current;
2343   struct parser_ctxt *toFree, *next;
2344
2345   if (!ctxp)
2346     return;
2347
2348   toFree = ctxp;
2349   next = ctxp->next;
2350   if (next)
2351     {
2352       next->incomplete_class = ctxp->incomplete_class;
2353       next->gclass_list = ctxp->gclass_list;
2354       lineno = ctxp->lineno;
2355       finput = ctxp->finput;
2356       current_class = ctxp->current_class;
2357     }
2358
2359   /* Set the single import class file flag to 0 for the current list
2360      of imported things */
2361   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2362     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
2363
2364   /* And restore those of the previous context */
2365   if ((ctxp = next))            /* Assignment is really meant here */
2366     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2367       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
2368
2369   if (generate)
2370     {
2371       toFree->next = ctxp_for_generation;
2372       ctxp_for_generation = toFree;
2373     }
2374   else
2375     free (toFree);
2376 }
2377
2378 /* Reporting JDK1.1 features not implemented */
2379
2380 static tree
2381 parse_jdk1_1_error (msg)
2382     char *msg;
2383 {
2384   sorry (": `%s' JDK1.1(TM) feature", msg);
2385   java_error_count++;
2386   return empty_stmt_node;
2387 }
2388
2389 static int do_warning = 0;
2390
2391 void
2392 yyerror (msg)
2393      char *msg;
2394 {
2395   static java_lc elc;
2396   static int  prev_lineno;
2397   static char *prev_msg;
2398
2399   int save_lineno;
2400   char *remainder, *code_from_source;
2401   extern struct obstack temporary_obstack;
2402
2403   if (!force_error && prev_lineno == lineno)
2404     return;
2405
2406   /* Save current error location but report latter, when the context is
2407      richer.  */
2408   if (ctxp->java_error_flag == 0)
2409     {
2410       ctxp->java_error_flag = 1;
2411       elc = ctxp->elc;
2412       /* Do something to use the previous line if we're reaching the
2413          end of the file... */
2414 #ifdef VERBOSE_SKELETON
2415       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
2416 #endif
2417       return;
2418     }
2419
2420   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
2421   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
2422     return;
2423
2424   ctxp->java_error_flag = 0;
2425   if (do_warning)
2426     java_warning_count++;
2427   else
2428     java_error_count++;
2429
2430   if (elc.col == 0 && msg[1] == ';')
2431     {
2432       elc.col  = ctxp->p_line->char_col-1;
2433       elc.line = ctxp->p_line->lineno;
2434     }
2435
2436   save_lineno = lineno;
2437   prev_lineno = lineno = elc.line;
2438   prev_msg = msg;
2439
2440   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
2441   obstack_grow0 (&temporary_obstack,
2442                  code_from_source, strlen (code_from_source));
2443   remainder = obstack_finish (&temporary_obstack);
2444   if (do_warning)
2445     warning ("%s.\n%s", msg, remainder);
2446   else
2447     error ("%s.\n%s", msg, remainder);
2448
2449   /* This allow us to cheaply avoid an extra 'Invalid expression
2450      statement' error report when errors have been already reported on
2451      the same line. This occurs when we report an error but don't have
2452      a synchronization point other than ';', which
2453      expression_statement is the only one to take care of.  */
2454   ctxp->prevent_ese = lineno = save_lineno;
2455 }
2456
2457 static void
2458 issue_warning_error_from_context (cl, msg, ap)
2459      tree cl;
2460      const char *msg;
2461      va_list ap;
2462 {
2463   char *saved, *saved_input_filename;
2464   char buffer [4096];
2465   vsprintf (buffer, msg, ap);
2466   force_error = 1;
2467
2468   ctxp->elc.line = EXPR_WFL_LINENO (cl);
2469   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
2470                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
2471
2472   /* We have a CL, that's a good reason for using it if it contains data */
2473   saved = ctxp->filename;
2474   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
2475     ctxp->filename = EXPR_WFL_FILENAME (cl);
2476   saved_input_filename = input_filename;
2477   input_filename = ctxp->filename;
2478   java_error (NULL);
2479   java_error (buffer);
2480   ctxp->filename = saved;
2481   input_filename = saved_input_filename;
2482   force_error = 0;
2483 }
2484
2485 /* Issue an error message at a current source line CL */
2486
2487 void
2488 parse_error_context VPROTO ((tree cl, const char *msg, ...))
2489 {
2490 #ifndef ANSI_PROTOTYPES
2491   tree cl;
2492   const char *msg;
2493 #endif
2494   va_list ap;
2495
2496   VA_START (ap, msg);
2497 #ifndef ANSI_PROTOTYPES
2498   cl = va_arg (ap, tree);
2499   msg = va_arg (ap, const char *);
2500 #endif
2501   issue_warning_error_from_context (cl, msg, ap);
2502   va_end (ap);
2503 }
2504
2505 /* Issue a warning at a current source line CL */
2506
2507 static void
2508 parse_warning_context VPROTO ((tree cl, const char *msg, ...))
2509 {
2510 #ifndef ANSI_PROTOTYPES
2511   tree cl;
2512   const char *msg;
2513 #endif
2514   va_list ap;
2515
2516   VA_START (ap, msg);
2517 #ifndef ANSI_PROTOTYPES
2518   cl = va_arg (ap, tree);
2519   msg = va_arg (ap, const char *);
2520 #endif
2521
2522   force_error = do_warning = 1;
2523   issue_warning_error_from_context (cl, msg, ap);
2524   do_warning = force_error = 0;
2525   va_end (ap);
2526 }
2527
2528 static tree
2529 find_expr_with_wfl (node)
2530      tree node;
2531 {
2532   while (node)
2533     {
2534       char code;
2535       tree to_return;
2536
2537       switch (TREE_CODE (node))
2538         {
2539         case BLOCK:
2540           return find_expr_with_wfl (BLOCK_EXPR_BODY (node));
2541
2542         case COMPOUND_EXPR:
2543           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
2544           if (to_return)
2545             return to_return;
2546           to_return = find_expr_with_wfl (TREE_OPERAND (node, 1));
2547           return to_return;
2548
2549         case LOOP_EXPR:
2550           return find_expr_with_wfl (TREE_OPERAND (node, 0));
2551
2552         case LABELED_BLOCK_EXPR:
2553           return find_expr_with_wfl (TREE_OPERAND (node, 1));
2554         default:
2555           code = TREE_CODE_CLASS (TREE_CODE (node));
2556           if (((code == '1') || (code == '2') || (code == 'e'))
2557               && EXPR_WFL_LINECOL (node))
2558             return node;
2559           return NULL_TREE;
2560         }
2561     }
2562   return NULL_TREE;
2563 }
2564
2565 /* Issue a missing return statement error. Uses METHOD to figure the
2566    last line of the method the error occurs in.  */
2567
2568 static void
2569 missing_return_error (method)
2570      tree method;
2571 {
2572   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
2573   parse_error_context (wfl_operator, "Missing return statement");
2574 }
2575
2576 /* Issue an unreachable statement error. From NODE, find the next
2577    statement to report appropriately.  */
2578 static void
2579 unreachable_stmt_error (node)
2580      tree node;
2581 {
2582   /* Browse node to find the next expression node that has a WFL. Use
2583      the location to report the error */
2584   if (TREE_CODE (node) == COMPOUND_EXPR)
2585     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
2586   else
2587     node = find_expr_with_wfl (node);
2588
2589   if (node)
2590     {
2591       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
2592       parse_error_context (wfl_operator, "Unreachable statement");
2593     }
2594   else
2595     fatal ("Can't get valid statement - unreachable_stmt_error");
2596 }
2597
2598 int
2599 java_report_errors ()
2600 {
2601   if (java_error_count)
2602     fprintf (stderr, "%d error%s",
2603              java_error_count, (java_error_count == 1 ? "" : "s"));
2604   if (java_warning_count)
2605     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
2606              java_warning_count, (java_warning_count == 1 ? "" : "s"));
2607   if (java_error_count || java_warning_count)
2608     putc ('\n', stderr);
2609   return java_error_count;
2610 }
2611
2612 static char *
2613 java_accstring_lookup (flags)
2614      int flags;
2615 {
2616   static char buffer [80];
2617 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
2618
2619   /* Access modifier looked-up first for easier report on forbidden
2620      access. */
2621   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
2622   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
2623   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
2624   if (flags & ACC_STATIC) COPY_RETURN ("static");
2625   if (flags & ACC_FINAL) COPY_RETURN ("final");
2626   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
2627   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
2628   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
2629   if (flags & ACC_NATIVE) COPY_RETURN ("native");
2630   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
2631   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
2632
2633   buffer [0] = '\0';
2634   return buffer;
2635 #undef COPY_RETURN
2636 }
2637
2638 /* Issuing error messages upon redefinition of classes, interfaces or
2639    variables. */
2640
2641 static void
2642 classitf_redefinition_error (context, id, decl, cl)
2643      char *context;
2644      tree id, decl, cl;
2645 {
2646   parse_error_context (cl, "%s `%s' already defined in %s:%d",
2647                        context, IDENTIFIER_POINTER (id),
2648                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
2649   /* Here we should point out where its redefined. It's a unicode. FIXME */
2650 }
2651
2652 static void
2653 variable_redefinition_error (context, name, type, line)
2654      tree context, name, type;
2655      int line;
2656 {
2657   char *type_name;
2658
2659   /* Figure a proper name for type. We might haven't resolved it */
2660   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
2661     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
2662   else
2663     type_name = lang_printable_name (type, 0);
2664
2665   parse_error_context (context,
2666                        "Variable `%s' is already defined in this method and "
2667                        "was declared `%s %s' at line %d",
2668                        IDENTIFIER_POINTER (name),
2669                        type_name, IDENTIFIER_POINTER (name), line);
2670 }
2671
2672 static tree
2673 build_array_from_name (type, type_wfl, name, ret_name)
2674      tree type, type_wfl, name, *ret_name;
2675 {
2676   int more_dims = 0;
2677   char *string;
2678
2679   /* Eventually get more dims */
2680   string = IDENTIFIER_POINTER (name);
2681   while (string [more_dims] == '[')
2682     more_dims++;
2683
2684   /* If we have, then craft a new type for this variable */
2685   if (more_dims)
2686     {
2687       name = get_identifier (&more_dims [string]);
2688
2689       /* If we have a pointer, use its type */
2690       if (TREE_CODE (type) == POINTER_TYPE)
2691         type = TREE_TYPE (type);
2692
2693       /* Building the first dimension of a primitive type uses this
2694          function */
2695       if (JPRIMITIVE_TYPE_P (type))
2696         {
2697           type = build_java_array_type (type, -1);
2698           CLASS_LOADED_P (type) = 1;
2699           more_dims--;
2700         }
2701       /* Otherwise, if we have a WFL for this type, use it (the type
2702          is already an array on an unresolved type, and we just keep
2703          on adding dimensions) */
2704       else if (type_wfl)
2705         type = type_wfl;
2706
2707       /* Add all the dimensions */
2708       while (more_dims--)
2709         type = build_unresolved_array_type (type);
2710
2711       /* The type may have been incomplete in the first place */
2712       if (type_wfl)
2713         type = obtain_incomplete_type (type);
2714     }
2715
2716   *ret_name = name;
2717   return type;
2718 }
2719
2720 /* Build something that the type identifier resolver will identify as
2721    being an array to an unresolved type. TYPE_WFL is a WFL on a
2722    identifier. */
2723
2724 static tree
2725 build_unresolved_array_type (type_or_wfl)
2726      tree type_or_wfl;
2727 {
2728   char *ptr;
2729
2730   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
2731      just create a array type */
2732   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
2733     {
2734       tree type = build_java_array_type (type_or_wfl, -1);
2735       CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
2736       return type;
2737     }
2738
2739   obstack_1grow (&temporary_obstack, '[');
2740   obstack_grow0 (&temporary_obstack,
2741                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
2742                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
2743   ptr = obstack_finish (&temporary_obstack);
2744   return build_expr_wfl (get_identifier (ptr),
2745                          EXPR_WFL_FILENAME (type_or_wfl),
2746                          EXPR_WFL_LINENO (type_or_wfl),
2747                          EXPR_WFL_COLNO (type_or_wfl));
2748 }
2749
2750 /* Check modifiers. If one doesn't fit, retrieve it in its declaration line
2751   and point it out.  */
2752
2753 static void
2754 check_modifiers (message, value, mask)
2755      char *message;
2756      int value;
2757      int mask;
2758 {
2759   /* Should point out the one that don't fit. ASCII/unicode,
2760      going backward. FIXME */
2761   if (value & ~mask)
2762     {
2763       int i, remainder = value & ~mask;
2764       for (i = 0; i <= 10; i++)
2765         if ((1 << i) & remainder)
2766           parse_error_context (ctxp->modifier_ctx [i], message,
2767                                java_accstring_lookup (1 << i));
2768     }
2769 }
2770
2771 static void
2772 parser_add_interface (class_decl, interface_decl, wfl)
2773      tree class_decl, interface_decl, wfl;
2774 {
2775   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
2776     parse_error_context (wfl, "Interface `%s' repeated",
2777                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
2778 }
2779
2780 /* Bulk of common class/interface checks. Return 1 if an error was
2781    encountered. TAG is 0 for a class, 1 for an interface.  */
2782
2783 static int
2784 check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
2785      int is_interface, flags;
2786      tree raw_name, qualified_name, decl, cl;
2787 {
2788   tree node;
2789
2790   if (!quiet_flag)
2791     fprintf (stderr, " %s %s", (is_interface ? "interface" : "class"),
2792              IDENTIFIER_POINTER (qualified_name));
2793
2794   /* Scope of an interface/class type name:
2795        - Can't be imported by a single type import
2796        - Can't already exists in the package */
2797   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
2798       && (node = find_name_in_single_imports (raw_name)))
2799     {
2800       parse_error_context
2801         (cl, "%s name `%s' clashes with imported type `%s'",
2802          (is_interface ? "Interface" : "Class"),
2803          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
2804       return 1;
2805     }
2806   if (decl && CLASS_COMPLETE_P (decl))
2807     {
2808       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
2809                                    qualified_name, decl, cl);
2810       return 1;
2811     }
2812
2813   /* If public, file name should match class/interface name */
2814   if (flags & ACC_PUBLIC)
2815     {
2816       char *f;
2817
2818       /* Contains OS dependent assumption on path separator. FIXME */
2819       for (f = &input_filename [strlen (input_filename)];
2820            f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR;
2821            f--)
2822         ;
2823       if (f[0] == '/' || f[0] == DIR_SEPARATOR)
2824         f++;
2825       if (strncmp (IDENTIFIER_POINTER (raw_name),
2826                    f , IDENTIFIER_LENGTH (raw_name)) ||
2827           f [IDENTIFIER_LENGTH (raw_name)] != '.')
2828         parse_error_context (cl, "Public %s `%s' must be defined in a file "
2829                              "called `%s.java'",
2830                              (is_interface ? "interface" : "class"),
2831                              IDENTIFIER_POINTER (qualified_name),
2832                              IDENTIFIER_POINTER (raw_name));
2833     }
2834
2835   check_modifiers ((is_interface ?
2836                     "Illegal modifier `%s' for interface declaration" :
2837                     "Illegal modifier `%s' for class declaration"), flags,
2838                    (is_interface ? INTERFACE_MODIFIERS : CLASS_MODIFIERS));
2839   return 0;
2840 }
2841
2842 /* If DECL is NULL, create and push a new DECL, record the current
2843    line CL and do other maintenance things.  */
2844
2845 static tree
2846 maybe_create_class_interface_decl (decl, qualified_name, cl)
2847      tree decl, qualified_name, cl;
2848 {
2849   if (!decl)
2850     decl = push_class (make_class (), qualified_name);
2851
2852   /* Take care of the file and line business */
2853   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
2854   DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
2855   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
2856   CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (TREE_TYPE (decl)) =
2857     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
2858
2859   ctxp->current_parsed_class = decl;
2860
2861   /* Link the declaration to the already seen ones */
2862   TREE_CHAIN (decl) = ctxp->class_list;
2863   ctxp->class_list = decl;
2864
2865   /* Create a new nodes in the global lists */
2866   ctxp->gclass_list = tree_cons (NULL_TREE, decl, ctxp->gclass_list);
2867   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
2868
2869   /* Install a new dependency list element */
2870   create_jdep_list (ctxp);
2871
2872   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
2873                           IDENTIFIER_POINTER (qualified_name)));
2874   return decl;
2875 }
2876
2877 static void
2878 add_superinterfaces (decl, interface_list)
2879      tree decl, interface_list;
2880 {
2881   tree node;
2882   /* Superinterface(s): if present and defined, parser_check_super_interface ()
2883      takes care of ensuring that:
2884        - This is an accessible interface type,
2885        - Circularity detection.
2886    parser_add_interface is then called. If present but not defined,
2887    the check operation is delayed until the super interface gets
2888    defined.  */
2889   for (node = interface_list; node; node = TREE_CHAIN (node))
2890     {
2891       tree current = TREE_PURPOSE (node);
2892       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
2893       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
2894         {
2895           if (!parser_check_super_interface (idecl, decl, current))
2896             parser_add_interface (decl, idecl, current);
2897         }
2898       else
2899         register_incomplete_type (JDEP_INTERFACE,
2900                                   current, decl, NULL_TREE);
2901     }
2902 }
2903
2904 /* Create an interface in pass1 and return its decl. Return the
2905    interface's decl in pass 2.  */
2906
2907 static tree
2908 create_interface (flags, id, super)
2909      int flags;
2910      tree id, super;
2911 {
2912   tree raw_name = EXPR_WFL_NODE (id);
2913   tree q_name = parser_qualified_classname (id);
2914   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
2915
2916   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
2917
2918   /* Basic checks: scope, redefinition, modifiers */
2919   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
2920     return NULL_TREE;
2921
2922   /* Interface modifiers check
2923        - public/abstract allowed (already done at that point)
2924        - abstract is obsolete (comes first, it's a warning, or should be)
2925        - Can't use twice the same (checked in the modifier rule) */
2926   if ((flags & ACC_ABSTRACT) && flag_redundant)
2927     parse_warning_context
2928       (MODIFIER_WFL (ABSTRACT_TK),
2929        "Redundant use of `abstract' modifier. Interface `%s' is implicitely "
2930        "abstract", IDENTIFIER_POINTER (raw_name));
2931
2932   /* Create a new decl if DECL is NULL, otherwise fix it */
2933   decl = maybe_create_class_interface_decl (decl, q_name, id);
2934
2935   /* Set super info and mark the class a complete */
2936   set_super_info (ACC_ABSTRACT | ACC_INTERFACE | flags, TREE_TYPE (decl),
2937                   object_type_node, ctxp->interface_number);
2938   ctxp->interface_number = 0;
2939   CLASS_COMPLETE_P (decl) = 1;
2940   add_superinterfaces (decl, super);
2941
2942   return decl;
2943 }
2944
2945 /* Create an class in pass1 and return its decl. Return class
2946    interface's decl in pass 2.  */
2947
2948 static tree
2949 create_class (flags, id, super, interfaces)
2950      int flags;
2951      tree id, super, interfaces;
2952 {
2953   tree raw_name = EXPR_WFL_NODE (id);
2954   tree class_id, decl;
2955   tree super_decl = NULL, super_decl_type;
2956
2957   class_id = parser_qualified_classname (id);
2958   decl = IDENTIFIER_CLASS_VALUE (class_id);
2959   ctxp->current_parsed_class_un = EXPR_WFL_NODE (id);
2960   EXPR_WFL_NODE (id) = class_id;
2961
2962   /* Basic check: scope, redefinition, modifiers */
2963   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
2964     return NULL_TREE;
2965
2966   /* Class modifier check:
2967        - Allowed modifier (already done at that point)
2968        - abstract AND final forbidden
2969        - Public classes defined in the correct file */
2970   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
2971     parse_error_context (id, "Class `%s' can't be declared both abstract "
2972                          "and final", IDENTIFIER_POINTER (raw_name));
2973
2974   /* Create a new decl if DECL is NULL, otherwise fix it */
2975   decl = maybe_create_class_interface_decl (decl, class_id, id);
2976
2977   /* If SUPER exists, use it, otherwise use Object */
2978   if (super)
2979     {
2980       /* Can't extend java.lang.Object */
2981       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
2982         {
2983           parse_error_context (id, "Can't extend `java.lang.Object'");
2984           return NULL_TREE;
2985         }
2986
2987       /* The class is known and exists if there is a decl. Otherwise,
2988          postpone the operation and do it later. */
2989       super_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (super));
2990       if (super_decl)
2991         {
2992           parser_check_super (super_decl, decl, id);
2993           super_decl_type = TREE_TYPE (super_decl);
2994         }
2995       else
2996         super_decl_type =
2997           register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
2998     }
2999   else if (TREE_TYPE (decl) != object_type_node)
3000     super_decl_type = object_type_node;
3001   /* We're defining java.lang.Object */
3002   else
3003     super_decl_type = NULL_TREE;
3004
3005   /* Set super info and mark the class a complete */
3006   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
3007                   ctxp->interface_number);
3008   ctxp->interface_number = 0;
3009   CLASS_COMPLETE_P (decl) = 1;
3010   add_superinterfaces (decl, interfaces);
3011
3012   /* Eventually sets the @deprecated tag flag */
3013   CHECK_DEPRECATED (decl);
3014
3015   return decl;
3016 }
3017
3018 /* Can't use lookup_field () since we don't want to load the class and
3019    can't set the CLASS_LOADED_P flag */
3020
3021 static tree
3022 find_field (class, name)
3023      tree class;
3024      tree name;
3025 {
3026   tree decl;
3027   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
3028     {
3029       if (DECL_NAME (decl) == name)
3030         return decl;
3031     }
3032   return NULL_TREE;
3033 }
3034
3035 /* Wrap around lookup_field that doesn't potentially upset the value
3036    of CLASS */
3037
3038 static tree
3039 lookup_field_wrapper (class, name)
3040      tree class, name;
3041 {
3042   tree type = class;
3043   tree decl;
3044   java_parser_context_save_global ();
3045   decl = lookup_field (&type, name);
3046   java_parser_context_restore_global ();
3047   return decl;
3048 }
3049
3050 /* Find duplicate field within the same class declarations and report
3051    the error. Returns 1 if a duplicated field was found, 0
3052    otherwise.  */
3053
3054 static int
3055 duplicate_declaration_error_p (new_field_name, new_type, cl)
3056      tree new_field_name, new_type, cl;
3057 {
3058   /* This might be modified to work with method decl as well */
3059   tree decl = find_field (TREE_TYPE (ctxp->current_parsed_class),
3060                           new_field_name);
3061   if (decl)
3062     {
3063       char *t1 = strdup (purify_type_name
3064                          ((TREE_CODE (new_type) == POINTER_TYPE
3065                            && TREE_TYPE (new_type) == NULL_TREE) ?
3066                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
3067                           lang_printable_name (new_type, 1)));
3068       /* The type may not have been completed by the time we report
3069          the error */
3070       char *t2 = strdup (purify_type_name
3071                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
3072                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
3073                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
3074                           lang_printable_name (TREE_TYPE (decl), 1)));
3075       parse_error_context
3076         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
3077          t1, IDENTIFIER_POINTER (new_field_name),
3078          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
3079          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3080       free (t1);
3081       free (t2);
3082       return 1;
3083     }
3084   return 0;
3085 }
3086
3087 /* Field registration routine. If TYPE doesn't exist, field
3088    declarations are linked to the undefined TYPE dependency list, to
3089    be later resolved in java_complete_class () */
3090
3091 static void
3092 register_fields (flags, type, variable_list)
3093      int flags;
3094      tree type, variable_list;
3095 {
3096   tree current, saved_type;
3097   tree class_type = TREE_TYPE (ctxp->current_parsed_class);
3098   int saved_lineno = lineno;
3099   int must_chain = 0;
3100   tree wfl = NULL_TREE;
3101
3102   /* If we're adding fields to interfaces, those fields are public,
3103      static, final */
3104   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
3105     {
3106       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
3107                                  flags, ACC_PUBLIC,
3108                                  "%s", "interface field(s)");
3109       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
3110                                  flags, ACC_STATIC,
3111                                  "%s", "interface field(s)");
3112       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
3113                                  flags, ACC_FINAL, "%s", "interface field(s)");
3114       check_modifiers ("Illegal interface member modifier `%s'", flags,
3115                        INTERFACE_FIELD_MODIFIERS);
3116       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
3117     }
3118
3119   /* Obtain a suitable type for resolution, if necessary */
3120   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
3121
3122   /* If TYPE is fully resolved and we don't have a reference, make one */
3123   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
3124
3125   for (current = variable_list, saved_type = type; current;
3126        current = TREE_CHAIN (current), type = saved_type)
3127     {
3128       tree real_type;
3129       tree field_decl;
3130       tree cl = TREE_PURPOSE (current);
3131       tree init = TREE_VALUE (current);
3132       tree current_name = EXPR_WFL_NODE (cl);
3133
3134       /* Process NAME, as it may specify extra dimension(s) for it */
3135       type = build_array_from_name (type, wfl, current_name, &current_name);
3136
3137       /* Type adjustment. We may have just readjusted TYPE because
3138          the variable specified more dimensions. Make sure we have
3139          a reference if we can and don't have one already. Also
3140          change the name if we have an init. */
3141       if (type != saved_type)
3142         {
3143           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
3144           if (init)
3145             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
3146         }
3147
3148       real_type = GET_REAL_TYPE (type);
3149       /* Check for redeclarations */
3150       if (duplicate_declaration_error_p (current_name, real_type, cl))
3151         continue;
3152
3153       /* Set lineno to the line the field was found and create a
3154          declaration for it. Eventually sets the @deprecated tag flag. */
3155       lineno = EXPR_WFL_LINENO (cl);
3156       field_decl = add_field (class_type, current_name, real_type, flags);
3157       CHECK_DEPRECATED (field_decl);
3158
3159       /* Check if we must chain. */
3160       if (must_chain)
3161         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
3162
3163       /* Default value of a static field is 0 and it is considered
3164          initialized. */
3165       if (flags & ACC_STATIC)
3166         INITIALIZED_P (field_decl) = 1;
3167
3168       /* If we have an initialization value tied to the field */
3169       if (init)
3170         {
3171           /* The field is declared static */
3172           if (flags & ACC_STATIC)
3173             {
3174               /* We include the field and its initialization part into
3175                  a list used to generate <clinit>. After <clinit> is
3176                  walked, field initializations will be processed and
3177                  fields initialized with known constants will be taken
3178                  out of <clinit> and have their DECL_INITIAL set
3179                  appropriately. */
3180               TREE_CHAIN (init) = ctxp->static_initialized;
3181               ctxp->static_initialized = init;
3182               DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
3183               if (TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
3184                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
3185             }
3186           /* A non-static field declared with an immediate initialization is
3187              to be initialized in <init>, if any.  This field is remembered
3188              to be processed at the time of the generation of <init>. */
3189           else
3190             {
3191               TREE_CHAIN (init) = ctxp->non_static_initialized;
3192               ctxp->non_static_initialized = init;
3193             }
3194           INITIALIZED_P (field_decl) = 1;
3195           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
3196         }
3197     }
3198   lineno = saved_lineno;
3199 }
3200
3201 /* Generate the method $finit$ that initializes fields initialized
3202    upon declaration.  */
3203
3204 static void
3205 maybe_generate_finit ()
3206 {
3207   tree mdecl, current;
3208
3209   if (!ctxp->non_static_initialized || java_error_count)
3210     return;
3211
3212   mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class),
3213                                     ACC_PRIVATE, void_type_node,
3214                                     finit_identifier_node, end_params_node);
3215   start_artificial_method_body (mdecl);
3216
3217   ctxp->non_static_initialized = nreverse (ctxp->non_static_initialized);
3218   for (current = ctxp->non_static_initialized; current;
3219        current = TREE_CHAIN (current))
3220     java_method_add_stmt (mdecl,
3221                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
3222                                                 current));
3223
3224   end_artificial_method_body (mdecl);
3225   CLASS_HAS_FINIT_P (TREE_TYPE (ctxp->current_parsed_class)) = 1;
3226   ctxp->non_static_initialized = NULL_TREE;
3227 }
3228
3229 /* Check whether it is necessary to generate a <clinit> for the class
3230    we just parsed. */
3231
3232 static void
3233 maybe_generate_clinit ()
3234 {
3235   tree mdecl, c;
3236
3237   if (!ctxp->static_initialized || java_error_count)
3238     return;
3239
3240   mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class),
3241                                     ACC_STATIC, void_type_node,
3242                                     clinit_identifier_node, end_params_node);
3243   start_artificial_method_body (mdecl);
3244
3245   /* Keep initialization in order to enforce 8.5 */
3246   ctxp->static_initialized = nreverse (ctxp->static_initialized);
3247
3248   /* We process the list of assignment we produced as the result of
3249      the declaration of initialized static field and add them as
3250      statement to the <clinit> method. */
3251   for (c = ctxp->static_initialized; c; c = TREE_CHAIN (c))
3252     {
3253       /* We build the assignment expression that will initialize the
3254          field to its value. There are strict rules on static
3255          initializers (8.5). FIXME */
3256       java_method_add_stmt (mdecl,
3257                             build_debugable_stmt (EXPR_WFL_LINECOL (c), c));
3258     }
3259
3260   end_artificial_method_body (mdecl);
3261   ctxp->static_initialized = NULL_TREE;
3262 }
3263
3264 /* Shared accros method_declarator and method_header to remember the
3265    patch stage that was reached during the declaration of the method.
3266    A method DECL is built differently is there is no patch
3267    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
3268    pending on the currently defined method.  */
3269
3270 static int patch_stage;
3271
3272 /* Check the method declaration and add the method to its current
3273    class.  If the argument list is known to contain incomplete types,
3274    the method is partially added and the registration will be resume
3275    once the method arguments resolved. If TYPE is NULL, we're dealing
3276    with a constructor.  */
3277
3278 static tree
3279 method_header (flags, type, mdecl, throws)
3280      int flags;
3281      tree type, mdecl, throws;
3282 {
3283   tree meth = TREE_VALUE (mdecl);
3284   tree id = TREE_PURPOSE (mdecl);
3285   tree this_class = TREE_TYPE (ctxp->current_parsed_class);
3286   tree type_wfl = NULL_TREE;
3287   tree meth_name = NULL_TREE, current, orig_arg;
3288   int saved_lineno;
3289   int constructor_ok = 0, must_chain;
3290
3291   check_modifiers_consistency (flags);
3292
3293   /* There are some forbidden modifiers for an abstract method and its
3294      class must be abstract as well.  */
3295   if (type && (flags & ACC_ABSTRACT))
3296     {
3297       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
3298       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
3299       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
3300       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
3301       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
3302       if (!CLASS_ABSTRACT (TYPE_NAME (this_class)))
3303         parse_error_context
3304           (id, "Class `%s' must be declared abstract to define abstract "
3305            "method `%s'",
3306            IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
3307            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
3308     }
3309   /* Things to be checked when declaring a constructor */
3310   if (!type)
3311     {
3312       int ec = java_error_count;
3313       /* 8.6: Constructor declarations: we might be trying to define a
3314          method without specifying a return type. */
3315       if (EXPR_WFL_NODE (id) != ctxp->current_parsed_class_un)
3316         parse_error_context
3317           (id, "Invalid method declaration, return type required");
3318       /* 8.6.3: Constructor modifiers */
3319       else
3320         {
3321           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
3322           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
3323           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
3324           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
3325           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
3326         }
3327       /* If we found error here, we don't consider it's OK to tread
3328          the method definition as a constructor, for the rest of this
3329          function */
3330       if (ec == java_error_count)
3331         constructor_ok = 1;
3332     }
3333
3334   /* Method declared within the scope of an interface are implicitly
3335      abstract and public. Conflicts with other erroneously provided
3336      modifiers are check right after. */
3337
3338   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
3339     {
3340       /* If FLAGS isn't set because of a modifier, turn the
3341          corresponding modifier WFL to NULL so we issue a warning on
3342          the obsolete use of the modifier */
3343       if (!(flags & ACC_PUBLIC))
3344         MODIFIER_WFL (PUBLIC_TK) = NULL;
3345       if (!(flags & ACC_ABSTRACT))
3346         MODIFIER_WFL (ABSTRACT_TK) = NULL;
3347       flags |= ACC_PUBLIC;
3348       flags |= ACC_ABSTRACT;
3349     }
3350
3351   /* Modifiers context reset moved up, so abstract method declaration
3352      modifiers can be later checked.  */
3353
3354   /* Set constructor returned type to void and method name to <init>,
3355      unless we found an error identifier the constructor (in which
3356      case we retain the original name) */
3357   if (!type)
3358     {
3359       type = void_type_node;
3360       if (constructor_ok)
3361         meth_name = init_identifier_node;
3362     }
3363   else
3364     meth_name = EXPR_WFL_NODE (id);
3365
3366   /* Do the returned type resolution and registration if necessary */
3367   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
3368
3369   if (meth_name)
3370     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
3371   EXPR_WFL_NODE (id) = meth_name;
3372   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
3373
3374   if (must_chain)
3375     {
3376       patch_stage = JDEP_METHOD_RETURN;
3377       register_incomplete_type (patch_stage, type_wfl, id, type);
3378       TREE_TYPE (meth) = GET_REAL_TYPE (type);
3379     }
3380   else
3381     TREE_TYPE (meth) = type;
3382
3383   saved_lineno = lineno;
3384   /* When defining an abstract or interface method, the curly
3385      bracket at level 1 doesn't exist because there is no function
3386      body */
3387   lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
3388             EXPR_WFL_LINENO (id));
3389
3390   /* Remember the original argument list */
3391   orig_arg = TYPE_ARG_TYPES (meth);
3392
3393   if (patch_stage)              /* includes ret type and/or all args */
3394     {
3395       jdep *jdep;
3396       meth = add_method_1 (this_class, flags, meth_name, meth);
3397       /* Patch for the return type */
3398       if (patch_stage == JDEP_METHOD_RETURN)
3399         {
3400           jdep = CLASSD_LAST (ctxp->classd_list);
3401           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
3402         }
3403       /* This is the stop JDEP. METH allows the function's signature
3404          to be computed. */
3405       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
3406     }
3407   else
3408     meth = add_method (this_class, flags, meth_name,
3409                        build_java_signature (meth));
3410
3411   /* Fix the method argument list so we have the argument name
3412      information */
3413   fix_method_argument_names (orig_arg, meth);
3414
3415   /* Register the parameter number and re-install the current line
3416      number */
3417   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
3418   lineno = saved_lineno;
3419
3420   /* Register exception specified by the `throws' keyword for
3421      resolution and set the method decl appropriate field to the list.
3422      Note: the grammar ensures that what we get here are class
3423      types. */
3424   if (throws)
3425     {
3426       throws = nreverse (throws);
3427       for (current = throws; current; current = TREE_CHAIN (current))
3428         {
3429           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
3430                                     NULL_TREE, NULL_TREE);
3431           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
3432             &TREE_VALUE (current);
3433         }
3434       DECL_FUNCTION_THROWS (meth) = throws;
3435     }
3436
3437   /* We set the DECL_NAME to ID so we can track the location where
3438      the function was declared. This allow us to report
3439      redefinition error accurately. When method are verified,
3440      DECL_NAME is reinstalled properly (using the content of the
3441      WFL node ID) (see check_method_redefinition). We don't do that
3442      when Object is being defined. Constructor <init> names will be
3443      reinstalled the same way. */
3444   if (TREE_TYPE (ctxp->current_parsed_class) != object_type_node)
3445     DECL_NAME (meth) = id;
3446
3447   /* Set the flag if we correctly processed a constructor */
3448   if (constructor_ok)
3449     DECL_CONSTRUCTOR_P (meth) = 1;
3450
3451   /* Eventually set the @deprecated tag flag */
3452   CHECK_DEPRECATED (meth);
3453
3454   return meth;
3455 }
3456
3457 static void
3458 fix_method_argument_names (orig_arg, meth)
3459     tree orig_arg, meth;
3460 {
3461   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
3462   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
3463     {
3464       TREE_PURPOSE (arg) = this_identifier_node;
3465       arg = TREE_CHAIN (arg);
3466     }
3467   while (orig_arg != end_params_node)
3468     {
3469       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
3470       orig_arg = TREE_CHAIN (orig_arg);
3471       arg = TREE_CHAIN (arg);
3472     }
3473 }
3474
3475 /* Complete the method declaration with METHOD_BODY.  */
3476
3477 static void
3478 complete_method_declaration (method_body)
3479      tree method_body;
3480 {
3481   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
3482   maybe_absorb_scoping_blocks ();
3483   /* Exit function's body */
3484   exit_block ();
3485   /* Merge last line of the function with first line, directly in the
3486      function decl. It will be used to emit correct debug info. */
3487   DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
3488 }
3489
3490 /* Build a an error message for constructor circularity errors.  */
3491
3492 static char *
3493 constructor_circularity_msg (from, to)
3494      tree from, to;
3495 {
3496   static char string [4096];
3497   char *t = strdup (lang_printable_name (from, 0));
3498   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
3499   free (t);
3500   return string;
3501 }
3502
3503 /* Verify a circular call to METH. Return 1 if an error is found, 0
3504    otherwise.  */
3505
3506 static int
3507 verify_constructor_circularity (meth, current)
3508      tree meth, current;
3509 {
3510   static tree list = NULL_TREE;
3511   tree c;
3512   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
3513     {
3514       if (TREE_VALUE (c) == meth)
3515         {
3516           char *t;
3517           if (list)
3518             {
3519               tree liste;
3520               list = nreverse (list);
3521               for (liste = list; liste; liste = TREE_CHAIN (liste))
3522                 {
3523                   parse_error_context
3524                     (TREE_PURPOSE (TREE_PURPOSE (liste)),
3525                      constructor_circularity_msg
3526                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
3527                   java_error_count--;
3528                 }
3529             }
3530           t = strdup (lang_printable_name (meth, 0));
3531           parse_error_context (TREE_PURPOSE (c),
3532                                "%s: recursive invocation of constructor `%s'",
3533                                constructor_circularity_msg (current, meth), t);
3534           free (t);
3535           list = NULL_TREE;
3536           return 1;
3537         }
3538     }
3539   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
3540     {
3541       list = tree_cons (c, current, list);
3542       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
3543         return 1;
3544       list = TREE_CHAIN (list);
3545     }
3546   return 0;
3547 }
3548
3549 /* Check modifiers that can be declared but exclusively */
3550
3551 static void
3552 check_modifiers_consistency (flags)
3553      int flags;
3554 {
3555   int acc_count = 0;
3556   tree cl = NULL_TREE;
3557
3558   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, 0, acc_count, cl);
3559   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, 1, acc_count, cl);
3560   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, 2, acc_count, cl);
3561   if (acc_count > 1)
3562     parse_error_context
3563       (cl, "Inconsistent member declaration. At most one of `public', "
3564        "`private', or `protected' may be specified");
3565 }
3566
3567 /* Check the methode header METH for abstract specifics features */
3568
3569 static void
3570 check_abstract_method_header (meth)
3571      tree meth;
3572 {
3573   int flags = get_access_flags_from_decl (meth);
3574   /* DECL_NAME might still be a WFL node */
3575   tree name = GET_METHOD_NAME (meth);
3576
3577   OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (ABSTRACT_TK), flags,
3578                              ACC_ABSTRACT, "abstract method `%s'",
3579                              IDENTIFIER_POINTER (name));
3580   OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK), flags,
3581                              ACC_PUBLIC, "abstract method `%s'",
3582                              IDENTIFIER_POINTER (name));
3583
3584   check_modifiers ("Illegal modifier `%s' for interface method",
3585                   flags, INTERFACE_METHOD_MODIFIERS);
3586 }
3587
3588 /* Create a FUNCTION_TYPE node and start augmenting it with the
3589    declared function arguments. Arguments type that can't be resolved
3590    are left as they are, but the returned node is marked as containing
3591    incomplete types.  */
3592
3593 static tree
3594 method_declarator (id, list)
3595      tree id, list;
3596 {
3597   tree arg_types = NULL_TREE, current, node;
3598   tree meth = make_node (FUNCTION_TYPE);
3599   jdep *jdep;
3600
3601   patch_stage = JDEP_NO_PATCH;
3602
3603   for (current = list; current; current = TREE_CHAIN (current))
3604     {
3605       int must_chain = 0;
3606       tree wfl_name = TREE_PURPOSE (current);
3607       tree type = TREE_VALUE (current);
3608       tree name = EXPR_WFL_NODE (wfl_name);
3609       tree already, arg_node;
3610       tree type_wfl = NULL_TREE;
3611       tree real_type;
3612
3613       /* Obtain a suitable type for resolution, if necessary */
3614       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
3615
3616       /* Process NAME, as it may specify extra dimension(s) for it */
3617       type = build_array_from_name (type, type_wfl, name, &name);
3618       EXPR_WFL_NODE (wfl_name) = name;
3619
3620       real_type = GET_REAL_TYPE (type);
3621       if (TREE_CODE (real_type) == RECORD_TYPE)
3622         {
3623           real_type = promote_type (real_type);
3624           if (TREE_CODE (type) == TREE_LIST)
3625             TREE_PURPOSE (type) = real_type;
3626         }
3627
3628       /* Check redefinition */
3629       for (already = arg_types; already; already = TREE_CHAIN (already))
3630         if (TREE_PURPOSE (already) == name)
3631           {
3632             parse_error_context
3633               (wfl_name, "Variable `%s' is used more than once in the "
3634                "argument list of method `%s'", IDENTIFIER_POINTER (name),
3635                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
3636             break;
3637           }
3638
3639       /* If we've an incomplete argument type, we know there is a location
3640          to patch when the type get resolved, later.  */
3641       jdep = NULL;
3642       if (must_chain)
3643         {
3644           patch_stage = JDEP_METHOD;
3645           type = register_incomplete_type (patch_stage,
3646                                            type_wfl, wfl_name, type);
3647           jdep = CLASSD_LAST (ctxp->classd_list);
3648           JDEP_MISC (jdep) = id;
3649         }
3650
3651       /* The argument node: a name and a (possibly) incomplete type */
3652       arg_node = build_tree_list (name, real_type);
3653       if (jdep)
3654         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
3655       TREE_CHAIN (arg_node) = arg_types;
3656       arg_types = arg_node;
3657     }
3658   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
3659   node = build_tree_list (id, meth);
3660   return node;
3661 }
3662
3663 static int
3664 unresolved_type_p (wfl, returned)
3665      tree wfl;
3666      tree *returned;
3667
3668 {
3669   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
3670     {
3671       tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
3672       if (returned)
3673         *returned = (decl ? TREE_TYPE (decl) : NULL_TREE);
3674       return 1;
3675     }
3676   if (returned)
3677     *returned = wfl;
3678   return 0;
3679 }
3680
3681 /* From NAME, build a qualified identifier node using the
3682    qualification from the current package definition. */
3683
3684 static tree
3685 parser_qualified_classname (name)
3686      tree name;
3687 {
3688   if (ctxp->package)
3689     return merge_qualified_name (ctxp->package, EXPR_WFL_NODE (name));
3690   else
3691     return EXPR_WFL_NODE (name);
3692 }
3693
3694 /* Called once the type a interface extends is resolved. Returns 0 if
3695    everything is OK.  */
3696
3697 static int
3698 parser_check_super_interface (super_decl, this_decl, this_wfl)
3699      tree super_decl, this_decl, this_wfl;
3700 {
3701   tree super_type = TREE_TYPE (super_decl);
3702
3703   /* Has to be an interface */
3704   if (!CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (super_decl))))
3705     {
3706       parse_error_context
3707         (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
3708          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
3709          IDENTIFIER_POINTER (DECL_NAME (super_decl)),
3710          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
3711           "interface" : "class"),
3712          IDENTIFIER_POINTER (DECL_NAME (this_decl)));
3713       return 1;
3714     }
3715
3716   /* Check scope: same package OK, other package: OK if public */
3717   if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
3718     return 1;
3719
3720   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
3721                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
3722                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
3723   return 0;
3724 }
3725
3726 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
3727    0 if everthing is OK.  */
3728
3729 static int
3730 parser_check_super (super_decl, this_decl, wfl)
3731      tree super_decl, this_decl, wfl;
3732 {
3733   tree super_type = TREE_TYPE (super_decl);
3734
3735   /* SUPER should be a CLASS (neither an array nor an interface) */
3736   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
3737     {
3738       parse_error_context
3739         (wfl, "Class `%s' can't subclass %s `%s'",
3740          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
3741          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
3742          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
3743       return 1;
3744     }
3745
3746   if (CLASS_FINAL (TYPE_NAME (super_type)))
3747     {
3748       parse_error_context (wfl, "Can't subclass final classes: %s",
3749                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
3750       return 1;
3751     }
3752
3753   /* Check scope: same package OK, other package: OK if public */
3754   if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
3755     return 1;
3756
3757   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
3758                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
3759                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
3760   return 0;
3761 }
3762
3763 /* Create a new dependency list and link it (in a LIFO manner) to the
3764    CTXP list of type dependency list.  */
3765
3766 static void
3767 create_jdep_list (ctxp)
3768      struct parser_ctxt *ctxp;
3769 {
3770   jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
3771   new->first = new->last = NULL;
3772   new->next = ctxp->classd_list;
3773   ctxp->classd_list = new;
3774 }
3775
3776 static jdeplist *
3777 reverse_jdep_list (ctxp)
3778      struct parser_ctxt *ctxp;
3779 {
3780   register jdeplist *prev = NULL, *current, *next;
3781   for (current = ctxp->classd_list; current; current = next)
3782     {
3783       next = current->next;
3784       current->next = prev;
3785       prev = current;
3786     }
3787   return prev;
3788 }
3789
3790 /* Create a fake pointer based on the ID stored in
3791    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
3792    registered again. */
3793
3794 static tree
3795 obtain_incomplete_type (type_name)
3796      tree type_name;
3797 {
3798   tree ptr, name;
3799
3800   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
3801     name = EXPR_WFL_NODE (type_name);
3802   else if (INCOMPLETE_TYPE_P (type_name))
3803     name = TYPE_NAME (type_name);
3804   else
3805     fatal ("invalid type name - obtain_incomplete_type");
3806
3807   for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
3808     if (TYPE_NAME (ptr) == name)
3809       break;
3810
3811   if (!ptr)
3812     {
3813       push_obstacks (&permanent_obstack, &permanent_obstack);
3814       BUILD_PTR_FROM_NAME (ptr, name);
3815       layout_type (ptr);
3816       pop_obstacks ();
3817       TREE_CHAIN (ptr) = ctxp->incomplete_class;
3818       ctxp->incomplete_class = ptr;
3819     }
3820
3821   return ptr;
3822 }
3823
3824 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
3825    non NULL instead of computing a new fake type based on WFL. The new
3826    dependency is inserted in the current type dependency list, in FIFO
3827    manner.  */
3828
3829 static tree
3830 register_incomplete_type (kind, wfl, decl, ptr)
3831      int kind;
3832      tree wfl, decl, ptr;
3833 {
3834   jdep *new = (jdep *)xmalloc (sizeof (jdep));
3835
3836   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
3837     ptr = obtain_incomplete_type (wfl);
3838
3839   JDEP_KIND (new) = kind;
3840   JDEP_DECL (new) = decl;
3841   JDEP_SOLV (new) = ptr;
3842   JDEP_WFL (new) = wfl;
3843   JDEP_CHAIN (new) = NULL;
3844   JDEP_MISC (new) = NULL_TREE;
3845   JDEP_GET_PATCH (new) = (tree *)NULL;
3846
3847   JDEP_INSERT (ctxp->classd_list, new);
3848
3849   return ptr;
3850 }
3851
3852 void
3853 java_check_circular_reference ()
3854 {
3855   tree current;
3856   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
3857     {
3858       tree type = TREE_TYPE (current);
3859       if (CLASS_INTERFACE (TYPE_NAME (type)))
3860         {
3861           /* Check all interfaces this class extends */
3862           tree basetype_vec = TYPE_BINFO_BASETYPES (type);
3863           int n, i;
3864
3865           if (!basetype_vec)
3866             return;
3867           n = TREE_VEC_LENGTH (basetype_vec);
3868           for (i = 0; i < n; i++)
3869             {
3870               tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
3871               if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
3872                   && interface_of_p (type, BINFO_TYPE (vec_elt)))
3873                 parse_error_context (lookup_cl (current),
3874                                      "Cyclic interface inheritance");
3875             }
3876         }
3877       else
3878         if (inherits_from_p (CLASSTYPE_SUPER (type), type))
3879           parse_error_context (lookup_cl (current),
3880                                "Cyclic class inheritance");
3881     }
3882 }
3883
3884 /* safe_layout_class just makes sure that we can load a class without
3885    disrupting the current_class, input_file, lineno, etc, information
3886    about the class processed currently.  */
3887
3888 void
3889 safe_layout_class (class)
3890      tree class;
3891 {
3892   tree save_current_class = current_class;
3893   char *save_input_filename = input_filename;
3894   int save_lineno = lineno;
3895
3896   push_obstacks (&permanent_obstack, &permanent_obstack);
3897
3898   layout_class (class);
3899   pop_obstacks ();
3900
3901   current_class = save_current_class;
3902   input_filename = save_input_filename;
3903   lineno = save_lineno;
3904   CLASS_LOADED_P (class) = 1;
3905 }
3906
3907 static tree
3908 jdep_resolve_class (dep)
3909      jdep *dep;
3910 {
3911   tree decl;
3912
3913   if (JDEP_RESOLVED_P (dep))
3914     decl = JDEP_RESOLVED_DECL (dep);
3915   else
3916     {
3917       decl = resolve_class (JDEP_TO_RESOLVE (dep),
3918                             JDEP_DECL (dep), JDEP_WFL (dep));
3919       JDEP_RESOLVED (dep, decl);
3920     }
3921
3922   if (!decl)
3923     complete_class_report_errors (dep);
3924
3925   return decl;
3926 }
3927
3928 /* Complete unsatisfied class declaration and their dependencies */
3929
3930 void
3931 java_complete_class ()
3932 {
3933   tree cclass;
3934   jdeplist *cclassd;
3935   int error_found;
3936   tree type;
3937
3938   push_obstacks (&permanent_obstack, &permanent_obstack);
3939
3940   /* Process imports and reverse the import on demand list */
3941   process_imports ();
3942   if (ctxp->import_demand_list)
3943     ctxp->import_demand_list = nreverse (ctxp->import_demand_list);
3944
3945   /* Rever things so we have the right order */
3946   ctxp->class_list = nreverse (ctxp->class_list);
3947   ctxp->classd_list = reverse_jdep_list (ctxp);
3948
3949   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
3950        cclass && cclassd;
3951        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
3952     {
3953       jdep *dep;
3954       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
3955         {
3956           tree decl;
3957           if (!(decl = jdep_resolve_class (dep)))
3958             continue;
3959
3960           /* Now it's time to patch */
3961           switch (JDEP_KIND (dep))
3962             {
3963             case JDEP_SUPER:
3964               /* Simply patch super */
3965               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
3966                 continue;
3967               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
3968                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
3969               break;
3970
3971             case JDEP_FIELD:
3972               {
3973                 /* We do part of the job done in add_field */
3974                 tree field_decl = JDEP_DECL (dep);
3975                 tree field_type = TREE_TYPE (decl);
3976                 push_obstacks (&permanent_obstack, &permanent_obstack);
3977                 if (TREE_CODE (field_type) == RECORD_TYPE)
3978                   field_type = promote_type (field_type);
3979                 pop_obstacks ();
3980                 TREE_TYPE (field_decl) = field_type;
3981                 DECL_ALIGN (field_decl) = 0;
3982                 layout_decl (field_decl, 0);
3983                 SOURCE_FRONTEND_DEBUG
3984                   (("Completed field/var decl `%s' with `%s'",
3985                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
3986                     IDENTIFIER_POINTER (DECL_NAME (decl))));
3987                 break;
3988               }
3989             case JDEP_METHOD:   /* We start patching a method */
3990             case JDEP_METHOD_RETURN:
3991               error_found = 0;
3992               while (1)
3993                 {
3994                   if (decl)
3995                     {
3996                       type = TREE_TYPE(decl);
3997                       if (TREE_CODE (type) == RECORD_TYPE)
3998                         type = promote_type (type);
3999                       JDEP_APPLY_PATCH (dep, type);
4000                       SOURCE_FRONTEND_DEBUG
4001                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
4002                            "Completing fct `%s' with ret type `%s'":
4003                            "Completing arg `%s' with type `%s'"),
4004                           IDENTIFIER_POINTER (EXPR_WFL_NODE
4005                                               (JDEP_DECL_WFL (dep))),
4006                           IDENTIFIER_POINTER (DECL_NAME (decl))));
4007                     }
4008                   else
4009                     error_found = 1;
4010                   dep = JDEP_CHAIN (dep);
4011                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
4012                     break;
4013                   else
4014                     decl = jdep_resolve_class (dep);
4015                 }
4016               if (!error_found)
4017                 {
4018                   tree mdecl = JDEP_DECL (dep), signature;
4019                   push_obstacks (&permanent_obstack, &permanent_obstack);
4020                   /* Recompute and reset the signature */
4021                   signature = build_java_signature (TREE_TYPE (mdecl));
4022                   set_java_signature (TREE_TYPE (mdecl), signature);
4023                   pop_obstacks ();
4024                 }
4025               else
4026                 continue;
4027               break;
4028
4029             case JDEP_INTERFACE:
4030               if (parser_check_super_interface (decl, JDEP_DECL (dep),
4031                                                 JDEP_WFL (dep)))
4032                 continue;
4033               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
4034               break;
4035
4036             case JDEP_PARM:
4037             case JDEP_VARIABLE:
4038               type = TREE_TYPE(decl);
4039               if (TREE_CODE (type) == RECORD_TYPE)
4040                 type = promote_type (type);
4041               JDEP_APPLY_PATCH (dep, type);
4042               break;
4043
4044             case JDEP_TYPE:
4045               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
4046               SOURCE_FRONTEND_DEBUG
4047                 (("Completing a random type dependency on a '%s' node",
4048                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
4049               break;
4050
4051             case JDEP_EXCEPTION:
4052               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
4053               SOURCE_FRONTEND_DEBUG
4054                 (("Completing `%s' `throws' argument node",
4055                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
4056               break;
4057
4058             default:
4059               fatal ("Can't handle patch code %d - java_complete_class",
4060                      JDEP_KIND (dep));
4061             }
4062         }
4063     }
4064   pop_obstacks ();
4065   return;
4066 }
4067
4068 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
4069    array.  */
4070
4071 static tree
4072 resolve_class (class_type, decl, cl)
4073      tree class_type, decl, cl;
4074 {
4075   char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
4076   char *base = name;
4077   tree resolved_type = TREE_TYPE (class_type);
4078   tree resolved_type_decl;
4079
4080   if (resolved_type != NULL_TREE)
4081     {
4082       tree resolved_type_decl = TYPE_NAME (resolved_type);
4083       if (resolved_type_decl == NULL_TREE
4084           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
4085         {
4086           resolved_type_decl = build_decl (TYPE_DECL,
4087                                            TYPE_NAME (class_type),
4088                                            resolved_type);
4089         }
4090       return resolved_type_decl;
4091     }
4092
4093   /* 1- Check to see if we have an array. If true, find what we really
4094      want to resolve  */
4095   while (name[0] == '[')
4096     name++;
4097   if (base != name)
4098     TYPE_NAME (class_type) = get_identifier (name);
4099
4100   /* 2- Resolve the bare type */
4101   if (!(resolved_type_decl = do_resolve_class (class_type, decl, cl)))
4102     return NULL_TREE;
4103   resolved_type = TREE_TYPE (resolved_type_decl);
4104
4105   /* 3- If we have and array, reconstruct the array down to its nesting */
4106   if (base != name)
4107     {
4108       while (base != name)
4109         {
4110           if (TREE_CODE (resolved_type) == RECORD_TYPE)
4111             resolved_type  = promote_type (resolved_type);
4112           resolved_type = build_java_array_type (resolved_type, -1);
4113           CLASS_LOADED_P (resolved_type) = 1;
4114           name--;
4115         }
4116       /* Build a fake decl for this, since this is what is expected to
4117          be returned.  */
4118       resolved_type_decl =
4119         build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
4120       /* Figure how those two things are important for error report. FIXME */
4121       DECL_SOURCE_LINE (resolved_type_decl) = 0;
4122       DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
4123       TYPE_NAME (class_type) = TYPE_NAME (resolved_type);
4124     }
4125   TREE_TYPE (class_type) = resolved_type;
4126   return resolved_type_decl;
4127 }
4128
4129 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
4130    are used to report error messages.  */
4131
4132 tree
4133 do_resolve_class (class_type, decl, cl)
4134      tree class_type;
4135      tree decl;
4136      tree cl;
4137 {
4138   tree new_class_decl;
4139   tree original_name = NULL_TREE;
4140
4141   /* Do not try to replace TYPE_NAME (class_type) by a variable, since
4142      its is changed by find_in_imports{_on_demand} */
4143
4144   /* 1- Check for the type in single imports */
4145   if (find_in_imports (class_type))
4146     return NULL_TREE;
4147
4148   /* 2- And check for the type in the current compilation unit. If it fails,
4149      try with a name qualified with the package name if appropriate. */
4150   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
4151     {
4152       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
4153           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
4154         load_class (TYPE_NAME (class_type), 0);
4155       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4156     }
4157
4158   original_name = TYPE_NAME (class_type);
4159   if (!QUALIFIED_P (TYPE_NAME (class_type)) && ctxp->package)
4160     TYPE_NAME (class_type) = merge_qualified_name (ctxp->package,
4161                                                    TYPE_NAME (class_type));
4162 #if 1
4163   if (!(new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
4164     load_class (TYPE_NAME (class_type), 0);
4165   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
4166     {
4167       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
4168           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
4169         load_class (TYPE_NAME (class_type), 0);
4170       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4171     }
4172 #else
4173   new_name = TYPE_NAME (class_type);
4174   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_name)) != NULL_TREE)
4175     {
4176       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
4177           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
4178         load_class (new_name, 0);
4179       return IDENTIFIER_CLASS_VALUE (new_name);
4180     }
4181   else
4182     {
4183       tree class = read_class (new_name);
4184       if (class != NULL_TREE)
4185         {
4186           tree decl = IDENTIFIER_CLASS_VALUE (new_name);
4187           if (decl == NULL_TREE)
4188             decl = push_class (class, new_name);
4189           return decl;
4190         }
4191     }
4192 #endif
4193   TYPE_NAME (class_type) = original_name;
4194
4195   /* 3- Check an other compilation unit that bears the name of type */
4196   load_class (TYPE_NAME (class_type), 0);
4197   if (check_pkg_class_access (TYPE_NAME (class_type),
4198                               (cl ? cl : lookup_cl (decl))))
4199     return NULL_TREE;
4200
4201   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
4202     return new_class_decl;
4203
4204   /* 4- Check the import on demands. Don't allow bar.baz to be
4205      imported from foo.* */
4206   if (!QUALIFIED_P (TYPE_NAME (class_type)))
4207     if (find_in_imports_on_demand (class_type))
4208       return NULL_TREE;
4209
4210   /* 5- Last call for a resolution */
4211   return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4212 }
4213
4214 /* Resolve NAME and lay it out (if not done and if not the current
4215    parsed class). Return a decl node. This function is meant to be
4216    called when type resolution is necessary during the walk pass.  */
4217
4218 static tree
4219 resolve_and_layout (something, cl)
4220      tree something;
4221      tree cl;
4222 {
4223   tree decl;
4224
4225   /* Don't do that on the current class */
4226   if (something == current_class)
4227     return TYPE_NAME (current_class);
4228
4229   /* Don't do anything for void and other primitive types */
4230   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
4231     return NULL_TREE;
4232
4233   /* Pointer types can be reall pointer types or fake pointers. When
4234      finding a real pointer, recheck for primitive types */
4235   if (TREE_CODE (something) == POINTER_TYPE)
4236     {
4237       if (TREE_TYPE (something))
4238         {
4239           something = TREE_TYPE (something);
4240           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
4241             return NULL_TREE;
4242         }
4243       else
4244         something = TYPE_NAME (something);
4245     }
4246
4247   /* Don't do anything for arrays of primitive types */
4248   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
4249       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
4250     return NULL_TREE;
4251
4252   /* If something is not and IDENTIFIER_NODE, it can be a a TYPE_DECL
4253      or a real TYPE */
4254   if (TREE_CODE (something) != IDENTIFIER_NODE)
4255     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
4256             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
4257
4258   if (!(decl = resolve_no_layout (something, cl)))
4259     return NULL_TREE;
4260
4261   /* Resolve and layout if necessary */
4262   layout_class_methods (TREE_TYPE (decl));
4263   if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl)))
4264     CHECK_METHODS (decl);
4265   if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl)))
4266     safe_layout_class (TREE_TYPE (decl));
4267
4268   return decl;
4269 }
4270
4271 /* Resolve a class, returns its decl but doesn't perform any
4272    layout. The current parsing context is saved and restored */
4273
4274 static tree
4275 resolve_no_layout (name, cl)
4276      tree name, cl;
4277 {
4278   tree ptr, decl;
4279   BUILD_PTR_FROM_NAME (ptr, name);
4280   java_parser_context_save_global ();
4281   decl = resolve_class (ptr, NULL_TREE, cl);
4282   java_parser_context_restore_global ();
4283
4284   return decl;
4285 }
4286
4287 /* Called when reporting errors. Skip leader '[' in a complex array
4288    type description that failed to be resolved.  */
4289
4290 static char *
4291 purify_type_name (name)
4292      char *name;
4293 {
4294   while (*name && *name == '[')
4295     name++;
4296   return name;
4297 }
4298
4299 /* The type CURRENT refers to can't be found. We print error messages.  */
4300
4301 static void
4302 complete_class_report_errors (dep)
4303      jdep *dep;
4304 {
4305   char *name;
4306
4307   if (!JDEP_WFL (dep))
4308     return;
4309
4310   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
4311   switch (JDEP_KIND (dep))
4312     {
4313     case JDEP_SUPER:
4314       parse_error_context
4315         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
4316          purify_type_name (name),
4317          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4318       break;
4319     case JDEP_FIELD:
4320       parse_error_context
4321         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
4322          purify_type_name (name),
4323          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4324       break;
4325     case JDEP_METHOD:           /* Covers arguments */
4326       parse_error_context
4327         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
4328          "argument `%s' of method `%s'",
4329          purify_type_name (name),
4330          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
4331          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
4332       break;
4333     case JDEP_METHOD_RETURN:    /* Covers return type */
4334       parse_error_context
4335         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
4336          "return type of method `%s'",
4337          purify_type_name (name),
4338          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
4339       break;
4340     case JDEP_INTERFACE:
4341       parse_error_context
4342         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
4343          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
4344          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
4345          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4346       break;
4347     case JDEP_VARIABLE:
4348       parse_error_context
4349         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
4350          "local variable `%s'",
4351          purify_type_name (IDENTIFIER_POINTER
4352                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
4353          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4354       break;
4355     case JDEP_EXCEPTION:        /* As specified by `throws' */
4356       parse_error_context
4357           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
4358          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
4359       break;
4360     default:
4361       /* Fix for -Wall. Just break doing nothing. The error will be
4362          caught later */
4363       break;
4364     }
4365 }
4366
4367 /* Check uninitialized final.  */
4368
4369 void
4370 java_check_final ()
4371 {
4372 }
4373
4374 /* Return a static string containing the DECL prototype string. If
4375    DECL is a constructor, use the class name instead of the form
4376    <init> */
4377
4378 static char *
4379 get_printable_method_name (decl)
4380      tree decl;
4381 {
4382   char *to_return;
4383   tree name;
4384
4385   if (DECL_CONSTRUCTOR_P (decl))
4386     {
4387       name = DECL_NAME (decl);
4388       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
4389     }
4390
4391   to_return = lang_printable_name (decl, 0);
4392   if (DECL_CONSTRUCTOR_P (decl))
4393     DECL_NAME (decl) = name;
4394
4395   return to_return;
4396 }
4397
4398 /* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
4399    nevertheless needs to be verfied, 1 otherwise.  */
4400
4401 static int
4402 reset_method_name (method)
4403      tree method;
4404 {
4405   if (DECL_NAME (method) != clinit_identifier_node
4406       && DECL_NAME (method) != finit_identifier_node)
4407     {
4408       /* NAME is just the plain name when Object is being defined */
4409       if (DECL_CONTEXT (method) != object_type_node)
4410         DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ?
4411                               init_identifier_node : GET_METHOD_NAME (method));
4412       return 0;
4413     }
4414   else
4415     return 1;
4416 }
4417
4418 /* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
4419
4420 tree
4421 java_get_real_method_name (method_decl)
4422      tree method_decl;
4423 {
4424   tree method_name = DECL_NAME (method_decl);
4425   if (DECL_CONSTRUCTOR_P (method_decl))
4426     return init_identifier_node;
4427
4428   /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
4429      and still can be a constructor. FIXME */
4430
4431   /* Don't confuse method only bearing the name of their class as
4432      constructors */
4433   else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl))
4434            && ctxp
4435            && ctxp->current_parsed_class_un == EXPR_WFL_NODE (method_name)
4436            && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED
4437            && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node)
4438     return init_identifier_node;
4439   else
4440     return EXPR_WFL_NODE (method_name);
4441 }
4442
4443 /* Track method being redefined inside the same class. As a side
4444    effect, set DECL_NAME to an IDENTIFIER (prior entering this
4445    function it's a FWL, so we can track errors more accurately */
4446
4447 static int
4448 check_method_redefinition (class, method)
4449      tree class, method;
4450 {
4451   tree redef, name;
4452   tree cl = DECL_NAME (method);
4453   tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
4454   /* decl name of artificial <clinit> and $finit$ doesn't need to be
4455      fixed and checked */
4456
4457   /* Reset the method name before running the check. If it returns 1,
4458      the method doesn't need to be verified with respect to method
4459      redeclaration and we return 0 */
4460   if (reset_method_name (method))
4461     return 0;
4462
4463   name = DECL_NAME (method);
4464   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
4465     {
4466       if (redef == method)
4467         break;
4468       if (DECL_NAME (redef) == name
4469           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef)))
4470         {
4471           parse_error_context
4472             (cl, "Duplicate %s declaration `%s'",
4473              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
4474              get_printable_method_name (redef));
4475           return 1;
4476         }
4477     }
4478   return 0;
4479 }
4480
4481 /* Check all the methods of CLASS. Methods are first completed then
4482    checked according to regular method existance rules.
4483    If no constructor were encountered, then build its declaration. */
4484
4485 static void
4486 java_check_regular_methods (class_decl)
4487      tree class_decl;
4488 {
4489   int saw_constructor = 0;
4490   tree method;
4491   tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
4492   tree super_class = CLASSTYPE_SUPER (class);
4493   tree saved_found_wfl = NULL_TREE, found = NULL_TREE;
4494   tree mthrows;
4495
4496   /* It is not necessary to check methods defined in java.lang.Object */
4497   if (class == object_type_node)
4498     return;
4499
4500   if (!TYPE_NVIRTUALS (class))
4501     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
4502
4503   /* Should take interfaces into account. FIXME */
4504   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
4505     {
4506       tree sig;
4507       tree method_wfl = DECL_NAME (method);
4508       int aflags;
4509
4510       /* If we previously found something and its name was saved,
4511          reinstall it now */
4512       if (found && saved_found_wfl)
4513         {
4514           DECL_NAME (found) = saved_found_wfl;
4515           saved_found_wfl = NULL_TREE;
4516         }
4517
4518       /* Check for redefinitions */
4519       if (check_method_redefinition (class, method))
4520         continue;
4521
4522       /* If we see one constructor a mark so we don't generate the
4523          default one. Also skip other verifications: constructors
4524          can't be inherited hence hiden or overriden */
4525      if (DECL_CONSTRUCTOR_P (method))
4526        {
4527          saw_constructor = 1;
4528          continue;
4529        }
4530
4531       /* We verify things thrown by the method. They must inherits from
4532          java.lang.Throwable */
4533       for (mthrows = DECL_FUNCTION_THROWS (method);
4534            mthrows; mthrows = TREE_CHAIN (mthrows))
4535         {
4536           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
4537             parse_error_context
4538               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be "
4539                "a subclass of class `java.lang.Throwable'",
4540                IDENTIFIER_POINTER
4541                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
4542         }
4543
4544       sig = build_java_argument_signature (TREE_TYPE (method));
4545       found = lookup_argument_method (super_class, DECL_NAME (method), sig);
4546
4547       /* Nothing overrides or it's a private method. */
4548       if (!found)
4549         continue;
4550       if (METHOD_PRIVATE (found))
4551         {
4552           found = NULL_TREE;
4553           continue;
4554         }
4555
4556       /* If found wasn't verified, it's DECL_NAME won't be set properly.
4557          We set it temporarily for the sake of the error report. */
4558       saved_found_wfl = DECL_NAME (found);
4559       reset_method_name (found);
4560
4561       /* Can't override a method with the same name and different return
4562          types. */
4563       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
4564         {
4565           char *t = strdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)),
4566                                                  0));
4567           parse_error_context
4568             (method_wfl,
4569              "Method `%s' was defined with return type `%s' in class `%s'",
4570              lang_printable_name (found, 0), t,
4571              IDENTIFIER_POINTER
4572                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4573           free (t);
4574         }
4575
4576       /* Can't override final. Can't override static. */
4577       if (METHOD_FINAL (found) || METHOD_STATIC (found))
4578         {
4579           /* Static *can* override static */
4580           if (METHOD_STATIC (found) && METHOD_STATIC (method))
4581             continue;
4582           parse_error_context
4583             (method_wfl,
4584              "%s methods can't be overriden. Method `%s' is %s in class `%s'",
4585              (METHOD_FINAL (found) ? "Final" : "Static"),
4586              lang_printable_name (found, 0),
4587              (METHOD_FINAL (found) ? "final" : "static"),
4588              IDENTIFIER_POINTER
4589                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4590           continue;
4591         }
4592       /* Static method can't override instance method. */
4593       if (METHOD_STATIC (method))
4594         {
4595           parse_error_context
4596             (method_wfl,
4597              "Instance methods can't be overriden by a static method. Method "
4598              "`%s' is an instance method in class `%s'",
4599              lang_printable_name (found, 0),
4600              IDENTIFIER_POINTER
4601                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4602           continue;
4603         }
4604
4605       aflags = get_access_flags_from_decl (found);
4606       /* - Overriding/hiding public must be public
4607          - Overriding/hiding protected must be protected or public
4608          - If the overriden or hidden method has default (package)
4609            access, then the overriding or hiding method must not be
4610            private; otherwise, a compile-time error occurs */
4611       if ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
4612           || (METHOD_PROTECTED (found)
4613               && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
4614           || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
4615               && METHOD_PRIVATE (method)))
4616         {
4617           parse_error_context
4618             (method_wfl,
4619              "Methods can't be overridden to be more private. Method `%s' is "
4620              "not %s in class `%s'", lang_printable_name (method, 0),
4621              (METHOD_PUBLIC (method) ? "public" :
4622               (METHOD_PRIVATE (method) ? "private" : "protected")),
4623              IDENTIFIER_POINTER (DECL_NAME
4624                                  (TYPE_NAME (DECL_CONTEXT (found)))));
4625           continue;
4626         }
4627
4628       /* Overriding methods must have compatible `throws' clauses on checked
4629          exceptions, if any */
4630       check_throws_clauses (method, method_wfl, found);
4631
4632       /* If the method has default access in an other package, then
4633          issue a warning that the current method doesn't override the
4634          one that was found elsewhere. Do not issue this warning when
4635          the match was found in java.lang.Object.  */
4636       if (DECL_CONTEXT (found) != object_type_node
4637           && (!aflags || (aflags > ACC_PROTECTED))
4638           && !class_in_current_package (DECL_CONTEXT (found))
4639           && flag_not_overriding)
4640         parse_warning_context
4641           (method_wfl, "Method `%s' in class `%s' does not "
4642            "override the corresponding method in class `%s', which is "
4643            "private to a different package",
4644            lang_printable_name (found, 0),
4645            IDENTIFIER_POINTER (DECL_NAME (class_decl)),
4646            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4647
4648       /* Inheriting multiple methods with the same signature. FIXME */
4649     }
4650
4651   /* Don't forget eventual pending found and saved_found_wfl. Take
4652      into account that we might have exited because we saw an
4653      aritifical method as the last entry. */
4654
4655   if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl)
4656     DECL_NAME (found) = saved_found_wfl;
4657
4658   if (!TYPE_NVIRTUALS (class))
4659     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
4660
4661   if (!saw_constructor)
4662     {
4663       /* No constructor seen, we craft one, at line 0. Since this
4664        operation takes place after we laid methods out
4665        (layout_class_methods), we prepare the its DECL
4666        appropriately. */
4667       int flags;
4668       tree decl;
4669
4670       /* If the class is declared PUBLIC, the default constructor is
4671          PUBLIC otherwise it has default access implied by no access
4672          modifiers. */
4673       flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
4674                ACC_PUBLIC : 0);
4675       decl = create_artificial_method (class, flags, void_type_node,
4676                                        init_identifier_node, end_params_node);
4677       DECL_CONSTRUCTOR_P (decl) = 1;
4678       layout_class_method (TREE_TYPE (class_decl), NULL_TREE, decl, NULL_TREE);
4679     }
4680 }
4681
4682 /* Return a non zero value if the `throws' clause of METHOD (if any)
4683    is incompatible with the `throws' clause of FOUND (if any).  */
4684
4685 static void
4686 check_throws_clauses (method, method_wfl, found)
4687      tree method, method_wfl, found;
4688 {
4689   tree mthrows, fthrows;
4690
4691   /* Can't check these things with class loaded from bytecode. FIXME */
4692   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
4693     return;
4694
4695   for (mthrows = DECL_FUNCTION_THROWS (method);
4696        mthrows; mthrows = TREE_CHAIN (mthrows))
4697     {
4698       /* We don't verify unchecked expressions */
4699       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
4700         continue;
4701       /* Checked expression must be compatible */
4702       for (fthrows = DECL_FUNCTION_THROWS (found);
4703            fthrows; fthrows = TREE_CHAIN (fthrows))
4704         if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
4705           break;
4706       if (!fthrows)
4707         {
4708           parse_error_context
4709             (method_wfl, "Invalid checked exception class `%s' in "
4710              "`throws' clause. The exception must be a subclass of an "
4711              "exception thrown by `%s' from class `%s'",
4712              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
4713              lang_printable_name (found, 0),
4714              IDENTIFIER_POINTER
4715                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4716         }
4717     }
4718 }
4719
4720 /* Check abstract method of interface INTERFACE */
4721
4722 static void
4723 java_check_abstract_methods (interface_decl)
4724      tree interface_decl;
4725 {
4726   int i, n;
4727   tree method, basetype_vec, found;
4728   tree interface = TREE_TYPE (interface_decl);
4729
4730   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
4731     {
4732       tree method_wfl = DECL_NAME (method);
4733
4734       /* 2- Check for double definition inside the defining interface */
4735       if (check_method_redefinition (interface, method))
4736         continue;
4737
4738       /* 3- Overriding is OK as far as we preserve the return type and
4739          the thrown exceptions (FIXME) */
4740       found = lookup_java_interface_method2 (interface, method);
4741       if (found)
4742         {
4743           char *t;
4744           tree saved_found_wfl = DECL_NAME (found);
4745           reset_method_name (found);
4746           t = strdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
4747           parse_error_context
4748             (method_wfl,
4749              "Method `%s' was defined with return type `%s' in class `%s'",
4750              lang_printable_name (found, 0), t,
4751              IDENTIFIER_POINTER
4752                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4753           free (t);
4754           continue;
4755
4756           DECL_NAME (found) = saved_found_wfl;
4757         }
4758     }
4759
4760   /* 4- Inherited methods can't differ by their returned types */
4761   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
4762     return;
4763   n = TREE_VEC_LENGTH (basetype_vec);
4764   for (i = 0; i < n; i++)
4765     {
4766       tree sub_interface_method, sub_interface;
4767       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
4768       if (!vec_elt)
4769         continue;
4770       sub_interface = BINFO_TYPE (vec_elt);
4771       for (sub_interface_method = TYPE_METHODS (sub_interface);
4772            sub_interface_method;
4773            sub_interface_method = TREE_CHAIN (sub_interface_method))
4774         {
4775           found = lookup_java_interface_method2 (interface,
4776                                                  sub_interface_method);
4777           if (found && (found != sub_interface_method))
4778             {
4779               tree saved_found_wfl = DECL_NAME (found);
4780               reset_method_name (found);
4781               parse_error_context
4782                 (lookup_cl (sub_interface_method),
4783                  "Interface `%s' inherits method `%s' from interface `%s'. "
4784                  "This method is redefined with a different return type in "
4785                  "interface `%s'",
4786                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
4787                  lang_printable_name (found, 0),
4788                  IDENTIFIER_POINTER
4789                    (DECL_NAME (TYPE_NAME
4790                                (DECL_CONTEXT (sub_interface_method)))),
4791                  IDENTIFIER_POINTER
4792                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4793               DECL_NAME (found) = saved_found_wfl;
4794             }
4795         }
4796     }
4797 }
4798
4799 /* Lookup methods in interfaces using their name and partial
4800    signature. Return a matching method only if their types differ.  */
4801
4802 static tree
4803 lookup_java_interface_method2 (class, method_decl)
4804      tree class, method_decl;
4805 {
4806   int i, n;
4807   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
4808
4809   if (!basetype_vec)
4810     return NULL_TREE;
4811
4812   n = TREE_VEC_LENGTH (basetype_vec);
4813   for (i = 0; i < n; i++)
4814     {
4815       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
4816       if ((BINFO_TYPE (vec_elt) != object_type_node)
4817           && (to_return =
4818               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
4819         return to_return;
4820     }
4821   for (i = 0; i < n; i++)
4822     {
4823       to_return = lookup_java_interface_method2
4824         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
4825       if (to_return)
4826         return to_return;
4827     }
4828
4829   return NULL_TREE;
4830 }
4831
4832 /* Lookup method using their name and partial signature. Return a
4833    matching method only if their types differ.  */
4834
4835 static tree
4836 lookup_java_method2 (clas, method_decl, do_interface)
4837      tree clas, method_decl;
4838      int do_interface;
4839 {
4840   tree method, method_signature, method_name, method_type, name;
4841
4842   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
4843   name = DECL_NAME (method_decl);
4844   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
4845                  EXPR_WFL_NODE (name) : name);
4846   method_type = TREE_TYPE (TREE_TYPE (method_decl));
4847
4848   while (clas != NULL_TREE)
4849     {
4850       for (method = TYPE_METHODS (clas);
4851            method != NULL_TREE;  method = TREE_CHAIN (method))
4852         {
4853           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
4854           tree name = DECL_NAME (method);
4855           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
4856                EXPR_WFL_NODE (name) : name) == method_name
4857               && method_sig == method_signature
4858               && TREE_TYPE (TREE_TYPE (method)) != method_type)
4859             return method;
4860         }
4861       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
4862     }
4863   return NULL_TREE;
4864 }
4865
4866 /* Return the line that matches DECL line number. Used during error
4867    report */
4868
4869 static tree
4870 lookup_cl (decl)
4871      tree decl;
4872 {
4873   static tree cl = NULL_TREE;
4874
4875   if (!decl)
4876     return NULL_TREE;
4877
4878   if (cl == NULL_TREE)
4879     cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
4880
4881   EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
4882   EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
4883
4884   return cl;
4885 }
4886
4887 /* Look for a simple name in the single-type import list */
4888
4889 static tree
4890 find_name_in_single_imports (name)
4891      tree name;
4892 {
4893   tree node;
4894
4895   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
4896     if (TREE_VALUE (node) == name)
4897       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
4898
4899   return NULL_TREE;
4900 }
4901
4902 /* Process all single-type import. */
4903
4904 static int
4905 process_imports ()
4906 {
4907   tree import;
4908   int error_found;
4909
4910   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
4911     {
4912       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
4913
4914       /* Don't load twice something already defined. */
4915       if (IDENTIFIER_CLASS_VALUE (to_be_found))
4916         continue;
4917       QUALIFIED_P (to_be_found) = 1;
4918       load_class (to_be_found, 0);
4919       error_found =
4920         check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
4921       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
4922         {
4923           parse_error_context (TREE_PURPOSE (import),
4924                                "Class or interface `%s' not found in import",
4925                                IDENTIFIER_POINTER (to_be_found));
4926           return 1;
4927         }
4928       if (error_found)
4929         return 1;
4930     }
4931   return 0;
4932 }
4933
4934 /* Possibly find a class imported by a single-type import statement. Return
4935    1 if an error occured, 0 otherwise. */
4936
4937 static int
4938 find_in_imports (class_type)
4939      tree class_type;
4940 {
4941   tree import;
4942
4943   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
4944     if (TREE_VALUE (import) == TYPE_NAME (class_type))
4945       {
4946         TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
4947         QUALIFIED_P (TYPE_NAME (class_type)) = 1;
4948       }
4949   return 0;
4950 }
4951
4952 static int
4953 note_possible_classname (name, len)
4954      char *name;
4955      int len;
4956 {
4957   tree node;
4958   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
4959     len = len - 5;
4960   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
4961     len = len - 6;
4962   else
4963     return 0;
4964   node = ident_subst (name, len, "", '/', '.', "");
4965   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
4966   QUALIFIED_P (node) = 1; /* As soon as we turn / into . */
4967   return 1;
4968 }
4969
4970 /* Read a import directory, gathering potential match for further type
4971    references. Indifferently reads a filesystem or a ZIP archive
4972    directory.  */
4973
4974 static void
4975 read_import_dir (wfl)
4976      tree wfl;
4977 {
4978   tree package_id = EXPR_WFL_NODE (wfl);
4979   char *package_name = IDENTIFIER_POINTER (package_id);
4980   int package_length = IDENTIFIER_LENGTH (package_id);
4981   DIR *dirp = NULL;
4982   JCF *saved_jcf = current_jcf;
4983
4984   int found = 0;
4985   int k;
4986   void *entry;
4987   struct buffer filename[1];
4988
4989
4990   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
4991     return;
4992   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
4993
4994   BUFFER_INIT (filename);
4995   buffer_grow (filename, package_length + 100);
4996
4997   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
4998     {
4999       char *entry_name = jcf_path_name (entry);
5000       int entry_length = strlen (entry_name);
5001       if (jcf_path_is_zipfile (entry))
5002         {
5003           ZipFile *zipf;
5004           buffer_grow (filename, entry_length);
5005           memcpy (filename->data, entry_name, entry_length - 1);
5006           filename->data[entry_length-1] = '\0';
5007           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
5008           if (zipf == NULL)
5009             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
5010           else
5011             {
5012               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
5013               BUFFER_RESET (filename);
5014               for (k = 0; k < package_length; k++)
5015                 {
5016                   char ch = package_name[k];
5017                   *filename->ptr++ = ch == '.' ? '/' : ch;
5018                 }
5019               *filename->ptr++ = '/';
5020
5021               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
5022                 {
5023                   char *current_entry = ZIPDIR_FILENAME (zipd);
5024                   int current_entry_len = zipd->filename_length;
5025
5026                   if (current_entry_len >= BUFFER_LENGTH (filename)
5027                       && strncmp (filename->data, current_entry,
5028                                   BUFFER_LENGTH (filename)) != 0)
5029                     continue;
5030                   found |= note_possible_classname (current_entry,
5031                                                     current_entry_len);
5032                 }
5033             }
5034         }
5035       else
5036         {
5037           BUFFER_RESET (filename);
5038           buffer_grow (filename, entry_length + package_length + 4);
5039           strcpy (filename->data, entry_name);
5040           filename->ptr = filename->data + entry_length;
5041           for (k = 0; k < package_length; k++)
5042             {
5043               char ch = package_name[k];
5044               *filename->ptr++ = ch == '.' ? '/' : ch;
5045             }
5046           *filename->ptr = '\0';
5047
5048           dirp = opendir (filename->data);
5049           if (dirp == NULL)
5050             continue;
5051           *filename->ptr++ = '/';
5052           for (;;)
5053             {
5054               int len;
5055               char *d_name;
5056               struct dirent *direntp = readdir (dirp);
5057               if (!direntp)
5058                 break;
5059               d_name = direntp->d_name;
5060               len = strlen (direntp->d_name);
5061               buffer_grow (filename, len+1);
5062               strcpy (filename->ptr, d_name);
5063               found |= note_possible_classname (filename->data + entry_length,
5064                                                 package_length+len+1);
5065             }
5066           if (dirp)
5067             closedir (dirp);
5068         }
5069     }
5070
5071   free (filename->data);
5072
5073   /* Here we should have a unified way of retrieving an entry, to be
5074      indexed. */
5075   if (!found)
5076     {
5077       static int first = 1;
5078       if (first)
5079         {
5080           char buffer [256];
5081           sprintf (buffer, "Can't find default package `%s'. Check "
5082                    "the CLASSPATH environment variable and the access to the "
5083                    "archives.", package_name);
5084           error (buffer);
5085           java_error_count++;
5086           first = 0;
5087         }
5088       else
5089         parse_error_context (wfl, "Package `%s' not found in import",
5090                              package_name);
5091       current_jcf = saved_jcf;
5092       return;
5093     }
5094   current_jcf = saved_jcf;
5095 }
5096
5097 /* Possibly find a type in the import on demands specified
5098    types. Returns 1 if an error occured, 0 otherwise. Run throught the
5099    entire list, to detected potential double definitions.  */
5100
5101 static int
5102 find_in_imports_on_demand (class_type)
5103      tree class_type;
5104 {
5105   tree node, import, node_to_use;
5106   int seen_once = -1;
5107   tree cl;
5108
5109   for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
5110     {
5111       char *id_name;
5112       obstack_grow (&temporary_obstack,
5113                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
5114                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
5115       obstack_1grow (&temporary_obstack, '.');
5116       obstack_grow0 (&temporary_obstack,
5117                      IDENTIFIER_POINTER (TYPE_NAME (class_type)),
5118                      IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
5119       id_name = obstack_finish (&temporary_obstack);
5120
5121       node = maybe_get_identifier (id_name);
5122       if (node && IS_A_CLASSFILE_NAME (node))
5123         {
5124           if (seen_once < 0)
5125             {
5126               cl = TREE_PURPOSE (import);
5127               seen_once = 1;
5128               node_to_use = node;
5129             }
5130           else
5131             {
5132               seen_once++;
5133               parse_error_context
5134                 (import, "Type `%s' also potentially defined in package `%s'",
5135                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
5136                  IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
5137             }
5138         }
5139     }
5140
5141   if (seen_once == 1)
5142     {
5143       /* Setup lineno so that it refers to the line of the import (in
5144          case we parse a class file and encounter errors */
5145       tree decl;
5146       int saved_lineno = lineno;
5147       lineno = EXPR_WFL_LINENO (cl);
5148       TYPE_NAME (class_type) = node_to_use;
5149       QUALIFIED_P (TYPE_NAME (class_type)) = 1;
5150       decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5151       /* If there is no DECL set for the class or if the class isn't
5152          loaded and not seen in source yet, the load */
5153       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
5154                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
5155         load_class (node_to_use, 0);
5156       lineno = saved_lineno;
5157       return check_pkg_class_access (TYPE_NAME (class_type), cl);
5158     }
5159   else
5160     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
5161 }
5162
5163 static tree
5164 resolve_package (pkg, next)
5165      tree pkg, *next;
5166 {
5167   tree type_name = NULL_TREE;
5168   char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg));
5169
5170   /* The trick is to determine when the package name stops and were
5171      the name of something contained in the package starts. Then we
5172      return a fully qualified name of what we want to get. */
5173
5174   /* Do a quick search on well known package names */
5175   if (!strncmp (name, "java.lang.reflect", 17))
5176     {
5177       *next =
5178         TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))));
5179       type_name = lookup_package_type (name, 17);
5180     }
5181   else if (!strncmp (name, "java.lang", 9))
5182     {
5183       *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)));
5184       type_name = lookup_package_type (name, 9);
5185     }
5186   else
5187     return NULL_TREE;           /* FIXME, search all imported packages. */
5188
5189   return type_name;
5190 }
5191
5192 static tree
5193 lookup_package_type (name, from)
5194      char *name;
5195      int from;
5196 {
5197   char subname [128];
5198   char *sub = &name[from+1];
5199   while (*sub != '.' && *sub)
5200     sub++;
5201   strncpy (subname, name, sub-name);
5202   subname [sub-name] = '\0';
5203   return get_identifier (subname);
5204 }
5205
5206 /* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
5207    access violations were found, 1 otherwise.  */
5208
5209 static int
5210 check_pkg_class_access (class_name, cl)
5211      tree class_name;
5212      tree cl;
5213 {
5214   tree type;
5215
5216   if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
5217     return 0;
5218
5219   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
5220     return 0;
5221
5222   if (!CLASS_PUBLIC (TYPE_NAME (type)))
5223     {
5224       /* Access to a private class within the same package is
5225          allowed. */
5226       tree l, r;
5227       breakdown_qualified (&l, &r, class_name);
5228       if (l == ctxp->package)
5229         return 0;
5230
5231       parse_error_context
5232         (cl, "Can't access %s `%s'. Only public classes and interfaces in "
5233          "other packages can be accessed",
5234          (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
5235          IDENTIFIER_POINTER (class_name));
5236       return 1;
5237     }
5238   return 0;
5239 }
5240
5241 /* Local variable declaration. */
5242
5243 static void
5244 declare_local_variables (modifier, type, vlist)
5245      int modifier;
5246      tree type;
5247      tree vlist;
5248 {
5249   tree decl, current, saved_type;
5250   tree type_wfl = NULL_TREE;
5251   int must_chain = 0;
5252
5253   /* Push a new block if statement were seen between the last time we
5254      pushed a block and now. Keep a cound of block to close */
5255   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)))
5256     {
5257       tree body = DECL_FUNCTION_BODY (current_function_decl);
5258       tree b = enter_block ();
5259       BLOCK_EXPR_ORIGIN(b) = body;
5260     }
5261
5262   if (modifier)
5263     {
5264       int i;
5265       for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
5266       if (modifier == ACC_FINAL)
5267         {
5268           if (flag_static_local_jdk1_1)
5269             parse_warning_context (ctxp->modifier_ctx [i],
5270                                    "Unsupported JDK1.1 `final' local variable "
5271                                    "(treated as non final)");
5272         }
5273       else
5274         {
5275           parse_error_context
5276             (ctxp->modifier_ctx [i],
5277              "Only `final' is allowed as a local variables modifier");
5278           return;
5279         }
5280     }
5281
5282   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
5283      hold the TYPE value if a new incomplete has to be created (as
5284      opposed to being found already existing and reused). */
5285   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
5286
5287   /* If TYPE is fully resolved and we don't have a reference, make one */
5288   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
5289
5290   /* Go through all the declared variables */
5291   for (current = vlist, saved_type = type; current;
5292        current = TREE_CHAIN (current), type = saved_type)
5293     {
5294       tree other, real_type;
5295       tree wfl  = TREE_PURPOSE (current);
5296       tree name = EXPR_WFL_NODE (wfl);
5297       tree init = TREE_VALUE (current);
5298
5299       /* Process NAME, as it may specify extra dimension(s) for it */
5300       type = build_array_from_name (type, type_wfl, name, &name);
5301
5302       /* Variable redefinition check */
5303       if ((other = lookup_name_in_blocks (name)))
5304         {
5305           variable_redefinition_error (wfl, name, TREE_TYPE (other),
5306                                        DECL_SOURCE_LINE (other));
5307           continue;
5308         }
5309
5310       /* Type adjustment. We may have just readjusted TYPE because
5311          the variable specified more dimensions. Make sure we have
5312          a reference if we can and don't have one already. */
5313       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
5314
5315       real_type = GET_REAL_TYPE (type);
5316       /* Never layout this decl. This will be done when its scope
5317          will be entered */
5318       decl = build_decl (VAR_DECL, name, real_type);
5319       BLOCK_CHAIN_DECL (decl);
5320
5321       /* Don't try to use an INIT statement when an error was found */
5322       if (init && java_error_count)
5323         init = NULL_TREE;
5324
5325       /* Add the initialization function to the current function's code */
5326       if (init)
5327         {
5328           /* Name might have been readjusted */
5329           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
5330           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
5331           java_method_add_stmt (current_function_decl,
5332                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
5333                                                       init));
5334         }
5335
5336       /* Setup dependency the type of the decl */
5337       if (must_chain)
5338         {
5339           jdep *dep;
5340           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
5341           dep = CLASSD_LAST (ctxp->classd_list);
5342           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
5343         }
5344     }
5345   SOURCE_FRONTEND_DEBUG (("Defined locals"));
5346 }
5347
5348 /* Called during parsing. Build decls from argument list.  */
5349
5350 static void
5351 source_start_java_method (fndecl)
5352      tree fndecl;
5353 {
5354   tree tem;
5355   tree parm_decl;
5356   int i;
5357
5358   current_function_decl = fndecl;
5359
5360   /* New scope for the function */
5361   enter_block ();
5362   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
5363        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
5364     {
5365       tree type = TREE_VALUE (tem);
5366       tree name = TREE_PURPOSE (tem);
5367
5368       /* If type is incomplete. Create an incomplete decl and ask for
5369          the decl to be patched later */
5370       if (INCOMPLETE_TYPE_P (type))
5371         {
5372           jdep *jdep;
5373           tree real_type = GET_REAL_TYPE (type);
5374           parm_decl = build_decl (PARM_DECL, name, real_type);
5375           type = obtain_incomplete_type (type);
5376           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
5377           jdep = CLASSD_LAST (ctxp->classd_list);
5378           JDEP_MISC (jdep) = name;
5379           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
5380         }
5381       else
5382         parm_decl = build_decl (PARM_DECL, name, type);
5383
5384       BLOCK_CHAIN_DECL (parm_decl);
5385     }
5386   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
5387   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
5388     nreverse (tem);
5389   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
5390 }
5391
5392 /* Called during parsing. Creates an artificial method declaration.  */
5393
5394 static tree
5395 create_artificial_method (class, flags, type, name, args)
5396      tree class;
5397      int flags;
5398      tree type, name, args;
5399 {
5400   int saved_lineno = lineno;
5401   tree mdecl;
5402
5403   lineno = 0;
5404   mdecl = make_node (FUNCTION_TYPE);
5405   TREE_TYPE (mdecl) = type;
5406   TYPE_ARG_TYPES (mdecl) = args;
5407   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
5408   lineno = saved_lineno;
5409   DECL_ARTIFICIAL (mdecl) = 1;
5410   return mdecl;
5411 }
5412
5413 /* Starts the body if an artifical method.  */
5414
5415 static void
5416 start_artificial_method_body (mdecl)
5417      tree mdecl;
5418 {
5419   DECL_SOURCE_LINE (mdecl) = 1;
5420   DECL_SOURCE_LINE_MERGE (mdecl, 1);
5421   source_start_java_method (mdecl);
5422   enter_block ();
5423 }
5424
5425 static void
5426 end_artificial_method_body (mdecl)
5427      tree mdecl;
5428 {
5429   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
5430   exit_block ();
5431 }
5432
5433 /* Called during expansion. Push decls formerly built from argument
5434    list so they're usable during expansion. */
5435
5436 static void
5437 expand_start_java_method (fndecl)
5438      tree fndecl;
5439 {
5440   tree tem, *ptr;
5441
5442   current_function_decl = fndecl;
5443
5444   announce_function (fndecl);
5445   pushlevel (1);                /* Push parameters */
5446   ptr = &DECL_ARGUMENTS (fndecl);
5447   tem  = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
5448   while (tem)
5449     {
5450       tree next = TREE_CHAIN (tem);
5451       tree type = TREE_TYPE (tem);
5452 #ifdef PROMOTE_PROTOTYPES
5453       if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
5454           && INTEGRAL_TYPE_P (type))
5455         type = integer_type_node;
5456 #endif
5457       DECL_ARG_TYPE (tem) = type;
5458       layout_decl (tem, 0);
5459       pushdecl (tem);
5460       INITIALIZED_P (tem) = 1;  /* Parms are initialized */
5461       *ptr = tem;
5462       ptr = &TREE_CHAIN (tem);
5463       tem = next;
5464     }
5465   *ptr = NULL_TREE;
5466   pushdecl_force_head (DECL_ARGUMENTS (fndecl));
5467   lineno = DECL_SOURCE_LINE_FIRST (fndecl);
5468 }
5469
5470 /* Terminate a function and expand its body.  */
5471
5472 static void
5473 source_end_java_method ()
5474 {
5475   tree fndecl = current_function_decl;
5476
5477   java_parser_context_save_global ();
5478   lineno = ctxp->last_ccb_indent1;
5479
5480   /* Set EH language codes */
5481   java_set_exception_lang_code ();
5482
5483   /* Generate function's code */
5484   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
5485       && ! flag_emit_class_files)
5486     expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
5487
5488   /* pop out of its parameters */
5489   pushdecl_force_head (DECL_ARGUMENTS (fndecl));
5490   poplevel (1, 0, 1);
5491   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
5492
5493   /* Generate rtl for function exit.  */
5494   if (! flag_emit_class_files)
5495     {
5496       lineno = DECL_SOURCE_LINE_LAST (fndecl);
5497       /* Emit catch-finally clauses */
5498       emit_handlers ();
5499       expand_function_end (input_filename, lineno, 0);
5500
5501       /* Run the optimizers and output assembler code for this function. */
5502       rest_of_compilation (fndecl);
5503     }
5504
5505   current_function_decl = NULL_TREE;
5506   /*  permanent_allocation (1); */
5507   java_parser_context_restore_global ();
5508 }
5509
5510 /* Record EXPR in the current function block. Complements compound
5511    expression second operand if necessary.  */
5512
5513 tree
5514 java_method_add_stmt (fndecl, expr)
5515      tree fndecl, expr;
5516 {
5517   return add_stmt_to_block (DECL_FUNCTION_BODY (fndecl), NULL_TREE, expr);
5518 }
5519
5520 static tree
5521 add_stmt_to_block (b, type, stmt)
5522      tree b, type, stmt;
5523 {
5524   tree body = BLOCK_EXPR_BODY (b), c;
5525
5526   if (java_error_count)
5527     return body;
5528
5529   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
5530     return body;
5531
5532   BLOCK_EXPR_BODY (b) = c;
5533   TREE_SIDE_EFFECTS (c) = 1;
5534   return c;
5535 }
5536
5537 /* Add STMT to EXISTING if possible, otherwise create a new
5538    COMPOUND_EXPR and add STMT to it. */
5539
5540 static tree
5541 add_stmt_to_compound (existing, type, stmt)
5542      tree existing, type, stmt;
5543 {
5544   if (existing)
5545     return build (COMPOUND_EXPR, type, existing, stmt);
5546   else
5547     return stmt;
5548 }
5549
5550 /* Hold THIS for the scope of the current public method decl.  */
5551 static tree current_this;
5552
5553 void java_layout_seen_class_methods ()
5554 {
5555   tree previous_list = all_class_list;
5556   tree end = NULL_TREE;
5557   tree current;
5558
5559   while (1)
5560     {
5561       for (current = previous_list;
5562            current != end; current = TREE_CHAIN (current))
5563         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
5564
5565       if (previous_list != all_class_list)
5566         {
5567           end = previous_list;
5568           previous_list = all_class_list;
5569         }
5570       else
5571         break;
5572     }
5573 }
5574
5575 /* Layout the methods of all classes loaded in one way on an
5576    other. Check methods of source parsed classes. Then reorder the
5577    fields and layout the classes or the type of all source parsed
5578    classes */
5579
5580 void
5581 java_layout_classes ()
5582 {
5583   tree current;
5584   int save_error_count = java_error_count;
5585
5586   /* Layout the methods of all classes seen so far */
5587   java_layout_seen_class_methods ();
5588   java_parse_abort_on_error ();
5589   all_class_list = NULL_TREE;
5590
5591   /* Then check the methods of all parsed classes */
5592   for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
5593     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
5594       CHECK_METHODS (TREE_VALUE (current));
5595   java_parse_abort_on_error ();
5596
5597   for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
5598     {
5599       current_class = TREE_TYPE (TREE_VALUE (current));
5600
5601       /* Reverse the fields, but leave the dummy field in front.
5602          Fields are already ordered for Object and Class */
5603       if (TYPE_FIELDS (current_class) && current_class != object_type_node
5604           && current_class != class_type_node)
5605       {
5606         /* If the dummy field is there, reverse the right fields and
5607            just layout the type for proper fields offset */
5608         if (!DECL_NAME (TYPE_FIELDS (current_class)))
5609           {
5610             tree fields = TYPE_FIELDS (current_class);
5611             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
5612             TYPE_SIZE (current_class) = NULL_TREE;
5613             layout_type (current_class);
5614           }
5615         /* We don't have a dummy field, we need to layout the class,
5616            after having reversed the fields */
5617         else
5618           {
5619             TYPE_FIELDS (current_class) =
5620               nreverse (TYPE_FIELDS (current_class));
5621             TYPE_SIZE (current_class) = NULL_TREE;
5622             layout_class (current_class);
5623           }
5624       }
5625       else
5626         layout_class (current_class);
5627
5628       /* From now on, the class is considered completely loaded */
5629       CLASS_LOADED_P (current_class) = 1;
5630
5631       /* Error reported by the caller */
5632       if (java_error_count)
5633         return;
5634     }
5635
5636   /* We might have reloaded classes durign the process of laying out
5637      classes for code generation. We must layout the methods of those
5638      late additions, as constructor checks might use them */
5639   java_layout_seen_class_methods ();
5640   java_parse_abort_on_error ();
5641 }
5642
5643 /* Expand all methods in all registered classes.  */
5644
5645 void
5646 java_complete_expand_methods ()
5647 {
5648   tree current;
5649
5650   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5651     {
5652       tree class_type = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current));
5653       tree decl;
5654
5655       current_class = TREE_TYPE (current);
5656
5657       /* Initialize a new constant pool */
5658       init_outgoing_cpool ();
5659
5660       /* We want <clinit> (if any) to be processed first. */
5661       decl = tree_last (TYPE_METHODS (class_type));
5662       if (decl && DECL_NAME (decl) == clinit_identifier_node)
5663         {
5664           tree list = nreverse (TYPE_METHODS (class_type));
5665           list = TREE_CHAIN (list);
5666           TREE_CHAIN (decl) = NULL_TREE;
5667           TYPE_METHODS (class_type) = chainon (decl, nreverse (list));
5668         }
5669
5670       /* Don't process function bodies in interfaces */
5671       if (!CLASS_INTERFACE (TYPE_NAME (current_class)))
5672         for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5673           {
5674             current_function_decl = decl;
5675             /* Don't generate debug info on line zero when expanding a
5676                generated constructor. */
5677             if (DECL_CONSTRUCTOR_P (decl) && !DECL_FUNCTION_BODY (decl))
5678               {
5679                 /* If we found errors, it's too dangerous to try to generate
5680                    and expand a constructor */
5681                 if (!java_error_count)
5682                   {
5683                     restore_line_number_status (1);
5684                     java_complete_expand_method (decl);
5685                     restore_line_number_status (0);
5686                   }
5687               }
5688             else if (METHOD_ABSTRACT (decl) || METHOD_NATIVE (decl))
5689               continue;
5690             else
5691               java_complete_expand_method (decl);
5692           }
5693
5694       /* Now verify constructor circularity (stop after the first one
5695          we find) */
5696       if (!CLASS_INTERFACE (TYPE_NAME (current_class)))
5697         for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5698           if (DECL_CONSTRUCTOR_P (decl) &&
5699               verify_constructor_circularity (decl, decl))
5700             break;
5701
5702       /* Make the class data, register it and run the rest of decl
5703          compilation on it */
5704       if (!java_error_count)
5705         {
5706           if (flag_emit_class_files)
5707             write_classfile (current_class);
5708           else if (! flag_syntax_only)
5709             finish_class (current_class);
5710         }
5711     }
5712 }
5713
5714 /* Hold a list of catch clauses list. The first element of this list is
5715    the list of the catch clauses of the currently analysed try block. */
5716 static tree currently_caught_type_list;
5717
5718 /* Complete and expand a method.  */
5719
5720 static void
5721 java_complete_expand_method (mdecl)
5722      tree mdecl;
5723 {
5724   /* Fix constructors before expanding them */
5725   if (DECL_CONSTRUCTOR_P (mdecl))
5726     fix_constructors (mdecl);
5727
5728   /* Expand functions that have a body */
5729   if (DECL_FUNCTION_BODY (mdecl))
5730     {
5731       tree fbody = DECL_FUNCTION_BODY (mdecl);
5732       tree block_body = BLOCK_EXPR_BODY (fbody);
5733       expand_start_java_method (mdecl);
5734       build_result_decl (mdecl);
5735
5736       current_this
5737         = (!METHOD_STATIC (mdecl) ?
5738            BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
5739
5740       /* Purge the `throws' list of unchecked exceptions */
5741       purge_unchecked_exceptions (mdecl);
5742
5743       /* Install exceptions thrown with `throws' */
5744       PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
5745
5746       if (block_body != NULL_TREE)
5747         {
5748           block_body = java_complete_tree (block_body);
5749           check_for_initialization (block_body);
5750         }
5751       BLOCK_EXPR_BODY (fbody) = block_body;
5752
5753       if ((block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
5754           && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE)
5755         missing_return_error (current_function_decl);
5756
5757       complete_start_java_method (mdecl);
5758
5759       /* Don't go any further if we've found error(s) during the
5760          expansion */
5761       if (!java_error_count)
5762         source_end_java_method ();
5763       else
5764         {
5765           pushdecl_force_head (DECL_ARGUMENTS (mdecl));
5766           poplevel (1, 0, 1);
5767         }
5768
5769       /* Pop the exceptions and sanity check */
5770       POP_EXCEPTIONS();
5771       if (currently_caught_type_list)
5772         fatal ("Exception list non empty - java_complete_expand_method");
5773     }
5774 }
5775
5776 /* Craft a body for default constructor. Patch existing constructor
5777    bodies with call to super() and field initialization statements if
5778    necessary.  */
5779
5780 static void
5781 fix_constructors (mdecl)
5782      tree mdecl;
5783 {
5784   tree body = DECL_FUNCTION_BODY (mdecl);
5785
5786   if (!body)
5787     {
5788       /* The constructor body must be crafted by hand. It's the
5789          constructor we defined when we realize we didn't have the
5790          CLASSNAME() constructor */
5791
5792       tree compound;
5793
5794       /* It is an error for the compiler to generate a default
5795          constructor if the superclass doesn't have a constructor that
5796          takes no argument */
5797       if (verify_constructor_super ())
5798         {
5799           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (current_class));
5800           char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
5801           parse_error_context (lookup_cl (TYPE_NAME (current_class)),
5802                                "No constructor matching `%s()' found in "
5803                                "class `%s'", n, n);
5804         }
5805
5806       start_artificial_method_body (mdecl);
5807
5808       /* We don't generate a super constructor invocation if we're
5809          compiling java.lang.Object. build_super_invocation takes care
5810          of that. */
5811       compound = java_method_add_stmt (mdecl, build_super_invocation ());
5812
5813       end_artificial_method_body (mdecl);
5814     }
5815   /* Search for an explicit constructor invocation */
5816   else
5817     {
5818       int found = 0;
5819       tree main_block = BLOCK_EXPR_BODY (body);
5820       tree compound = NULL_TREE;
5821
5822       while (body)
5823         switch (TREE_CODE (body))
5824           {
5825           case CALL_EXPR:
5826             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
5827             body = NULL_TREE;
5828             break;
5829           case COMPOUND_EXPR:
5830           case EXPR_WITH_FILE_LOCATION:
5831             body = TREE_OPERAND (body, 0);
5832             break;
5833           case BLOCK:
5834             body = BLOCK_EXPR_BODY (body);
5835             break;
5836           default:
5837             found = 0;
5838             body = NULL_TREE;
5839           }
5840       /* The constructor is missing an invocation of super() */
5841       if (!found)
5842         compound = add_stmt_to_compound (compound, NULL_TREE,
5843                                          build_super_invocation ());
5844
5845       /* Fix the constructor main block if we're adding extra stmts */
5846       if (compound)
5847         {
5848           compound = add_stmt_to_compound (compound, NULL_TREE,
5849                                            BLOCK_EXPR_BODY (main_block));
5850           BLOCK_EXPR_BODY (main_block) = compound;
5851         }
5852     }
5853 }
5854
5855 /* Browse constructors in the super class, searching for a constructor
5856    that doesn't take any argument. Return 0 if one is found, 1
5857    otherwise. */
5858
5859 static int
5860 verify_constructor_super ()
5861 {
5862   tree class = CLASSTYPE_SUPER (current_class);
5863   if (!class)
5864     return 0;
5865
5866   if (class)
5867     {
5868       tree mdecl;
5869       for (mdecl = TYPE_METHODS (class); mdecl; mdecl = TREE_CHAIN (mdecl))
5870         {
5871           if (DECL_CONSTRUCTOR_P (mdecl)
5872               && TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (mdecl))) == end_params_node)
5873             return 0;
5874         }
5875     }
5876   return 1;
5877 }
5878
5879 /* Expand finals.  */
5880
5881 void
5882 java_expand_finals ()
5883 {
5884 }
5885
5886 /* Generate code for all context remembered for code generation.  */
5887
5888 void
5889 java_expand_classes ()
5890 {
5891   int save_error_count = java_error_count;
5892   java_parse_abort_on_error ();
5893   if (!(ctxp = ctxp_for_generation))
5894     return;
5895   java_layout_classes ();
5896   java_parse_abort_on_error ();
5897
5898   for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
5899     {
5900       ctxp = ctxp_for_generation;
5901       lang_init_source (2);            /* Error msgs have method prototypes */
5902       java_complete_expand_methods (); /* Complete and expand method bodies */
5903       java_parse_abort_on_error ();
5904       java_expand_finals ();          /* Expand and check the finals */
5905       java_parse_abort_on_error ();
5906       java_check_final ();            /* Check unitialized final  */
5907       java_parse_abort_on_error ();
5908     }
5909 }
5910
5911 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
5912    a tree list node containing RIGHT. Fore coming RIGHTs will be
5913    chained to this hook. LOCATION contains the location of the
5914    separating `.' operator.  */
5915
5916 static tree
5917 make_qualified_primary (primary, right, location)
5918      tree primary, right;
5919      int location;
5920 {
5921   tree wfl;
5922
5923   /* We want to process THIS . xxx symbolicaly, to keep it consistent
5924      with the way we're processing SUPER. A THIS from a primary as a
5925      different form than a SUPER. Turn THIS into something symbolic */
5926   if (TREE_CODE (primary) == THIS_EXPR)
5927     {
5928       wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0);
5929       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
5930       wfl = make_qualified_name (wfl, right, location);
5931       PRIMARY_P (wfl) = 1;
5932       return wfl;
5933     }
5934   /* Other non WFL node are wrapped around a WFL */
5935   else if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
5936     {
5937       wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
5938       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
5939       EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (primary, NULL_TREE);
5940     }
5941   else
5942     {
5943       wfl = primary;
5944       if (!EXPR_WFL_QUALIFICATION (primary))
5945         EXPR_WFL_QUALIFICATION (primary) =
5946           build_tree_list (primary, NULL_TREE);
5947     }
5948
5949   EXPR_WFL_LINECOL (right) = location;
5950   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
5951   PRIMARY_P (wfl) =  1;
5952   return wfl;
5953 }
5954
5955 /* Simple merge of two name separated by a `.' */
5956
5957 static tree
5958 merge_qualified_name (left, right)
5959      tree left, right;
5960 {
5961   tree node;
5962   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
5963                 IDENTIFIER_LENGTH (left));
5964   obstack_1grow (&temporary_obstack, '.');
5965   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
5966                  IDENTIFIER_LENGTH (right));
5967   node =  get_identifier (obstack_base (&temporary_obstack));
5968   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
5969   QUALIFIED_P (node) = 1;
5970   return node;
5971 }
5972
5973 /* Merge the two parts of a qualified name into LEFT.  Set the
5974    location information of the resulting node to LOCATION, usually
5975    inherited from the location information of the `.' operator. */
5976
5977 static tree
5978 make_qualified_name (left, right, location)
5979      tree left, right;
5980      int location;
5981 {
5982 #ifdef USE_COMPONENT_REF
5983   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
5984   EXPR_WFL_LINECOL (node) = location;
5985   return node;
5986 #else
5987   tree left_id = EXPR_WFL_NODE (left);
5988   tree right_id = EXPR_WFL_NODE (right);
5989   tree wfl, merge;
5990
5991   merge = merge_qualified_name (left_id, right_id);
5992
5993   /* Left wasn't qualified and is now qualified */
5994   if (!QUALIFIED_P (left_id))
5995     {
5996       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
5997       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
5998       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
5999     }
6000
6001   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
6002   EXPR_WFL_LINECOL (wfl) = location;
6003   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
6004
6005   EXPR_WFL_NODE (left) = merge;
6006   return left;
6007 #endif
6008 }
6009
6010 /* Extract the last identifier component of the qualified in WFL. The
6011    last identifier is removed from the linked list */
6012
6013 static tree
6014 cut_identifier_in_qualified (wfl)
6015      tree wfl;
6016 {
6017   tree q;
6018   tree previous = NULL_TREE;
6019   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
6020     if (!TREE_CHAIN (q))
6021       {
6022         if (!previous)
6023           fatal ("Operating on a non qualified qualified WFL - "
6024                  "cut_identifier_in_qualified");
6025         TREE_CHAIN (previous) = NULL_TREE;
6026         return TREE_PURPOSE (q);
6027       }
6028 }
6029
6030 /* Resolve the expression name NAME. Return its decl.  */
6031
6032 static tree
6033 resolve_expression_name (id, orig)
6034      tree id;
6035      tree *orig;
6036 {
6037   tree name = EXPR_WFL_NODE (id);
6038   tree decl;
6039
6040   /* 6.5.5.1: Simple expression names */
6041   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
6042     {
6043       /* 15.13.1: NAME can appear within the scope of a local variable
6044          declaration */
6045       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
6046         return decl;
6047
6048       /* 15.13.1: NAME can appear within a class declaration */
6049       else
6050         {
6051           decl = lookup_field_wrapper (current_class, name);
6052           if (decl)
6053             {
6054               int fs = FIELD_STATIC (decl);
6055               /* Instance variable (8.3.1.1) can't appear within
6056                  static method, static initializer or initializer for
6057                  a static variable. */
6058               if (!fs && METHOD_STATIC (current_function_decl))
6059                 {
6060                   parse_error_context
6061                     (id, "Can't make a static reference to nonstatic variable "
6062                      "`%s' in class `%s'",
6063                      IDENTIFIER_POINTER (name),
6064                      IDENTIFIER_POINTER (DECL_NAME
6065                                          (TYPE_NAME (current_class))));
6066                   return error_mark_node;
6067                 }
6068               /* Instance variables can't appear as an argument of
6069                  an explicit constructor invocation */
6070               if (!fs && ctxp->explicit_constructor_p)
6071                 {
6072                   parse_error_context
6073                     (id, "Can't reference `%s' before the superclass "
6074                      "constructor has been called", IDENTIFIER_POINTER (name));
6075                   return error_mark_node;
6076                 }
6077
6078               /* Otherwise build what it takes to access the field */
6079               decl = build_field_ref ((fs ? NULL_TREE : current_this),
6080                                       current_class, name);
6081               if (fs && !flag_emit_class_files)
6082                 decl = build_class_init (current_class, decl);
6083               /* We may be asked to save the real field access node */
6084               if (orig)
6085                 *orig = decl;
6086               /* And we return what we got */
6087               return decl;
6088             }
6089           /* Fall down to error report on undefined variable */
6090         }
6091     }
6092   /* 6.5.5.2 Qualified Expression Names */
6093   else
6094     {
6095       if (orig)
6096         *orig = NULL_TREE;
6097       qualify_ambiguous_name (id);
6098       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
6099       /* 15.10.2: Accessing Superclass Members using super */
6100       return resolve_field_access (id, NULL, NULL);
6101     }
6102
6103   /* We've got an error here */
6104   parse_error_context (id, "Undefined variable `%s'",
6105                        IDENTIFIER_POINTER (name));
6106
6107   return error_mark_node;
6108 }
6109
6110 /* 15.10.1 Field Acess Using a Primary and/or Expression Name.
6111    We return something suitable to generate the field access. We also
6112    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
6113    recipient's address can be null. */
6114
6115 static tree
6116 resolve_field_access (qual_wfl, field_decl, field_type)
6117      tree qual_wfl;
6118      tree *field_decl, *field_type;
6119 {
6120   int is_static = 0;
6121   tree field_ref;
6122   tree decl, where_found, type_found;
6123
6124   if (resolve_qualified_expression_name (qual_wfl, &decl,
6125                                          &where_found, &type_found))
6126     return error_mark_node;
6127
6128   /* Resolve the LENGTH field of an array here */
6129   if (DECL_NAME (decl) == length_identifier_node && TYPE_ARRAY_P (type_found)
6130       && ! flag_emit_class_files)
6131     {
6132       tree length = build_java_array_length_access (where_found);
6133       field_ref =
6134         build_java_arraynull_check (type_found, length, int_type_node);
6135     }
6136   /* We might have been trying to resolve field.method(). In which
6137      case, the resolution is over and decl is the answer */
6138   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
6139     field_ref = decl;
6140   else if (JDECL_P (decl))
6141     {
6142       int static_final_found = 0;
6143       if (!type_found)
6144         type_found = DECL_CONTEXT (decl);
6145       is_static = JDECL_P (decl) && FIELD_STATIC (decl);
6146       if (FIELD_FINAL (decl)
6147           && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))
6148           && DECL_LANG_SPECIFIC (decl)
6149           && DECL_INITIAL (decl))
6150         {
6151           field_ref = DECL_INITIAL (decl);
6152           static_final_found = 1;
6153         }
6154       else
6155         field_ref = build_field_ref ((is_static ? NULL_TREE : where_found),
6156                                      type_found, DECL_NAME (decl));
6157       if (field_ref == error_mark_node)
6158         return error_mark_node;
6159       if (is_static && !static_final_found && !flag_emit_class_files)
6160         {
6161           field_ref = build_class_init (type_found, field_ref);
6162           /* If the static field was identified by an expression that
6163              needs to be generated, make the field access a compound
6164              expression whose first part of the evaluation of the
6165              field selector part. */
6166           if (where_found && TREE_CODE (where_found) != TYPE_DECL
6167               && TREE_CODE (where_found) != RECORD_TYPE)
6168             {
6169               tree type = QUAL_DECL_TYPE (field_ref);
6170               field_ref = build (COMPOUND_EXPR, type, where_found, field_ref);
6171             }
6172         }
6173     }
6174   else
6175     field_ref = decl;
6176
6177   if (field_decl)
6178     *field_decl = decl;
6179   if (field_type)
6180     *field_type = (QUAL_DECL_TYPE (decl) ?
6181                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
6182   return field_ref;
6183 }
6184
6185 /* If NODE is an access to f static field, strip out the class
6186    initialization part and return the field decl, otherwise, return
6187    NODE. */
6188
6189 static tree
6190 strip_out_static_field_access_decl (node)
6191     tree node;
6192 {
6193   if (TREE_CODE (node) == COMPOUND_EXPR)
6194     {
6195       tree op1 = TREE_OPERAND (node, 1);
6196       if (TREE_CODE (op1) == COMPOUND_EXPR)
6197          {
6198            tree call = TREE_OPERAND (op1, 0);
6199            if (TREE_CODE (call) == CALL_EXPR
6200                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
6201                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
6202                == soft_initclass_node)
6203              return TREE_OPERAND (op1, 1);
6204          }
6205     }
6206   return node;
6207 }
6208
6209 /* 6.5.5.2: Qualified Expression Names */
6210
6211 static int
6212 resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
6213      tree wfl;
6214      tree *found_decl, *type_found, *where_found;
6215 {
6216   int from_type = 0;            /* Field search initiated from a type */
6217   int from_super = 0, from_cast = 0;
6218   int previous_call_static = 0;
6219   int is_static;
6220   tree decl = NULL_TREE, type = NULL_TREE, q;
6221   *type_found = *where_found = NULL_TREE;
6222
6223   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
6224     {
6225       tree qual_wfl = QUAL_WFL (q);
6226
6227       /* 15.10.1 Field Access Using a Primary */
6228       switch (TREE_CODE (qual_wfl))
6229         {
6230         case CALL_EXPR:
6231         case NEW_CLASS_EXPR:
6232           /* If the access to the function call is a non static field,
6233              build the code to access it. */
6234           if (JDECL_P (decl) && !FIELD_STATIC (decl))
6235             {
6236               decl = maybe_access_field (decl, *where_found,
6237                                          DECL_CONTEXT (decl));
6238               if (decl == error_mark_node)
6239                 return 1;
6240             }
6241           /* And code for the function call */
6242           if (complete_function_arguments (qual_wfl))
6243             return 1;
6244           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
6245             CALL_USING_SUPER (qual_wfl) = 1;
6246           *where_found =
6247             patch_method_invocation (qual_wfl, decl, type, &is_static, NULL);
6248           if (*where_found == error_mark_node)
6249             return 1;
6250           *type_found = type = QUAL_DECL_TYPE (*where_found);
6251
6252           /* If the previous call was static and this one is too,
6253              build a compound expression to hold the two (because in
6254              that case, previous function calls aren't transported as
6255              forcoming function's argument. */
6256           if (previous_call_static && is_static)
6257             {
6258               decl = build (COMPOUND_EXPR, type, decl, *where_found);
6259               TREE_SIDE_EFFECTS (decl) = 1;
6260             }
6261           else
6262             {
6263               previous_call_static = is_static;
6264               decl = *where_found;
6265             }
6266           continue;
6267
6268         case NEW_ARRAY_EXPR:
6269           *where_found = decl = java_complete_tree (qual_wfl);
6270           if (decl == error_mark_node)
6271             return 1;
6272           *type_found = type = QUAL_DECL_TYPE (decl);
6273           CLASS_LOADED_P (type) = 1;
6274           continue;
6275
6276         case CONVERT_EXPR:
6277           *where_found = decl = java_complete_tree (qual_wfl);
6278           if (decl == error_mark_node)
6279             return 1;
6280           *type_found = type = QUAL_DECL_TYPE (decl);
6281           from_cast = 1;
6282           continue;
6283
6284         case CONDITIONAL_EXPR:
6285         case STRING_CST:
6286           *where_found = decl = java_complete_tree (qual_wfl);
6287           if (decl == error_mark_node)
6288             return 1;
6289           *type_found = type = QUAL_DECL_TYPE (decl);
6290           continue;
6291
6292         case ARRAY_REF:
6293           /* If the access to the function call is a non static field,
6294              build the code to access it. */
6295           if (JDECL_P (decl) && !FIELD_STATIC (decl))
6296             {
6297               decl = maybe_access_field (decl, *where_found, type);
6298               if (decl == error_mark_node)
6299                 return 1;
6300             }
6301           /* And code for the array reference expression */
6302           decl = java_complete_tree (qual_wfl);
6303           if (decl == error_mark_node)
6304             return 1;
6305           type = QUAL_DECL_TYPE (decl);
6306           continue;
6307
6308         default:
6309           /* Fix for -Wall Just go to the next statement. Don't
6310              continue */
6311         }
6312
6313       /* If we fall here, we weren't processing a (static) function call. */
6314       previous_call_static = 0;
6315
6316       /* It can be the keyword THIS */
6317       if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
6318         {
6319           if (!current_this)
6320             {
6321               parse_error_context
6322                 (wfl, "Keyword `this' used outside allowed context");
6323               return 1;
6324             }
6325           /* We have to generate code for intermediate acess */
6326           *where_found = decl = current_this;
6327           *type_found = type = QUAL_DECL_TYPE (decl);
6328           continue;
6329         }
6330
6331       /* 15.10.2 Accessing Superclass Members using SUPER */
6332       if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
6333         {
6334           tree node;
6335           /* Check on the restricted use of SUPER */
6336           if (METHOD_STATIC (current_function_decl)
6337               || current_class == object_type_node)
6338             {
6339               parse_error_context
6340                 (wfl, "Keyword `super' used outside allowed context");
6341               return 1;
6342             }
6343           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
6344           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
6345                              CLASSTYPE_SUPER (current_class),
6346                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
6347           *where_found = decl = java_complete_tree (node);
6348           if (decl == error_mark_node)
6349             return 1;
6350           *type_found = type = QUAL_DECL_TYPE (decl);
6351           from_super = from_type = 1;
6352           continue;
6353         }
6354
6355       /* 15.13.1: Can't search for field name in packages, so we
6356          assume a variable/class name was meant. */
6357       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
6358         {
6359           tree name = resolve_package (wfl, &q);
6360           if (name)
6361             {
6362               *where_found = decl = resolve_no_layout (name, qual_wfl);
6363               /* We wan't to be absolutely that the class is laid
6364                  out. We're going to search something inside it. */
6365               *type_found = type = TREE_TYPE (decl);
6366               layout_class (type);
6367               from_type = 1;
6368               /* Should be a list, really. FIXME */
6369               RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 1;
6370               RESOLVE_PACKAGE_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 0;
6371             }
6372           else
6373             {
6374               if (from_super || from_cast)
6375                 parse_error_context
6376                   ((from_cast ? qual_wfl : wfl),
6377                    "No variable `%s' defined in class `%s'",
6378                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
6379                    lang_printable_name (type, 0));
6380               else
6381                 parse_error_context
6382                   (qual_wfl, "Undefined variable or class name: `%s'",
6383                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
6384               return 1;
6385             }
6386         }
6387
6388       /* We have a type name. It's been already resolved when the
6389          expression was qualified. */
6390       else if (RESOLVE_TYPE_NAME_P (qual_wfl))
6391         {
6392           if (!(decl = QUAL_RESOLUTION (q)))
6393             return 1;           /* Error reported already */
6394
6395           if (not_accessible_p (TREE_TYPE (decl), decl, 0))
6396             {
6397               parse_error_context
6398                 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
6399                  java_accstring_lookup (get_access_flags_from_decl (decl)),
6400                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))),
6401                  IDENTIFIER_POINTER (DECL_NAME (decl)),
6402                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
6403               return 1;
6404             }
6405           check_deprecation (qual_wfl, decl);
6406
6407           type = TREE_TYPE (decl);
6408           from_type = 1;
6409         }
6410       /* We resolve and expression name */
6411       else
6412         {
6413           tree field_decl;
6414
6415           /* If there exists an early resolution, use it. That occurs
6416              only once and we know that there are more things to
6417              come. Don't do that when processing something after SUPER
6418              (we need more thing to be put in place below */
6419           if (!from_super && QUAL_RESOLUTION (q))
6420             {
6421               decl = QUAL_RESOLUTION (q);
6422               if (!type)
6423                 {
6424                   if (!FIELD_STATIC (decl))
6425                     *where_found = current_this;
6426                   else
6427                     {
6428                       *where_found = TREE_TYPE (decl);
6429                       if (TREE_CODE (*where_found) == POINTER_TYPE)
6430                         *where_found = TREE_TYPE (*where_found);
6431                     }
6432                 }
6433             }
6434
6435           /* We have to search for a field, knowing the type of its
6436              container. The flag FROM_TYPE indicates that we resolved
6437              the last member of the expression as a type name, which
6438              means that for the resolution of this field, we'll look
6439              for other errors than if it was resolved as a member of
6440              an other field. */
6441           else
6442             {
6443               int is_static;
6444               tree field_decl_type; /* For layout */
6445
6446               if (!from_type && !JREFERENCE_TYPE_P (type))
6447                 {
6448                   parse_error_context
6449                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
6450                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
6451                      lang_printable_name (type, 0),
6452                      IDENTIFIER_POINTER (DECL_NAME (field_decl)));
6453                   return 1;
6454                 }
6455
6456               field_decl = lookup_field_wrapper (type,
6457                                                  EXPR_WFL_NODE (qual_wfl));
6458               if (field_decl == NULL_TREE)
6459                 {
6460                   parse_error_context
6461                     (qual_wfl, "No variable `%s' defined in class `%s'",
6462                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
6463                      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
6464                   return 1;
6465                 }
6466               if (field_decl == error_mark_node)
6467                 return 1;
6468
6469               /* Layout the type of field_decl, since we may need
6470                  it. Don't do primitive types or loaded classes. The
6471                  situation of non primitive arrays may not handled
6472                  properly here. FIXME */
6473               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
6474                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
6475               else
6476                 field_decl_type = TREE_TYPE (field_decl);
6477               if (!JPRIMITIVE_TYPE_P (field_decl_type)
6478                   && !CLASS_LOADED_P (field_decl_type)
6479                   && !TYPE_ARRAY_P (field_decl_type))
6480                 resolve_and_layout (field_decl_type, NULL_TREE);
6481               if (TYPE_ARRAY_P (field_decl_type))
6482                 CLASS_LOADED_P (field_decl_type) = 1;
6483
6484               /* Check on accessibility here */
6485               if (not_accessible_p (type, field_decl, from_super))
6486                 {
6487                   parse_error_context
6488                     (qual_wfl,
6489                      "Can't access %s field `%s.%s' from `%s'",
6490                      java_accstring_lookup
6491                        (get_access_flags_from_decl (field_decl)),
6492                      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))),
6493                      IDENTIFIER_POINTER (DECL_NAME (field_decl)),
6494                      IDENTIFIER_POINTER
6495                        (DECL_NAME (TYPE_NAME (current_class))));
6496                   return 1;
6497                 }
6498               check_deprecation (qual_wfl, field_decl);
6499
6500               /* There are things to check when fields are accessed
6501                  from type. There are no restrictions on a static
6502                  declaration of the field when it is accessed from an
6503                  interface */
6504               is_static = FIELD_STATIC (field_decl);
6505               if (!from_super && from_type
6506                   && !TYPE_INTERFACE_P (type) && !is_static)
6507                 {
6508                   parse_error_context
6509                     (qual_wfl, "Can't make a static reference to nonstatic "
6510                      "variable `%s' in class `%s'",
6511                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
6512                      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
6513                   return 1;
6514                 }
6515               from_cast = from_super = 0;
6516
6517               /* If we need to generate something to get a proper
6518                  handle on what this field is accessed from, do it
6519                  now. */
6520               if (!is_static)
6521                 {
6522                   decl = maybe_access_field (decl, *where_found, *type_found);
6523                   if (decl == error_mark_node)
6524                     return 1;
6525                 }
6526
6527               /* We want to keep the location were found it, and the type
6528                  we found. */
6529               *where_found = decl;
6530               *type_found = type;
6531
6532               /* This is the decl found and eventually the next one to
6533                  search from */
6534               decl = field_decl;
6535             }
6536           from_type = 0;
6537           type = QUAL_DECL_TYPE (decl);
6538         }
6539     }
6540   *found_decl = decl;
6541   return 0;
6542 }
6543
6544 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
6545    can't be accessed from REFERENCE (a record type). */
6546
6547 int not_accessible_p (reference, member, from_super)
6548      tree reference, member;
6549      int from_super;
6550 {
6551   int access_flag = get_access_flags_from_decl (member);
6552
6553   /* Access always granted for members declared public */
6554   if (access_flag & ACC_PUBLIC)
6555     return 0;
6556
6557   /* Check access on protected members */
6558   if (access_flag & ACC_PROTECTED)
6559     {
6560       /* Access granted if it occurs from within the package
6561          containing the class in which the protected member is
6562          declared */
6563       if (class_in_current_package (DECL_CONTEXT (member)))
6564         return 0;
6565
6566       /* If accessed with the form `super.member', then access is granted */
6567       if (from_super)
6568         return 0;
6569
6570       /* Otherwise, access is granted if occuring from the class where
6571          member is declared or a subclass of it */
6572       if (inherits_from_p (reference, current_class))
6573         return 0;
6574       return 1;
6575     }
6576
6577   /* Check access on private members. Access is granted only if it
6578      occurs from within the class in witch it is declared */
6579   if (access_flag & ACC_PRIVATE)
6580     return (current_class == DECL_CONTEXT (member) ? 0 : 1);
6581
6582   /* Default access are permitted only when occuring within the
6583      package in which the type (REFERENCE) is declared. In other words,
6584      REFERENCE is defined in the current package */
6585   if (ctxp->package)
6586     return !class_in_current_package (reference);
6587
6588   /* Otherwise, access is granted */
6589   return 0;
6590 }
6591
6592 /* Test deprecated decl access.  */
6593 static void
6594 check_deprecation (wfl, decl)
6595      tree wfl, decl;
6596 {
6597   char *file = DECL_SOURCE_FILE (decl);
6598   /* Complain if the field is deprecated and the file it was defined
6599      in isn't compiled at the same time the file which contains its
6600      use is */
6601   if (DECL_DEPRECATED (decl)
6602       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
6603     {
6604       char the [20];
6605       switch (TREE_CODE (decl))
6606         {
6607         case FUNCTION_DECL:
6608           strcpy (the, "method");
6609           break;
6610         case FIELD_DECL:
6611           strcpy (the, "field");
6612           break;
6613         case TYPE_DECL:
6614           strcpy (the, "class");
6615           break;
6616         default:
6617           fatal ("unexpected DECL code - check_deprecation");
6618         }
6619       parse_warning_context
6620         (wfl, "The %s `%s' in class `%s' has been deprecated",
6621          the, lang_printable_name (decl, 0),
6622          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
6623     }
6624 }
6625
6626 /* Returns 1 if class was declared in the current package, 0 otherwise */
6627
6628 static int
6629 class_in_current_package (class)
6630      tree class;
6631 {
6632   static tree cache = NULL_TREE;
6633   int qualified_flag;
6634   tree left;
6635
6636   if (cache == class)
6637     return 1;
6638
6639   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
6640
6641   /* If the current package is empty and the name of CLASS is
6642      qualified, class isn't in the current package.  If there is a
6643      current package and the name of the CLASS is not qualified, class
6644      isn't in the current package */
6645   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
6646     return 0;
6647
6648   /* If there is not package and the name of CLASS isn't qualified,
6649      they belong to the same unnamed package */
6650   if (!ctxp->package && !qualified_flag)
6651     return 1;
6652
6653   /* Compare the left part of the name of CLASS with the package name */
6654   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
6655   if (ctxp->package == left)
6656     {
6657       cache = class;
6658       return 1;
6659     }
6660   return 0;
6661 }
6662
6663 /* This function may generate code to access DECL from WHERE. This is
6664    done only if certain conditions meet.  */
6665
6666 static tree
6667 maybe_access_field (decl, where, type)
6668   tree decl, where, type;
6669 {
6670   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
6671       && !FIELD_STATIC (decl))
6672     decl = build_field_ref (where ? where : current_this,
6673                             (type ? type : DECL_CONTEXT (decl)),
6674                             DECL_NAME (decl));
6675   return decl;
6676 }
6677
6678 /* Build a method invocation, by patching PATCH. If non NULL
6679    and according to the situation, PRIMARY and WHERE may be
6680    used. IS_STATIC is set to 1 if the invoked function is static. */
6681
6682 static tree
6683 patch_method_invocation (patch, primary, where, is_static, ret_decl)
6684      tree patch, primary, where;
6685      int *is_static;
6686      tree *ret_decl;
6687 {
6688   tree wfl = TREE_OPERAND (patch, 0);
6689   tree args = TREE_OPERAND (patch, 1);
6690   tree name = EXPR_WFL_NODE (wfl);
6691   tree list;
6692   int is_static_flag = 0;
6693   int is_super_init = 0;
6694   tree this_arg = NULL_TREE;
6695
6696   /* Should be overriden if everything goes well. Otherwise, if
6697      something fails, it should keep this value. It stop the
6698      evaluation of a bogus assignment. See java_complete_tree,
6699      MODIFY_EXPR: for the reasons why we sometimes want to keep on
6700      evaluating an assignment */
6701   TREE_TYPE (patch) = error_mark_node;
6702
6703   /* Since lookup functions are messing with line numbers, save the
6704      context now.  */
6705   java_parser_context_save_global ();
6706
6707   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
6708
6709   /* Resolution of qualified name, excluding constructors */
6710   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
6711     {
6712       tree class_decl, identifier, identifier_wfl;
6713       /* Extract the last IDENTIFIER of the qualified
6714          expression. This is a wfl and we will use it's location
6715          data during error report. */
6716       identifier_wfl = cut_identifier_in_qualified (wfl);
6717       identifier = EXPR_WFL_NODE (identifier_wfl);
6718
6719       /* Given the context, IDENTIFIER is syntactically qualified
6720          as a MethodName. We need to qualify what's before */
6721       qualify_ambiguous_name (wfl);
6722
6723       /* Package resolution are erroneous */
6724       if (RESOLVE_PACKAGE_NAME_P (wfl))
6725         {
6726           tree remainder;
6727           breakdown_qualified (&remainder, NULL, EXPR_WFL_NODE (wfl));
6728           parse_error_context (wfl, "Can't search method `%s' in package "
6729                                "`%s'",IDENTIFIER_POINTER (identifier),
6730                                IDENTIFIER_POINTER (remainder));
6731           PATCH_METHOD_RETURN_ERROR ();
6732         }
6733       /* We're resolving a call from a type */
6734       else if (RESOLVE_TYPE_NAME_P (wfl))
6735         {
6736           tree decl = QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl));
6737           tree name = DECL_NAME (decl);
6738           tree type;
6739
6740           class_decl = resolve_and_layout (name, wfl);
6741           if (CLASS_INTERFACE (decl))
6742             {
6743               parse_error_context
6744                 (identifier_wfl, "Can't make static reference to method "
6745                  "`%s' in interface `%s'", IDENTIFIER_POINTER (identifier),
6746                  IDENTIFIER_POINTER (name));
6747               PATCH_METHOD_RETURN_ERROR ();
6748             }
6749           /* Look the method up in the type selector. The method ought
6750              to be static. */
6751           type = TREE_TYPE (class_decl);
6752           list = lookup_method_invoke (0, wfl, type, identifier, args);
6753           if (list && !METHOD_STATIC (list))
6754             {
6755               char *fct_name = strdup (lang_printable_name (list, 0));
6756               parse_error_context
6757                 (identifier_wfl,
6758                  "Can't make static reference to method `%s %s' in class `%s'",
6759                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
6760                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
6761               free (fct_name);
6762               PATCH_METHOD_RETURN_ERROR ();
6763             }
6764           args = nreverse (args);
6765         }
6766       /* We're resolving an expression name */
6767       else
6768         {
6769           tree field, type;
6770
6771           /* 1- Find the field to which the call applies */
6772           field = resolve_field_access (wfl, NULL, &type);
6773           if (field == error_mark_node)
6774             PATCH_METHOD_RETURN_ERROR ();
6775           /* field is used in lieu of a primary. It alows us not to
6776            report errors on erroneous use of `this' in
6777            constructors. */
6778           primary = field;
6779
6780           /* 2- Do the layout of the class where the last field
6781              was found, so we can search it. */
6782           class_decl = resolve_and_layout (type, NULL_TREE);
6783           if (class_decl != NULL_TREE)
6784           type = TREE_TYPE (class_decl);
6785
6786           /* 3- Retrieve a filtered list of method matches, Refine
6787              if necessary. In any cases, point out errors.  */
6788           list = lookup_method_invoke (0, identifier_wfl, type,
6789                                        identifier, args);
6790
6791           /* 4- Add the field as an argument */
6792           args = nreverse (args);
6793           this_arg = field;
6794         }
6795
6796       /* IDENTIFIER_WFL will be used to report any problem further */
6797       wfl = identifier_wfl;
6798     }
6799   /* Resolution of simple names, names generated after a primary: or
6800      constructors */
6801   else
6802     {
6803       tree class_to_search;
6804       int lc;           /* Looking for Constructor */
6805
6806       /* We search constructor in their target class */
6807       if (CALL_CONSTRUCTOR_P (patch))
6808         {
6809           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
6810             class_to_search = EXPR_WFL_NODE (wfl);
6811           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
6812                    this_identifier_node)
6813             class_to_search = NULL_TREE;
6814           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
6815                    super_identifier_node)
6816             {
6817               is_super_init = 1;
6818               if (CLASSTYPE_SUPER (current_class))
6819                 class_to_search =
6820                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
6821               else
6822                 {
6823                   parse_error_context (wfl, "Can't invoke super constructor "
6824                                        "on java.lang.Object");
6825                   PATCH_METHOD_RETURN_ERROR ();
6826                 }
6827             }
6828
6829           /* Class to search is NULL if we're searching the current one */
6830           if (class_to_search)
6831             {
6832               class_to_search = resolve_and_layout (class_to_search,
6833                                                     NULL_TREE);
6834               if (!class_to_search)
6835                 {
6836                   parse_error_context
6837                     (wfl, "Class `%s' not found in type declaration",
6838                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
6839                   PATCH_METHOD_RETURN_ERROR ();
6840                 }
6841
6842               /* Can't instantiate an abstract class, but we can
6843                  invoke it's constructor. It's use within the `new'
6844                  context is denied here. */
6845               if (CLASS_ABSTRACT (class_to_search)
6846                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
6847                 {
6848                   parse_error_context
6849                     (wfl, "Class `%s' is an abstract class. It can't be "
6850                      "instantiated", IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
6851                   PATCH_METHOD_RETURN_ERROR ();
6852                 }
6853               class_to_search = TREE_TYPE (class_to_search);
6854             }
6855           else
6856             class_to_search = current_class;
6857           lc = 1;
6858         }
6859       /* This is a regular search in the local class, unless an
6860          alternate class is specified. */
6861       else
6862         {
6863           class_to_search = (where ? where : current_class);
6864           lc = 0;
6865         }
6866
6867       /* NAME is a simple identifier or comes from a primary. Search
6868          in the class whose declaration contain the method being
6869          invoked. */
6870       resolve_and_layout (class_to_search, NULL_TREE);
6871       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
6872
6873       /* Don't continue if no method were found, as the next statement
6874          can't be executed then. */
6875       if (!list)
6876         PATCH_METHOD_RETURN_ERROR ();
6877
6878       /* Check for static reference if non static methods */
6879       if (check_for_static_method_reference (wfl, patch, list,
6880                                              class_to_search, primary))
6881         PATCH_METHOD_RETURN_ERROR ();
6882
6883       /* Non static methods are called with the current object extra
6884          argument. If patch a `new TYPE()', the argument is the value
6885          returned by the object allocator. If method is resolved as a
6886          primary, use the primary otherwise use the current THIS. */
6887       args = nreverse (args);
6888       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
6889         this_arg = primary ? primary : current_this;
6890     }
6891
6892   /* Merge point of all resolution schemes. If we have nothing, this
6893      is an error, already signaled */
6894   if (!list)
6895     PATCH_METHOD_RETURN_ERROR ();
6896
6897   /* Check accessibility, position the is_static flag, build and
6898      return the call */
6899   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0))
6900     {
6901       char *fct_name = strdup (lang_printable_name (list, 0));
6902       parse_error_context
6903         (wfl, "Can't access %s method `%s %s.%s' from `%s'",
6904          java_accstring_lookup (get_access_flags_from_decl (list)),
6905          lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
6906          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))),
6907          fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
6908       free (fct_name);
6909       PATCH_METHOD_RETURN_ERROR ();
6910     }
6911   check_deprecation (wfl, list);
6912
6913   is_static_flag = METHOD_STATIC (list);
6914   if (! METHOD_STATIC (list) && this_arg != NULL_TREE)
6915     args = tree_cons (NULL_TREE, this_arg, args);
6916
6917   /* In the context of an explicit constructor invocation, we can't
6918      invoke any method relying on `this'. Exceptions are: we're
6919      invoking a static function, primary exists and is not the current
6920      this, we're creating a new object. */
6921   if (ctxp->explicit_constructor_p
6922       && !is_static_flag
6923       && (!primary || primary == current_this)
6924       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
6925     {
6926       parse_error_context
6927         (wfl, "Can't reference `this' before the superclass constructor has "
6928          "been called");
6929       PATCH_METHOD_RETURN_ERROR ();
6930     }
6931   java_parser_context_restore_global ();
6932   if (is_static)
6933     *is_static = is_static_flag;
6934   /* Sometimes, we want the decl of the selected method. Such as for
6935      EH checking */
6936   if (ret_decl)
6937     *ret_decl = list;
6938   patch = patch_invoke (patch, list, args);
6939   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
6940     {
6941       /* Generate the code used to initialize fields declared with an
6942          initialization statement. For now, it returns a call the the
6943          artificial function $finit$, if required. */
6944
6945       tree finit_call =
6946         build_method_invocation (build_expr_wfl (finit_identifier_node,
6947                                                  input_filename, 0, 0),
6948                                  NULL_TREE);
6949       patch = build (COMPOUND_EXPR, void_type_node, patch,
6950                      java_complete_tree (finit_call));
6951       CAN_COMPLETE_NORMALLY (patch) = 1;
6952     }
6953   return patch;
6954 }
6955
6956 /* Check that we're not trying to do a static reference to a method in
6957    non static method. Return 1 if it's the case, 0 otherwise. */
6958
6959 static int
6960 check_for_static_method_reference (wfl, node, method, where, primary)
6961      tree wfl, node, method, where, primary;
6962 {
6963   if (METHOD_STATIC (current_function_decl)
6964       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
6965     {
6966       char *fct_name = strdup (lang_printable_name (method, 0));
6967       parse_error_context
6968         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
6969          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
6970          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
6971       free (fct_name);
6972       return 1;
6973     }
6974   return 0;
6975 }
6976
6977 /* Patch an invoke expression METHOD and ARGS, based on its invocation
6978    mode.  */
6979
6980 static tree
6981 patch_invoke (patch, method, args)
6982      tree patch, method, args;
6983 {
6984   tree dtable, func;
6985   tree original_call, t, ta;
6986
6987   /* Last step for args: convert build-in types. If we're dealing with
6988      a new TYPE() type call, the first argument to the constructor
6989      isn't found in the incomming argument list, but delivered by
6990      `new' */
6991   t = TYPE_ARG_TYPES (TREE_TYPE (method));
6992   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
6993     t = TREE_CHAIN (t);
6994   for (ta = args; t != end_params_node && ta;
6995        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
6996     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
6997         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
6998       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
6999
7000   if (flag_emit_class_files)
7001     func = method;
7002   else
7003     {
7004       tree signature = build_java_signature (TREE_TYPE (method));
7005       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
7006         {
7007         case INVOKE_VIRTUAL:
7008           dtable = invoke_build_dtable (0, args);
7009           func = build_invokevirtual (dtable, method);
7010           break;
7011
7012         case INVOKE_SUPER:
7013         case INVOKE_STATIC:
7014           func = build_known_method_ref (method, TREE_TYPE (method),
7015                                          DECL_CONTEXT (method),
7016                                          signature, args);
7017           break;
7018
7019         case INVOKE_INTERFACE:
7020           dtable = invoke_build_dtable (1, args);
7021           func = build_invokeinterface (dtable, DECL_NAME (method), signature);
7022           break;
7023
7024         default:
7025           fatal ("internal error - unknown invocation_mode result");
7026         }
7027
7028       /* Ensure self_type is initialized, (invokestatic). FIXME */
7029       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
7030     }
7031
7032   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
7033   TREE_OPERAND (patch, 0) = func;
7034   TREE_OPERAND (patch, 1) = args;
7035   original_call = patch;
7036
7037   /* We're processing a `new TYPE ()' form. New is called an its
7038      returned value is the first argument to the constructor. We build
7039      a COMPOUND_EXPR and use saved expression so that the overall NEW
7040      expression value is a pointer to a newly created and initialized
7041      class. */
7042   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
7043     {
7044       tree class = DECL_CONTEXT (method);
7045       tree c1, saved_new, size, new;
7046       if (flag_emit_class_files)
7047         {
7048           TREE_TYPE (patch) = build_pointer_type (class);
7049           return patch;
7050         }
7051       if (!TYPE_SIZE (class))
7052         safe_layout_class (class);
7053       size = size_in_bytes (class);
7054       new = build (CALL_EXPR, promote_type (class),
7055                    build_address_of (alloc_object_node),
7056                    tree_cons (NULL_TREE, build_class_ref (class),
7057                               build_tree_list (NULL_TREE,
7058                                                size_in_bytes (class))),
7059                    NULL_TREE);
7060       saved_new = save_expr (new);
7061       c1 = build_tree_list (NULL_TREE, saved_new);
7062       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
7063       TREE_OPERAND (original_call, 1) = c1;
7064       TREE_SET_CODE (original_call, CALL_EXPR);
7065       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
7066     }
7067   return patch;
7068 }
7069
7070 static int
7071 invocation_mode (method, super)
7072      tree method;
7073      int super;
7074 {
7075   int access = get_access_flags_from_decl (method);
7076
7077   if (super)
7078     return INVOKE_SUPER;
7079
7080   if (access & ACC_STATIC || access & ACC_FINAL || access & ACC_PRIVATE)
7081     return INVOKE_STATIC;
7082
7083   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
7084     return INVOKE_STATIC;
7085
7086   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
7087     return INVOKE_INTERFACE;
7088
7089   if (DECL_CONSTRUCTOR_P (method))
7090     return INVOKE_STATIC;
7091
7092   return INVOKE_VIRTUAL;
7093 }
7094
7095 /* Retrieve a refined list of matching methods. It covers the step
7096    15.11.2 (Compile-Time Step 2) */
7097
7098 static tree
7099 lookup_method_invoke (lc, cl, class, name, arg_list)
7100      int lc;
7101      tree cl;
7102      tree class, name, arg_list;
7103 {
7104   tree atl = end_params_node;           /* Arg Type List */
7105   tree method, signature, list, node;
7106   char *candidates;             /* Used for error report */
7107
7108   /* Fix the arguments */
7109   for (node = arg_list; node; node = TREE_CHAIN (node))
7110     {
7111       tree current_arg = TREE_TYPE (TREE_VALUE (node));
7112       /* Non primitive type may have to be resolved */
7113       if (!JPRIMITIVE_TYPE_P (current_arg))
7114         resolve_and_layout (current_arg, NULL_TREE);
7115       /* And promoted */
7116       if (TREE_CODE (current_arg) == RECORD_TYPE)
7117         current_arg = promote_type (current_arg);
7118       atl = tree_cons (NULL_TREE, current_arg, atl);
7119     }
7120
7121   /* Find all candidates and then refine the list, searching for the
7122      most specific method. */
7123   list = find_applicable_accessible_methods_list (lc, class, name, atl);
7124   list = find_most_specific_methods_list (list);
7125   if (list && !TREE_CHAIN (list))
7126     return TREE_VALUE (list);
7127
7128   /* Issue an error. List candidates if any. Candidates are listed
7129      only if accessible (non accessible methods may end-up here for
7130      the sake of a better error report). */
7131   candidates = NULL;
7132   if (list)
7133     {
7134       tree current;
7135       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
7136       for (current = list; current; current = TREE_CHAIN (current))
7137         {
7138           tree cm = TREE_VALUE (current);
7139           char string [4096];
7140           if (!cm || not_accessible_p (class, cm, 0))
7141             continue;
7142           sprintf
7143             (string, "  `%s' in `%s'%s",
7144              get_printable_method_name (cm),
7145              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
7146              (TREE_CHAIN (current) ? "\n" : ""));
7147           obstack_grow (&temporary_obstack, string, strlen (string));
7148         }
7149       obstack_1grow (&temporary_obstack, '\0');
7150       candidates = obstack_finish (&temporary_obstack);
7151     }
7152   /* Issue the error message */
7153   method = make_node (FUNCTION_TYPE);
7154   TYPE_ARG_TYPES (method) = atl;
7155   signature = build_java_argument_signature (method);
7156   parse_error_context (cl, "Can't find %s `%s(%s)' in class `%s'%s",
7157                        (lc ? "constructor" : "method"),
7158                        (lc ?
7159                         IDENTIFIER_POINTER(DECL_NAME (TYPE_NAME (class))) :
7160                         IDENTIFIER_POINTER (name)),
7161                        IDENTIFIER_POINTER (signature),
7162                        IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class))),
7163                        (candidates ? candidates : ""));
7164   return NULL_TREE;
7165 }
7166
7167 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
7168    when we're looking for a constructor. */
7169
7170 static tree
7171 find_applicable_accessible_methods_list (lc, class, name, arglist)
7172      int lc;
7173      tree class, name, arglist;
7174 {
7175   tree method;
7176   tree list = NULL_TREE, all_list = NULL_TREE;
7177
7178   while (class != NULL_TREE)
7179     {
7180       for (method = TYPE_METHODS (class);
7181            method != NULL_TREE;  method = TREE_CHAIN (method))
7182         {
7183           if (lc && !DECL_CONSTRUCTOR_P (method))
7184             continue;
7185           else if (!lc && (DECL_CONSTRUCTOR_P (method)
7186                            || (GET_METHOD_NAME (method) != name)))
7187             continue;
7188
7189           if (argument_types_convertible (method, arglist))
7190             {
7191               /* Retain accessible methods only */
7192               if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
7193                                      method, 0))
7194                 list = tree_cons (NULL_TREE, method, list);
7195               else
7196               /* Also retain all selected method here */
7197                 all_list = tree_cons (NULL_TREE, method, list);
7198             }
7199         }
7200       /* When dealing with constructor, stop here, otherwise search
7201          other classes */
7202       class = (lc ? NULL_TREE : CLASSTYPE_SUPER (class));
7203     }
7204   /* Either return the list obtained or all selected (but
7205      inaccessible) methods for better error report. */
7206   return (!list ? all_list : list);
7207 }
7208
7209 /* 15.11.2.2 Choose the Most Specific Method */
7210
7211 static tree
7212 find_most_specific_methods_list (list)
7213      tree list;
7214 {
7215   int max = 0;
7216   tree current, new_list = NULL_TREE;
7217   for (current = list; current; current = TREE_CHAIN (current))
7218     {
7219       tree method;
7220       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
7221
7222       for (method = list; method; method = TREE_CHAIN (method))
7223         {
7224           /* Don't test a method against itself */
7225           if (method == current)
7226             continue;
7227
7228           /* Compare arguments and location where method where declared */
7229           if (argument_types_convertible (TREE_VALUE (method),
7230                                           TREE_VALUE (current))
7231               && valid_method_invocation_conversion_p
7232                    (DECL_CONTEXT (TREE_VALUE (method)),
7233                     DECL_CONTEXT (TREE_VALUE (current))))
7234             {
7235               int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current));
7236               max = (v > max ? v : max);
7237             }
7238         }
7239     }
7240
7241   /* Review the list and select the maximally specific methods */
7242   for (current = list; current; current = TREE_CHAIN (current))
7243     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
7244       new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
7245
7246   /* If we can't find one, lower expectations and try to gather multiple
7247      maximally specific methods */
7248   while (!new_list)
7249     {
7250       while (--max > 0)
7251         {
7252           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
7253             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
7254         }
7255       return new_list;
7256     }
7257
7258   return new_list;
7259 }
7260
7261 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
7262    converted by method invocation conversion (5.3) to the type of the
7263    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
7264    to change less often than M1. */
7265
7266 static int
7267 argument_types_convertible (m1, m2_or_arglist)
7268     tree m1, m2_or_arglist;
7269 {
7270   static tree m2_arg_value = NULL_TREE;
7271   static tree m2_arg_cache = NULL_TREE;
7272
7273   register tree m1_arg, m2_arg;
7274
7275   m1_arg = TYPE_ARG_TYPES (TREE_TYPE (m1));
7276   if (!METHOD_STATIC (m1))
7277     m1_arg = TREE_CHAIN (m1_arg);
7278
7279   if (m2_arg_value == m2_or_arglist)
7280     m2_arg = m2_arg_cache;
7281   else
7282     {
7283       /* M2_OR_ARGLIST can be a function DECL or a raw list of
7284          argument types */
7285       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
7286         {
7287           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
7288           if (!METHOD_STATIC (m2_or_arglist))
7289             m2_arg = TREE_CHAIN (m2_arg);
7290         }
7291       else
7292         m2_arg = m2_or_arglist;
7293
7294       m2_arg_value = m2_or_arglist;
7295       m2_arg_cache = m2_arg;
7296     }
7297
7298   while (m1_arg != end_params_node && m2_arg != end_params_node)
7299     {
7300       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
7301       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
7302                                                  TREE_VALUE (m2_arg)))
7303         break;
7304       m1_arg = TREE_CHAIN (m1_arg);
7305       m2_arg = TREE_CHAIN (m2_arg);
7306     }
7307   return m1_arg == end_params_node && m2_arg == end_params_node;
7308 }
7309
7310 /* Qualification routines */
7311
7312 static void
7313 qualify_ambiguous_name (id)
7314      tree id;
7315 {
7316   tree qual, qual_wfl, name, decl, ptr_type, saved_current_class;
7317   int again, super_found = 0, this_found = 0, new_array_found = 0;
7318
7319   /* We first qualify the first element, then derive qualification of
7320      others based on the first one. If the first element is qualified
7321      by a resolution (field or type), this resolution is stored in the
7322      QUAL_RESOLUTION of the qual element being examined. We need to
7323      save the current_class since the use of SUPER might change the
7324      its value. */
7325   saved_current_class = current_class;
7326   qual = EXPR_WFL_QUALIFICATION (id);
7327   do {
7328
7329     /* Simple qualified expression feature a qual_wfl that is a
7330        WFL. Expression derived from a primary feature more complicated
7331        things like a CALL_EXPR. Expression from primary need to be
7332        worked out to extract the part on which the qualification will
7333        take place. */
7334     qual_wfl = QUAL_WFL (qual);
7335     switch (TREE_CODE (qual_wfl))
7336       {
7337       case CALL_EXPR:
7338         qual_wfl = TREE_OPERAND (qual_wfl, 0);
7339         if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
7340           {
7341             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
7342             qual_wfl = QUAL_WFL (qual);
7343           }
7344         break;
7345       case NEW_ARRAY_EXPR:
7346         qual = TREE_CHAIN (qual);
7347         new_array_found = again = 1;
7348         continue;
7349       case NEW_CLASS_EXPR:
7350       case CONVERT_EXPR:
7351         qual_wfl = TREE_OPERAND (qual_wfl, 0);
7352         break;
7353       case ARRAY_REF:
7354         while (TREE_CODE (qual_wfl) == ARRAY_REF)
7355           qual_wfl = TREE_OPERAND (qual_wfl, 0);
7356         break;
7357       default:
7358         /* Fix for -Wall. Just break doing nothing */
7359         break;
7360       }
7361     name = EXPR_WFL_NODE (qual_wfl);
7362     ptr_type = current_class;
7363     again = 0;
7364     /* If we have a THIS (from a primary), we set the context accordingly */
7365     if (name == this_identifier_node)
7366       {
7367         qual = TREE_CHAIN (qual);
7368         qual_wfl = QUAL_WFL (qual);
7369         if (TREE_CODE (qual_wfl) == CALL_EXPR)
7370           again = 1;
7371         else
7372           name = EXPR_WFL_NODE (qual_wfl);
7373         this_found = 1;
7374       }
7375     /* If we have a SUPER, we set the context accordingly */
7376     if (name == super_identifier_node)
7377       {
7378         current_class = CLASSTYPE_SUPER (ptr_type);
7379         /* Check that there is such a thing as a super class. If not,
7380            return.  The error will be caught later on, during the
7381            resolution */
7382         if (!current_class)
7383           {
7384             current_class = saved_current_class;
7385             return;
7386           }
7387         qual = TREE_CHAIN (qual);
7388         /* Do one more interation to set things up */
7389         super_found = again = 1;
7390       }
7391     /* Loop one more time if we're dealing with ?: or a string
7392        constant, or a convert expression */
7393     if (TREE_CODE (qual_wfl) == CONDITIONAL_EXPR
7394         || TREE_CODE (qual_wfl) == STRING_CST
7395         || TREE_CODE (qual_wfl) == CONVERT_EXPR)
7396       {
7397         qual = TREE_CHAIN (qual);
7398         qual_wfl = QUAL_WFL (qual);
7399         again = 1;
7400       }
7401   } while (again);
7402
7403   /* If name appears within the scope of a location variable
7404      declaration or parameter declaration, then it is an expression
7405      name. We don't carry this test out if we're in the context of the
7406      use of SUPER or THIS */
7407   if (!this_found && !super_found && (decl = IDENTIFIER_LOCAL_VALUE (name)))
7408     {
7409       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
7410       QUAL_RESOLUTION (qual) = decl;
7411     }
7412
7413   /* If within the class/interface NAME was found to be used there
7414      exists a (possibly inherited) field named NAME, then this is an
7415      expression name. If we saw a NEW_ARRAY_EXPR before and want to
7416      address length, it is OK. */
7417   else if ((decl = lookup_field_wrapper (ptr_type, name))
7418            || (new_array_found && name == length_identifier_node))
7419     {
7420       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
7421       QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
7422     }
7423
7424   /* We reclassify NAME as a type name if:
7425      - NAME is a class/interface declared within the compilation
7426        unit containing NAME,
7427      - NAME is imported via a single-type-import declaration,
7428      - NAME is declared in an another compilation unit of the package
7429        of the compilation unit containing NAME,
7430      - NAME is declared by exactly on type-import-on-demand declaration
7431      of the compilation unit containing NAME. */
7432   else if ((decl = resolve_and_layout (name, NULL_TREE)))
7433     {
7434       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
7435       QUAL_RESOLUTION (qual) = decl;
7436     }
7437
7438   /* Method call are expression name */
7439   else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
7440            || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF)
7441     RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
7442
7443   /* Check here that NAME isn't declared by more than one
7444      type-import-on-demand declaration of the compilation unit
7445      containing NAME. FIXME */
7446
7447   /* Otherwise, NAME is reclassified as a package name */
7448   else
7449     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
7450
7451   /* Propagate the qualification accross other components of the
7452      qualified name */
7453   for (qual = TREE_CHAIN (qual); qual;
7454        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
7455     {
7456       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
7457         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
7458       else
7459         RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
7460     }
7461
7462   /* Store the global qualification for the ambiguous part of ID back
7463      into ID fields */
7464   if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
7465     RESOLVE_EXPRESSION_NAME_P (id) = 1;
7466   else if (RESOLVE_TYPE_NAME_P (qual_wfl))
7467     RESOLVE_TYPE_NAME_P (id) = 1;
7468   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
7469     RESOLVE_PACKAGE_NAME_P (id) = 1;
7470
7471   /* Restore the current class */
7472   current_class = saved_current_class;
7473 }
7474
7475 static int
7476 breakdown_qualified (left, right, source)
7477     tree *left, *right, source;
7478 {
7479   char *p = IDENTIFIER_POINTER (source), *base;
7480   int   l = IDENTIFIER_LENGTH (source);
7481
7482   /* Breakdown NAME into REMAINDER . IDENTIFIER */
7483   base = p;
7484   p += (l-1);
7485   while (*p != '.' && p != base)
7486     p--;
7487
7488   /* We didn't find a '.'. Return an error */
7489   if (p == base)
7490     return 1;
7491
7492   *p = '\0';
7493   if (right)
7494     *right = get_identifier (p+1);
7495   *left = get_identifier (IDENTIFIER_POINTER (source));
7496   *p = '.';
7497
7498   return 0;
7499 }
7500
7501 /* Patch tree nodes in a function body. When a BLOCK is found, push
7502    local variable decls if present.
7503    Same as java_complete_lhs, but does resolve static finals to values. */
7504
7505 static tree
7506 java_complete_tree (node)
7507      tree node;
7508 {
7509   node = java_complete_lhs (node);
7510   if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node)
7511       && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE)
7512     {
7513       tree value = DECL_INITIAL (node);
7514       DECL_INITIAL (node) = NULL_TREE;
7515       value = fold_constant_for_init (value, node);
7516       DECL_INITIAL (node) = value;
7517       if (value != NULL_TREE)
7518         return value;
7519     }
7520   return node;
7521 }
7522
7523 /* Patch tree nodes in a function body. When a BLOCK is found, push
7524    local variable decls if present.
7525    Same as java_complete_tree, but does not resolve static finals to values. */
7526
7527 static tree
7528 java_complete_lhs (node)
7529      tree node;
7530 {
7531   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
7532   int flag;
7533
7534   /* CONVERT_EXPR always has its type set, even though it needs to be
7535      worked out. */
7536   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
7537     return node;
7538
7539   /* The switch block implements cases processing container nodes
7540      first.  Contained nodes are always written back. Leaves come
7541      next and return a value. */
7542   switch (TREE_CODE (node))
7543     {
7544     case BLOCK:
7545
7546       /* 1- Block section.
7547          Set the local values on decl names so we can identify them
7548          faster when they're referenced. At that stage, identifiers
7549          are legal so we don't check for declaration errors. */
7550       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
7551         {
7552           DECL_CONTEXT (cn) = current_function_decl;
7553           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
7554           INITIALIZED_P (cn) = 0;
7555         }
7556       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
7557           CAN_COMPLETE_NORMALLY (node) = 1;
7558       else
7559         {
7560           tree stmt = BLOCK_EXPR_BODY (node);
7561           tree *ptr;
7562           int error_seen = 0;
7563           if (TREE_CODE (stmt) == COMPOUND_EXPR)
7564             {
7565               /* Re-order from (((A; B); C); ...; Z) to
7566                  (A; (B; (C ; (...; Z)))).
7567                  This makes it easier to scan the statements left-to-right
7568                  without using recursion (which might overflow the stack
7569                  if the block has many statements. */
7570               for (;;)
7571                 {
7572                   tree left = TREE_OPERAND (stmt, 0);
7573                   if (TREE_CODE (left) != COMPOUND_EXPR)
7574                     break;
7575                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
7576                   TREE_OPERAND (left, 1) = stmt;
7577                   stmt = left;
7578                 }
7579               BLOCK_EXPR_BODY (node) = stmt;
7580             }
7581
7582           /* Now do the actual complete, without deep recursion for
7583              long blocks. */
7584           ptr = &BLOCK_EXPR_BODY (node);
7585           while (TREE_CODE (*ptr) == COMPOUND_EXPR
7586                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
7587             {
7588               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
7589               tree *next = &TREE_OPERAND (*ptr, 1);
7590               TREE_OPERAND (*ptr, 0) = cur;
7591               if (TREE_CODE (cur) == ERROR_MARK)
7592                 error_seen++;
7593               else if (! CAN_COMPLETE_NORMALLY (cur))
7594                 {
7595                   wfl_op2 = *next;
7596                   for (;;)
7597                     {
7598                       if (TREE_CODE (wfl_op2) == BLOCK)
7599                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
7600                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
7601                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
7602                       else
7603                         break;
7604                     }
7605                   if (TREE_CODE (wfl_op2) != CASE_EXPR
7606                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
7607                     unreachable_stmt_error (*ptr);
7608                 }
7609               ptr = next;
7610             }
7611           *ptr = java_complete_tree (*ptr);
7612
7613           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
7614             return error_mark_node;
7615           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
7616         }
7617       /* Turn local bindings to null */
7618       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
7619         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
7620
7621       TREE_TYPE (node) = void_type_node;
7622       break;
7623
7624       /* 2- They are expressions but ultimately deal with statements */
7625
7626     case THROW_EXPR:
7627       wfl_op1 = TREE_OPERAND (node, 0);
7628       COMPLETE_CHECK_OP_0 (node);
7629       /* CAN_COMPLETE_NORMALLY (node) = 0; */
7630       return patch_throw_statement (node, wfl_op1);
7631
7632     case SYNCHRONIZED_EXPR:
7633       wfl_op1 = TREE_OPERAND (node, 0);
7634       return patch_synchronized_statement (node, wfl_op1);
7635
7636     case TRY_EXPR:
7637       return patch_try_statement (node);
7638
7639     case TRY_FINALLY_EXPR:
7640       COMPLETE_CHECK_OP_0 (node);
7641       COMPLETE_CHECK_OP_1 (node);
7642       CAN_COMPLETE_NORMALLY (node)
7643         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
7644            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
7645       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
7646       return node;
7647
7648     case CLEANUP_POINT_EXPR:
7649       COMPLETE_CHECK_OP_0 (node);
7650       TREE_TYPE (node) = void_type_node;
7651       CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
7652       return node;
7653
7654     case WITH_CLEANUP_EXPR:
7655       COMPLETE_CHECK_OP_0 (node);
7656       COMPLETE_CHECK_OP_2 (node);
7657       CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
7658       TREE_TYPE (node) = void_type_node;
7659       return node;
7660
7661     case LABELED_BLOCK_EXPR:
7662       PUSH_LABELED_BLOCK (node);
7663       if (LABELED_BLOCK_BODY (node))
7664         COMPLETE_CHECK_OP_1 (node);
7665       TREE_TYPE (node) = void_type_node;
7666       POP_LABELED_BLOCK ();
7667       if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
7668         CAN_COMPLETE_NORMALLY (node) = 1;
7669       return node;
7670
7671     case EXIT_BLOCK_EXPR:
7672       /* We don't complete operand 1, because it's the return value of
7673          the EXIT_BLOCK_EXPR which doesn't exist it Java */
7674       return patch_bc_statement (node);
7675
7676     case CASE_EXPR:
7677       cn = java_complete_tree (TREE_OPERAND (node, 0));
7678       if (cn == error_mark_node)
7679         return cn;
7680
7681       /* First, the case expression must be constant */
7682       cn = fold (cn);
7683
7684       if (!TREE_CONSTANT (cn))
7685         {
7686           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
7687           parse_error_context (node, "Constant expression required");
7688           return error_mark_node;
7689         }
7690
7691       nn = ctxp->current_loop;
7692
7693       /* It must be assignable to the type of the switch expression. */
7694       if (!try_builtin_assignconv (NULL_TREE,
7695                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
7696         {
7697           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
7698           parse_error_context
7699             (wfl_operator,
7700              "Incompatible type for case. Can't convert `%s' to `int'",
7701              lang_printable_name (TREE_TYPE (cn), 0));
7702           return error_mark_node;
7703         }
7704
7705       cn = fold (convert (int_type_node, cn));
7706
7707       /* Multiple instance of a case label bearing the same
7708          value is checked during code generation. The case
7709          expression is allright so far. */
7710       TREE_OPERAND (node, 0) = cn;
7711       TREE_TYPE (node) = void_type_node;
7712       CAN_COMPLETE_NORMALLY (node) = 1;
7713       TREE_SIDE_EFFECTS (node) = 1;
7714       break;
7715
7716     case DEFAULT_EXPR:
7717       nn = ctxp->current_loop;
7718       /* Only one default label is allowed per switch statement */
7719       if (SWITCH_HAS_DEFAULT (nn))
7720         {
7721           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
7722           parse_error_context (wfl_operator,
7723                                "Duplicate case label: `default'");
7724           return error_mark_node;
7725         }
7726       else
7727         SWITCH_HAS_DEFAULT (nn) = 1;
7728       TREE_TYPE (node) = void_type_node;
7729       TREE_SIDE_EFFECTS (node) = 1;
7730       CAN_COMPLETE_NORMALLY (node) = 1;
7731       break;
7732
7733     case SWITCH_EXPR:
7734     case LOOP_EXPR:
7735       PUSH_LOOP (node);
7736       /* Check whether the loop was enclosed in a labeled
7737          statement. If not, create one, insert the loop in it and
7738          return the node */
7739       nn = patch_loop_statement (node);
7740
7741       /* Anyways, walk the body of the loop */
7742       if (TREE_CODE (node) == LOOP_EXPR)
7743         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
7744       /* Switch statement: walk the switch expression and the cases */
7745       else
7746         node = patch_switch_statement (node);
7747
7748       if (TREE_OPERAND (node, 0) == error_mark_node)
7749         return error_mark_node;
7750       TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
7751       /* If we returned something different, that's because we
7752          inserted a label. Pop the label too. */
7753       if (nn != node)
7754         {
7755           if (CAN_COMPLETE_NORMALLY (node))
7756             CAN_COMPLETE_NORMALLY (nn) = 1;
7757           POP_LABELED_BLOCK ();
7758         }
7759       POP_LOOP ();
7760       return nn;
7761
7762     case EXIT_EXPR:
7763       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
7764       return patch_exit_expr (node);
7765
7766     case COND_EXPR:
7767       /* Condition */
7768       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
7769       if (TREE_OPERAND (node, 0) == error_mark_node)
7770         return error_mark_node;
7771       /* then-else branches */
7772       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
7773       if (TREE_OPERAND (node, 1) == error_mark_node)
7774         return error_mark_node;
7775       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
7776       if (TREE_OPERAND (node, 2) == error_mark_node)
7777         return error_mark_node;
7778       return patch_if_else_statement (node);
7779       break;
7780
7781     case CONDITIONAL_EXPR:
7782       /* Condition */
7783       wfl_op1 = TREE_OPERAND (node, 0);
7784       COMPLETE_CHECK_OP_0 (node);
7785       wfl_op2 = TREE_OPERAND (node, 1);
7786       COMPLETE_CHECK_OP_1 (node);
7787       wfl_op3 = TREE_OPERAND (node, 2);
7788       COMPLETE_CHECK_OP_2 (node);
7789       return patch_conditional_expr (node, wfl_op1, wfl_op2);
7790
7791       /* 3- Expression section */
7792     case COMPOUND_EXPR:
7793       wfl_op2 = TREE_OPERAND (node, 1);
7794       TREE_OPERAND (node, 0) = nn =
7795         java_complete_tree (TREE_OPERAND (node, 0));
7796       if (wfl_op2 == empty_stmt_node)
7797         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
7798       else
7799         {
7800           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
7801             {
7802               /* An unreachable condition in a do-while statement
7803                  is *not* (technically) an unreachable statement. */
7804               nn = wfl_op2;
7805               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
7806                 nn = EXPR_WFL_NODE (nn);
7807               if (TREE_CODE (nn) != EXIT_EXPR)
7808                 {
7809                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
7810                   parse_error_context (wfl_operator, "Unreachable statement");
7811                 }
7812             }
7813           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
7814           if (TREE_OPERAND (node, 1) == error_mark_node)
7815             return error_mark_node;
7816           CAN_COMPLETE_NORMALLY (node)
7817             = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
7818         }
7819       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
7820       break;
7821
7822     case RETURN_EXPR:
7823       /* CAN_COMPLETE_NORMALLY (node) = 0; */
7824       return patch_return (node);
7825
7826     case EXPR_WITH_FILE_LOCATION:
7827       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
7828           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
7829         {
7830           node = resolve_expression_name (node, NULL);
7831           if (node == error_mark_node)
7832             return node;
7833           CAN_COMPLETE_NORMALLY (node) = 1;
7834         }
7835       else
7836         {
7837           tree body;
7838           int save_lineno = lineno;
7839           lineno = EXPR_WFL_LINENO (node);
7840           body = java_complete_tree (EXPR_WFL_NODE (node));
7841           lineno = save_lineno;
7842           EXPR_WFL_NODE (node) = body;
7843           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
7844           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
7845           if (body == error_mark_node)
7846             {
7847               /* Its important for the evaluation of assignment that
7848                  this mark on the TREE_TYPE is propagated. */
7849               TREE_TYPE (node) = error_mark_node;
7850               return error_mark_node;
7851             }
7852           else
7853             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
7854
7855         }
7856       break;
7857
7858     case NEW_ARRAY_EXPR:
7859       /* Patch all the dimensions */
7860       flag = 0;
7861       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
7862         {
7863           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
7864           tree dim = java_complete_tree (TREE_VALUE (cn));
7865           if (dim == error_mark_node)
7866             {
7867               flag = 1;
7868               continue;
7869             }
7870           else
7871             {
7872               TREE_VALUE (cn) = dim;
7873               /* Setup the location of the current dimension, for
7874                  later error report. */
7875               TREE_PURPOSE (cn) =
7876                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
7877               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
7878             }
7879         }
7880       /* They complete the array creation expression, if no errors
7881          were found. */
7882       CAN_COMPLETE_NORMALLY (node) = 1;
7883       return (flag ? error_mark_node : patch_newarray (node));
7884
7885     case NEW_CLASS_EXPR:
7886     case CALL_EXPR:
7887       /* Complete function's argument(s) first */
7888       if (complete_function_arguments (node))
7889         return error_mark_node;
7890       else
7891         {
7892           tree decl, wfl = TREE_OPERAND (node, 0);
7893           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
7894
7895           node = patch_method_invocation (node, NULL_TREE,
7896                                           NULL_TREE, 0, &decl);
7897           if (node == error_mark_node)
7898             return error_mark_node;
7899
7900           check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
7901           /* If we call this(...), register signature and positions */
7902           if (in_this)
7903             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
7904               tree_cons (wfl, decl,
7905                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
7906           CAN_COMPLETE_NORMALLY (node) = 1;
7907           return force_evaluation_order (node);
7908         }
7909
7910     case MODIFY_EXPR:
7911       /* Save potential wfls */
7912       wfl_op1 = TREE_OPERAND (node, 0);
7913       wfl_op2 = TREE_OPERAND (node, 1);
7914       TREE_OPERAND (node, 0) = java_complete_lhs (wfl_op1);
7915       if (TREE_OPERAND (node, 0) == error_mark_node)
7916         return error_mark_node;
7917
7918       if (COMPOUND_ASSIGN_P (wfl_op2))
7919         {
7920           tree lvalue;
7921           tree other =
7922             java_complete_tree (TREE_OPERAND (wfl_op2, 0));
7923
7924           /* Hand stablize the lhs on both places */
7925           lvalue = stabilize_reference (other);
7926           TREE_OPERAND (node, 0) = lvalue;
7927           TREE_OPERAND (TREE_OPERAND (node, 1), 0) = lvalue;
7928         }
7929
7930       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
7931          function to complete this RHS */
7932       if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT)
7933         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
7934                                    TREE_OPERAND (node, 1));
7935       else
7936         nn = java_complete_tree (TREE_OPERAND (node, 1));
7937
7938       /* There are cases where the type of RHS is fixed. In those
7939          cases, if the evaluation of the RHS fails, we further the
7940          evaluation of the assignment to detect more errors. */
7941       if (nn == error_mark_node)
7942         {
7943           /* It's hopeless, but we can further things on to discover
7944              an error during the assignment. In any cases, the
7945              assignment operation fails. */
7946           if (TREE_CODE (TREE_OPERAND (node, 1)) != EXPR_WITH_FILE_LOCATION
7947               && TREE_CODE (TREE_OPERAND (node, 1)) != NEW_ARRAY_INIT
7948               && TREE_TYPE (TREE_OPERAND (node, 1)) != error_mark_node)
7949             patch_assignment (node, wfl_op1, wfl_op2);
7950
7951           /* Now, we still mark the lhs as initialized */
7952           if (JDECL_P (TREE_OPERAND (node, 0)))
7953             INITIALIZED_P (TREE_OPERAND (node, 0)) = 1;
7954
7955           return error_mark_node;
7956         }
7957       TREE_OPERAND (node, 1) = nn;
7958
7959       /* In case we're handling = with a String as a RHS, we need to
7960          produce a String out of the RHS (it might still be a
7961          STRING_CST or a StringBuffer at this stage */
7962       if ((nn = patch_string (TREE_OPERAND (node, 1))))
7963         TREE_OPERAND (node, 1) = nn;
7964       node = patch_assignment (node, wfl_op1, wfl_op2);
7965       CAN_COMPLETE_NORMALLY (node) = 1;
7966
7967       /* Before returning the node, in the context of a static field
7968          assignment in <clinit>, we may want to carray further
7969          optimizations. (VAR_DECL means it's a static field. See
7970          add_field. */
7971       if (DECL_NAME (current_function_decl) == clinit_identifier_node
7972           && MODIFY_EXPR_FROM_INITIALIZATION_P (node)
7973           && TREE_CODE (TREE_OPERAND (node, 0)) == VAR_DECL)
7974         node = patch_initialized_static_field (node);
7975
7976       return node;
7977
7978     case MULT_EXPR:
7979     case PLUS_EXPR:
7980     case MINUS_EXPR:
7981     case LSHIFT_EXPR:
7982     case RSHIFT_EXPR:
7983     case URSHIFT_EXPR:
7984     case BIT_AND_EXPR:
7985     case BIT_XOR_EXPR:
7986     case BIT_IOR_EXPR:
7987     case TRUNC_MOD_EXPR:
7988     case RDIV_EXPR:
7989     case TRUTH_ANDIF_EXPR:
7990     case TRUTH_ORIF_EXPR:
7991     case EQ_EXPR:
7992     case NE_EXPR:
7993     case GT_EXPR:
7994     case GE_EXPR:
7995     case LT_EXPR:
7996     case LE_EXPR:
7997       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
7998          knows how to handle those cases. */
7999       wfl_op1 = TREE_OPERAND (node, 0);
8000       wfl_op2 = TREE_OPERAND (node, 1);
8001
8002       CAN_COMPLETE_NORMALLY (node) = 1;
8003       /* Don't complete string nodes if dealing with the PLUS operand. */
8004       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
8005         {
8006           TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
8007           if (TREE_OPERAND (node, 0) == error_mark_node)
8008             return error_mark_node;
8009         }
8010       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
8011         {
8012           TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
8013           if (TREE_OPERAND (node, 1) == error_mark_node)
8014             return error_mark_node;
8015         }
8016       return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
8017
8018     case INSTANCEOF_EXPR:
8019       wfl_op1 = TREE_OPERAND (node, 0);
8020       COMPLETE_CHECK_OP_0 (node);
8021       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
8022
8023     case UNARY_PLUS_EXPR:
8024     case NEGATE_EXPR:
8025     case TRUTH_NOT_EXPR:
8026     case BIT_NOT_EXPR:
8027     case PREDECREMENT_EXPR:
8028     case PREINCREMENT_EXPR:
8029     case POSTDECREMENT_EXPR:
8030     case POSTINCREMENT_EXPR:
8031     case CONVERT_EXPR:
8032       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
8033          how to handle those cases. */
8034       wfl_op1 = TREE_OPERAND (node, 0);
8035       CAN_COMPLETE_NORMALLY (node) = 1;
8036       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
8037       if (TREE_OPERAND (node, 0) == error_mark_node)
8038         return error_mark_node;
8039       node = patch_unaryop (node, wfl_op1);
8040       CAN_COMPLETE_NORMALLY (node) = 1;
8041       break;
8042
8043     case ARRAY_REF:
8044       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
8045          how to handle those cases. */
8046       wfl_op1 = TREE_OPERAND (node, 0);
8047       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
8048       if (TREE_OPERAND (node, 0) == error_mark_node)
8049         return error_mark_node;
8050       if (!flag_emit_class_files)
8051         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
8052       /* The same applies to wfl_op2 */
8053       wfl_op2 = TREE_OPERAND (node, 1);
8054       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
8055       if (TREE_OPERAND (node, 1) == error_mark_node)
8056         return error_mark_node;
8057       if (!flag_emit_class_files)
8058         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
8059       return patch_array_ref (node);
8060
8061     case RECORD_TYPE:
8062       return node;;
8063
8064     case COMPONENT_REF:
8065       /* The first step in the re-write of qualified name handling.  FIXME.
8066          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
8067       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
8068       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
8069         {
8070           tree name = TREE_OPERAND (node, 1);
8071           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
8072           if (field == NULL_TREE)
8073             {
8074               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
8075               return error_mark_node;
8076             }
8077           if (! FIELD_STATIC (field))
8078             {
8079               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
8080               return error_mark_node;
8081             }
8082           return field;
8083         }
8084       else
8085         fatal ("unimplemented java_complete_tree for COMPONENT_REF");
8086       break;
8087
8088     case THIS_EXPR:
8089       /* Can't use THIS in a static environment */
8090       if (!current_this)
8091         {
8092           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8093           parse_error_context (wfl_operator, "Keyword `this' used outside "
8094                                "allowed context");
8095           TREE_TYPE (node) = error_mark_node;
8096           return error_mark_node;
8097         }
8098       if (ctxp->explicit_constructor_p)
8099         {
8100           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8101           parse_error_context
8102             (wfl_operator, "Can't reference `this' or `super' before the "
8103              "superclass constructor has been called");
8104           TREE_TYPE (node) = error_mark_node;
8105           return error_mark_node;
8106         }
8107       return current_this;
8108
8109     default:
8110       CAN_COMPLETE_NORMALLY (node) = 1;
8111       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
8112          and it's time to turn it into the appropriate String object
8113          */
8114       if ((node = patch_string (node)))
8115         return node;
8116       fatal ("No case for tree code `%s' - java_complete_tree\n",
8117              tree_code_name [TREE_CODE (node)]);
8118     }
8119   return node;
8120 }
8121
8122 /* Complete function call's argument. Return a non zero value is an
8123    error was found.  */
8124
8125 static int
8126 complete_function_arguments (node)
8127      tree node;
8128 {
8129   int flag = 0;
8130   tree cn;
8131
8132   ctxp->explicit_constructor_p += (CALL_THIS_CONSTRUCTOR_P (node) ? 1 : 0);
8133   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
8134     {
8135       tree wfl = TREE_VALUE (cn), parm, temp;
8136       parm = java_complete_tree (wfl);
8137       if (parm == error_mark_node)
8138         {
8139           flag = 1;
8140           continue;
8141         }
8142       /* If have a string literal that we haven't transformed yet or a
8143          crafted string buffer, as a result of use of the the String
8144          `+' operator. Build `parm.toString()' and expand it. */
8145       if ((temp = patch_string (parm)))
8146         parm = temp;
8147       /* Inline PRIMTYPE.TYPE read access */
8148       parm = maybe_build_primttype_type_ref (parm, wfl);
8149
8150       TREE_VALUE (cn) = parm;
8151     }
8152   ctxp->explicit_constructor_p -= (CALL_THIS_CONSTRUCTOR_P (node) ? 1 : 0);
8153   return flag;
8154 }
8155
8156 /* Sometimes (for loops and variable initialized during their
8157    declaration), we want to wrap a statement around a WFL and turn it
8158    debugable.  */
8159
8160 static tree
8161 build_debugable_stmt (location, stmt)
8162     int location;
8163     tree stmt;
8164 {
8165   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
8166     {
8167       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
8168       EXPR_WFL_LINECOL (stmt) = location;
8169     }
8170   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
8171   return stmt;
8172 }
8173
8174 static tree
8175 build_expr_block (body, decls)
8176      tree body, decls;
8177 {
8178   tree node = make_node (BLOCK);
8179   BLOCK_EXPR_DECLS (node) = decls;
8180   BLOCK_EXPR_BODY (node) = body;
8181   if (body)
8182     TREE_TYPE (node) = TREE_TYPE (body);
8183   TREE_SIDE_EFFECTS (node) = 1;
8184   return node;
8185 }
8186
8187 /* Create a new function block and link it approriately to current
8188    function block chain */
8189
8190 static tree
8191 enter_block ()
8192 {
8193   return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE)));
8194 }
8195
8196 /* Link block B supercontext to the previous block. The current
8197    function DECL is used as supercontext when enter_a_block is called
8198    for the first time for a given function. The current function body
8199    (DECL_FUNCTION_BODY) is set to be block B.  */
8200
8201 static tree
8202 enter_a_block (b)
8203      tree b;
8204 {
8205   tree fndecl = current_function_decl;
8206
8207   if (!DECL_FUNCTION_BODY (fndecl))
8208     {
8209       BLOCK_SUPERCONTEXT (b) = fndecl;
8210       DECL_FUNCTION_BODY (fndecl) = b;
8211     }
8212   else
8213     {
8214       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
8215       DECL_FUNCTION_BODY (fndecl) = b;
8216     }
8217   return b;
8218 }
8219
8220 /* Exit a block by changing the current function body
8221    (DECL_FUNCTION_BODY) to the current block super context, only if
8222    the block being exited isn't the method's top level one.  */
8223
8224 static tree
8225 exit_block ()
8226 {
8227   tree b = DECL_FUNCTION_BODY (current_function_decl);
8228
8229   if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
8230     DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
8231
8232   return b;
8233 }
8234
8235 /* Lookup for NAME in the nested function's blocks, all the way up to
8236    the current toplevel one. It complies with Java's local variable
8237    scoping rules.  */
8238
8239 static tree
8240 lookup_name_in_blocks (name)
8241      tree name;
8242 {
8243   tree b = DECL_FUNCTION_BODY (current_function_decl);
8244
8245   while (b != current_function_decl)
8246     {
8247       tree current;
8248
8249       /* Paranoid sanity check. To be removed */
8250       if (TREE_CODE (b) != BLOCK)
8251         fatal ("non block expr function body - lookup_name_in_blocks");
8252
8253       for (current = BLOCK_EXPR_DECLS (b); current;
8254            current = TREE_CHAIN (current))
8255         if (DECL_NAME (current) == name)
8256           return current;
8257       b = BLOCK_SUPERCONTEXT (b);
8258     }
8259   return NULL_TREE;
8260 }
8261
8262 static void
8263 maybe_absorb_scoping_blocks ()
8264 {
8265   while (BLOCK_EXPR_ORIGIN (DECL_FUNCTION_BODY (current_function_decl)))
8266     {
8267       tree b = exit_block ();
8268       java_method_add_stmt (current_function_decl, b);
8269       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
8270     }
8271 }
8272
8273 \f
8274 /* This section of the source is reserved to build_* functions that
8275    are building incomplete tree nodes and the patch_* functions that
8276    are completing them.  */
8277
8278 /* Build a super() constructor invocation. Returns empty_stmt_node if
8279    we're currently dealing with the class java.lang.Object. */
8280
8281 static tree
8282 build_super_invocation ()
8283 {
8284   if (current_class == object_type_node)
8285     return empty_stmt_node;
8286   else
8287     {
8288       tree super_wfl = build_wfl_node (super_identifier_node,
8289                                        input_filename, 0, 0);
8290       return build_method_invocation (super_wfl, NULL_TREE);
8291     }
8292 }
8293
8294 /* Build a SUPER/THIS qualified method invocation.  */
8295
8296 static tree
8297 build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
8298      int use_this;
8299      tree name, args;
8300      int lloc, rloc;
8301
8302 {
8303   tree invok;
8304   tree wfl =
8305     build_wfl_node ((use_this ? this_identifier_node : super_identifier_node),
8306                     input_filename, 0, 0);
8307   EXPR_WFL_LINECOL (wfl) = lloc;
8308   invok = build_method_invocation (name, args);
8309   return make_qualified_primary (wfl, invok, rloc);
8310 }
8311
8312 /* Build an incomplete CALL_EXPR node. */
8313
8314 static tree
8315 build_method_invocation (name, args)
8316     tree name;
8317     tree args;
8318 {
8319   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
8320   TREE_SIDE_EFFECTS (call) = 1;
8321   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
8322   return call;
8323 }
8324
8325 /* Build an incomplete new xxx(...) node. */
8326
8327 static tree
8328 build_new_invocation (name, args)
8329     tree name, args;
8330 {
8331   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
8332   TREE_SIDE_EFFECTS (call) = 1;
8333   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
8334   return call;
8335 }
8336
8337 /* Build an incomplete assignment expression. */
8338
8339 static tree
8340 build_assignment (op, op_location, lhs, rhs)
8341      int op, op_location;
8342      tree lhs, rhs;
8343 {
8344   tree assignment;
8345   /* Build the corresponding binop if we deal with a Compound
8346      Assignment operator. Mark the binop sub-tree as part of a
8347      Compound Assignment expression */
8348   if (op != ASSIGN_TK)
8349     {
8350       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
8351       COMPOUND_ASSIGN_P (rhs) = 1;
8352     }
8353   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
8354   TREE_SIDE_EFFECTS (assignment) = 1;
8355   EXPR_WFL_LINECOL (assignment) = op_location;
8356   return assignment;
8357 }
8358
8359 /* Print an INTEGER_CST node in a static buffer, and return the buffer. */
8360
8361 char *
8362 print_int_node (node)
8363     tree node;
8364 {
8365   static char buffer [80];
8366   if (TREE_CONSTANT_OVERFLOW (node))
8367     sprintf (buffer, "<overflow>");
8368
8369   if (TREE_INT_CST_HIGH (node) == 0)
8370     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
8371              TREE_INT_CST_LOW (node));
8372   else if (TREE_INT_CST_HIGH (node) == -1
8373            && TREE_INT_CST_LOW (node) != 0)
8374     {
8375       buffer [0] = '-';
8376       sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
8377                -TREE_INT_CST_LOW (node));
8378     }
8379   else
8380     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
8381              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
8382
8383   return buffer;
8384 }
8385
8386 /* Return 1 if you an assignment of a FINAL is attempted */
8387
8388 static int
8389 check_final_assignment (lvalue, wfl)
8390      tree lvalue, wfl;
8391 {
8392   if (JDECL_P (lvalue) && FIELD_FINAL (lvalue) &&
8393       DECL_NAME (current_function_decl) != clinit_identifier_node)
8394     {
8395       parse_error_context
8396         (wfl, "Can't assign a value to the final variable `%s'",
8397          IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
8398       return 1;
8399     }
8400   return 0;
8401 }
8402
8403 /* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
8404    read. This is needed to avoid circularities in the implementation
8405    of these fields in libjava. */
8406
8407 static tree
8408 maybe_build_primttype_type_ref (rhs, wfl)
8409     tree rhs, wfl;
8410 {
8411   tree to_return = NULL_TREE;
8412   tree rhs_type = TREE_TYPE (rhs);
8413   if (TREE_CODE (rhs) == COMPOUND_EXPR)
8414     {
8415       tree n = TREE_OPERAND (rhs, 1);
8416       if (TREE_CODE (n) == VAR_DECL
8417           && DECL_NAME (n) == TYPE_identifier_node
8418           && rhs_type == class_ptr_type)
8419         {
8420           char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
8421           if (!strncmp (self_name, "java.lang.", 10))
8422             to_return = build_primtype_type_ref (self_name);
8423         }
8424     }
8425   return (to_return ? to_return : rhs );
8426 }
8427
8428 /* 15.25 Assignment operators. */
8429
8430 static tree
8431 patch_assignment (node, wfl_op1, wfl_op2)
8432      tree node;
8433      tree wfl_op1;
8434      tree wfl_op2;
8435 {
8436   tree rhs = TREE_OPERAND (node, 1);
8437   tree lvalue = TREE_OPERAND (node, 0), llvalue;
8438   tree lhs_type, rhs_type, new_rhs = NULL_TREE;
8439   int error_found = 0;
8440   int lvalue_from_array = 0;
8441
8442   /* Can't assign to a final. */
8443   if (check_final_assignment (lvalue, wfl_op1))
8444     error_found = 1;
8445
8446   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8447
8448   /* Lhs can be a named variable */
8449   if (JDECL_P (lvalue))
8450     {
8451       INITIALIZED_P (lvalue) = 1;
8452       lhs_type = TREE_TYPE (lvalue);
8453     }
8454   /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
8455      comment on reason why */
8456   else if (TREE_CODE (wfl_op1) == ARRAY_REF)
8457     {
8458       lhs_type = TREE_TYPE (lvalue);
8459       lvalue_from_array = 1;
8460     }
8461   /* Or a field access */
8462   else if (TREE_CODE (lvalue) == COMPONENT_REF)
8463     lhs_type = TREE_TYPE (lvalue);
8464   /* Or a function return slot */
8465   else if (TREE_CODE (lvalue) == RESULT_DECL)
8466     lhs_type = TREE_TYPE (lvalue);
8467   /* Otherwise, we might want to try to write into an optimized static
8468      final, this is an of a different nature, reported further on. */
8469   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
8470            && resolve_expression_name (wfl_op1, &llvalue)
8471            && check_final_assignment (llvalue, wfl_op1))
8472     {
8473       error_found = 1;
8474       /* What we should do instead is resetting the all the flags
8475          previously set, exchange lvalue for llvalue and continue. */
8476       return error_mark_node;
8477     }
8478   else
8479     {
8480       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
8481       error_found = 1;
8482     }
8483
8484   rhs_type = TREE_TYPE (rhs);
8485   /* 5.1 Try the assignment conversion for builtin type. */
8486   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
8487
8488   /* 5.2 If it failed, try a reference conversion */
8489   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
8490     lhs_type = promote_type (rhs_type);
8491
8492   /* 15.25.2 If we have a compound assignment, convert RHS into the
8493      type of the LHS */
8494   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
8495     new_rhs = convert (lhs_type, rhs);
8496
8497   /* Explicit cast required. This is an error */
8498   if (!new_rhs)
8499     {
8500       char *t1 = strdup (lang_printable_name (TREE_TYPE (rhs), 0));
8501       char *t2 = strdup (lang_printable_name (lhs_type, 0));
8502       tree wfl;
8503       char operation [32];      /* Max size known */
8504
8505       /* If the assignment is part of a declaration, we use the WFL of
8506          the declared variable to point out the error and call it a
8507          declaration problem. If the assignment is a genuine =
8508          operator, we call is a operator `=' problem, otherwise we
8509          call it an assignment problem. In both of these last cases,
8510          we use the WFL of the operator to indicate the error. */
8511
8512       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
8513         {
8514           wfl = wfl_op1;
8515           strcpy (operation, "declaration");
8516         }
8517       else
8518         {
8519           wfl = wfl_operator;
8520           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
8521             strcpy (operation, "assignment");
8522           else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
8523             strcpy (operation, "`return'");
8524           else
8525             strcpy (operation, "`='");
8526         }
8527
8528       parse_error_context
8529         (wfl, (!valid_cast_to_p (rhs_type, lhs_type) ?
8530                "Incompatible type for %s. Can't convert `%s' to `%s'" :
8531                "Incompatible type for %s. Explicit cast "
8532                "needed to convert `%s' to `%s'"), operation, t1, t2);
8533       free (t1); free (t2);
8534       error_found = 1;
8535     }
8536
8537   /* Inline read access to java.lang.PRIMTYPE.TYPE */
8538   if (new_rhs)
8539     new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2);
8540
8541   if (error_found)
8542     return error_mark_node;
8543
8544   /* If we built a compound expression as the result of a reference
8545      assignment into an array element, return it here. */
8546   if (TREE_CODE (node) == COMPOUND_EXPR)
8547     return node;
8548
8549   TREE_OPERAND (node, 0) = lvalue;
8550   TREE_OPERAND (node, 1) = new_rhs;
8551   TREE_TYPE (node) = lhs_type;
8552   return node;
8553 }
8554
8555 /* Optimize static (final) field initialized upon declaration.
8556      - If the field is static final and is assigned to a primitive
8557        constant type, then set its DECL_INITIAL to the value.
8558      - More to come.  */
8559
8560 static tree
8561 patch_initialized_static_field (node)
8562      tree node;
8563 {
8564   tree field = TREE_OPERAND (node, 0);
8565   tree value = TREE_OPERAND (node, 1);
8566
8567   if (DECL_INITIAL (field) != NULL_TREE)
8568     {
8569       tree type = TREE_TYPE (value);
8570       if (FIELD_FINAL (field) && TREE_CONSTANT (value)
8571           && (JPRIMITIVE_TYPE_P (type)
8572               || (flag_emit_class_files
8573                   && TREE_CODE (type) == POINTER_TYPE
8574                   && TREE_TYPE (type) == string_type_node)))
8575         {
8576           DECL_INITIAL (field) = value;
8577           return empty_stmt_node;
8578         }
8579       DECL_INITIAL (field) = NULL_TREE;
8580     }
8581   return node;
8582 }
8583
8584 /* Check that type SOURCE can be cast into type DEST. If the cast
8585    can't occur at all, return 0 otherwise 1. This function is used to
8586    produce accurate error messages on the reasons why an assignment
8587    failed. */
8588
8589 static tree
8590 try_reference_assignconv (lhs_type, rhs)
8591      tree lhs_type, rhs;
8592 {
8593   tree new_rhs = NULL_TREE;
8594   tree rhs_type = TREE_TYPE (rhs);
8595
8596   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
8597     {
8598       /* `null' may be assigned to any reference type */
8599       if (rhs == null_pointer_node)
8600         new_rhs = null_pointer_node;
8601       /* Try the reference assignment conversion */
8602       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
8603         new_rhs = rhs;
8604       /* This is a magic assignment that we process differently */
8605       else if (rhs == soft_exceptioninfo_call_node)
8606         new_rhs = rhs;
8607     }
8608   return new_rhs;
8609 }
8610
8611 /* Check that RHS can be converted into LHS_TYPE by the assignment
8612    conversion (5.2), for the cases of RHS being a builtin type. Return
8613    NULL_TREE if the conversion fails or if because RHS isn't of a
8614    builtin type. Return a converted RHS if the conversion is possible.  */
8615
8616 static tree
8617 try_builtin_assignconv (wfl_op1, lhs_type, rhs)
8618      tree wfl_op1, lhs_type, rhs;
8619 {
8620   tree new_rhs = NULL_TREE;
8621   tree rhs_type = TREE_TYPE (rhs);
8622
8623   /* Zero accepted everywhere */
8624   if (TREE_CODE (rhs) == INTEGER_CST
8625       && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0
8626       && JPRIMITIVE_TYPE_P (rhs_type))
8627     new_rhs = convert (lhs_type, rhs);
8628
8629   /* 5.1.1 Try Identity Conversion,
8630      5.1.2 Try Widening Primitive Conversion */
8631   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
8632     new_rhs = convert (lhs_type, rhs);
8633
8634   /* Try a narrowing primitive conversion (5.1.3):
8635        - expression is a constant expression of type int AND
8636        - variable is byte, short or char AND
8637        - The value of the expression is representable in the type of the
8638          variable */
8639   else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
8640            && (lhs_type == byte_type_node || lhs_type == char_type_node
8641                || lhs_type == short_type_node))
8642     {
8643       if (int_fits_type_p (rhs, lhs_type))
8644         new_rhs = convert (lhs_type, rhs);
8645       else if (wfl_op1)         /* Might be called with a NULL */
8646         parse_warning_context
8647           (wfl_op1, "Constant expression `%s' to wide for narrowing "
8648            "primitive conversion to `%s'",
8649            print_int_node (rhs), lang_printable_name (lhs_type, 0));
8650       /* Reported a warning that will turn into an error further
8651          down, so we don't return */
8652     }
8653
8654   return new_rhs;
8655 }
8656
8657 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
8658    conversion (5.1.1) or widening primitve conversion (5.1.2).  Return
8659    0 is the conversion test fails.  This implements parts the method
8660    invocation convertion (5.3).  */
8661
8662 static int
8663 valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
8664      tree lhs_type, rhs_type;
8665 {
8666   /* 5.1.1: This is the identity conversion part. */
8667   if (lhs_type == rhs_type)
8668     return 1;
8669
8670   /* Reject non primitive types */
8671   if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type))
8672     return 0;
8673
8674   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
8675      than a char can't be converted into a char. Short can't too, but
8676      the < test below takes care of that */
8677   if (lhs_type == char_type_node && rhs_type == byte_type_node)
8678     return 0;
8679
8680   /* Accept all promoted type here. Note, we can't use <= in the test
8681      below, because we still need to bounce out assignments of short
8682      to char and the likes */
8683   if (lhs_type == int_type_node
8684       && (rhs_type == promoted_byte_type_node
8685           || rhs_type == promoted_short_type_node
8686           || rhs_type == promoted_char_type_node
8687           || rhs_type == promoted_boolean_type_node))
8688     return 1;
8689
8690   /* From here, an integral is widened if its precision is smaller
8691      than the precision of the LHS or if the LHS is a floating point
8692      type, or the RHS is a float and the RHS a double. */
8693   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
8694        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
8695       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
8696       || (rhs_type == float_type_node && lhs_type == double_type_node))
8697     return 1;
8698
8699   return 0;
8700 }
8701
8702 /* Check that something of SOURCE type can be assigned or cast to
8703    something of DEST type at runtime. Return 1 if the operation is
8704    valid, 0 otherwise. If CAST is set to 1, we're treating the case
8705    were SOURCE is cast into DEST, which borrows a lot of the
8706    assignment check. */
8707
8708 static int
8709 valid_ref_assignconv_cast_p (source, dest, cast)
8710      tree source;
8711      tree dest;
8712      int cast;
8713 {
8714   /* SOURCE or DEST might be null if not from a declared entity. */
8715   if (!source || !dest)
8716     return 0;
8717   if (JNULLP_TYPE_P (source))
8718     return 1;
8719   if (TREE_CODE (source) == POINTER_TYPE)
8720     source = TREE_TYPE (source);
8721   if (TREE_CODE (dest) == POINTER_TYPE)
8722     dest = TREE_TYPE (dest);
8723   /* Case where SOURCE is a class type */
8724   if (TYPE_CLASS_P (source))
8725     {
8726       if (TYPE_CLASS_P (dest))
8727         return  source == dest || inherits_from_p (source, dest)
8728           || (cast && inherits_from_p (dest, source));
8729       if (TYPE_INTERFACE_P (dest))
8730         {
8731           /* If doing a cast and SOURCE is final, the operation is
8732              always correct a compile time (because even if SOURCE
8733              does not implement DEST, a subclass of SOURCE might). */
8734           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
8735             return 1;
8736           /* Otherwise, SOURCE must implement DEST */
8737           return interface_of_p (dest, source);
8738         }
8739       /* DEST is an array, cast permited if SOURCE is of Object type */
8740       return (cast && source == object_type_node ? 1 : 0);
8741     }
8742   if (TYPE_INTERFACE_P (source))
8743     {
8744       if (TYPE_CLASS_P (dest))
8745         {
8746           /* If not casting, DEST must be the Object type */
8747           if (!cast)
8748             return dest == object_type_node;
8749           /* We're doing a cast. The cast is always valid is class
8750              DEST is not final, otherwise, DEST must implement SOURCE */
8751           else if (!CLASS_FINAL (TYPE_NAME (dest)))
8752             return 1;
8753           else
8754             return interface_of_p (source, dest);
8755         }
8756       if (TYPE_INTERFACE_P (dest))
8757         {
8758           /* If doing a cast, then if SOURCE and DEST contain method
8759              with the same signature but different return type, then
8760              this is a (compile time) error */
8761           if (cast)
8762             {
8763               tree method_source, method_dest;
8764               tree source_type;
8765               tree source_sig;
8766               tree source_name;
8767               for (method_source = TYPE_METHODS (source); method_source;
8768                    method_source = TREE_CHAIN (method_source))
8769                 {
8770                   source_sig =
8771                     build_java_argument_signature (TREE_TYPE (method_source));
8772                   source_type = TREE_TYPE (TREE_TYPE (method_source));
8773                   source_name = DECL_NAME (method_source);
8774                   for (method_dest = TYPE_METHODS (dest);
8775                        method_dest; method_dest = TREE_CHAIN (method_dest))
8776                     if (source_sig ==
8777                         build_java_argument_signature (TREE_TYPE (method_dest))
8778                         && source_name == DECL_NAME (method_dest)
8779                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
8780                       return 0;
8781                 }
8782               return 1;
8783             }
8784           else
8785             return source == dest || interface_of_p (dest, source);
8786         }
8787       else                      /* Array */
8788         return 0;
8789     }
8790   if (TYPE_ARRAY_P (source))
8791     {
8792       if (TYPE_CLASS_P (dest))
8793         return dest == object_type_node;
8794       /* Can't cast an array to an interface unless the interface is
8795          java.lang.Cloneable */
8796       if (TYPE_INTERFACE_P (dest))
8797         return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0);
8798       else                      /* Arrays */
8799         {
8800           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
8801           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
8802
8803           /* In case of severe errors, they turn out null */
8804           if (!dest_element_type || !source_element_type)
8805             return 0;
8806           if (source_element_type == dest_element_type)
8807             return 1;
8808           return valid_ref_assignconv_cast_p (source_element_type,
8809                                               dest_element_type, cast);
8810         }
8811       return 0;
8812     }
8813   return 0;
8814 }
8815
8816 static int
8817 valid_cast_to_p (source, dest)
8818      tree source;
8819      tree dest;
8820 {
8821   if (TREE_CODE (source) == POINTER_TYPE)
8822     source = TREE_TYPE (source);
8823   if (TREE_CODE (dest) == POINTER_TYPE)
8824     dest = TREE_TYPE (dest);
8825
8826   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
8827     return valid_ref_assignconv_cast_p (source, dest, 1);
8828
8829   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
8830     return 1;
8831
8832   return 0;
8833 }
8834
8835 /* Method invocation conversion test. Return 1 if type SOURCE can be
8836    converted to type DEST through the methond invocation conversion
8837    process (5.3) */
8838
8839 static tree
8840 do_unary_numeric_promotion (arg)
8841      tree arg;
8842 {
8843   tree type = TREE_TYPE (arg);
8844   if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32
8845       : TREE_CODE (type) == CHAR_TYPE)
8846     arg = convert (int_type_node, arg);
8847   return arg;
8848 }
8849
8850 /* Return a non zero value if SOURCE can be converted into DEST using
8851    the method invocation conversion rule (5.3).  */
8852 static int
8853 valid_method_invocation_conversion_p (dest, source)
8854      tree dest, source;
8855 {
8856   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
8857            && valid_builtin_assignconv_identity_widening_p (dest, source))
8858           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
8859               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
8860               && valid_ref_assignconv_cast_p (source, dest, 0)));
8861 }
8862
8863 /* Build an incomplete binop expression. */
8864
8865 static tree
8866 build_binop (op, op_location, op1, op2)
8867      enum tree_code op;
8868      int op_location;
8869      tree op1, op2;
8870 {
8871   tree binop = build (op, NULL_TREE, op1, op2);
8872   TREE_SIDE_EFFECTS (binop) = 1;
8873   /* Store the location of the operator, for better error report. The
8874      string of the operator will be rebuild based on the OP value. */
8875   EXPR_WFL_LINECOL (binop) = op_location;
8876   return binop;
8877 }
8878
8879 /* Build the string of the operator retained by NODE. If NODE is part
8880    of a compound expression, add an '=' at the end of the string. This
8881    function is called when an error needs to be reported on an
8882    operator. The string is returned as a pointer to a static character
8883    buffer. */
8884
8885 static char *
8886 operator_string (node)
8887      tree node;
8888 {
8889 #define BUILD_OPERATOR_STRING(S)                                        \
8890   {                                                                     \
8891     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
8892     return buffer;                                                      \
8893   }
8894
8895   static char buffer [10];
8896   switch (TREE_CODE (node))
8897     {
8898     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
8899     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
8900     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
8901     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
8902     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
8903     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
8904     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
8905     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
8906     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
8907     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
8908     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
8909     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
8910     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
8911     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
8912     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
8913     case GT_EXPR: BUILD_OPERATOR_STRING (">");
8914     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
8915     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
8916     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
8917     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
8918     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
8919     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
8920     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
8921     case PREINCREMENT_EXPR:     /* Fall through */
8922     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
8923     case PREDECREMENT_EXPR:     /* Fall through */
8924     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
8925     default:
8926       fatal ("unregistered operator %s - operator_string",
8927              tree_code_name [TREE_CODE (node)]);
8928     }
8929   return NULL;
8930 #undef BUILD_OPERATOR_STRING
8931 }
8932
8933 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
8934    errors but we modify NODE so that it contains the type computed
8935    according to the expression, when it's fixed. Otherwise, we write
8936    error_mark_node as the type. It allows us to further the analysis
8937    of remaining nodes and detects more errors in certain cases.  */
8938
8939 static tree
8940 patch_binop (node, wfl_op1, wfl_op2)
8941      tree node;
8942      tree wfl_op1;
8943      tree wfl_op2;
8944 {
8945   tree op1 = TREE_OPERAND (node, 0);
8946   tree op2 = TREE_OPERAND (node, 1);
8947   tree op1_type = TREE_TYPE (op1);
8948   tree op2_type = TREE_TYPE (op2);
8949   tree prom_type;
8950   int code = TREE_CODE (node);
8951
8952   /* If 1, tell the routine that we have to return error_mark_node
8953      after checking for the initialization of the RHS */
8954   int error_found = 0;
8955
8956   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8957
8958   switch (code)
8959     {
8960     /* 15.16 Multiplicative operators */
8961     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
8962     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
8963     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
8964       if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
8965         {
8966           if (!JPRIMITIVE_TYPE_P (op1_type))
8967             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
8968           if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
8969             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
8970           TREE_TYPE (node) = error_mark_node;
8971           error_found = 1;
8972           break;
8973         }
8974       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
8975       /* Change the division operator if necessary */
8976       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
8977         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
8978
8979       /* This one is more complicated. FLOATs are processed by a
8980          function call to soft_fmod. Duplicate the value of the
8981          COMPOUND_ASSIGN_P flag. */
8982       if (code == TRUNC_MOD_EXPR)
8983         {
8984           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
8985           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
8986           TREE_SIDE_EFFECTS (mod)
8987             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
8988           return mod;
8989         }
8990       break;
8991
8992     /* 15.17 Additive Operators */
8993     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
8994
8995       /* Operation is valid if either one argument is a string
8996          constant, a String object or a StringBuffer crafted for the
8997          purpose of the a previous usage of the String concatenation
8998          operator */
8999
9000       if (TREE_CODE (op1) == STRING_CST
9001           || TREE_CODE (op2) == STRING_CST
9002           || JSTRING_TYPE_P (op1_type)
9003           || JSTRING_TYPE_P (op2_type)
9004           || IS_CRAFTED_STRING_BUFFER_P (op1)
9005           || IS_CRAFTED_STRING_BUFFER_P (op2))
9006         return build_string_concatenation (op1, op2);
9007
9008     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
9009                                    Numeric Types */
9010       if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
9011         {
9012           if (!JPRIMITIVE_TYPE_P (op1_type))
9013             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
9014           if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
9015             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
9016           TREE_TYPE (node) = error_mark_node;
9017           error_found = 1;
9018           break;
9019         }
9020       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
9021       break;
9022
9023     /* 15.18 Shift Operators */
9024     case LSHIFT_EXPR:
9025     case RSHIFT_EXPR:
9026     case URSHIFT_EXPR:
9027       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
9028         {
9029           if (!JINTEGRAL_TYPE_P (op1_type))
9030             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
9031           else
9032             parse_error_context
9033               (wfl_operator, (JPRIMITIVE_TYPE_P (op2_type) ?
9034                "Incompatible type for `%s'. Explicit cast needed to convert "
9035                "shift distance from `%s' to integral" :
9036                "Incompatible type for `%s'. Can't convert shift distance from "
9037                "`%s' to integral"),
9038                operator_string (node), lang_printable_name (op2_type, 0));
9039           TREE_TYPE (node) = error_mark_node;
9040           error_found = 1;
9041           break;
9042         }
9043
9044       /* Unary numeric promotion (5.6.1) is performed on each operand
9045          separatly */
9046       op1 = do_unary_numeric_promotion (op1);
9047       op2 = do_unary_numeric_promotion (op2);
9048
9049       /* The type of the shift expression is the type of the promoted
9050          type of the left-hand operand */
9051       prom_type = TREE_TYPE (op1);
9052
9053       /* Shift int only up to 0x1f and long up to 0x3f */
9054       if (prom_type == int_type_node)
9055         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
9056                            build_int_2 (0x1f, 0)));
9057       else
9058         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
9059                            build_int_2 (0x3f, 0)));
9060
9061       /* The >>> operator is a >> operating on unsigned quantities */
9062       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
9063         {
9064           tree to_return;
9065           tree utype = unsigned_type (prom_type);
9066           op1 = convert (utype, op1);
9067           TREE_SET_CODE (node, RSHIFT_EXPR);
9068           TREE_OPERAND (node, 0) = op1;
9069           TREE_OPERAND (node, 1) = op2;
9070           TREE_TYPE (node) = utype;
9071           to_return = convert (prom_type, node);
9072           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
9073           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
9074           TREE_SIDE_EFFECTS (to_return)
9075             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
9076           return to_return;
9077         }
9078       break;
9079
9080       /* 15.19.1 Type Comparison Operator instaceof */
9081     case INSTANCEOF_EXPR:
9082
9083       TREE_TYPE (node) = boolean_type_node;
9084
9085       if (!(op2_type = resolve_type_during_patch (op2)))
9086         return error_mark_node;
9087
9088       /* The first operand must be a reference type or the null type */
9089       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
9090         error_found = 1;        /* Error reported further below */
9091
9092       /* The second operand must be a reference type */
9093       if (!JREFERENCE_TYPE_P (op2_type))
9094         {
9095           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
9096           parse_error_context
9097             (wfl_operator, "Invalid argument `%s' for `instanceof'",
9098              lang_printable_name (op2_type, 0));
9099           error_found = 1;
9100         }
9101
9102       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
9103         {
9104           /* If the first operand is null, the result is always false */
9105           if (op1 == null_pointer_node)
9106             return boolean_false_node;
9107           else if (flag_emit_class_files)
9108             {
9109               TREE_OPERAND (node, 1) = op2_type;
9110               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
9111               return node;
9112             }
9113           /* Otherwise we have to invoke instance of to figure it out */
9114           else
9115             {
9116               tree call =
9117                 build (CALL_EXPR, boolean_type_node,
9118                        build_address_of (soft_instanceof_node),
9119                        tree_cons
9120                        (NULL_TREE, op1,
9121                         build_tree_list (NULL_TREE,
9122                                          build_class_ref (op2_type))),
9123                        NULL_TREE);
9124               TREE_SIDE_EFFECTS (call) = TREE_SIDE_EFFECTS (op1);
9125               return call;
9126             }
9127         }
9128       /* There is no way the expression operand can be an instance of
9129          the type operand. This is a compile time error. */
9130       else
9131         {
9132           char *t1 = strdup (lang_printable_name (op1_type, 0));
9133           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
9134           parse_error_context
9135             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
9136              t1, lang_printable_name (op2_type, 0));
9137           free (t1);
9138           error_found = 1;
9139         }
9140
9141       break;
9142
9143       /* 15.21 Bitwise and Logical Operators */
9144     case BIT_AND_EXPR:
9145     case BIT_XOR_EXPR:
9146     case BIT_IOR_EXPR:
9147       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
9148         /* Binary numeric promotion is performed on both operand and the
9149            expression retain that type */
9150         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
9151
9152       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
9153                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
9154         /* The type of the bitwise operator expression is BOOLEAN */
9155         prom_type = boolean_type_node;
9156       else
9157         {
9158           if (!JINTEGRAL_TYPE_P (op1_type))
9159             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
9160           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
9161             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
9162           TREE_TYPE (node) = error_mark_node;
9163           error_found = 1;
9164           /* Insert a break here if adding thing before the switch's
9165              break for this case */
9166         }
9167       break;
9168
9169       /* 15.22 Conditional-And Operator */
9170     case TRUTH_ANDIF_EXPR:
9171       /* 15.23 Conditional-Or Operator */
9172     case TRUTH_ORIF_EXPR:
9173       /* Operands must be of BOOLEAN type */
9174       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
9175           TREE_CODE (op2_type) != BOOLEAN_TYPE)
9176         {
9177           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
9178             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
9179           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
9180             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
9181           TREE_TYPE (node) = boolean_type_node;
9182           error_found = 1;
9183           break;
9184         }
9185       /* The type of the conditional operators is BOOLEAN */
9186       prom_type = boolean_type_node;
9187       break;
9188
9189       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
9190     case LT_EXPR:
9191     case GT_EXPR:
9192     case LE_EXPR:
9193     case GE_EXPR:
9194       /* The type of each of the operands must be a primitive numeric
9195          type */
9196       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
9197         {
9198           if (!JNUMERIC_TYPE_P (op1_type))
9199             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
9200           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
9201             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
9202           TREE_TYPE (node) = boolean_type_node;
9203           error_found = 1;
9204           break;
9205         }
9206       /* Binary numeric promotion is performed on the operands */
9207       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
9208       /* The type of the relation expression is always BOOLEAN */
9209       prom_type = boolean_type_node;
9210       break;
9211
9212       /* 15.20 Equality Operator */
9213     case EQ_EXPR:
9214     case NE_EXPR:
9215       /* 15.20.1 Numerical Equality Operators == and != */
9216       /* Binary numeric promotion is performed on the operands */
9217       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
9218         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
9219
9220       /* 15.20.2 Boolean Equality Operators == and != */
9221       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
9222           TREE_CODE (op2_type) == BOOLEAN_TYPE)
9223         ;                       /* Nothing to do here */
9224
9225       /* 15.20.3 Reference Equality Operators == and != */
9226       /* Types have to be either references or the null type. If
9227          they're references, it must be possible to convert either
9228          type to the other by casting conversion. */
9229       else if (op1 == null_pointer_node || op2 == null_pointer_node
9230                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
9231                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
9232                        || valid_ref_assignconv_cast_p (op2_type,
9233                                                        op1_type, 1))))
9234         ;                       /* Nothing to do here */
9235
9236       /* Else we have an error figure what can't be converted into
9237          what and report the error */
9238       else
9239         {
9240           char *t1;
9241           t1 = strdup (lang_printable_name (op1_type, 0));
9242           parse_error_context
9243             (wfl_operator, "Incompatible type for `%s'. Can't convert `%s' "
9244              "to `%s'", operator_string (node), t1,
9245              lang_printable_name (op2_type, 0));
9246           free (t1);
9247           TREE_TYPE (node) = boolean_type_node;
9248           error_found = 1;
9249           break;
9250         }
9251       prom_type = boolean_type_node;
9252       break;
9253     }
9254
9255   if (error_found)
9256     return error_mark_node;
9257
9258   TREE_OPERAND (node, 0) = op1;
9259   TREE_OPERAND (node, 1) = op2;
9260   TREE_TYPE (node) = prom_type;
9261   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
9262
9263   return fold (node);
9264 }
9265
9266 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
9267    zero value, the value of CSTE comes after the valude of STRING */
9268
9269 static tree
9270 do_merge_string_cste (cste, string, string_len, after)
9271      tree cste;
9272      char *string;
9273      int string_len, after;
9274 {
9275   int len = TREE_STRING_LENGTH (cste) + string_len;
9276   char *old = TREE_STRING_POINTER (cste);
9277   TREE_STRING_LENGTH (cste) = len;
9278   TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1);
9279   if (after)
9280     {
9281       strcpy (TREE_STRING_POINTER (cste), string);
9282       strcat (TREE_STRING_POINTER (cste), old);
9283     }
9284   else
9285     {
9286       strcpy (TREE_STRING_POINTER (cste), old);
9287       strcat (TREE_STRING_POINTER (cste), string);
9288     }
9289   return cste;
9290 }
9291
9292 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
9293    new STRING_CST on success, NULL_TREE on failure */
9294
9295 static tree
9296 merge_string_cste (op1, op2, after)
9297      tree op1, op2;
9298      int after;
9299 {
9300   /* Handle two string constants right away */
9301   if (TREE_CODE (op2) == STRING_CST)
9302     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
9303                                  TREE_STRING_LENGTH (op2), after);
9304
9305   /* Reasonable integer constant can be treated right away */
9306   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
9307     {
9308       static char *boolean_true = "true";
9309       static char *boolean_false = "false";
9310       static char *null_pointer = "null";
9311       char ch[3];
9312       char *string;
9313
9314       if (op2 == boolean_true_node)
9315         string = boolean_true;
9316       else if (op2 == boolean_false_node)
9317         string = boolean_false;
9318       else if (op2 == null_pointer_node)
9319         string = null_pointer;
9320       else if (TREE_TYPE (op2) == char_type_node)
9321         {
9322           ch[0] = (char )TREE_INT_CST_LOW (op2);
9323           ch[1] = '\0';
9324           string = ch;
9325         }
9326       else
9327           string = print_int_node (op2);
9328
9329       return do_merge_string_cste (op1, string, strlen (string), after);
9330     }
9331   return NULL_TREE;
9332 }
9333
9334 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
9335    has to be a STRING_CST and the other part must be a STRING_CST or a
9336    INTEGRAL constant. Return a new STRING_CST if the operation
9337    succeed, NULL_TREE otherwise.
9338
9339    If the case we want to optimize for space, we might want to return
9340    NULL_TREE for each invocation of this routine. FIXME */
9341
9342 static tree
9343 string_constant_concatenation (op1, op2)
9344      tree op1, op2;
9345 {
9346   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
9347     {
9348       tree string, rest;
9349       int invert;
9350
9351       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
9352       rest   = (string == op1 ? op2 : op1);
9353       invert = (string == op1 ? 0 : 1 );
9354
9355       /* Walk REST, only if it looks reasonable */
9356       if (TREE_CODE (rest) != STRING_CST
9357           && !IS_CRAFTED_STRING_BUFFER_P (rest)
9358           && !JSTRING_TYPE_P (TREE_TYPE (rest))
9359           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
9360         {
9361           rest = java_complete_tree (rest);
9362           if (rest == error_mark_node)
9363             return error_mark_node;
9364           rest = fold (rest);
9365         }
9366       return merge_string_cste (string, rest, invert);
9367     }
9368   return NULL_TREE;
9369 }
9370
9371 /* Implement the `+' operator. Does static optimization if possible,
9372    otherwise create (if necessary) and append elements to a
9373    StringBuffer. The StringBuffer will be carried around until it is
9374    used for a function call or an assignment. Then toString() will be
9375    called on it to turn it into a String object. */
9376
9377 static tree
9378 build_string_concatenation (op1, op2)
9379      tree op1, op2;
9380 {
9381   tree result;
9382   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
9383
9384
9385   /* Try to do some static optimization */
9386   if ((result = string_constant_concatenation (op1, op2)))
9387     return result;
9388
9389   /* Discard null constants on either sides of the expression */
9390   if (TREE_CODE (op1) == STRING_CST && !TREE_STRING_LENGTH (op1))
9391     {
9392       op1 = op2;
9393       op2 = NULL_TREE;
9394     }
9395   else if (TREE_CODE (op2) == STRING_CST && !TREE_STRING_LENGTH (op2))
9396     op2 = NULL_TREE;
9397
9398   /* If operands are string constant, turn then into object references */
9399   if (TREE_CODE (op1) == STRING_CST)
9400     op1 = patch_string_cst (op1);
9401   if (op2 && TREE_CODE (op2) == STRING_CST)
9402     op2 = patch_string_cst (op2);
9403
9404   /* If either one of the constant is null and the other non null
9405      operand is a String object, return it. */
9406   if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
9407     return op1;
9408
9409   /* If OP1 isn't already a StringBuffer, create and
9410      initialize a new one */
9411   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
9412     {
9413       /* Two solutions here:
9414          1) OP1 is a string reference, we call new StringBuffer(OP1)
9415          2) OP1 is something else, we call new StringBuffer().append(OP1). */
9416       if (JSTRING_TYPE_P (TREE_TYPE (op1)))
9417         op1 = BUILD_STRING_BUFFER (op1);
9418       else
9419         {
9420           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
9421           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
9422         }
9423     }
9424
9425   if (op2)
9426     {
9427       /* OP1 is no longer the last node holding a crafted StringBuffer */
9428       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
9429       /* Create a node for `{new...,xxx}.append (op2)' */
9430       if (op2)
9431         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
9432     }
9433
9434   /* Mark the last node holding a crafted StringBuffer */
9435   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
9436
9437   TREE_SIDE_EFFECTS (op1) = side_effects;
9438   return op1;
9439 }
9440
9441 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
9442    StringBuffer. If no string were found to be patched, return
9443    NULL. */
9444
9445 static tree
9446 patch_string (node)
9447     tree node;
9448 {
9449   if (node == error_mark_node)
9450     return error_mark_node;
9451   if (TREE_CODE (node) == STRING_CST)
9452     return patch_string_cst (node);
9453   else if (IS_CRAFTED_STRING_BUFFER_P (node))
9454     {
9455       int saved = ctxp->explicit_constructor_p;
9456       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
9457       tree ret;
9458       /* Temporary disable forbid the use of `this'. */
9459       ctxp->explicit_constructor_p = 0;
9460       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
9461       /* Restore it at its previous value */
9462       ctxp->explicit_constructor_p = saved;
9463       return ret;
9464     }
9465   return NULL_TREE;
9466 }
9467
9468 /* Build the internal representation of a string constant.  */
9469
9470 static tree
9471 patch_string_cst (node)
9472      tree node;
9473 {
9474   int location;
9475   if (! flag_emit_class_files)
9476     {
9477       push_obstacks (&permanent_obstack, &permanent_obstack);
9478       node = get_identifier (TREE_STRING_POINTER (node));
9479       location = alloc_name_constant (CONSTANT_String, node);
9480       node = build_ref_from_constant_pool (location);
9481     }
9482   TREE_TYPE (node) = promote_type (string_type_node);
9483   TREE_CONSTANT (node) = 1;
9484   return node;
9485 }
9486
9487 /* Build an incomplete unary operator expression. */
9488
9489 static tree
9490 build_unaryop (op_token, op_location, op1)
9491      int op_token, op_location;
9492      tree op1;
9493 {
9494   enum tree_code op;
9495   tree unaryop;
9496   switch (op_token)
9497     {
9498     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
9499     case MINUS_TK: op = NEGATE_EXPR; break;
9500     case NEG_TK: op = TRUTH_NOT_EXPR; break;
9501     case NOT_TK: op = BIT_NOT_EXPR; break;
9502     default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
9503                     op_token);
9504     }
9505
9506   unaryop = build1 (op, NULL_TREE, op1);
9507   TREE_SIDE_EFFECTS (unaryop) = 1;
9508   /* Store the location of the operator, for better error report. The
9509      string of the operator will be rebuild based on the OP value. */
9510   EXPR_WFL_LINECOL (unaryop) = op_location;
9511   return unaryop;
9512 }
9513
9514 /* Special case for the ++/-- operators, since they require an extra
9515    argument to build, which is set to NULL and patched
9516    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
9517
9518 static tree
9519 build_incdec (op_token, op_location, op1, is_post_p)
9520      int op_token, op_location;
9521      tree op1;
9522      int is_post_p;
9523 {
9524   static enum tree_code lookup [2][2] =
9525     {
9526       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
9527       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
9528     };
9529   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
9530                      NULL_TREE, op1, NULL_TREE);
9531   TREE_SIDE_EFFECTS (node) = 1;
9532   /* Store the location of the operator, for better error report. The
9533      string of the operator will be rebuild based on the OP value. */
9534   EXPR_WFL_LINECOL (node) = op_location;
9535   return node;
9536 }
9537
9538 /* Build an incomplete cast operator, based on the use of the
9539    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
9540    set. java_complete_tree is trained to walk a CONVERT_EXPR even
9541    though its type is already set.  */
9542
9543 static tree
9544 build_cast (location, type, exp)
9545      int location;
9546      tree type, exp;
9547 {
9548   tree node = build1 (CONVERT_EXPR, type, exp);
9549   EXPR_WFL_LINECOL (node) = location;
9550   return node;
9551 }
9552
9553 /* 15.14 Unary operators. We return error_mark_node in case of error,
9554    but preserve the type of NODE if the type is fixed.  */
9555
9556 static tree
9557 patch_unaryop (node, wfl_op)
9558      tree node;
9559      tree wfl_op;
9560 {
9561   tree op = TREE_OPERAND (node, 0);
9562   tree op_type = TREE_TYPE (op);
9563   tree prom_type, value, decl;
9564   int code = TREE_CODE (node);
9565   int error_found = 0;
9566
9567   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
9568
9569   switch (code)
9570     {
9571       /* 15.13.2 Postfix Increment Operator ++ */
9572     case POSTINCREMENT_EXPR:
9573       /* 15.13.3 Postfix Increment Operator -- */
9574     case POSTDECREMENT_EXPR:
9575       /* 15.14.1 Prefix Increment Operator ++ */
9576     case PREINCREMENT_EXPR:
9577       /* 15.14.2 Prefix Decrement Operator -- */
9578     case PREDECREMENT_EXPR:
9579       decl = strip_out_static_field_access_decl (op);
9580       if (!JDECL_P (decl)
9581           && !((TREE_CODE (decl) == INDIRECT_REF
9582                 || TREE_CODE (decl) == COMPONENT_REF)
9583                && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))))
9584         {
9585           tree lvalue;
9586           /* Before screaming, check that we're not in fact trying to
9587              increment a optimized static final access, in which case
9588              we issue an different error message. */
9589           if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION
9590                 && resolve_expression_name (wfl_op, &lvalue)
9591                 && check_final_assignment (lvalue, wfl_op)))
9592             parse_error_context (wfl_operator, "Invalid argument to `%s'",
9593                                  operator_string (node));
9594           TREE_TYPE (node) = error_mark_node;
9595           error_found = 1;
9596         }
9597       else if (check_final_assignment (op, wfl_op))
9598         error_found = 1;
9599
9600       /* From now on, we know that op if a variable and that it has a
9601          valid wfl. We use wfl_op to locate errors related to the
9602          ++/-- operand. */
9603       else if (!JNUMERIC_TYPE_P (op_type))
9604         {
9605           parse_error_context
9606             (wfl_op, "Invalid argument type `%s' to `%s'",
9607              lang_printable_name (op_type, 0), operator_string (node));
9608           TREE_TYPE (node) = error_mark_node;
9609           error_found = 1;
9610         }
9611       else
9612         {
9613           /* Before the addition, binary numeric promotion is performed on
9614              both operands */
9615           value = build_int_2 (1, 0);
9616           TREE_TYPE (node) =
9617             binary_numeric_promotion (op_type, TREE_TYPE (value), &op, &value);
9618           /* And write the promoted incremented and increment */
9619           TREE_OPERAND (node, 0) = op;
9620           TREE_OPERAND (node, 1) = value;
9621           /* Convert the overall back into its original type. */
9622           return fold (convert (op_type, node));
9623         }
9624       break;
9625
9626       /* 15.14.3 Unary Plus Operator + */
9627     case UNARY_PLUS_EXPR:
9628       /* 15.14.4 Unary Minus Operator - */
9629     case NEGATE_EXPR:
9630       if (!JNUMERIC_TYPE_P (op_type))
9631         {
9632           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
9633           TREE_TYPE (node) = error_mark_node;
9634           error_found = 1;
9635         }
9636       /* Unary numeric promotion is performed on operand */
9637       else
9638         {
9639           op = do_unary_numeric_promotion (op);
9640           prom_type = TREE_TYPE (op);
9641           if (code == UNARY_PLUS_EXPR)
9642             return fold (op);
9643         }
9644       break;
9645
9646       /* 15.14.5 Bitwise Complement Operator ~ */
9647     case BIT_NOT_EXPR:
9648       if (!JINTEGRAL_TYPE_P (op_type))
9649         {
9650           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
9651           TREE_TYPE (node) = error_mark_node;
9652           error_found = 1;
9653         }
9654       else
9655         {
9656           op = do_unary_numeric_promotion (op);
9657           prom_type = TREE_TYPE (op);
9658         }
9659       break;
9660
9661       /* 15.14.6 Logical Complement Operator ! */
9662     case TRUTH_NOT_EXPR:
9663       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
9664         {
9665           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
9666           /* But the type is known. We will report an error if further
9667              attempt of a assignment is made with this rhs */
9668           TREE_TYPE (node) = boolean_type_node;
9669           error_found = 1;
9670         }
9671       else
9672         prom_type = boolean_type_node;
9673       break;
9674
9675       /* 15.15 Cast Expression */
9676     case CONVERT_EXPR:
9677       value = patch_cast (node, wfl_operator);
9678       if (value == error_mark_node)
9679         {
9680           /* If this cast is part of an assignment, we tell the code
9681              that deals with it not to complain about a mismatch,
9682              because things have been cast, anyways */
9683           TREE_TYPE (node) = error_mark_node;
9684           error_found = 1;
9685         }
9686       else
9687         {
9688           value = fold (value);
9689           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
9690           return value;
9691         }
9692       break;
9693     }
9694
9695   if (error_found)
9696     return error_mark_node;
9697
9698   /* There are cases where node has been replaced by something else
9699      and we don't end up returning here: UNARY_PLUS_EXPR,
9700      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
9701   TREE_OPERAND (node, 0) = fold (op);
9702   TREE_TYPE (node) = prom_type;
9703   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
9704   return fold (node);
9705 }
9706
9707 /* Generic type resolution that sometimes takes place during node
9708    patching. Returned the resolved type or generate an error
9709    message. Return the resolved type or NULL_TREE.  */
9710
9711 static tree
9712 resolve_type_during_patch (type)
9713      tree type;
9714 {
9715   if (unresolved_type_p (type, NULL))
9716     {
9717       tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
9718       if (!type_decl)
9719         {
9720           parse_error_context (type,
9721                                "Class `%s' not found in type declaration",
9722                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
9723           return NULL_TREE;
9724         }
9725       else
9726         {
9727           CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1;
9728           return TREE_TYPE (type_decl);
9729         }
9730     }
9731   return type;
9732 }
9733 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
9734    found. Otherwise NODE or something meant to replace it is returned.  */
9735
9736 static tree
9737 patch_cast (node, wfl_operator)
9738      tree node;
9739      tree wfl_operator;
9740 {
9741   tree op = TREE_OPERAND (node, 0);
9742   tree op_type = TREE_TYPE (op);
9743   tree cast_type = TREE_TYPE (node);
9744   char *t1;
9745
9746   /* First resolve OP_TYPE if unresolved */
9747   if (!(cast_type = resolve_type_during_patch (cast_type)))
9748     return error_mark_node;
9749
9750   /* Check on cast that are proven correct at compile time */
9751   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
9752     {
9753       static tree convert_narrow ();
9754       /* Same type */
9755       if (cast_type == op_type)
9756         return node;
9757
9758       /* float and double type are converted to the original type main
9759          variant and then to the target type. */
9760       if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
9761         op = convert (integer_type_node, op);
9762
9763       /* Try widening/narowwing convertion. Potentially, things need
9764          to be worked out in gcc so we implement the extreme cases
9765          correctly. fold_convert() needs to be fixed. */
9766       return convert (cast_type, op);
9767     }
9768
9769   /* It's also valid to cast a boolean into a boolean */
9770   if (op_type == boolean_type_node && cast_type == boolean_type_node)
9771     return node;
9772
9773   /* null can be casted to references */
9774   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
9775     return build_null_of_type (cast_type);
9776
9777   /* The remaining legal casts involve conversion between reference
9778      types. Check for their compile time correctness. */
9779   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
9780       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
9781     {
9782       TREE_TYPE (node) = promote_type (cast_type);
9783       /* Now, the case can be determined correct at compile time if
9784          OP_TYPE can be converted into CAST_TYPE by assignment
9785          conversion (5.2) */
9786
9787       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
9788         {
9789           TREE_SET_CODE (node, NOP_EXPR);
9790           return node;
9791         }
9792
9793       if (flag_emit_class_files)
9794         {
9795           TREE_SET_CODE (node, CONVERT_EXPR);
9796           return node;
9797         }
9798
9799       /* The cast requires a run-time check */
9800       return build (CALL_EXPR, promote_type (cast_type),
9801                     build_address_of (soft_checkcast_node),
9802                     tree_cons (NULL_TREE, build_class_ref (cast_type),
9803                                build_tree_list (NULL_TREE, op)),
9804                     NULL_TREE);
9805     }
9806
9807   /* Any other casts are proven incorrect at compile time */
9808   t1 = strdup (lang_printable_name (op_type, 0));
9809   parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
9810                        t1, lang_printable_name (cast_type, 0));
9811   free (t1);
9812   return error_mark_node;
9813 }
9814
9815 /* Build a null constant and give it the type TYPE.  */
9816
9817 static tree
9818 build_null_of_type (type)
9819      tree type;
9820 {
9821   tree node = build_int_2 (0, 0);
9822   TREE_TYPE (node) = promote_type (type);
9823   return node;
9824 }
9825
9826 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
9827    a list of indices. */
9828 static tree
9829 build_array_ref (location, array, index)
9830      int location;
9831      tree array, index;
9832 {
9833   tree node = build (ARRAY_REF, NULL_TREE, array, index);
9834   EXPR_WFL_LINECOL (node) = location;
9835   return node;
9836 }
9837
9838 /* 15.12 Array Access Expression */
9839
9840 static tree
9841 patch_array_ref (node)
9842      tree node;
9843 {
9844   tree array = TREE_OPERAND (node, 0);
9845   tree array_type  = TREE_TYPE (array);
9846   tree index = TREE_OPERAND (node, 1);
9847   tree index_type = TREE_TYPE (index);
9848   int error_found = 0;
9849
9850   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
9851
9852   if (TREE_CODE (array_type) == POINTER_TYPE)
9853     array_type = TREE_TYPE (array_type);
9854
9855   /* The array reference must be an array */
9856   if (!TYPE_ARRAY_P (array_type))
9857     {
9858       parse_error_context
9859         (wfl_operator, "`[]' can only be applied to arrays. It can't be "
9860          "applied to `%s'", lang_printable_name (array_type, 0));
9861       TREE_TYPE (node) = error_mark_node;
9862       error_found = 1;
9863     }
9864
9865   /* The array index underdoes unary numeric promotion. The promoted
9866      type must be int */
9867   index = do_unary_numeric_promotion (index);
9868   if (TREE_TYPE (index) != int_type_node)
9869     {
9870       int could_cast = valid_cast_to_p (index_type, int_type_node);
9871       parse_error_context
9872         (wfl_operator,
9873          (could_cast ? "Incompatible type for `[]'. Explicit cast needed to "
9874           "convert `%s' to `int'" : "Incompatible type for `[]'. "
9875           "Can't convert `%s' to `int'"),
9876          lang_printable_name (index_type, 0));
9877       TREE_TYPE (node) = error_mark_node;
9878       error_found = 1;
9879     }
9880
9881   if (error_found)
9882     return error_mark_node;
9883
9884   array_type = TYPE_ARRAY_ELEMENT (array_type);
9885
9886   if (flag_emit_class_files)
9887     {
9888       TREE_OPERAND (node, 0) = array;
9889       TREE_OPERAND (node, 1) = index;
9890     }
9891   else
9892     {
9893       /* The save_expr is for correct evaluation order.  It would be cleaner
9894          to use force_evaluation_order (see comment there), but that is
9895          difficult when we also have to deal with bounds checking. */
9896       if (TREE_SIDE_EFFECTS (index))
9897         array = save_expr (array);
9898       node = build_java_arrayaccess (array, array_type, index);
9899       if (TREE_SIDE_EFFECTS (index))
9900         node = build (COMPOUND_EXPR, array_type, array, node);
9901     }
9902   TREE_TYPE (node) = array_type;
9903   return node;
9904 }
9905
9906 /* 15.9 Array Creation Expressions */
9907
9908 static tree
9909 build_newarray_node (type, dims, extra_dims)
9910      tree type;
9911      tree dims;
9912      int extra_dims;
9913 {
9914   tree node =
9915     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
9916            build_int_2 (extra_dims, 0));
9917   return node;
9918 }
9919
9920 static tree
9921 patch_newarray (node)
9922      tree node;
9923 {
9924   tree type = TREE_OPERAND (node, 0);
9925   tree dims = TREE_OPERAND (node, 1);
9926   tree cdim, array_type;
9927   int error_found = 0;
9928   int ndims = 0;
9929   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
9930
9931   /* Dimension types are verified. It's better for the types to be
9932      verified in order. */
9933   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
9934     {
9935       int dim_error = 0;
9936       tree dim = TREE_VALUE (cdim);
9937
9938       /* Dim might have been saved during its evaluation */
9939       dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
9940
9941       /* The type of each specified dimension must be an integral type. */
9942       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
9943         dim_error = 1;
9944
9945       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
9946          promoted type must be int. */
9947       else
9948         {
9949           dim = do_unary_numeric_promotion (dim);
9950           if (TREE_TYPE (dim) != int_type_node)
9951             dim_error = 1;
9952         }
9953
9954       /* Report errors on types here */
9955       if (dim_error)
9956         {
9957           parse_error_context
9958             (TREE_PURPOSE (cdim),
9959              "Incompatible type for dimension in array creation expression. "
9960              "%s convert `%s' to `int'",
9961              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
9962               "Explicit cast needed to" : "Can't"),
9963              lang_printable_name (TREE_TYPE (dim), 0));
9964           error_found = 1;
9965         }
9966
9967       TREE_PURPOSE (cdim) = NULL_TREE;
9968     }
9969
9970   /* Resolve array base type if unresolved */
9971   if (!(type = resolve_type_during_patch (type)))
9972     error_found = 1;
9973
9974   if (error_found)
9975     {
9976       /* We don't want further evaluation of this bogus array creation
9977          operation */
9978       TREE_TYPE (node) = error_mark_node;
9979       return error_mark_node;
9980     }
9981
9982   /* Set array_type to the actual (promoted) array type of the result. */
9983   if (TREE_CODE (type) == RECORD_TYPE)
9984     type = build_pointer_type (type);
9985   while (--xdims >= 0)
9986     {
9987       type = promote_type (build_java_array_type (type, -1));
9988     }
9989   dims = nreverse (dims);
9990   array_type = type;
9991   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
9992     {
9993       type = array_type;
9994       array_type = build_java_array_type (type,
9995                                           TREE_CODE (cdim) == INTEGER_CST ?
9996                                           TREE_INT_CST_LOW (cdim) : -1);
9997       array_type = promote_type (array_type);
9998     }
9999   dims = nreverse (dims);
10000
10001   /* The node is transformed into a function call. Things are done
10002      differently according to the number of dimensions. If the number
10003      of dimension is equal to 1, then the nature of the base type
10004      (primitive or not) matters. */
10005   if (ndims == 1)
10006     return build_new_array (type, TREE_VALUE (dims));
10007
10008   /* Can't reuse what's already written in expr.c because it uses the
10009      JVM stack representation. Provide a build_multianewarray. FIXME */
10010   return build (CALL_EXPR, array_type,
10011                 build_address_of (soft_multianewarray_node),
10012                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
10013                            tree_cons (NULL_TREE,
10014                                       build_int_2 (ndims, 0), dims )),
10015                 NULL_TREE);
10016 }
10017
10018 /* 10.6 Array initializer.  */
10019
10020 /* Build a wfl for array element that don't have one, so we can
10021    pin-point errors.  */
10022
10023 static tree
10024 maybe_build_array_element_wfl (node)
10025      tree node;
10026 {
10027   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
10028     return build_expr_wfl (NULL_TREE, ctxp->filename,
10029                            ctxp->elc.line, ctxp->elc.prev_col);
10030   else
10031     return NULL_TREE;
10032 }
10033
10034 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
10035    identification of initialized arrays easier to detect during walk
10036    and expansion.  */
10037
10038 static tree
10039 build_new_array_init (location, values)
10040      int location;
10041      tree values;
10042 {
10043   tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
10044   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
10045   EXPR_WFL_LINECOL (to_return) = location;
10046   return to_return;
10047 }
10048
10049 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
10050    occurred.  Otherwise return NODE after having set its type
10051    appropriately.  */
10052
10053 static tree
10054 patch_new_array_init (type, node)
10055      tree type, node;
10056 {
10057   int error_seen = 0;
10058   tree current, element_type;
10059   HOST_WIDE_INT length;
10060   int all_constant = 1;
10061   tree init = TREE_OPERAND (node, 0);
10062
10063   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
10064     {
10065       parse_error_context (node,
10066                            "Invalid array initializer for non-array type `%s'",
10067                            lang_printable_name (type, 1));
10068       return error_mark_node;
10069     }
10070   type = TREE_TYPE (type);
10071   element_type = TYPE_ARRAY_ELEMENT (type);
10072
10073   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
10074
10075   for (length = 0, current = CONSTRUCTOR_ELTS (init);
10076        current;  length++, current = TREE_CHAIN (current))
10077     {
10078       tree elt = TREE_VALUE (current);
10079       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
10080         {
10081           error_seen |= array_constructor_check_entry (element_type, current);
10082           elt = TREE_VALUE (current);
10083           /* When compiling to native code, STRING_CST is converted to
10084              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
10085           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
10086             all_constant = 0;
10087         }
10088       else
10089         {
10090           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
10091           TREE_PURPOSE (current) = NULL_TREE;
10092           all_constant = 0;
10093         }
10094       if (elt && TREE_VALUE (elt) == error_mark_node)
10095         error_seen = 1;
10096     }
10097
10098   if (error_seen)
10099     return error_mark_node;
10100
10101   /* Create a new type. We can't reuse the one we have here by
10102      patching its dimension because it originally is of dimension -1
10103      hence reused by gcc. This would prevent triangular arrays. */
10104   type = build_java_array_type (element_type, length);
10105   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
10106   TREE_TYPE (node) = promote_type (type);
10107   TREE_CONSTANT (init) = all_constant;
10108   TREE_CONSTANT (node) = all_constant;
10109   return node;
10110 }
10111
10112 /* Verify that one entry of the initializer element list can be
10113    assigned to the array base type. Report 1 if an error occurred, 0
10114    otherwise.  */
10115
10116 static int
10117 array_constructor_check_entry (type, entry)
10118      tree type, entry;
10119 {
10120   char *array_type_string = NULL;       /* For error reports */
10121   tree value, type_value, new_value, wfl_value, patched;
10122   int error_seen = 0;
10123
10124   new_value = NULL_TREE;
10125   wfl_value = TREE_VALUE (entry);
10126
10127   value = java_complete_tree (TREE_VALUE (entry));
10128   /* patch_string return error_mark_node if arg is error_mark_node */
10129   if ((patched = patch_string (value)))
10130     value = patched;
10131   if (value == error_mark_node)
10132     return 1;
10133
10134   type_value = TREE_TYPE (value);
10135
10136   /* At anytime, try_builtin_assignconv can report a warning on
10137      constant overflow during narrowing. */
10138   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
10139   new_value = try_builtin_assignconv (wfl_operator, type, value);
10140   if (!new_value && (new_value = try_reference_assignconv (type, value)))
10141     type_value = promote_type (type);
10142
10143   /* Check and report errors */
10144   if (!new_value)
10145     {
10146       char *msg = (!valid_cast_to_p (type_value, type) ?
10147                    "Can't" : "Explicit cast needed to");
10148       if (!array_type_string)
10149         array_type_string = strdup (lang_printable_name (type, 1));
10150       parse_error_context
10151         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
10152          msg, lang_printable_name (type_value, 1), array_type_string);
10153       error_seen = 1;
10154     }
10155
10156   if (new_value)
10157     {
10158       new_value = maybe_build_primttype_type_ref (new_value, wfl_operator);
10159       TREE_VALUE (entry) = new_value;
10160     }
10161
10162   if (array_type_string)
10163     free (array_type_string);
10164
10165   TREE_PURPOSE (entry) = NULL_TREE;
10166   return error_seen;
10167 }
10168
10169 static tree
10170 build_this (location)
10171      int location;
10172 {
10173   tree node = build_wfl_node (this_identifier_node, input_filename, 0, 0);
10174   TREE_SET_CODE (node, THIS_EXPR);
10175   EXPR_WFL_LINECOL (node) = location;
10176   return node;
10177 }
10178
10179 /* 14.15 The return statement. It builds a modify expression that
10180    assigns the returned value to the RESULT_DECL that hold the value
10181    to be returned. */
10182
10183 static tree
10184 build_return (location, op)
10185      int location;
10186      tree op;
10187 {
10188   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
10189   EXPR_WFL_LINECOL (node) = location;
10190   node = build_debugable_stmt (location, node);
10191   return node;
10192 }
10193
10194 static tree
10195 patch_return (node)
10196      tree node;
10197 {
10198   tree return_exp = TREE_OPERAND (node, 0);
10199   tree meth = current_function_decl;
10200   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
10201   int error_found = 0;
10202
10203   TREE_TYPE (node) = error_mark_node;
10204   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10205
10206   /* It's invalid to have a return value within a function that is
10207      declared with the keyword void or that is a constructor */
10208   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
10209     error_found = 1;
10210
10211   /* It's invalid to have a no return value within a function that
10212      isn't declared with the keyword `void' */
10213   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
10214     error_found = 2;
10215
10216   if (error_found)
10217     {
10218       if (!DECL_CONSTRUCTOR_P (meth))
10219         {
10220           char *t = strdup (lang_printable_name (mtype, 0));
10221           parse_error_context (wfl_operator,
10222                                "`return' with%s value from `%s %s'",
10223                                (error_found == 1 ? "" : "out"),
10224                                t, lang_printable_name (meth, 0));
10225           free (t);
10226         }
10227       else
10228         parse_error_context (wfl_operator,
10229                              "`return' with value from constructor `%s'",
10230                              lang_printable_name (meth, 0));
10231       return error_mark_node;
10232     }
10233
10234   /* If we have a return_exp, build a modify expression and expand
10235      it. Note: at that point, the assignment is declared valid, but we
10236      may want to carry some more hacks */
10237   if (return_exp)
10238     {
10239       tree exp = java_complete_tree (return_exp);
10240       tree modify, patched;
10241
10242       /* If the function returned value and EXP are booleans, EXP has
10243       to be converted into the type of DECL_RESULT, which is integer
10244       (see complete_start_java_method) */
10245       if (TREE_TYPE (exp) == boolean_type_node &&
10246           TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node)
10247         exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp);
10248
10249       /* `null' can be assigned to a function returning a reference */
10250       if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) &&
10251           exp == null_pointer_node)
10252         exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth)));
10253
10254       if ((patched = patch_string (exp)))
10255         exp = patched;
10256
10257       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
10258       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
10259       modify = java_complete_tree (modify);
10260
10261       if (modify != error_mark_node)
10262         {
10263           TREE_SIDE_EFFECTS (modify) = 1;
10264           TREE_OPERAND (node, 0) = modify;
10265         }
10266       else
10267         return error_mark_node;
10268     }
10269   TREE_TYPE (node) = void_type_node;
10270   TREE_SIDE_EFFECTS (node) = 1;
10271   return node;
10272 }
10273
10274 /* 14.8 The if Statement */
10275
10276 static tree
10277 build_if_else_statement (location, expression, if_body, else_body)
10278      int location;
10279      tree expression, if_body, else_body;
10280 {
10281   tree node;
10282   if (!else_body)
10283     else_body = empty_stmt_node;
10284   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
10285   EXPR_WFL_LINECOL (node) = location;
10286   node = build_debugable_stmt (location, node);
10287   return node;
10288 }
10289
10290 static tree
10291 patch_if_else_statement (node)
10292      tree node;
10293 {
10294   tree expression = TREE_OPERAND (node, 0);
10295
10296   TREE_TYPE (node) = error_mark_node;
10297   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10298
10299   /* The type of expression must be boolean */
10300   if (TREE_TYPE (expression) != boolean_type_node
10301       && TREE_TYPE (expression) != promoted_boolean_type_node)
10302     {
10303       parse_error_context
10304         (wfl_operator,
10305          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
10306          lang_printable_name (TREE_TYPE (expression), 0));
10307       return error_mark_node;
10308     }
10309
10310   TREE_TYPE (node) = void_type_node;
10311   TREE_SIDE_EFFECTS (node) = 1;
10312   CAN_COMPLETE_NORMALLY (node)
10313     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
10314     | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2));
10315   return node;
10316 }
10317
10318 /* 14.6 Labeled Statements */
10319
10320 /* Action taken when a lableled statement is parsed. a new
10321    LABELED_BLOCK_EXPR is created. No statement is attached to the
10322    label, yet.  */
10323
10324 static tree
10325 build_labeled_block (location, label)
10326      int location;
10327      tree label;
10328 {
10329   tree label_name = merge_qualified_name (label_id, label);
10330   tree label_decl, node;
10331
10332   /* Issue an error if we try to reuse a label that was previously
10333      declared */
10334   if (IDENTIFIER_LOCAL_VALUE (label_name))
10335     {
10336       EXPR_WFL_LINECOL (wfl_operator) = location;
10337       parse_error_context (wfl_operator, "Declaration of `%s' shadows "
10338                              "a previous label declaration",
10339                              IDENTIFIER_POINTER (label));
10340       EXPR_WFL_LINECOL (wfl_operator) =
10341         EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
10342       parse_error_context (wfl_operator, "This is the location of the "
10343                            "previous declaration of label `%s'",
10344                            IDENTIFIER_POINTER (label));
10345       java_error_count--;
10346     }
10347
10348   label_decl = create_label_decl (label_name);
10349   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
10350   EXPR_WFL_LINECOL (node) = location;
10351   TREE_SIDE_EFFECTS (node) = 1;
10352   return node;
10353 }
10354
10355 /* Generate a label crafting a unique name for it. This is used to
10356    implicitely label loops that aren't the body part of labeled
10357    statement.  */
10358
10359 static tree
10360 generate_labeled_block ()
10361 {
10362   return build_labeled_block (0, generate_name ());
10363 }
10364
10365 /* A labeled statement LBE is attached a statement.  */
10366
10367 static tree
10368 complete_labeled_statement (lbe, statement)
10369      tree lbe;                  /* Labeled block expr */
10370      tree statement;
10371 {
10372   /* In anyways, tie the loop to its statement */
10373   LABELED_BLOCK_BODY (lbe) = statement;
10374
10375   /* Ok, if statement is a for loop, we have to attach the labeled
10376      statement to the block the for loop belongs to and return the
10377      block instead */
10378   if (TREE_CODE (statement) == LOOP_EXPR && IS_FOR_LOOP_P (statement))
10379     {
10380       java_method_add_stmt (current_function_decl, lbe);
10381       return exit_block ();
10382     }
10383
10384   return lbe;
10385 }
10386
10387 /* 14.10, 14.11, 14.12 Loop Statements */
10388
10389 /* Create an empty LOOP_EXPR and make it the last in the nested loop
10390    list. */
10391
10392 static tree
10393 build_new_loop (loop_body)
10394      tree loop_body;
10395 {
10396   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
10397   TREE_SIDE_EFFECTS (loop) = 1;
10398   PUSH_LOOP (loop);
10399   return loop;
10400 }
10401
10402 /* Create a loop body according to the following structure:
10403      COMPOUND_EXPR
10404        COMPOUND_EXPR            (loop main body)
10405          EXIT_EXPR              (this order is for while/for loops.
10406          LABELED_BLOCK_EXPR      the order is reversed for do loops)
10407            LABEL_DECL           (a continue occuring here branches at the
10408            BODY                  end of this labeled block)
10409        INCREMENT                (if any)
10410
10411   REVERSED, if non zero, tells that the loop condition expr comes
10412   after the body, like in the do-while loop.
10413
10414   To obtain a loop, the loop body structure described above is
10415   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
10416
10417    LABELED_BLOCK_EXPR
10418      LABEL_DECL                   (use this label to exit the loop)
10419      LOOP_EXPR
10420        <structure described above> */
10421
10422 static tree
10423 build_loop_body (location, condition, reversed)
10424      int location;
10425      tree condition;
10426      int reversed;
10427 {
10428   tree first, second, body;
10429
10430   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
10431   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
10432   condition = build_debugable_stmt (location, condition);
10433   TREE_SIDE_EFFECTS (condition) = 1;
10434
10435   body = generate_labeled_block ();
10436   first = (reversed ? body : condition);
10437   second = (reversed ? condition : body);
10438   return
10439     build (COMPOUND_EXPR, NULL_TREE,
10440            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
10441 }
10442
10443 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
10444    their order) on the current loop. Unlink the current loop from the
10445    loop list.  */
10446
10447 static tree
10448 complete_loop_body (location, condition, body, reversed)
10449      int location;
10450      tree condition, body;
10451      int reversed;
10452 {
10453   tree to_return = ctxp->current_loop;
10454   tree loop_body = LOOP_EXPR_BODY (to_return);
10455   if (condition)
10456     {
10457       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
10458       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
10459          The real EXIT_EXPR is one operand further. */
10460       EXPR_WFL_LINECOL (cnode) = location;
10461       /* This one is for accurate error reports */
10462       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
10463       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
10464     }
10465   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
10466   POP_LOOP ();
10467   return to_return;
10468 }
10469
10470 /* Tailored version of complete_loop_body for FOR loops, when FOR
10471    loops feature the condition part */
10472
10473 static tree
10474 complete_for_loop (location, condition, update, body)
10475     int location;
10476     tree condition, update, body;
10477 {
10478   /* Put the condition and the loop body in place */
10479   tree loop = complete_loop_body (location, condition, body, 0);
10480   /* LOOP is the current loop which has been now popped of the loop
10481      stack. Install the update block */
10482   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
10483   return loop;
10484 }
10485
10486 /* If the loop isn't surrounded by a labeled statement, create one and
10487    insert LOOP as it's body.  */
10488
10489 static tree
10490 patch_loop_statement (loop)
10491      tree loop;
10492 {
10493   tree loop_label, to_return_as_loop;
10494
10495   if (LOOP_HAS_LABEL_P (loop))
10496     {
10497       loop_label = ctxp->current_labeled_block;
10498       to_return_as_loop = loop;
10499     }
10500   else
10501     {
10502       loop_label = generate_labeled_block ();
10503       LABELED_BLOCK_BODY (loop_label) = loop;
10504       PUSH_LABELED_BLOCK (loop_label);
10505       to_return_as_loop = loop_label;
10506     }
10507   TREE_TYPE (to_return_as_loop) = void_type_node;
10508   return to_return_as_loop;
10509 }
10510
10511 /* 14.13, 14.14: break and continue Statements */
10512
10513 /* Build a break or a continue statement. a null NAME indicates an
10514    unlabeled break/continue statement.  */
10515
10516 static tree
10517 build_bc_statement (location, is_break, name)
10518      int location, is_break;
10519      tree name;
10520 {
10521   tree break_continue, label_block_expr = NULL_TREE;
10522
10523   if (name)
10524     {
10525       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
10526             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
10527         /* Null means that we don't have a target for this named
10528            break/continue. In this case, we make the target to be the
10529            label name, so that the error can be reported accuratly in
10530            patch_bc_statement. */
10531         label_block_expr = EXPR_WFL_NODE (name);
10532     }
10533   /* Unlabeled break/continue will be handled during the
10534      break/continue patch operation */
10535   break_continue
10536     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
10537
10538   IS_BREAK_STMT_P (break_continue) = is_break;
10539   TREE_SIDE_EFFECTS (break_continue) = 1;
10540   EXPR_WFL_LINECOL (break_continue) = location;
10541   break_continue = build_debugable_stmt (location, break_continue);
10542   return break_continue;
10543 }
10544
10545 /* Verification of a break/continue statement. */
10546
10547 static tree
10548 patch_bc_statement (node)
10549      tree node;
10550 {
10551   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
10552   int is_unlabeled = 0;
10553   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10554
10555   /* Not having a target means that the break/continue statement is
10556      unlabeled. We try to find a decent label for it */
10557   if (!bc_label)
10558     {
10559       is_unlabeled = 1;
10560       /* There should be a loop/switch to branch to */
10561       if (ctxp->current_loop)
10562         {
10563           if (TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
10564             {
10565               /* At that stage, we're in the loop body, which is
10566                  encapsulated around a LABELED_BLOCK_EXPR. So searching
10567                  the current loop label requires us to consider the
10568                  labeled block before the current one. */
10569               if (!LOOP_HAS_LABEL_SKIP_P (ctxp->current_loop))
10570                 fatal ("unlabeled loop has no installed label -- "
10571                        "patch_bc_statement");
10572               bc_label = TREE_CHAIN (ctxp->current_labeled_block);
10573             }
10574           /* For a SWITCH statement, this is the current one */
10575           else
10576             bc_label = ctxp->current_labeled_block;
10577         }
10578       /* Not having a loop to break/continue to is an error */
10579       else
10580         {
10581           parse_error_context (wfl_operator, "`%s' must be in loop%s",
10582                                (IS_BREAK_STMT_P (node) ? "break" : "continue"),
10583                                (IS_BREAK_STMT_P (node) ? " or switch" : ""));
10584           return error_mark_node;
10585         }
10586     }
10587   /* Having an identifier here means that the target is unknown. */
10588   else if (TREE_CODE (bc_label) == IDENTIFIER_NODE)
10589     {
10590       parse_error_context (wfl_operator, "No label definition found for `%s'",
10591                            IDENTIFIER_POINTER (bc_label));
10592       return error_mark_node;
10593     }
10594
10595   /* Find the statement we're targeting. */
10596   target_stmt = LABELED_BLOCK_BODY (bc_label);
10597
10598   /* Target loop is slightly burrowed in the case of a for loop, it
10599      appears at the first sight to be a block. */
10600   if (TREE_CODE (target_stmt) == BLOCK)
10601     {
10602       tree sub = BLOCK_SUBBLOCKS (target_stmt);
10603       if (sub && TREE_CODE (sub) == COMPOUND_EXPR && TREE_OPERAND (sub, 1)
10604           && TREE_CODE (TREE_OPERAND (sub, 1)) == LOOP_EXPR)
10605         target_stmt = TREE_OPERAND (sub, 1);
10606     }
10607
10608   /* 14.13 The break Statement */
10609   if (IS_BREAK_STMT_P (node))
10610     {
10611       /* Named break are always fine, as far as they have a target
10612          (already verified). Anonymous break need to target
10613          while/do/for/switch */
10614       if (is_unlabeled &&
10615           !(TREE_CODE (target_stmt) == LOOP_EXPR        /* do/while/for */
10616             || TREE_CODE (target_stmt) == SWITCH_EXPR)) /* switch */
10617         {
10618           parse_error_context (wfl_operator,
10619                                "`break' must be in loop or switch");
10620           return error_mark_node;
10621         }
10622       /* If previously unlabeled, install the new found label */
10623       if (is_unlabeled)
10624         EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
10625     }
10626   /* 14.14 The continue Statement */
10627   /* The continue statement must always target a loop, unnamed or not. */
10628   else
10629     {
10630       if (TREE_CODE (target_stmt) != LOOP_EXPR) /* do/while/for */
10631         {
10632           parse_error_context (wfl_operator, "`continue' must be in loop");
10633           return error_mark_node;
10634         }
10635       /* Everything looks good. We can fix the `continue' jump to go
10636          at the place in the loop were the continue is.  For unlabeled
10637          continue, the continuation point is the current labeled
10638          block, by construction. */
10639       if (is_unlabeled)
10640         EXIT_BLOCK_LABELED_BLOCK (node) =
10641           bc_label = ctxp->current_labeled_block;
10642     }
10643
10644   CAN_COMPLETE_NORMALLY (bc_label) = 1;
10645
10646   /* Our break/continue don't return values. */
10647   TREE_TYPE (node) = void_type_node;
10648   /* Encapsulate the break within a compound statement so that it's
10649      expanded all the times by expand_expr (and not clobered
10650      sometimes, like after a if statement) */
10651   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
10652   TREE_SIDE_EFFECTS (node) = 1;
10653   return node;
10654 }
10655
10656 /* Process the exit expression belonging to a loop. Its type must be
10657    boolean.  */
10658
10659 static tree
10660 patch_exit_expr (node)
10661      tree node;
10662 {
10663   tree expression = TREE_OPERAND (node, 0);
10664   TREE_TYPE (node) = error_mark_node;
10665   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10666
10667   /* The type of expression must be boolean */
10668   if (TREE_TYPE (expression) != boolean_type_node)
10669     {
10670       parse_error_context
10671         (wfl_operator,
10672          "Incompatible type for loop conditional. Can't convert `%s' to "
10673          "`boolean'",
10674          lang_printable_name (TREE_TYPE (expression), 0));
10675       return error_mark_node;
10676     }
10677   /* Now we know things are allright, invert the condition, fold and
10678      return */
10679   TREE_OPERAND (node, 0) =
10680     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
10681
10682   if (! integer_zerop (TREE_OPERAND (node, 0))
10683       && ctxp->current_loop != NULL_TREE
10684       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
10685     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
10686   if (! integer_onep (TREE_OPERAND (node, 0)))
10687     CAN_COMPLETE_NORMALLY (node) = 1;
10688
10689
10690   TREE_TYPE (node) = void_type_node;
10691   return node;
10692 }
10693
10694 /* 14.9 Switch statement */
10695
10696 static tree
10697 patch_switch_statement (node)
10698      tree node;
10699 {
10700   tree se = TREE_OPERAND (node, 0), se_type;
10701
10702   /* Complete the switch expression */
10703   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
10704   se_type = TREE_TYPE (se);
10705   /* The type of the switch expression must be char, byte, short or
10706      int */
10707   if (!JINTEGRAL_TYPE_P (se_type))
10708     {
10709       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10710       parse_error_context (wfl_operator, "Incompatible type for `switch'. "
10711                            "Can't convert `%s' to `int'",
10712                            lang_printable_name (se_type, 0));
10713       /* This is what java_complete_tree will check */
10714       TREE_OPERAND (node, 0) = error_mark_node;
10715       return error_mark_node;
10716     }
10717
10718   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10719
10720   /* Ready to return */
10721   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
10722     {
10723       TREE_TYPE (node) = error_mark_node;
10724       return error_mark_node;
10725     }
10726   TREE_TYPE (node) = void_type_node;
10727   TREE_SIDE_EFFECTS (node) = 1;
10728   CAN_COMPLETE_NORMALLY (node)
10729     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
10730       || ! SWITCH_HAS_DEFAULT (node);
10731   return node;
10732 }
10733
10734 /* 14.18 The try statement */
10735
10736 /* Wrap BLOCK around a LABELED_BLOCK, set DECL to the newly generated
10737    exit labeld and issue a jump to FINALLY_LABEL:
10738
10739    LABELED_BLOCK
10740      BLOCK
10741        <orignal_statments>
10742        DECL = &LABEL_DECL
10743        GOTO_EXPR
10744          FINALLY_LABEL
10745      LABEL_DECL */
10746
10747 static tree
10748 build_jump_to_finally (block, decl, finally_label, type)
10749      tree block, decl, finally_label, type;
10750 {
10751   tree stmt;
10752   tree new_block = build (LABELED_BLOCK_EXPR, type,
10753                           create_label_decl (generate_name ()), block);
10754
10755   stmt = build (MODIFY_EXPR, void_type_node, decl,
10756                 build_address_of (LABELED_BLOCK_LABEL (new_block)));
10757   TREE_SIDE_EFFECTS (stmt) = 1;
10758   CAN_COMPLETE_NORMALLY (stmt) = 1;
10759   add_stmt_to_block (block, type, stmt);
10760   stmt = build (GOTO_EXPR, void_type_node, finally_label);
10761   TREE_SIDE_EFFECTS (stmt) = 1;
10762   add_stmt_to_block (block, type, stmt);
10763   return new_block;
10764 }
10765
10766 static tree
10767 build_try_statement (location, try_block, catches)
10768      int location;
10769      tree try_block, catches;
10770 {
10771   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
10772   EXPR_WFL_LINECOL (node) = location;
10773   return node;
10774 }
10775
10776 static tree
10777 build_try_finally_statement (location, try_block, finally)
10778      int location;
10779      tree try_block, finally;
10780 {
10781   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
10782   EXPR_WFL_LINECOL (node) = location;
10783   return node;
10784 }
10785
10786 static tree
10787 patch_try_statement (node)
10788      tree node;
10789 {
10790   int error_found = 0;
10791   tree try = TREE_OPERAND (node, 0);
10792   /* Exception handlers are considered in left to right order */
10793   tree catch = nreverse (TREE_OPERAND (node, 1));
10794   tree current, caught_type_list = NULL_TREE;
10795
10796   /* Check catch clauses, if any. Every time we find an error, we try
10797      to process the next catch clause. We process the catch clause before
10798      the try block so that when processing the try block we can check thrown
10799      exceptions againts the caught type list. */
10800   for (current = catch; current; current = TREE_CHAIN (current))
10801     {
10802       tree carg_decl, carg_type;
10803       tree sub_current, catch_block, catch_clause;
10804       int unreachable;
10805
10806       /* At this point, the structure of the catch clause is
10807            CATCH_EXPR           (catch node)
10808              BLOCK              (with the decl of the parameter)
10809                COMPOUND_EXPR
10810                  MODIFY_EXPR   (assignment of the catch parameter)
10811                  BLOCK          (catch clause block)
10812        */
10813       catch_clause = TREE_OPERAND (current, 0);
10814       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
10815       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
10816
10817       /* Catch clauses can't have more than one parameter declared,
10818          but it's already enforced by the grammar. Make sure that the
10819          only parameter of the clause statement in of class Throwable
10820          or a subclass of Throwable, but that was done earlier. The
10821          catch clause parameter type has also been resolved. */
10822
10823       /* Just make sure that the catch clause parameter type inherits
10824          from java.lang.Throwable */
10825       if (!inherits_from_p (carg_type, throwable_type_node))
10826         {
10827           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
10828           parse_error_context (wfl_operator,
10829                                "Can't catch class `%s'. Catch clause "
10830                                "parameter type must be a subclass of "
10831                                "class `java.lang.Throwable'",
10832                                lang_printable_name (carg_type, 0));
10833           error_found = 1;
10834           continue;
10835         }
10836
10837       /* Partial check for unreachable catch statement: The catch
10838          clause is reachable iff is no earlier catch block A in
10839          the try statement such that the type of the catch
10840          clause's parameter is the same as or a subclass of the
10841          type of A's parameter */
10842       unreachable = 0;
10843       for (sub_current = catch;
10844            sub_current != current; sub_current = TREE_CHAIN (sub_current))
10845         {
10846           tree sub_catch_clause, decl;
10847           sub_catch_clause = TREE_OPERAND (sub_current, 0);
10848           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
10849
10850           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
10851             {
10852               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
10853               parse_error_context
10854                 (wfl_operator, "`catch' not reached because of the catch "
10855                  "clause at line %d", EXPR_WFL_LINENO (sub_current));
10856               unreachable = error_found = 1;
10857               break;
10858             }
10859         }
10860       /* Complete the catch clause block */
10861       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
10862       if (catch_block == error_mark_node)
10863         {
10864           error_found = 1;
10865           continue;
10866         }
10867       if (CAN_COMPLETE_NORMALLY (catch_block))
10868         CAN_COMPLETE_NORMALLY (node) = 1;
10869       TREE_OPERAND (current, 0) = catch_block;
10870
10871       if (unreachable)
10872         continue;
10873
10874       /* Things to do here: the exception must be thrown */
10875
10876       /* Link this type to the caught type list */
10877       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
10878     }
10879
10880   PUSH_EXCEPTIONS (caught_type_list);
10881   if ((try = java_complete_tree (try)) == error_mark_node)
10882     error_found = 1;
10883   if (CAN_COMPLETE_NORMALLY (try))
10884     CAN_COMPLETE_NORMALLY (node) = 1;
10885   POP_EXCEPTIONS ();
10886
10887   /* Verification ends here */
10888   if (error_found)
10889     return error_mark_node;
10890
10891   TREE_OPERAND (node, 0) = try;
10892   TREE_OPERAND (node, 1) = catch;
10893   TREE_TYPE (node) = void_type_node;
10894   return node;
10895 }
10896
10897 /* 14.17 The synchronized Statement */
10898
10899 static tree
10900 patch_synchronized_statement (node, wfl_op1)
10901     tree node, wfl_op1;
10902 {
10903   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
10904   tree block = TREE_OPERAND (node, 1);
10905
10906   tree enter, exit, expr_decl, assignment;
10907
10908   if (expr == error_mark_node)
10909     {
10910       block = java_complete_tree (block);
10911       return expr;
10912     }
10913
10914   /* The TYPE of expr must be a reference type */
10915   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
10916     {
10917       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
10918       parse_error_context (wfl_operator, "Incompatible type for `synchronized'"
10919                            ". Can't convert `%s' to `java.lang.Object'",
10920                            lang_printable_name (TREE_TYPE (expr), 0));
10921       return error_mark_node;
10922     }
10923
10924   /* Generate a try-finally for the synchronized statement, except
10925      that the handler that catches all throw exception calls
10926      _Jv_MonitorExit and then rethrow the exception.
10927      The synchronized statement is then implemented as:
10928      TRY
10929        {
10930          _Jv_MonitorEnter (expression)
10931          synchronized_block
10932          _Jv_MonitorExit (expression)
10933        }
10934      CATCH_ALL
10935        {
10936          e = _Jv_exception_info ();
10937          _Jv_MonitorExit (expression)
10938          Throw (e);
10939        } */
10940
10941   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
10942   BUILD_MONITOR_ENTER (enter, expr_decl);
10943   BUILD_MONITOR_EXIT (exit, expr_decl);
10944   CAN_COMPLETE_NORMALLY (enter) = 1;
10945   CAN_COMPLETE_NORMALLY (exit) = 1;
10946   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
10947   TREE_SIDE_EFFECTS (assignment) = 1;
10948   node = build1 (CLEANUP_POINT_EXPR, NULL_TREE,
10949                  build (COMPOUND_EXPR, NULL_TREE,
10950                         build (WITH_CLEANUP_EXPR, NULL_TREE,
10951                                build (COMPOUND_EXPR, NULL_TREE,
10952                                       assignment, enter),
10953                                NULL_TREE, exit),
10954                         block));
10955   node = build_expr_block (node, expr_decl);
10956
10957   return java_complete_tree (node);
10958 }
10959
10960 /* 14.16 The throw Statement */
10961
10962 static tree
10963 patch_throw_statement (node, wfl_op1)
10964     tree node, wfl_op1;
10965 {
10966   tree expr = TREE_OPERAND (node, 0);
10967   tree type = TREE_TYPE (expr);
10968   int unchecked_ok = 0, tryblock_throws_ok = 0;
10969
10970   /* Thrown expression must be assignable to java.lang.Throwable */
10971   if (!try_reference_assignconv (throwable_type_node, expr))
10972     {
10973       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
10974       parse_error_context (wfl_operator, "Can't throw `%s'; it must be a "
10975                            "subclass of class `java.lang.Throwable'",
10976                            lang_printable_name (type, 0));
10977       /* If the thrown expression was a reference, we further the
10978          compile-time check. */
10979       if (!JREFERENCE_TYPE_P (type))
10980         return error_mark_node;
10981     }
10982
10983   /* At least one of the following must be true */
10984
10985   /* The type of the throw expression is a not checked exception,
10986      i.e. is a unchecked expression. */
10987   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
10988
10989   /* Throw is contained in a try statement and at least one catch
10990      clause can receive the thrown expression or the current method is
10991      declared to throw such an exception. Or, the throw statement is
10992      contained in a method or constructor declaration and the type of
10993      the Expression is assignable to at least one type listed in the
10994      throws clause the declaration. */
10995   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
10996   if (!unchecked_ok)
10997     tryblock_throws_ok =
10998       check_thrown_exceptions_do (TREE_TYPE (expr));
10999   if (!(unchecked_ok || tryblock_throws_ok))
11000     {
11001       /* If there is a surrounding try block that has no matching
11002          clatch clause, report it first. A surrounding try block exits
11003          only if there is something after the list of checked
11004          exception thrown by the current function (if any). */
11005       if (IN_TRY_BLOCK_P ())
11006         parse_error_context (wfl_operator, "Checked exception `%s' can't be "
11007                              "caught by any of the catch clause(s) "
11008                              "of the surrounding `try' block",
11009                              lang_printable_name (type, 0));
11010       /* If we have no surrounding try statement and the method doesn't have
11011          any throws, report it now. FIXME */
11012       else if (!EXCEPTIONS_P (currently_caught_type_list)
11013                && !tryblock_throws_ok)
11014         parse_error_context (wfl_operator, "Checked exception `%s' isn't "
11015                              "thrown from a `try' block",
11016                              lang_printable_name (type, 0));
11017       /* Otherwise, the current method doesn't have the appropriate
11018          throws declaration */
11019       else
11020         parse_error_context (wfl_operator, "Checked exception `%s' doesn't "
11021                              "match any of current method's `throws' "
11022                              "declaration(s)",
11023                              lang_printable_name (type, 0));
11024       return error_mark_node;
11025     }
11026
11027   /* If a throw statement is contained in a static initializer, then a
11028      compile-time check ensures that either its value is always an
11029      unchecked exception or its value is always caught by some try
11030      statement that contains it. FIXME, static initializer. */
11031
11032   if (! flag_emit_class_files)
11033     BUILD_THROW (node, expr);
11034   return node;
11035 }
11036
11037 /* Check that exception said to be thrown by method DECL can be
11038    effectively caught from where DECL is invoked.  */
11039
11040 static void
11041 check_thrown_exceptions (location, decl)
11042      int location;
11043      tree decl;
11044 {
11045   tree throws;
11046   /* For all the unchecked exceptions thrown by DECL */
11047   for (throws = DECL_FUNCTION_THROWS (decl); throws;
11048        throws = TREE_CHAIN (throws))
11049     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
11050       {
11051 #if 1
11052         /* Temporary hack to suppresses errors about cloning arrays. FIXME */
11053         if (DECL_NAME (decl) == get_identifier ("clone"))
11054           continue;
11055 #endif
11056         EXPR_WFL_LINECOL (wfl_operator) = location;
11057         parse_error_context
11058           (wfl_operator, "Exception `%s' must be caught, or it must be "
11059            "declared in the `throws' clause of `%s'",
11060            lang_printable_name (TREE_VALUE (throws), 0),
11061            IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
11062       }
11063 }
11064
11065 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
11066    try-catch blocks, OR is listed in the `throws' clause of the
11067    current method.  */
11068
11069 static int
11070 check_thrown_exceptions_do (exception)
11071      tree exception;
11072 {
11073   tree list = currently_caught_type_list;
11074   resolve_and_layout (exception, NULL_TREE);
11075   /* First, all the nested try-catch-finally at that stage. The
11076      last element contains `throws' clause exceptions, if any. */
11077   if (IS_UNCHECKED_EXCEPTION_P (exception))
11078     return 1;
11079   while (list)
11080     {
11081       tree caught;
11082       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
11083         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
11084           return 1;
11085       list = TREE_CHAIN (list);
11086     }
11087   return 0;
11088 }
11089
11090 static void
11091 purge_unchecked_exceptions (mdecl)
11092      tree mdecl;
11093 {
11094   tree throws = DECL_FUNCTION_THROWS (mdecl);
11095   tree new = NULL_TREE;
11096
11097   while (throws)
11098     {
11099       tree next = TREE_CHAIN (throws);
11100       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
11101         {
11102           TREE_CHAIN (throws) = new;
11103           new = throws;
11104         }
11105       throws = next;
11106     }
11107   /* List is inverted here, but it doesn't matter */
11108   DECL_FUNCTION_THROWS (mdecl) = new;
11109 }
11110
11111 /* 15.24 Conditional Operator ?: */
11112
11113 static tree
11114 patch_conditional_expr (node, wfl_cond, wfl_op1)
11115      tree node, wfl_cond, wfl_op1;
11116 {
11117   tree cond = TREE_OPERAND (node, 0);
11118   tree op1 = TREE_OPERAND (node, 1);
11119   tree op2 = TREE_OPERAND (node, 2);
11120   tree resulting_type = NULL_TREE;
11121   tree t1, t2, patched;
11122   int error_found = 0;
11123
11124   /* Operands of ?: might be StringBuffers crafted as a result of a
11125      string concatenation. Obtain a descent operand here.  */
11126   if ((patched = patch_string (op1)))
11127     TREE_OPERAND (node, 1) = op1 = patched;
11128   if ((patched = patch_string (op2)))
11129     TREE_OPERAND (node, 2) = op2 = patched;
11130
11131   t1 = TREE_TYPE (op1);
11132   t2 = TREE_TYPE (op2);
11133
11134   /* The first expression must be a boolean */
11135   if (TREE_TYPE (cond) != boolean_type_node)
11136     {
11137       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
11138       parse_error_context (wfl_operator, "Incompatible type for `?:'. Can't "
11139                            "convert `%s' to `boolean'",
11140                            lang_printable_name (TREE_TYPE (cond), 0));
11141       error_found = 1;
11142     }
11143
11144   /* Second and third can be numeric, boolean (i.e. primitive),
11145      references or null. Anything else results in an error */
11146   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
11147         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
11148             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
11149         || (t1 == boolean_type_node && t2 == boolean_type_node)))
11150     error_found = 1;
11151
11152   /* Determine the type of the conditional expression. Same types are
11153      easy to deal with */
11154   else if (t1 == t2)
11155     resulting_type = t1;
11156
11157   /* There are different rules for numeric types */
11158   else if (JNUMERIC_TYPE_P (t1))
11159     {
11160       /* if byte/short found, the resulting type is short */
11161       if ((t1 == byte_type_node && t2 == short_type_node)
11162           || (t1 == short_type_node && t2 == byte_type_node))
11163         resulting_type = short_type_node;
11164
11165       /* If t1 is a constant int and t2 is of type byte, short or char
11166          and t1's value fits in t2, then the resulting type is t2 */
11167       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
11168           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
11169         resulting_type = t2;
11170
11171       /* If t2 is a constant int and t1 is of type byte, short or char
11172          and t2's value fits in t1, then the resulting type is t1 */
11173       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
11174           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
11175         resulting_type = t1;
11176
11177       /* Otherwise, binary numeric promotion is applied and the
11178          resulting type is the promoted type of operand 1 and 2 */
11179       else
11180         resulting_type = binary_numeric_promotion (t2, t2,
11181                                                    &TREE_OPERAND (node, 1),
11182                                                    &TREE_OPERAND (node, 2));
11183     }
11184
11185   /* Cases of a reference and a null type */
11186   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
11187     resulting_type = t1;
11188
11189   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
11190     resulting_type = t2;
11191
11192   /* Last case: different reference types. If a type can be converted
11193      into the other one by assignment conversion, the latter
11194      determines the type of the expression */
11195   else if ((resulting_type = try_reference_assignconv (t1, op2)))
11196     resulting_type = promote_type (t1);
11197
11198   else if ((resulting_type = try_reference_assignconv (t2, op1)))
11199     resulting_type = promote_type (t2);
11200
11201   /* If we don't have any resulting type, we're in trouble */
11202   if (!resulting_type)
11203     {
11204       char *t = strdup (lang_printable_name (t1, 0));
11205       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
11206       parse_error_context (wfl_operator, "Incompatible type for `?:'. Can't "
11207                            "convert `%s' to `%s'", t,
11208                            lang_printable_name (t2, 0));
11209       free (t);
11210       error_found = 1;
11211     }
11212
11213   if (error_found)
11214     {
11215       TREE_TYPE (node) = error_mark_node;
11216       return error_mark_node;
11217     }
11218
11219   TREE_TYPE (node) = resulting_type;
11220   TREE_SET_CODE (node, COND_EXPR);
11221   CAN_COMPLETE_NORMALLY (node) = 1;
11222   return node;
11223 }
11224
11225 /* Try to constant fold NODE.
11226    If NODE is not a constant expression, return NULL_EXPR.
11227    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
11228
11229 static tree
11230 fold_constant_for_init (node, context)
11231      tree node;
11232      tree context;
11233 {
11234   tree op0, op1, val;
11235   enum tree_code code = TREE_CODE (node);
11236
11237   if (code == INTEGER_CST || code == REAL_CST || code == STRING_CST)
11238     return node;
11239   if (TREE_TYPE (node) != NULL_TREE)
11240     return NULL_TREE;
11241
11242   switch (code)
11243     {
11244     case PLUS_EXPR:
11245     case MINUS_EXPR:
11246     case MULT_EXPR:
11247     case TRUNC_MOD_EXPR:
11248     case RDIV_EXPR:
11249     case LSHIFT_EXPR:
11250     case RSHIFT_EXPR:
11251     case URSHIFT_EXPR:
11252     case BIT_AND_EXPR:
11253     case BIT_XOR_EXPR:
11254     case BIT_IOR_EXPR:
11255     case TRUTH_ANDIF_EXPR:
11256     case TRUTH_ORIF_EXPR:
11257     case EQ_EXPR:
11258     case NE_EXPR:
11259     case GT_EXPR:
11260     case GE_EXPR:
11261     case LT_EXPR:
11262     case LE_EXPR:
11263       op0 = TREE_OPERAND (node, 0);
11264       op1 = TREE_OPERAND (node, 1);
11265       val = fold_constant_for_init (op0, context);
11266       if (val == NULL_TREE || ! TREE_CONSTANT (val))
11267         return NULL_TREE;
11268       TREE_OPERAND (node, 0) = val;
11269       val = fold_constant_for_init (op1, context);
11270       if (val == NULL_TREE || ! TREE_CONSTANT (val))
11271         return NULL_TREE;
11272       TREE_OPERAND (node, 1) = val;
11273       return patch_binop (node, op0, op1);
11274
11275     case UNARY_PLUS_EXPR:
11276     case NEGATE_EXPR:
11277     case TRUTH_NOT_EXPR:
11278     case BIT_NOT_EXPR:
11279     case CONVERT_EXPR:
11280       op0 = TREE_OPERAND (node, 0);
11281       val = fold_constant_for_init (op0, context);
11282       if (val == NULL_TREE || ! TREE_CONSTANT (val))
11283         return NULL_TREE;
11284       TREE_OPERAND (node, 0) = val;
11285       return patch_unaryop (node, op0);
11286       break;
11287
11288     case COND_EXPR:
11289       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
11290       if (val == NULL_TREE || ! TREE_CONSTANT (val))
11291         return NULL_TREE;
11292       TREE_OPERAND (node, 0) = val;
11293       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
11294       if (val == NULL_TREE || ! TREE_CONSTANT (val))
11295         return NULL_TREE;
11296       TREE_OPERAND (node, 1) = val;
11297       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
11298       if (val == NULL_TREE || ! TREE_CONSTANT (val))
11299         return NULL_TREE;
11300       TREE_OPERAND (node, 2) = val;
11301       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
11302         : TREE_OPERAND (node, 2);
11303
11304     case VAR_DECL:
11305       if (! FIELD_STATIC (node) || ! FIELD_FINAL (node)
11306           || DECL_INITIAL (node) == NULL_TREE)
11307         return NULL_TREE;
11308       val = DECL_INITIAL (node);
11309       /* Guard against infinite recursion. */
11310       DECL_INITIAL (node) = NULL_TREE;
11311       val = fold_constant_for_init (val, DECL_CONTEXT (node));
11312       DECL_INITIAL (node) = val;
11313       return val;
11314
11315     case EXPR_WITH_FILE_LOCATION:
11316       /* Compare java_complete_tree and resolve_expression_name. */
11317       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11318           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11319         {
11320           tree name = EXPR_WFL_NODE (node);
11321           tree decl;
11322           if (PRIMARY_P (node))
11323             return NULL_TREE;
11324           else if (! QUALIFIED_P (name))
11325             {
11326               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
11327               if (! FIELD_STATIC (decl))
11328                 return NULL_TREE;
11329               return fold_constant_for_init (decl, decl);
11330             }
11331           else
11332             {
11333 #if 0
11334               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
11335               qualify_ambiguous_name (node);
11336               if (resolve_field_access (node, &decl, NULL)
11337                   && decl != NULL_TREE)
11338                 return fold_constant_for_init (decl, decl);
11339 #endif
11340               return NULL_TREE;
11341             }
11342         }
11343       else
11344         {
11345           op0 = TREE_OPERAND (node, 0);
11346           val = fold_constant_for_init (op0, context);
11347           if (val == NULL_TREE || ! TREE_CONSTANT (val))
11348             return NULL_TREE;
11349           TREE_OPERAND (node, 0) = val;
11350           return val;
11351         }
11352
11353 #ifdef USE_COMPONENT_REF
11354     case IDENTIFIER:
11355     case COMPONENT_REF:
11356       ?;
11357 #endif
11358
11359     default:
11360       return NULL_TREE;
11361     }
11362 }
11363
11364 #ifdef USE_COMPONENT_REF
11365 /* Context is 'T' for TypeName, 'P' for PackageName,
11366    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
11367
11368 tree
11369 resolve_simple_name (name, context)
11370      tree name;
11371      int context;
11372 {
11373 }
11374
11375 tree
11376 resolve_qualified_name (name, context)
11377      tree name;
11378      int context;
11379 {
11380 }
11381 #endif