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