summaryrefslogtreecommitdiff
path: root/gnu/dist/toolchain/gcc/java/parse.y
diff options
context:
space:
mode:
authortv <tv@NetBSD.org>2000-07-26 00:17:09 +0000
committertv <tv@NetBSD.org>2000-07-26 00:17:09 +0000
commitdc36174cbda5524f93f5b7f403e5f43dfdd98cae (patch)
tree779f68d62a9c8fb600acae82e6aca92114174bad /gnu/dist/toolchain/gcc/java/parse.y
parent48b9eee5e169e02e12f31b637e0495fc0bef28e0 (diff)
Import of gcc 2.95.2 into new gnu/dist/toolchain layout.
Diffstat (limited to 'gnu/dist/toolchain/gcc/java/parse.y')
-rw-r--r--gnu/dist/toolchain/gcc/java/parse.y11775
1 files changed, 11775 insertions, 0 deletions
diff --git a/gnu/dist/toolchain/gcc/java/parse.y b/gnu/dist/toolchain/gcc/java/parse.y
new file mode 100644
index 00000000000..8abd4a7c079
--- /dev/null
+++ b/gnu/dist/toolchain/gcc/java/parse.y
@@ -0,0 +1,11775 @@
+/* Source code parsing and tree node generation for the GNU compiler
+ for the Java(TM) language.
+ Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* This file parses java source code and issues a tree node image
+suitable for code generation (byte code and targeted CPU assembly
+language).
+
+The grammar conforms to the Java grammar described in "The Java(TM)
+Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
+1996, ISBN 0-201-63451-1"
+
+The following modifications were brought to the original grammar:
+
+method_body: added the rule '| block SC_TK'
+static_initializer: added the rule 'static block SC_TK'.
+
+Note: All the extra rules described above should go away when the
+ empty_statement rule will work.
+
+statement_nsi: 'nsi' should be read no_short_if.
+
+Some rules have been modified to support JDK1.1 inner classes
+definitions and other extensions. */
+
+%{
+#include "config.h"
+#include "system.h"
+#include <dirent.h>
+#include "tree.h"
+#include "rtl.h"
+#include "obstack.h"
+#include "toplev.h"
+#include "flags.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include "lex.h"
+#include "parse.h"
+#include "zipfile.h"
+#include "convert.h"
+#include "buffer.h"
+#include "xref.h"
+#include "except.h"
+
+#ifndef DIR_SEPARATOR
+#define DIR_SEPARATOR '/'
+#endif
+
+/* Local function prototypes */
+static char *java_accstring_lookup PROTO ((int));
+static void classitf_redefinition_error PROTO ((char *,tree, tree, tree));
+static void variable_redefinition_error PROTO ((tree, tree, tree, int));
+static void check_modifiers PROTO ((char *, int, int));
+static tree create_class PROTO ((int, tree, tree, tree));
+static tree create_interface PROTO ((int, tree, tree));
+static tree find_field PROTO ((tree, tree));
+static tree lookup_field_wrapper PROTO ((tree, tree));
+static int duplicate_declaration_error_p PROTO ((tree, tree, tree));
+static void register_fields PROTO ((int, tree, tree));
+static tree parser_qualified_classname PROTO ((tree));
+static int parser_check_super PROTO ((tree, tree, tree));
+static int parser_check_super_interface PROTO ((tree, tree, tree));
+static void check_modifiers_consistency PROTO ((int));
+static tree lookup_cl PROTO ((tree));
+static tree lookup_java_method2 PROTO ((tree, tree, int));
+static tree method_header PROTO ((int, tree, tree, tree));
+static void fix_method_argument_names PROTO ((tree ,tree));
+static tree method_declarator PROTO ((tree, tree));
+static void parse_warning_context PVPROTO ((tree cl, const char *msg, ...))
+ ATTRIBUTE_PRINTF_2;
+static void issue_warning_error_from_context PROTO ((tree, const char *msg, va_list));
+static tree parse_jdk1_1_error PROTO ((char *));
+static void complete_class_report_errors PROTO ((jdep *));
+static int process_imports PROTO ((void));
+static void read_import_dir PROTO ((tree));
+static int find_in_imports_on_demand PROTO ((tree));
+static int find_in_imports PROTO ((tree));
+static int check_pkg_class_access PROTO ((tree, tree));
+static tree resolve_package PROTO ((tree, tree *));
+static tree lookup_package_type PROTO ((char *, int));
+static tree lookup_package_type_and_set_next PROTO ((char *, int, tree *));
+static tree resolve_class PROTO ((tree, tree, tree));
+static void declare_local_variables PROTO ((int, tree, tree));
+static void source_start_java_method PROTO ((tree));
+static void source_end_java_method PROTO ((void));
+static void expand_start_java_method PROTO ((tree));
+static tree find_name_in_single_imports PROTO ((tree));
+static void check_abstract_method_header PROTO ((tree));
+static tree lookup_java_interface_method2 PROTO ((tree, tree));
+static tree resolve_expression_name PROTO ((tree, tree *));
+static tree maybe_create_class_interface_decl PROTO ((tree, tree, tree));
+static int check_class_interface_creation PROTO ((int, int, tree,
+ tree, tree, tree));
+static tree patch_method_invocation PROTO ((tree, tree, tree,
+ int *, tree *));
+static int breakdown_qualified PROTO ((tree *, tree *, tree));
+static tree resolve_and_layout PROTO ((tree, tree));
+static tree resolve_no_layout PROTO ((tree, tree));
+static int invocation_mode PROTO ((tree, int));
+static tree find_applicable_accessible_methods_list PROTO ((int, tree,
+ tree, tree));
+static void search_applicable_methods_list PROTO ((int, tree, tree, tree,
+ tree *, tree *));
+static tree find_most_specific_methods_list PROTO ((tree));
+static int argument_types_convertible PROTO ((tree, tree));
+static tree patch_invoke PROTO ((tree, tree, tree));
+static tree lookup_method_invoke PROTO ((int, tree, tree, tree, tree));
+static tree register_incomplete_type PROTO ((int, tree, tree, tree));
+static tree obtain_incomplete_type PROTO ((tree));
+static tree java_complete_lhs PROTO ((tree));
+static tree java_complete_tree PROTO ((tree));
+static void java_complete_expand_method PROTO ((tree));
+static int unresolved_type_p PROTO ((tree, tree *));
+static void create_jdep_list PROTO ((struct parser_ctxt *));
+static tree build_expr_block PROTO ((tree, tree));
+static tree enter_block PROTO ((void));
+static tree enter_a_block PROTO ((tree));
+static tree exit_block PROTO ((void));
+static tree lookup_name_in_blocks PROTO ((tree));
+static void maybe_absorb_scoping_blocks PROTO ((void));
+static tree build_method_invocation PROTO ((tree, tree));
+static tree build_new_invocation PROTO ((tree, tree));
+static tree build_assignment PROTO ((int, int, tree, tree));
+static tree build_binop PROTO ((enum tree_code, int, tree, tree));
+static int check_final_assignment PROTO ((tree ,tree));
+static tree patch_assignment PROTO ((tree, tree, tree ));
+static tree patch_binop PROTO ((tree, tree, tree));
+static tree build_unaryop PROTO ((int, int, tree));
+static tree build_incdec PROTO ((int, int, tree, int));
+static tree patch_unaryop PROTO ((tree, tree));
+static tree build_cast PROTO ((int, tree, tree));
+static tree build_null_of_type PROTO ((tree));
+static tree patch_cast PROTO ((tree, tree));
+static int valid_ref_assignconv_cast_p PROTO ((tree, tree, int));
+static int valid_builtin_assignconv_identity_widening_p PROTO ((tree, tree));
+static int valid_cast_to_p PROTO ((tree, tree));
+static int valid_method_invocation_conversion_p PROTO ((tree, tree));
+static tree try_builtin_assignconv PROTO ((tree, tree, tree));
+static tree try_reference_assignconv PROTO ((tree, tree));
+static tree build_unresolved_array_type PROTO ((tree));
+static tree build_array_from_name PROTO ((tree, tree, tree, tree *));
+static tree build_array_ref PROTO ((int, tree, tree));
+static tree patch_array_ref PROTO ((tree));
+static tree make_qualified_name PROTO ((tree, tree, int));
+static tree merge_qualified_name PROTO ((tree, tree));
+static tree make_qualified_primary PROTO ((tree, tree, int));
+static int resolve_qualified_expression_name PROTO ((tree, tree *,
+ tree *, tree *));
+static void qualify_ambiguous_name PROTO ((tree));
+static void maybe_generate_clinit PROTO ((void));
+static tree resolve_field_access PROTO ((tree, tree *, tree *));
+static tree build_newarray_node PROTO ((tree, tree, int));
+static tree patch_newarray PROTO ((tree));
+static tree resolve_type_during_patch PROTO ((tree));
+static tree build_this PROTO ((int));
+static tree build_return PROTO ((int, tree));
+static tree patch_return PROTO ((tree));
+static tree maybe_access_field PROTO ((tree, tree, tree));
+static int complete_function_arguments PROTO ((tree));
+static int check_for_static_method_reference PROTO ((tree, tree, tree, tree, tree));
+static int not_accessible_p PROTO ((tree, tree, int));
+static void check_deprecation PROTO ((tree, tree));
+static int class_in_current_package PROTO ((tree));
+static tree build_if_else_statement PROTO ((int, tree, tree, tree));
+static tree patch_if_else_statement PROTO ((tree));
+static tree add_stmt_to_compound PROTO ((tree, tree, tree));
+static tree add_stmt_to_block PROTO ((tree, tree, tree));
+static tree patch_exit_expr PROTO ((tree));
+static tree build_labeled_block PROTO ((int, tree));
+static tree finish_labeled_statement PROTO ((tree, tree));
+static tree build_bc_statement PROTO ((int, int, tree));
+static tree patch_bc_statement PROTO ((tree));
+static tree patch_loop_statement PROTO ((tree));
+static tree build_new_loop PROTO ((tree));
+static tree build_loop_body PROTO ((int, tree, int));
+static tree finish_loop_body PROTO ((int, tree, tree, int));
+static tree build_debugable_stmt PROTO ((int, tree));
+static tree finish_for_loop PROTO ((int, tree, tree, tree));
+static tree patch_switch_statement PROTO ((tree));
+static tree string_constant_concatenation PROTO ((tree, tree));
+static tree build_string_concatenation PROTO ((tree, tree));
+static tree patch_string_cst PROTO ((tree));
+static tree patch_string PROTO ((tree));
+static tree build_try_statement PROTO ((int, tree, tree));
+static tree build_try_finally_statement PROTO ((int, tree, tree));
+static tree patch_try_statement PROTO ((tree));
+static tree patch_synchronized_statement PROTO ((tree, tree));
+static tree patch_throw_statement PROTO ((tree, tree));
+static void check_thrown_exceptions PROTO ((int, tree));
+static int check_thrown_exceptions_do PROTO ((tree));
+static void purge_unchecked_exceptions PROTO ((tree));
+static void check_throws_clauses PROTO ((tree, tree, tree));
+static void finish_method_declaration PROTO ((tree));
+static tree build_super_invocation PROTO (());
+static int verify_constructor_circularity PROTO ((tree, tree));
+static char *constructor_circularity_msg PROTO ((tree, tree));
+static tree build_this_super_qualified_invocation PROTO ((int, tree, tree,
+ int, int));
+static char *get_printable_method_name PROTO ((tree));
+static tree patch_conditional_expr PROTO ((tree, tree, tree));
+static void maybe_generate_finit PROTO (());
+static void fix_constructors PROTO ((tree));
+static int verify_constructor_super PROTO (());
+static tree create_artificial_method PROTO ((tree, int, tree, tree, tree));
+static void start_artificial_method_body PROTO ((tree));
+static void end_artificial_method_body PROTO ((tree));
+static int check_method_redefinition PROTO ((tree, tree));
+static int reset_method_name PROTO ((tree));
+static void java_check_regular_methods PROTO ((tree));
+static void java_check_abstract_methods PROTO ((tree));
+static tree maybe_build_primttype_type_ref PROTO ((tree, tree));
+static void unreachable_stmt_error PROTO ((tree));
+static tree find_expr_with_wfl PROTO ((tree));
+static void missing_return_error PROTO ((tree));
+static tree build_new_array_init PROTO ((int, tree));
+static tree patch_new_array_init PROTO ((tree, tree));
+static tree maybe_build_array_element_wfl PROTO ((tree));
+static int array_constructor_check_entry PROTO ((tree, tree));
+static char *purify_type_name PROTO ((char *));
+static tree fold_constant_for_init PROTO ((tree, tree));
+static tree strip_out_static_field_access_decl PROTO ((tree));
+static jdeplist *reverse_jdep_list PROTO ((struct parser_ctxt *));
+static void static_ref_err PROTO ((tree, tree, tree));
+
+/* Number of error found so far. */
+int java_error_count;
+/* Number of warning found so far. */
+int java_warning_count;
+/* Tell when not to fold, when doing xrefs */
+int do_not_fold;
+
+/* The current parser context */
+struct parser_ctxt *ctxp;
+
+/* List of things that were analyzed for which code will be generated */
+static struct parser_ctxt *ctxp_for_generation = NULL;
+
+/* binop_lookup maps token to tree_code. It is used where binary
+ operations are involved and required by the parser. RDIV_EXPR
+ covers both integral/floating point division. The code is changed
+ once the type of both operator is worked out. */
+
+static enum tree_code binop_lookup[19] =
+ {
+ PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
+ LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
+ BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
+ TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
+ EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
+ };
+#define BINOP_LOOKUP(VALUE) \
+ binop_lookup [((VALUE) - PLUS_TK)% \
+ (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
+
+/* Fake WFL used to report error message. It is initialized once if
+ needed and reused with it's location information is overriden. */
+tree wfl_operator = NULL_TREE;
+
+/* The "$L" identifier we use to create labels. */
+static tree label_id = NULL_TREE;
+
+/* The "StringBuffer" identifier used for the String `+' operator. */
+static tree wfl_string_buffer = NULL_TREE;
+
+/* The "append" identifier used for String `+' operator. */
+static tree wfl_append = NULL_TREE;
+
+/* The "toString" identifier used for String `+' operator. */
+static tree wfl_to_string = NULL_TREE;
+
+/* The "java.lang" import qualified name. */
+static tree java_lang_id = NULL_TREE;
+
+/* The "java.lang.Cloneable" qualified name. */
+static tree java_lang_cloneable = NULL_TREE;
+
+/* Context and flag for static blocks */
+static tree current_static_block = NULL_TREE;
+
+%}
+
+%union {
+ tree node;
+ int sub_token;
+ struct {
+ int token;
+ int location;
+ } operator;
+ int value;
+}
+
+%{
+#include "lex.c"
+%}
+
+%pure_parser
+
+/* Things defined here have to match the order of what's in the
+ binop_lookup table. */
+
+%token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
+%token LS_TK SRS_TK ZRS_TK
+%token AND_TK XOR_TK OR_TK
+%token BOOL_AND_TK BOOL_OR_TK
+%token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
+
+/* This maps to the same binop_lookup entry than the token above */
+
+%token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
+%token REM_ASSIGN_TK
+%token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
+%token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
+
+
+/* Modifier TOKEN have to be kept in this order. Don't scramble it */
+
+%token PUBLIC_TK PRIVATE_TK PROTECTED_TK
+%token STATIC_TK FINAL_TK SYNCHRONIZED_TK
+%token VOLATILE_TK TRANSIENT_TK NATIVE_TK
+%token PAD_TK ABSTRACT_TK MODIFIER_TK
+
+/* Keep those two in order, too */
+%token DECR_TK INCR_TK
+
+/* From now one, things can be in any order */
+
+%token DEFAULT_TK IF_TK THROW_TK
+%token BOOLEAN_TK DO_TK IMPLEMENTS_TK
+%token THROWS_TK BREAK_TK IMPORT_TK
+%token ELSE_TK INSTANCEOF_TK RETURN_TK
+%token VOID_TK CATCH_TK INTERFACE_TK
+%token CASE_TK EXTENDS_TK FINALLY_TK
+%token SUPER_TK WHILE_TK CLASS_TK
+%token SWITCH_TK CONST_TK TRY_TK
+%token FOR_TK NEW_TK CONTINUE_TK
+%token GOTO_TK PACKAGE_TK THIS_TK
+
+%token BYTE_TK SHORT_TK INT_TK LONG_TK
+%token CHAR_TK INTEGRAL_TK
+
+%token FLOAT_TK DOUBLE_TK FP_TK
+
+%token ID_TK
+
+%token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
+
+%token ASSIGN_ANY_TK ASSIGN_TK
+%token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
+
+%token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
+%token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
+
+%type <value> modifiers MODIFIER_TK
+
+%type <node> super ID_TK identifier
+%type <node> name simple_name qualified_name
+%type <node> class_declaration type_declaration compilation_unit
+ field_declaration method_declaration extends_interfaces
+ interfaces interface_type_list
+ interface_declaration class_member_declaration
+ import_declarations package_declaration
+ type_declarations interface_body
+ interface_member_declaration constant_declaration
+ interface_member_declarations interface_type
+ abstract_method_declaration interface_type_list
+%type <node> class_body_declaration class_member_declaration
+ static_initializer constructor_declaration block
+%type <node> class_body_declarations constructor_header
+%type <node> class_or_interface_type class_type class_type_list
+ constructor_declarator explicit_constructor_invocation
+%type <node> dim_expr dim_exprs this_or_super throws
+
+%type <node> variable_declarator_id variable_declarator
+ variable_declarators variable_initializer
+ variable_initializers constructor_body
+ array_initializer
+
+%type <node> class_body block_end constructor_block_end
+%type <node> statement statement_without_trailing_substatement
+ labeled_statement if_then_statement label_decl
+ if_then_else_statement while_statement for_statement
+ statement_nsi labeled_statement_nsi do_statement
+ if_then_else_statement_nsi while_statement_nsi
+ for_statement_nsi statement_expression_list for_init
+ for_update statement_expression expression_statement
+ primary_no_new_array expression primary
+ array_creation_expression array_type
+ class_instance_creation_expression field_access
+ method_invocation array_access something_dot_new
+ argument_list postfix_expression while_expression
+ post_increment_expression post_decrement_expression
+ unary_expression_not_plus_minus unary_expression
+ pre_increment_expression pre_decrement_expression
+ unary_expression_not_plus_minus cast_expression
+ multiplicative_expression additive_expression
+ shift_expression relational_expression
+ equality_expression and_expression
+ exclusive_or_expression inclusive_or_expression
+ conditional_and_expression conditional_or_expression
+ conditional_expression assignment_expression
+ left_hand_side assignment for_header for_begin
+ constant_expression do_statement_begin empty_statement
+ switch_statement synchronized_statement throw_statement
+ try_statement switch_expression switch_block
+ catches catch_clause catch_clause_parameter finally
+%type <node> return_statement break_statement continue_statement
+
+%type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
+%type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
+%type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
+%type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
+%type <operator> ASSIGN_ANY_TK assignment_operator
+%token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
+%token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
+%token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
+%token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
+%token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
+%type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
+%type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
+
+%type <node> method_body
+
+%type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
+ STRING_LIT_TK NULL_TK VOID_TK
+
+%type <node> IF_TK WHILE_TK FOR_TK
+
+%type <node> formal_parameter_list formal_parameter
+ method_declarator method_header
+
+%type <node> primitive_type reference_type type
+ BOOLEAN_TK INTEGRAL_TK FP_TK
+
+%%
+/* 19.2 Production from 2.3: The Syntactic Grammar */
+goal:
+ compilation_unit
+ {}
+;
+
+/* 19.3 Productions from 3: Lexical structure */
+literal:
+ INT_LIT_TK
+| FP_LIT_TK
+| BOOL_LIT_TK
+| CHAR_LIT_TK
+| STRING_LIT_TK
+| NULL_TK
+;
+
+/* 19.4 Productions from 4: Types, Values and Variables */
+type:
+ primitive_type
+| reference_type
+;
+
+primitive_type:
+ INTEGRAL_TK
+| FP_TK
+| BOOLEAN_TK
+;
+
+reference_type:
+ class_or_interface_type
+| array_type
+;
+
+class_or_interface_type:
+ name
+;
+
+class_type:
+ class_or_interface_type /* Default rule */
+;
+
+interface_type:
+ class_or_interface_type
+;
+
+array_type:
+ primitive_type OSB_TK CSB_TK
+ {
+ $$ = build_java_array_type ($1, -1);
+ CLASS_LOADED_P ($$) = 1;
+ }
+| name OSB_TK CSB_TK
+ { $$ = build_unresolved_array_type ($1); }
+| array_type OSB_TK CSB_TK
+ { $$ = build_unresolved_array_type ($1); }
+| primitive_type OSB_TK error
+ {RULE ("']' expected"); RECOVER;}
+| array_type OSB_TK error
+ {RULE ("']' expected"); RECOVER;}
+;
+
+/* 19.5 Productions from 6: Names */
+name:
+ simple_name /* Default rule */
+| qualified_name /* Default rule */
+;
+
+simple_name:
+ identifier /* Default rule */
+;
+
+qualified_name:
+ name DOT_TK identifier
+ { $$ = make_qualified_name ($1, $3, $2.location); }
+;
+
+identifier:
+ ID_TK
+;
+
+/* 19.6: Production from 7: Packages */
+compilation_unit:
+ {$$ = NULL;}
+| package_declaration
+| import_declarations
+| type_declarations
+| package_declaration import_declarations
+| package_declaration type_declarations
+| import_declarations type_declarations
+| package_declaration import_declarations type_declarations
+;
+
+import_declarations:
+ import_declaration
+ {
+ $$ = NULL;
+ }
+| import_declarations import_declaration
+ {
+ $$ = NULL;
+ }
+;
+
+type_declarations:
+ type_declaration
+| type_declarations type_declaration
+;
+
+package_declaration:
+ PACKAGE_TK name SC_TK
+ { ctxp->package = EXPR_WFL_NODE ($2); }
+| PACKAGE_TK error
+ {yyerror ("Missing name"); RECOVER;}
+| PACKAGE_TK name error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+import_declaration:
+ single_type_import_declaration
+| type_import_on_demand_declaration
+;
+
+single_type_import_declaration:
+ IMPORT_TK name SC_TK
+ {
+ tree name = EXPR_WFL_NODE ($2), node, last_name;
+ int i = IDENTIFIER_LENGTH (name)-1;
+ char *last = &IDENTIFIER_POINTER (name)[i];
+ while (last != IDENTIFIER_POINTER (name))
+ {
+ if (last [0] == '.')
+ break;
+ last--;
+ }
+ last_name = get_identifier (++last);
+ if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
+ {
+ tree err = find_name_in_single_imports (last_name);
+ if (err && err != name)
+ parse_error_context
+ ($2, "Ambiguous class: `%s' and `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (err));
+ else
+ REGISTER_IMPORT ($2, last_name)
+ }
+ else
+ REGISTER_IMPORT ($2, last_name);
+ }
+| IMPORT_TK error
+ {yyerror ("Missing name"); RECOVER;}
+| IMPORT_TK name error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+type_import_on_demand_declaration:
+ IMPORT_TK name DOT_TK MULT_TK SC_TK
+ {
+ tree name = EXPR_WFL_NODE ($2);
+ /* Don't import java.lang.* twice. */
+ if (name != java_lang_id)
+ {
+ tree node = build_tree_list ($2, NULL_TREE);
+ read_import_dir ($2);
+ TREE_CHAIN (node) = ctxp->import_demand_list;
+ ctxp->import_demand_list = node;
+ }
+ }
+| IMPORT_TK name DOT_TK error
+ {yyerror ("'*' expected"); RECOVER;}
+| IMPORT_TK name DOT_TK MULT_TK error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+type_declaration:
+ class_declaration
+ {
+ maybe_generate_finit ();
+ maybe_generate_clinit ();
+ $$ = $1;
+ }
+| interface_declaration
+ {
+ maybe_generate_clinit ();
+ $$ = $1;
+ }
+| SC_TK
+ { $$ = NULL; }
+| error
+ {
+ YYERROR_NOW;
+ yyerror ("Class or interface declaration expected");
+ }
+;
+
+/* 19.7 Shortened from the original:
+ modifiers: modifier | modifiers modifier
+ modifier: any of public... */
+modifiers:
+ MODIFIER_TK
+ {
+ $$ = (1 << $1);
+ }
+| modifiers MODIFIER_TK
+ {
+ int acc = (1 << $2);
+ if ($$ & acc)
+ parse_error_context
+ (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
+ java_accstring_lookup (acc));
+ else
+ {
+ $$ |= acc;
+ }
+ }
+;
+
+/* 19.8.1 Production from $8.1: Class Declaration */
+class_declaration:
+ modifiers CLASS_TK identifier super interfaces
+ { create_class ($1, $3, $4, $5); }
+ class_body
+ {
+ $$ = $7;
+ }
+| CLASS_TK identifier super interfaces
+ { create_class (0, $2, $3, $4); }
+ class_body
+ {
+ $$ = $6;
+ }
+| modifiers CLASS_TK error
+ {yyerror ("Missing class name"); RECOVER;}
+| CLASS_TK error
+ {yyerror ("Missing class name"); RECOVER;}
+| CLASS_TK identifier error
+ {
+ if (!ctxp->class_err) yyerror ("'{' expected");
+ DRECOVER(class1);
+ }
+| modifiers CLASS_TK identifier error
+ {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
+;
+
+super:
+ { $$ = NULL; }
+| EXTENDS_TK class_type
+ { $$ = $2; }
+| EXTENDS_TK class_type error
+ {yyerror ("'{' expected"); ctxp->class_err=1;}
+| EXTENDS_TK error
+ {yyerror ("Missing super class name"); ctxp->class_err=1;}
+;
+
+interfaces:
+ { $$ = NULL_TREE; }
+| IMPLEMENTS_TK interface_type_list
+ { $$ = $2; }
+| IMPLEMENTS_TK error
+ {
+ ctxp->class_err=1;
+ yyerror ("Missing interface name");
+ }
+;
+
+interface_type_list:
+ interface_type
+ {
+ ctxp->interface_number = 1;
+ $$ = build_tree_list ($1, NULL_TREE);
+ }
+| interface_type_list C_TK interface_type
+ {
+ ctxp->interface_number++;
+ $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
+ }
+| interface_type_list C_TK error
+ {yyerror ("Missing interface name"); RECOVER;}
+;
+
+class_body:
+ OCB_TK CCB_TK
+ {
+ /* Store the location of the `}' when doing xrefs */
+ if (flag_emit_xref)
+ DECL_END_SOURCE_LINE (ctxp->current_parsed_class) =
+ EXPR_WFL_ADD_COL ($2.location, 1);
+ $$ = ctxp->current_parsed_class;
+ }
+| OCB_TK class_body_declarations CCB_TK
+ {
+ /* Store the location of the `}' when doing xrefs */
+ if (flag_emit_xref)
+ DECL_END_SOURCE_LINE (ctxp->current_parsed_class) =
+ EXPR_WFL_ADD_COL ($3.location, 1);
+ $$ = ctxp->current_parsed_class;
+ }
+;
+
+class_body_declarations:
+ class_body_declaration
+| class_body_declarations class_body_declaration
+;
+
+class_body_declaration:
+ class_member_declaration
+| static_initializer
+| constructor_declaration
+| block /* Added, JDK1.1, instance initializer */
+ { $$ = parse_jdk1_1_error ("instance initializer"); }
+;
+
+class_member_declaration:
+ field_declaration
+| field_declaration SC_TK
+ { $$ = $1; }
+| method_declaration
+| class_declaration /* Added, JDK1.1 inner classes */
+ { $$ = parse_jdk1_1_error ("inner classe declaration"); }
+| interface_declaration /* Added, JDK1.1 inner classes */
+ { $$ = parse_jdk1_1_error ("inner interface declaration"); }
+;
+
+/* 19.8.2 Productions from 8.3: Field Declarations */
+field_declaration:
+ type variable_declarators SC_TK
+ { register_fields (0, $1, $2); }
+| modifiers type variable_declarators SC_TK
+ {
+ check_modifiers
+ ("Illegal modifier `%s' for field declaration",
+ $1, FIELD_MODIFIERS);
+ check_modifiers_consistency ($1);
+ register_fields ($1, $2, $3);
+ }
+;
+
+variable_declarators:
+ /* Should we use build_decl_list () instead ? FIXME */
+ variable_declarator /* Default rule */
+| variable_declarators C_TK variable_declarator
+ { $$ = chainon ($1, $3); }
+| variable_declarators C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+variable_declarator:
+ variable_declarator_id
+ { $$ = build_tree_list ($1, NULL_TREE); }
+| variable_declarator_id ASSIGN_TK variable_initializer
+ {
+ if (java_error_count)
+ $3 = NULL_TREE;
+ $$ = build_tree_list
+ ($1, build_assignment ($2.token, $2.location, $1, $3));
+ }
+| variable_declarator_id ASSIGN_TK error
+ {
+ yyerror ("Missing variable initializer");
+ $$ = build_tree_list ($1, NULL_TREE);
+ RECOVER;
+ }
+| variable_declarator_id ASSIGN_TK variable_initializer error
+ {
+ yyerror ("';' expected");
+ $$ = build_tree_list ($1, NULL_TREE);
+ RECOVER;
+ }
+;
+
+variable_declarator_id:
+ identifier
+| variable_declarator_id OSB_TK CSB_TK
+ { $$ = build_unresolved_array_type ($1); }
+| identifier error
+ {yyerror ("Invalid declaration"); DRECOVER(vdi);}
+| variable_declarator_id OSB_TK error
+ {yyerror ("']' expected"); DRECOVER(vdi);}
+| variable_declarator_id CSB_TK error
+ {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
+;
+
+variable_initializer:
+ expression
+| array_initializer
+;
+
+/* 19.8.3 Productions from 8.4: Method Declarations */
+method_declaration:
+ method_header
+ {
+ current_function_decl = $1;
+ source_start_java_method (current_function_decl);
+ }
+ method_body
+ { finish_method_declaration ($3); }
+| method_header error
+ {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
+;
+
+method_header:
+ type method_declarator throws
+ { $$ = method_header (0, $1, $2, $3); }
+| VOID_TK method_declarator throws
+ { $$ = method_header (0, void_type_node, $2, $3); }
+| modifiers type method_declarator throws
+ { $$ = method_header ($1, $2, $3, $4); }
+| modifiers VOID_TK method_declarator throws
+ { $$ = method_header ($1, void_type_node, $3, $4); }
+| type error
+ {RECOVER;}
+| modifiers type error
+ {RECOVER;}
+| VOID_TK error
+ {yyerror ("Identifier expected"); RECOVER;}
+| modifiers VOID_TK error
+ {yyerror ("Identifier expected"); RECOVER;}
+| modifiers error
+ {
+ yyerror ("Invalid method declaration, return type required");
+ RECOVER;
+ }
+;
+
+method_declarator:
+ identifier OP_TK CP_TK
+ { $$ = method_declarator ($1, NULL_TREE); }
+| identifier OP_TK formal_parameter_list CP_TK
+ { $$ = method_declarator ($1, $3); }
+| method_declarator OSB_TK CSB_TK
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = $2.location;
+ TREE_PURPOSE ($1) =
+ build_unresolved_array_type (TREE_PURPOSE ($1));
+ parse_warning_context
+ (wfl_operator,
+ "Discouraged form of returned type specification");
+ }
+| identifier OP_TK error
+ {yyerror ("')' expected"); DRECOVER(method_declarator);}
+| method_declarator OSB_TK error
+ {yyerror ("']' expected"); RECOVER;}
+;
+
+formal_parameter_list:
+ formal_parameter
+ {
+ ctxp->formal_parameter_number = 1;
+ }
+| formal_parameter_list C_TK formal_parameter
+ {
+ ctxp->formal_parameter_number += 1;
+ $$ = chainon ($1, $3);
+ }
+| formal_parameter_list C_TK error
+ {yyerror ("Missing formal parameter term"); RECOVER;}
+;
+
+formal_parameter:
+ type variable_declarator_id
+ {
+ $$ = build_tree_list ($2, $1);
+ }
+| modifiers type variable_declarator_id /* Added, JDK1.1 final parms */
+ {
+ parse_jdk1_1_error ("final parameters");
+ $$ = build_tree_list ($3, $2);
+ }
+| type error
+ {yyerror ("Missing identifier"); RECOVER;}
+| modifiers type error
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ yyerror ("Missing identifier"); RECOVER;
+ }
+;
+
+throws:
+ { $$ = NULL_TREE; }
+| THROWS_TK class_type_list
+ { $$ = $2; }
+| THROWS_TK error
+ {yyerror ("Missing class type term"); RECOVER;}
+;
+
+class_type_list:
+ class_type
+ { $$ = build_tree_list ($1, $1); }
+| class_type_list C_TK class_type
+ { $$ = tree_cons ($3, $3, $1); }
+| class_type_list C_TK error
+ {yyerror ("Missing class type term"); RECOVER;}
+;
+
+method_body:
+ block
+| block SC_TK
+| SC_TK
+ { $$ = NULL_TREE; } /* Probably not the right thing to do. */
+;
+
+/* 19.8.4 Productions from 8.5: Static Initializers */
+static_initializer:
+ static block
+ {
+ TREE_CHAIN ($2) = ctxp->static_initialized;
+ ctxp->static_initialized = $2;
+ }
+| static block SC_TK /* Shouldn't be here. FIXME */
+ {
+ TREE_CHAIN ($2) = ctxp->static_initialized;
+ ctxp->static_initialized = $2;
+ }
+;
+
+static: /* Test lval.sub_token here */
+ MODIFIER_TK
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ }
+;
+
+/* 19.8.5 Productions from 8.6: Constructor Declarations */
+constructor_declaration:
+ constructor_header
+ {
+ current_function_decl = $1;
+ source_start_java_method (current_function_decl);
+ }
+ constructor_body
+ { finish_method_declaration ($3); }
+;
+
+constructor_header:
+ constructor_declarator throws
+ { $$ = method_header (0, NULL_TREE, $1, $2); }
+| modifiers constructor_declarator throws
+ { $$ = method_header ($1, NULL_TREE, $2, $3); }
+;
+
+constructor_declarator:
+ simple_name OP_TK CP_TK
+ { $$ = method_declarator ($1, NULL_TREE); }
+| simple_name OP_TK formal_parameter_list CP_TK
+ { $$ = method_declarator ($1, $3); }
+;
+
+constructor_body:
+ /* Unlike regular method, we always need a complete (empty)
+ body so we can safely perform all the required code
+ addition (super invocation and field initialization) */
+ block_begin constructor_block_end
+ {
+ BLOCK_EXPR_BODY ($2) = empty_stmt_node;
+ $$ = $2;
+ }
+| block_begin explicit_constructor_invocation constructor_block_end
+ { $$ = $3; }
+| block_begin block_statements constructor_block_end
+ { $$ = $3; }
+| block_begin explicit_constructor_invocation block_statements constructor_block_end
+ { $$ = $4; }
+;
+
+constructor_block_end:
+ block_end
+| block_end SC_TK
+
+/* Error recovery for that rule moved down expression_statement: rule. */
+explicit_constructor_invocation:
+ this_or_super OP_TK CP_TK SC_TK
+ {
+ $$ = build_method_invocation ($1, NULL_TREE);
+ $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
+ $$ = java_method_add_stmt (current_function_decl, $$);
+ }
+| this_or_super OP_TK argument_list CP_TK SC_TK
+ {
+ $$ = build_method_invocation ($1, $3);
+ $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
+ $$ = java_method_add_stmt (current_function_decl, $$);
+ }
+ /* Added, JDK1.1 inner classes. Modified because the rule
+ 'primary' couldn't work. */
+| name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
+ {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
+| name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
+ {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
+;
+
+this_or_super: /* Added, simplifies error diagnostics */
+ THIS_TK
+ {
+ tree wfl = build_wfl_node (this_identifier_node);
+ EXPR_WFL_LINECOL (wfl) = $1.location;
+ $$ = wfl;
+ }
+| SUPER_TK
+ {
+ tree wfl = build_wfl_node (super_identifier_node);
+ EXPR_WFL_LINECOL (wfl) = $1.location;
+ $$ = wfl;
+ }
+;
+
+/* 19.9 Productions from 9: Interfaces */
+/* 19.9.1 Productions from 9.1: Interfaces Declarations */
+interface_declaration:
+ INTERFACE_TK identifier
+ { create_interface (0, $2, NULL_TREE); }
+ interface_body
+ {
+ $$ = $4;
+ }
+| modifiers INTERFACE_TK identifier
+ { create_interface ($1, $3, NULL_TREE); }
+ interface_body
+ {
+ $$ = $5;
+ }
+| INTERFACE_TK identifier extends_interfaces
+ { create_interface (0, $2, $3); }
+ interface_body
+ {
+ $$ = $5;
+ }
+| modifiers INTERFACE_TK identifier extends_interfaces
+ { create_interface ($1, $3, $4); }
+ interface_body
+ {
+ $$ = $6;
+ }
+| INTERFACE_TK identifier error
+ {yyerror ("'{' expected"); RECOVER;}
+| modifiers INTERFACE_TK identifier error
+ {yyerror ("'{' expected"); RECOVER;}
+;
+
+extends_interfaces:
+ EXTENDS_TK interface_type
+ {
+ ctxp->interface_number = 1;
+ $$ = build_tree_list ($2, NULL_TREE);
+ }
+| extends_interfaces C_TK interface_type
+ {
+ ctxp->interface_number++;
+ $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
+ }
+| EXTENDS_TK error
+ {yyerror ("Invalid interface type"); RECOVER;}
+| extends_interfaces C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+interface_body:
+ OCB_TK CCB_TK
+ { $$ = NULL_TREE; }
+| OCB_TK interface_member_declarations CCB_TK
+ { $$ = NULL_TREE; }
+;
+
+interface_member_declarations:
+ interface_member_declaration
+| interface_member_declarations interface_member_declaration
+;
+
+interface_member_declaration:
+ constant_declaration
+| abstract_method_declaration
+| class_declaration /* Added, JDK1.1 inner classes */
+ { $$ = parse_jdk1_1_error ("inner class declaration"); }
+| interface_declaration /* Added, JDK1.1 inner classes */
+ { $$ = parse_jdk1_1_error ("inner interface declaration"); }
+;
+
+constant_declaration:
+ field_declaration
+;
+
+abstract_method_declaration:
+ method_header SC_TK
+ {
+ check_abstract_method_header ($1);
+ current_function_decl = NULL_TREE; /* FIXME ? */
+ }
+| method_header error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+/* 19.10 Productions from 10: Arrays */
+array_initializer:
+ OCB_TK CCB_TK
+ { $$ = build_new_array_init ($1.location, NULL_TREE); }
+| OCB_TK variable_initializers CCB_TK
+ { $$ = build_new_array_init ($1.location, $2); }
+| OCB_TK variable_initializers C_TK CCB_TK
+ { $$ = build_new_array_init ($1.location, $2); }
+;
+
+variable_initializers:
+ variable_initializer
+ {
+ $$ = tree_cons (maybe_build_array_element_wfl ($1),
+ $1, NULL_TREE);
+ }
+| variable_initializers C_TK variable_initializer
+ {
+ $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
+ }
+| variable_initializers C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+/* 19.11 Production from 14: Blocks and Statements */
+block:
+ OCB_TK CCB_TK
+ {
+ /* Store the location of the `}' when doing xrefs */
+ if (current_function_decl && flag_emit_xref)
+ DECL_END_SOURCE_LINE (current_function_decl) =
+ EXPR_WFL_ADD_COL ($2.location, 1);
+ $$ = empty_stmt_node;
+ }
+| block_begin block_statements block_end
+ { $$ = $3; }
+;
+
+block_begin:
+ OCB_TK
+ { enter_block (); }
+;
+
+block_end:
+ CCB_TK
+ {
+ maybe_absorb_scoping_blocks ();
+ /* Store the location of the `}' when doing xrefs */
+ if (current_function_decl && flag_emit_xref)
+ DECL_END_SOURCE_LINE (current_function_decl) =
+ EXPR_WFL_ADD_COL ($1.location, 1);
+ $$ = exit_block ();
+ }
+;
+
+block_statements:
+ block_statement
+| block_statements block_statement
+;
+
+block_statement:
+ local_variable_declaration_statement
+| statement
+ { java_method_add_stmt (current_function_decl, $1); }
+| class_declaration /* Added, JDK1.1 inner classes */
+ { parse_jdk1_1_error ("inner class declaration"); }
+;
+
+local_variable_declaration_statement:
+ local_variable_declaration SC_TK /* Can't catch missing ';' here */
+;
+
+local_variable_declaration:
+ type variable_declarators
+ { declare_local_variables (0, $1, $2); }
+| modifiers type variable_declarators /* Added, JDK1.1 final locals */
+ { declare_local_variables ($1, $2, $3); }
+;
+
+statement:
+ statement_without_trailing_substatement
+| labeled_statement
+| if_then_statement
+| if_then_else_statement
+| while_statement
+| for_statement
+ { $$ = exit_block (); }
+;
+
+statement_nsi:
+ statement_without_trailing_substatement
+| labeled_statement_nsi
+| if_then_else_statement_nsi
+| while_statement_nsi
+| for_statement_nsi
+ { $$ = exit_block (); }
+;
+
+statement_without_trailing_substatement:
+ block
+| empty_statement
+| expression_statement
+| switch_statement
+| do_statement
+| break_statement
+| continue_statement
+| return_statement
+| synchronized_statement
+| throw_statement
+| try_statement
+;
+
+empty_statement:
+ SC_TK
+ { $$ = empty_stmt_node; }
+;
+
+label_decl:
+ identifier REL_CL_TK
+ {
+ $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
+ EXPR_WFL_NODE ($1));
+ pushlevel (2);
+ push_labeled_block ($$);
+ PUSH_LABELED_BLOCK ($$);
+ }
+;
+
+labeled_statement:
+ label_decl statement
+ { $$ = finish_labeled_statement ($1, $2); }
+| identifier error
+ {yyerror ("':' expected"); RECOVER;}
+;
+
+labeled_statement_nsi:
+ label_decl statement_nsi
+ { $$ = finish_labeled_statement ($1, $2); }
+;
+
+/* We concentrate here a bunch of error handling rules that we couldn't write
+ earlier, because expression_statement catches a missing ';'. */
+expression_statement:
+ statement_expression SC_TK
+ {
+ /* We have a statement. Generate a WFL around it so
+ we can debug it */
+ $$ = build_expr_wfl ($1, input_filename, lineno, 0);
+ /* We know we have a statement, so set the debug
+ info to be eventually generate here. */
+ $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
+ }
+| error SC_TK
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ }
+| error OCB_TK
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ }
+| error CCB_TK
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ }
+| this_or_super OP_TK error
+ {yyerror ("')' expected"); RECOVER;}
+| this_or_super OP_TK CP_TK error
+ {
+ yyerror ("Constructor invocation must be first "
+ "thing in a constructor");
+ RECOVER;
+ }
+| this_or_super OP_TK argument_list error
+ {yyerror ("')' expected"); RECOVER;}
+| this_or_super OP_TK argument_list CP_TK error
+ {
+ yyerror ("Constructor invocation must be first "
+ "thing in a constructor");
+ RECOVER;
+ }
+| name DOT_TK SUPER_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK error
+ {yyerror ("')' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK argument_list error
+ {yyerror ("')' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
+ {yyerror ("';' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK CP_TK error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+statement_expression:
+ assignment
+| pre_increment_expression
+| pre_decrement_expression
+| post_increment_expression
+| post_decrement_expression
+| method_invocation
+| class_instance_creation_expression
+;
+
+if_then_statement:
+ IF_TK OP_TK expression CP_TK statement
+ {
+ $$ = build_if_else_statement ($2.location, $3,
+ $5, NULL_TREE);
+ }
+| IF_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| IF_TK OP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| IF_TK OP_TK expression error
+ {yyerror ("')' expected"); RECOVER;}
+;
+
+if_then_else_statement:
+ IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
+ { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
+;
+
+if_then_else_statement_nsi:
+ IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
+ { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
+;
+
+switch_statement:
+ switch_expression
+ {
+ enter_block ();
+ }
+ switch_block
+ {
+ /* Make into "proper list" of COMPOUND_EXPRs.
+ I.e. make the last statment also have its own
+ COMPOUND_EXPR. */
+ maybe_absorb_scoping_blocks ();
+ TREE_OPERAND ($1, 1) = exit_block ();
+ $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
+ }
+;
+
+switch_expression:
+ SWITCH_TK OP_TK expression CP_TK
+ {
+ $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
+ EXPR_WFL_LINECOL ($$) = $2.location;
+ }
+| SWITCH_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| SWITCH_TK OP_TK error
+ {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
+| SWITCH_TK OP_TK expression CP_TK error
+ {yyerror ("'{' expected"); RECOVER;}
+;
+
+/* Default assignment is there to avoid type node on switch_block
+ node. */
+
+switch_block:
+ OCB_TK CCB_TK
+ { $$ = NULL_TREE; }
+| OCB_TK switch_labels CCB_TK
+ { $$ = NULL_TREE; }
+| OCB_TK switch_block_statement_groups CCB_TK
+ { $$ = NULL_TREE; }
+| OCB_TK switch_block_statement_groups switch_labels CCB_TK
+ { $$ = NULL_TREE; }
+;
+
+switch_block_statement_groups:
+ switch_block_statement_group
+| switch_block_statement_groups switch_block_statement_group
+;
+
+switch_block_statement_group:
+ switch_labels block_statements
+;
+
+switch_labels:
+ switch_label
+| switch_labels switch_label
+;
+
+switch_label:
+ CASE_TK constant_expression REL_CL_TK
+ {
+ tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
+ EXPR_WFL_LINECOL (lab) = $1.location;
+ java_method_add_stmt (current_function_decl, lab);
+ }
+| DEFAULT_TK REL_CL_TK
+ {
+ tree lab = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
+ EXPR_WFL_LINECOL (lab) = $1.location;
+ java_method_add_stmt (current_function_decl, lab);
+ }
+| CASE_TK error
+ {yyerror ("Missing or invalid constant expression"); RECOVER;}
+| CASE_TK constant_expression error
+ {yyerror ("':' expected"); RECOVER;}
+| DEFAULT_TK error
+ {yyerror ("':' expected"); RECOVER;}
+;
+
+while_expression:
+ WHILE_TK OP_TK expression CP_TK
+ {
+ tree body = build_loop_body ($2.location, $3, 0);
+ $$ = build_new_loop (body);
+ }
+;
+
+while_statement:
+ while_expression statement
+ { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
+| WHILE_TK error
+ {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
+| WHILE_TK OP_TK error
+ {yyerror ("Missing term and ')' expected"); RECOVER;}
+| WHILE_TK OP_TK expression error
+ {yyerror ("')' expected"); RECOVER;}
+;
+
+while_statement_nsi:
+ while_expression statement_nsi
+ { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
+;
+
+do_statement_begin:
+ DO_TK
+ {
+ tree body = build_loop_body (0, NULL_TREE, 1);
+ $$ = build_new_loop (body);
+ }
+ /* Need error handing here. FIXME */
+;
+
+do_statement:
+ do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
+ { $$ = finish_loop_body ($4.location, $5, $2, 1); }
+;
+
+for_statement:
+ for_begin SC_TK expression SC_TK for_update CP_TK statement
+ { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7); }
+| for_begin SC_TK SC_TK for_update CP_TK statement
+ {
+ $$ = finish_for_loop (0, NULL_TREE, $4, $6);
+ /* We have not condition, so we get rid of the EXIT_EXPR */
+ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
+ empty_stmt_node;
+ }
+| for_begin SC_TK error
+ {yyerror ("Invalid control expression"); RECOVER;}
+| for_begin SC_TK expression SC_TK error
+ {yyerror ("Invalid update expression"); RECOVER;}
+| for_begin SC_TK SC_TK error
+ {yyerror ("Invalid update expression"); RECOVER;}
+;
+
+for_statement_nsi:
+ for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
+ { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
+| for_begin SC_TK SC_TK for_update CP_TK statement_nsi
+ {
+ $$ = finish_for_loop (0, NULL_TREE, $4, $6);
+ /* We have not condition, so we get rid of the EXIT_EXPR */
+ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
+ empty_stmt_node;
+ }
+;
+
+for_header:
+ FOR_TK OP_TK
+ {
+ /* This scope defined for local variable that may be
+ defined within the scope of the for loop */
+ enter_block ();
+ }
+| FOR_TK error
+ {yyerror ("'(' expected"); DRECOVER(for_1);}
+| FOR_TK OP_TK error
+ {yyerror ("Invalid init statement"); RECOVER;}
+;
+
+for_begin:
+ for_header for_init
+ {
+ /* We now declare the loop body. The loop is
+ declared as a for loop. */
+ tree body = build_loop_body (0, NULL_TREE, 0);
+ $$ = build_new_loop (body);
+ IS_FOR_LOOP_P ($$) = 1;
+ /* The loop is added to the current block the for
+ statement is defined within */
+ java_method_add_stmt (current_function_decl, $$);
+ }
+;
+for_init: /* Can be empty */
+ { $$ = empty_stmt_node; }
+| statement_expression_list
+ {
+ /* Init statement recorded within the previously
+ defined block scope */
+ $$ = java_method_add_stmt (current_function_decl, $1);
+ }
+| local_variable_declaration
+ {
+ /* Local variable are recorded within the previously
+ defined block scope */
+ $$ = NULL_TREE;
+ }
+| statement_expression_list error
+ {yyerror ("';' expected"); DRECOVER(for_init_1);}
+;
+
+for_update: /* Can be empty */
+ {$$ = empty_stmt_node;}
+| statement_expression_list
+ { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
+;
+
+statement_expression_list:
+ statement_expression
+ { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
+| statement_expression_list C_TK statement_expression
+ { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
+| statement_expression_list C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+break_statement:
+ BREAK_TK SC_TK
+ { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
+| BREAK_TK identifier SC_TK
+ { $$ = build_bc_statement ($1.location, 1, $2); }
+| BREAK_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| BREAK_TK identifier error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+continue_statement:
+ CONTINUE_TK SC_TK
+ { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
+| CONTINUE_TK identifier SC_TK
+ { $$ = build_bc_statement ($1.location, 0, $2); }
+| CONTINUE_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| CONTINUE_TK identifier error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+return_statement:
+ RETURN_TK SC_TK
+ { $$ = build_return ($1.location, NULL_TREE); }
+| RETURN_TK expression SC_TK
+ { $$ = build_return ($1.location, $2); }
+| RETURN_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| RETURN_TK expression error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+throw_statement:
+ THROW_TK expression SC_TK
+ {
+ $$ = build1 (THROW_EXPR, NULL_TREE, $2);
+ EXPR_WFL_LINECOL ($$) = $1.location;
+ }
+| THROW_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| THROW_TK expression error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+synchronized_statement:
+ synchronized OP_TK expression CP_TK block
+ {
+ $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
+ EXPR_WFL_LINECOL ($$) =
+ EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
+ }
+| synchronized OP_TK expression CP_TK error
+ {yyerror ("'{' expected"); RECOVER;}
+| synchronized error
+ {yyerror ("'(' expected"); RECOVER;}
+| synchronized OP_TK error CP_TK
+ {yyerror ("Missing term"); RECOVER;}
+| synchronized OP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+synchronized:
+ MODIFIER_TK
+ {
+ if ((1 << $1) != ACC_SYNCHRONIZED)
+ fatal ("synchronized was '%d' - yyparse", (1 << $1));
+ }
+;
+
+try_statement:
+ TRY_TK block catches
+ { $$ = build_try_statement ($1.location, $2, $3); }
+| TRY_TK block finally
+ { $$ = build_try_finally_statement ($1.location, $2, $3); }
+| TRY_TK block catches finally
+ { $$ = build_try_finally_statement
+ ($1.location, build_try_statement ($1.location,
+ $2, $3), $4);
+ }
+| TRY_TK error
+ {yyerror ("'{' expected"); DRECOVER (try_statement);}
+;
+
+catches:
+ catch_clause
+| catches catch_clause
+ {
+ TREE_CHAIN ($2) = $1;
+ $$ = $2;
+ }
+;
+
+catch_clause:
+ catch_clause_parameter block
+ {
+ java_method_add_stmt (current_function_decl, $2);
+ exit_block ();
+ $$ = $1;
+ }
+
+catch_clause_parameter:
+ CATCH_TK OP_TK formal_parameter CP_TK
+ {
+ /* We add a block to define a scope for
+ formal_parameter (CCBP). The formal parameter is
+ declared initialized by the appropriate function
+ call */
+ tree ccpb = enter_block ();
+ tree init = build_assignment (ASSIGN_TK, $2.location,
+ TREE_PURPOSE ($3),
+ soft_exceptioninfo_call_node);
+ declare_local_variables (0, TREE_VALUE ($3),
+ build_tree_list (TREE_PURPOSE ($3),
+ init));
+ $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
+ EXPR_WFL_LINECOL ($$) = $1.location;
+ }
+| CATCH_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| CATCH_TK OP_TK error
+ {yyerror ("Missing term or ')' expected"); DRECOVER (2);}
+| CATCH_TK OP_TK error CP_TK /* That's for () */
+ {yyerror ("')' expected"); DRECOVER (1);}
+;
+
+finally:
+ FINALLY_TK block
+ { $$ = $2; }
+| FINALLY_TK error
+ {yyerror ("'{' expected"); RECOVER; }
+;
+
+/* 19.12 Production from 15: Expressions */
+primary:
+ primary_no_new_array
+| array_creation_expression
+;
+
+primary_no_new_array:
+ literal
+| THIS_TK
+ { $$ = build_this ($1.location); }
+| OP_TK expression CP_TK
+ {$$ = $2;}
+| class_instance_creation_expression
+| field_access
+| method_invocation
+| array_access
+ /* type DOT_TK CLASS_TK doens't work. So we split the rule
+ 'type' into its components. Missing is something for array,
+ which will complete the reference_type part. FIXME */
+| name DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+ { $$ = parse_jdk1_1_error ("named class literals"); }
+| primitive_type DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+ { $$ = build_class_ref ($1); }
+| VOID_TK DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+ { $$ = build_class_ref (void_type_node); }
+ /* Added, JDK1.1 inner classes. Documentation is wrong
+ refering to a 'ClassName' (class_name) rule that doesn't
+ exist. Used name instead. */
+| name DOT_TK THIS_TK
+ { $$ = parse_jdk1_1_error ("class literals"); }
+| OP_TK expression error
+ {yyerror ("')' expected"); RECOVER;}
+| name DOT_TK error
+ {yyerror ("'class' or 'this' expected" ); RECOVER;}
+| primitive_type DOT_TK error
+ {yyerror ("'class' expected" ); RECOVER;}
+| VOID_TK DOT_TK error
+ {yyerror ("'class' expected" ); RECOVER;}
+;
+
+class_instance_creation_expression:
+ NEW_TK class_type OP_TK argument_list CP_TK
+ { $$ = build_new_invocation ($2, $4); }
+| NEW_TK class_type OP_TK CP_TK
+ { $$ = build_new_invocation ($2, NULL_TREE); }
+ /* Added, JDK1.1 inner classes but modified to use
+ 'class_type' instead of 'TypeName' (type_name) mentionned
+ in the documentation but doesn't exist. */
+| NEW_TK class_type OP_TK argument_list CP_TK class_body
+ { $$ = parse_jdk1_1_error ("inner class instance creation"); }
+| NEW_TK class_type OP_TK CP_TK class_body
+ { $$ = parse_jdk1_1_error ("inner class instance creation"); }
+ /* Added, JDK1.1 inner classes, modified to use name or
+ primary instead of primary solely which couldn't work in
+ all situations. */
+| something_dot_new identifier OP_TK CP_TK
+| something_dot_new identifier OP_TK CP_TK class_body
+| something_dot_new identifier OP_TK argument_list CP_TK
+| something_dot_new identifier OP_TK argument_list CP_TK class_body
+| NEW_TK error SC_TK
+ {yyerror ("'(' expected"); DRECOVER(new_1);}
+| NEW_TK class_type error
+ {yyerror ("'(' expected"); RECOVER;}
+| NEW_TK class_type OP_TK error
+ {yyerror ("')' or term expected"); RECOVER;}
+| NEW_TK class_type OP_TK argument_list error
+ {yyerror ("')' expected"); RECOVER;}
+| something_dot_new error
+ {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
+| something_dot_new identifier error
+ {yyerror ("'(' expected"); RECOVER;}
+;
+
+something_dot_new: /* Added, not part of the specs. */
+ name DOT_TK NEW_TK
+| primary DOT_TK NEW_TK
+;
+
+argument_list:
+ expression
+ {
+ $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
+ ctxp->formal_parameter_number = 1;
+ }
+| argument_list C_TK expression
+ {
+ ctxp->formal_parameter_number += 1;
+ $$ = tree_cons (NULL_TREE, $3, $1);
+ }
+| argument_list C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+array_creation_expression:
+ NEW_TK primitive_type dim_exprs
+ { $$ = build_newarray_node ($2, $3, 0); }
+| NEW_TK class_or_interface_type dim_exprs
+ { $$ = build_newarray_node ($2, $3, 0); }
+| NEW_TK primitive_type dim_exprs dims
+ { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
+| NEW_TK class_or_interface_type dim_exprs dims
+ { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
+ /* Added, JDK1.1 anonymous array. Initial documentation rule
+ modified */
+| NEW_TK class_or_interface_type dims array_initializer
+ { $$ = parse_jdk1_1_error ("anonymous array"); }
+| NEW_TK primitive_type dims array_initializer
+ { $$ = parse_jdk1_1_error ("anonymous array"); }
+| NEW_TK error CSB_TK
+ {yyerror ("'[' expected"); DRECOVER ("]");}
+| NEW_TK error OSB_TK
+ {yyerror ("']' expected"); RECOVER;}
+;
+
+dim_exprs:
+ dim_expr
+ { $$ = build_tree_list (NULL_TREE, $1); }
+| dim_exprs dim_expr
+ { $$ = tree_cons (NULL_TREE, $2, $$); }
+;
+
+dim_expr:
+ OSB_TK expression CSB_TK
+ {
+ EXPR_WFL_LINECOL ($2) = $1.location;
+ $$ = $2;
+ }
+| OSB_TK expression error
+ {yyerror ("']' expected"); RECOVER;}
+| OSB_TK error
+ {
+ yyerror ("Missing term");
+ yyerror ("']' expected");
+ RECOVER;
+ }
+;
+
+dims:
+ OSB_TK CSB_TK
+ {
+ int allocate = 0;
+ /* If not initialized, allocate memory for the osb
+ numbers stack */
+ if (!ctxp->osb_limit)
+ {
+ allocate = ctxp->osb_limit = 32;
+ ctxp->osb_depth = -1;
+ }
+ /* If capacity overflown, reallocate a bigger chuck */
+ else if (ctxp->osb_depth+1 == ctxp->osb_limit)
+ allocate = ctxp->osb_limit << 1;
+
+ if (allocate)
+ {
+ allocate *= sizeof (int);
+ if (ctxp->osb_number)
+ ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
+ allocate);
+ else
+ ctxp->osb_number = (int *)xmalloc (allocate);
+ }
+ ctxp->osb_depth++;
+ CURRENT_OSB (ctxp) = 1;
+ }
+| dims OSB_TK CSB_TK
+ { CURRENT_OSB (ctxp)++; }
+| dims OSB_TK error
+ { yyerror ("']' expected"); RECOVER;}
+;
+
+field_access:
+ primary DOT_TK identifier
+ { $$ = make_qualified_primary ($1, $3, $2.location); }
+ /* FIXME - REWRITE TO:
+ { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
+| SUPER_TK DOT_TK identifier
+ {
+ tree super_wfl =
+ build_wfl_node (super_identifier_node);
+ EXPR_WFL_LINECOL (super_wfl) = $1.location;
+ $$ = make_qualified_name (super_wfl, $3, $2.location);
+ }
+| SUPER_TK error
+ {yyerror ("Field expected"); DRECOVER (super_field_acces);}
+;
+
+method_invocation:
+ name OP_TK CP_TK
+ { $$ = build_method_invocation ($1, NULL_TREE); }
+| name OP_TK argument_list CP_TK
+ { $$ = build_method_invocation ($1, $3); }
+| primary DOT_TK identifier OP_TK CP_TK
+ {
+ if (TREE_CODE ($1) == THIS_EXPR)
+ $$ = build_this_super_qualified_invocation
+ (1, $3, NULL_TREE, 0, $2.location);
+ else
+ {
+ tree invok = build_method_invocation ($3, NULL_TREE);
+ $$ = make_qualified_primary ($1, invok, $2.location);
+ }
+ }
+| primary DOT_TK identifier OP_TK argument_list CP_TK
+ {
+ if (TREE_CODE ($1) == THIS_EXPR)
+ $$ = build_this_super_qualified_invocation
+ (1, $3, $5, 0, $2.location);
+ else
+ {
+ tree invok = build_method_invocation ($3, $5);
+ $$ = make_qualified_primary ($1, invok, $2.location);
+ }
+ }
+| SUPER_TK DOT_TK identifier OP_TK CP_TK
+ {
+ $$ = build_this_super_qualified_invocation
+ (0, $3, NULL_TREE, $1.location, $2.location);
+ }
+| SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
+ {
+ $$ = build_this_super_qualified_invocation
+ (0, $3, $5, $1.location, $2.location);
+ }
+ /* Screws up thing. I let it here until I'm convinced it can
+ be removed. FIXME
+| primary DOT_TK error
+ {yyerror ("'(' expected"); DRECOVER(bad);} */
+| SUPER_TK DOT_TK error CP_TK
+ { yyerror ("'(' expected"); DRECOVER (method_invocation); }
+| SUPER_TK DOT_TK error DOT_TK
+ { yyerror ("'(' expected"); DRECOVER (method_invocation); }
+;
+
+array_access:
+ name OSB_TK expression CSB_TK
+ { $$ = build_array_ref ($2.location, $1, $3); }
+| primary_no_new_array OSB_TK expression CSB_TK
+ { $$ = build_array_ref ($2.location, $1, $3); }
+| name OSB_TK error
+ {
+ yyerror ("Missing term and ']' expected");
+ DRECOVER(array_access);
+ }
+| name OSB_TK expression error
+ {
+ yyerror ("']' expected");
+ DRECOVER(array_access);
+ }
+| primary_no_new_array OSB_TK error
+ {
+ yyerror ("Missing term and ']' expected");
+ DRECOVER(array_access);
+ }
+| primary_no_new_array OSB_TK expression error
+ {
+ yyerror ("']' expected");
+ DRECOVER(array_access);
+ }
+;
+
+postfix_expression:
+ primary
+| name
+| post_increment_expression
+| post_decrement_expression
+;
+
+post_increment_expression:
+ postfix_expression INCR_TK
+ { $$ = build_incdec ($2.token, $2.location, $1, 1); }
+;
+
+post_decrement_expression:
+ postfix_expression DECR_TK
+ { $$ = build_incdec ($2.token, $2.location, $1, 1); }
+;
+
+unary_expression:
+ pre_increment_expression
+| pre_decrement_expression
+| PLUS_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| MINUS_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| unary_expression_not_plus_minus
+| PLUS_TK error
+ {yyerror ("Missing term"); RECOVER}
+| MINUS_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+pre_increment_expression:
+ INCR_TK unary_expression
+ {$$ = build_incdec ($1.token, $1.location, $2, 0); }
+| INCR_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+pre_decrement_expression:
+ DECR_TK unary_expression
+ {$$ = build_incdec ($1.token, $1.location, $2, 0); }
+| DECR_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+unary_expression_not_plus_minus:
+ postfix_expression
+| NOT_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| NEG_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| cast_expression
+| NOT_TK error
+ {yyerror ("Missing term"); RECOVER}
+| NEG_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+cast_expression: /* Error handling here is potentially weak */
+ OP_TK primitive_type dims CP_TK unary_expression
+ {
+ tree type = $2;
+ while (CURRENT_OSB (ctxp)--)
+ type = build_java_array_type (type, -1);
+ ctxp->osb_depth--;
+ $$ = build_cast ($1.location, type, $5);
+ }
+| OP_TK primitive_type CP_TK unary_expression
+ { $$ = build_cast ($1.location, $2, $4); }
+| OP_TK expression CP_TK unary_expression_not_plus_minus
+ { $$ = build_cast ($1.location, $2, $4); }
+| OP_TK name dims CP_TK unary_expression_not_plus_minus
+ {
+ char *ptr;
+ while (CURRENT_OSB (ctxp)--)
+ obstack_1grow (&temporary_obstack, '[');
+ ctxp->osb_depth--;
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
+ ptr = obstack_finish (&temporary_obstack);
+ EXPR_WFL_NODE ($2) = get_identifier (ptr);
+ $$ = build_cast ($1.location, $2, $5);
+ }
+| OP_TK primitive_type OSB_TK error
+ {yyerror ("']' expected, invalid type expression");}
+| OP_TK error
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid type expression"); RECOVER;
+ RECOVER;
+ }
+| OP_TK primitive_type dims CP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| OP_TK primitive_type CP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| OP_TK name dims CP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+multiplicative_expression:
+ unary_expression
+| multiplicative_expression MULT_TK unary_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token),
+ $2.location, $1, $3);
+ }
+| multiplicative_expression DIV_TK unary_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| multiplicative_expression REM_TK unary_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| multiplicative_expression MULT_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| multiplicative_expression DIV_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| multiplicative_expression REM_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+additive_expression:
+ multiplicative_expression
+| additive_expression PLUS_TK multiplicative_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| additive_expression MINUS_TK multiplicative_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| additive_expression PLUS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| additive_expression MINUS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+shift_expression:
+ additive_expression
+| shift_expression LS_TK additive_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| shift_expression SRS_TK additive_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| shift_expression ZRS_TK additive_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| shift_expression LS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| shift_expression SRS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| shift_expression ZRS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+relational_expression:
+ shift_expression
+| relational_expression LT_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression GT_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression LTE_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression GTE_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression INSTANCEOF_TK reference_type
+ { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
+| relational_expression LT_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression GT_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression LTE_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression GTE_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression INSTANCEOF_TK error
+ {yyerror ("Invalid reference type"); RECOVER;}
+;
+
+equality_expression:
+ relational_expression
+| equality_expression EQ_TK relational_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| equality_expression NEQ_TK relational_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| equality_expression EQ_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| equality_expression NEQ_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+and_expression:
+ equality_expression
+| and_expression AND_TK equality_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| and_expression AND_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+exclusive_or_expression:
+ and_expression
+| exclusive_or_expression XOR_TK and_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| exclusive_or_expression XOR_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+inclusive_or_expression:
+ exclusive_or_expression
+| inclusive_or_expression OR_TK exclusive_or_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| inclusive_or_expression OR_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+conditional_and_expression:
+ inclusive_or_expression
+| conditional_and_expression BOOL_AND_TK inclusive_or_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| conditional_and_expression BOOL_AND_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+conditional_or_expression:
+ conditional_and_expression
+| conditional_or_expression BOOL_OR_TK conditional_and_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| conditional_or_expression BOOL_OR_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+conditional_expression: /* Error handling here is weak */
+ conditional_or_expression
+| conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
+ {
+ $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
+ EXPR_WFL_LINECOL ($$) = $2.location;
+ }
+| conditional_or_expression REL_QM_TK REL_CL_TK error
+ {
+ YYERROR_NOW;
+ yyerror ("Missing term");
+ DRECOVER (1);
+ }
+| conditional_or_expression REL_QM_TK error
+ {yyerror ("Missing term"); DRECOVER (2);}
+| conditional_or_expression REL_QM_TK expression REL_CL_TK error
+ {yyerror ("Missing term"); DRECOVER (3);}
+;
+
+assignment_expression:
+ conditional_expression
+| assignment
+;
+
+assignment:
+ left_hand_side assignment_operator assignment_expression
+ { $$ = build_assignment ($2.token, $2.location, $1, $3); }
+| left_hand_side assignment_operator error
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Missing term");
+ DRECOVER (assign);
+ }
+;
+
+left_hand_side:
+ name
+| field_access
+| array_access
+;
+
+assignment_operator:
+ ASSIGN_ANY_TK
+| ASSIGN_TK
+;
+
+expression:
+ assignment_expression
+;
+
+constant_expression:
+ expression
+;
+
+%%
+
+
+/* Flag for the error report routine to issue the error the first time
+ it's called (overriding the default behavior which is to drop the
+ first invocation and honor the second one, taking advantage of a
+ richer context. */
+static int force_error = 0;
+
+/* Create a new parser context and make it the current one. */
+
+void
+java_push_parser_context ()
+{
+ struct parser_ctxt *new =
+ (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
+
+ bzero ((PTR) new, sizeof (struct parser_ctxt));
+ new->next = ctxp;
+ ctxp = new;
+ if (ctxp->next)
+ {
+ ctxp->incomplete_class = ctxp->next->incomplete_class;
+ ctxp->gclass_list = ctxp->next->gclass_list;
+ }
+}
+
+/* If the first file of a file list was a class file, no context
+ exists for a source file to be parsed. This boolean remembers that
+ java_parser_context_save_global might have created a dummy one, so
+ that java_parser_context_restore_global can pop it. */
+static int extra_ctxp_pushed_p = 0;
+
+void
+java_parser_context_save_global ()
+{
+ if (!ctxp)
+ {
+ java_push_parser_context ();
+ extra_ctxp_pushed_p = 1;
+ }
+ ctxp->finput = finput;
+ ctxp->lineno = lineno;
+ ctxp->current_class = current_class;
+ ctxp->filename = input_filename;
+ ctxp->current_function_decl = current_function_decl;
+}
+
+void
+java_parser_context_restore_global ()
+{
+ finput = ctxp->finput;
+ lineno = ctxp->lineno;
+ current_class = ctxp->current_class;
+ input_filename = ctxp->filename;
+ current_function_decl = ctxp->current_function_decl;
+ if (!ctxp->next && extra_ctxp_pushed_p)
+ {
+ java_pop_parser_context (0);
+ extra_ctxp_pushed_p = 0;
+ }
+}
+
+void
+java_pop_parser_context (generate)
+ int generate;
+{
+ tree current;
+ struct parser_ctxt *toFree, *next;
+
+ if (!ctxp)
+ return;
+
+ toFree = ctxp;
+ next = ctxp->next;
+ if (next)
+ {
+ next->incomplete_class = ctxp->incomplete_class;
+ next->gclass_list = ctxp->gclass_list;
+ lineno = ctxp->lineno;
+ finput = ctxp->finput;
+ current_class = ctxp->current_class;
+ }
+
+ /* Set the single import class file flag to 0 for the current list
+ of imported things */
+ for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
+
+ /* And restore those of the previous context */
+ if ((ctxp = next)) /* Assignment is really meant here */
+ for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
+
+ if (generate)
+ {
+ toFree->next = ctxp_for_generation;
+ ctxp_for_generation = toFree;
+ }
+ else
+ free (toFree);
+}
+
+/* Reporting JDK1.1 features not implemented */
+
+static tree
+parse_jdk1_1_error (msg)
+ char *msg;
+{
+ sorry (": `%s' JDK1.1(TM) feature", msg);
+ java_error_count++;
+ return empty_stmt_node;
+}
+
+static int do_warning = 0;
+
+void
+yyerror (msg)
+ char *msg;
+{
+ static java_lc elc;
+ static int prev_lineno;
+ static char *prev_msg;
+
+ int save_lineno;
+ char *remainder, *code_from_source;
+ extern struct obstack temporary_obstack;
+
+ if (!force_error && prev_lineno == lineno)
+ return;
+
+ /* Save current error location but report latter, when the context is
+ richer. */
+ if (ctxp->java_error_flag == 0)
+ {
+ ctxp->java_error_flag = 1;
+ elc = ctxp->elc;
+ /* Do something to use the previous line if we're reaching the
+ end of the file... */
+#ifdef VERBOSE_SKELETON
+ printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
+#endif
+ return;
+ }
+
+ /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
+ if (!force_error && msg == prev_msg && prev_lineno == elc.line)
+ return;
+
+ ctxp->java_error_flag = 0;
+ if (do_warning)
+ java_warning_count++;
+ else
+ java_error_count++;
+
+ if (elc.col == 0 && msg[1] == ';')
+ {
+ elc.col = ctxp->p_line->char_col-1;
+ elc.line = ctxp->p_line->lineno;
+ }
+
+ save_lineno = lineno;
+ prev_lineno = lineno = elc.line;
+ prev_msg = msg;
+
+ code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
+ obstack_grow0 (&temporary_obstack,
+ code_from_source, strlen (code_from_source));
+ remainder = obstack_finish (&temporary_obstack);
+ if (do_warning)
+ warning ("%s.\n%s", msg, remainder);
+ else
+ error ("%s.\n%s", msg, remainder);
+
+ /* This allow us to cheaply avoid an extra 'Invalid expression
+ statement' error report when errors have been already reported on
+ the same line. This occurs when we report an error but don't have
+ a synchronization point other than ';', which
+ expression_statement is the only one to take care of. */
+ ctxp->prevent_ese = lineno = save_lineno;
+}
+
+static void
+issue_warning_error_from_context (cl, msg, ap)
+ tree cl;
+ const char *msg;
+ va_list ap;
+{
+ char *saved, *saved_input_filename;
+ char buffer [4096];
+ vsprintf (buffer, msg, ap);
+ force_error = 1;
+
+ ctxp->elc.line = EXPR_WFL_LINENO (cl);
+ ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
+ (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
+
+ /* We have a CL, that's a good reason for using it if it contains data */
+ saved = ctxp->filename;
+ if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
+ ctxp->filename = EXPR_WFL_FILENAME (cl);
+ saved_input_filename = input_filename;
+ input_filename = ctxp->filename;
+ java_error (NULL);
+ java_error (buffer);
+ ctxp->filename = saved;
+ input_filename = saved_input_filename;
+ force_error = 0;
+}
+
+/* Issue an error message at a current source line CL */
+
+void
+parse_error_context VPROTO ((tree cl, const char *msg, ...))
+{
+#ifndef ANSI_PROTOTYPES
+ tree cl;
+ const char *msg;
+#endif
+ va_list ap;
+
+ VA_START (ap, msg);
+#ifndef ANSI_PROTOTYPES
+ cl = va_arg (ap, tree);
+ msg = va_arg (ap, const char *);
+#endif
+ issue_warning_error_from_context (cl, msg, ap);
+ va_end (ap);
+}
+
+/* Issue a warning at a current source line CL */
+
+static void
+parse_warning_context VPROTO ((tree cl, const char *msg, ...))
+{
+#ifndef ANSI_PROTOTYPES
+ tree cl;
+ const char *msg;
+#endif
+ va_list ap;
+
+ VA_START (ap, msg);
+#ifndef ANSI_PROTOTYPES
+ cl = va_arg (ap, tree);
+ msg = va_arg (ap, const char *);
+#endif
+
+ force_error = do_warning = 1;
+ issue_warning_error_from_context (cl, msg, ap);
+ do_warning = force_error = 0;
+ va_end (ap);
+}
+
+static tree
+find_expr_with_wfl (node)
+ tree node;
+{
+ while (node)
+ {
+ char code;
+ tree to_return;
+
+ switch (TREE_CODE (node))
+ {
+ case BLOCK:
+ node = BLOCK_EXPR_BODY (node);
+ continue;
+
+ case COMPOUND_EXPR:
+ to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
+ if (to_return)
+ return to_return;
+ node = TREE_OPERAND (node, 1);
+ continue;
+
+ case LOOP_EXPR:
+ node = TREE_OPERAND (node, 0);
+ continue;
+
+ case LABELED_BLOCK_EXPR:
+ node = TREE_OPERAND (node, 1);
+ continue;
+
+ default:
+ code = TREE_CODE_CLASS (TREE_CODE (node));
+ if (((code == '1') || (code == '2') || (code == 'e'))
+ && EXPR_WFL_LINECOL (node))
+ return node;
+ return NULL_TREE;
+ }
+ }
+ return NULL_TREE;
+}
+
+/* Issue a missing return statement error. Uses METHOD to figure the
+ last line of the method the error occurs in. */
+
+static void
+missing_return_error (method)
+ tree method;
+{
+ EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
+ parse_error_context (wfl_operator, "Missing return statement");
+}
+
+/* Issue an unreachable statement error. From NODE, find the next
+ statement to report appropriately. */
+static void
+unreachable_stmt_error (node)
+ tree node;
+{
+ /* Browse node to find the next expression node that has a WFL. Use
+ the location to report the error */
+ if (TREE_CODE (node) == COMPOUND_EXPR)
+ node = find_expr_with_wfl (TREE_OPERAND (node, 1));
+ else
+ node = find_expr_with_wfl (node);
+
+ if (node)
+ {
+ EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
+ parse_error_context (wfl_operator, "Unreachable statement");
+ }
+ else
+ fatal ("Can't get valid statement - unreachable_stmt_error");
+}
+
+int
+java_report_errors ()
+{
+ if (java_error_count)
+ fprintf (stderr, "%d error%s",
+ java_error_count, (java_error_count == 1 ? "" : "s"));
+ if (java_warning_count)
+ fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
+ java_warning_count, (java_warning_count == 1 ? "" : "s"));
+ if (java_error_count || java_warning_count)
+ putc ('\n', stderr);
+ return java_error_count;
+}
+
+static char *
+java_accstring_lookup (flags)
+ int flags;
+{
+ static char buffer [80];
+#define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
+
+ /* Access modifier looked-up first for easier report on forbidden
+ access. */
+ if (flags & ACC_PUBLIC) COPY_RETURN ("public");
+ if (flags & ACC_PRIVATE) COPY_RETURN ("private");
+ if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
+ if (flags & ACC_STATIC) COPY_RETURN ("static");
+ if (flags & ACC_FINAL) COPY_RETURN ("final");
+ if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
+ if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
+ if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
+ if (flags & ACC_NATIVE) COPY_RETURN ("native");
+ if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
+ if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
+
+ buffer [0] = '\0';
+ return buffer;
+#undef COPY_RETURN
+}
+
+/* Issuing error messages upon redefinition of classes, interfaces or
+ variables. */
+
+static void
+classitf_redefinition_error (context, id, decl, cl)
+ char *context;
+ tree id, decl, cl;
+{
+ parse_error_context (cl, "%s `%s' already defined in %s:%d",
+ context, IDENTIFIER_POINTER (id),
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ /* Here we should point out where its redefined. It's a unicode. FIXME */
+}
+
+static void
+variable_redefinition_error (context, name, type, line)
+ tree context, name, type;
+ int line;
+{
+ char *type_name;
+
+ /* Figure a proper name for type. We might haven't resolved it */
+ if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
+ type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
+ else
+ type_name = lang_printable_name (type, 0);
+
+ parse_error_context (context,
+ "Variable `%s' is already defined in this method and "
+ "was declared `%s %s' at line %d",
+ IDENTIFIER_POINTER (name),
+ type_name, IDENTIFIER_POINTER (name), line);
+}
+
+static tree
+build_array_from_name (type, type_wfl, name, ret_name)
+ tree type, type_wfl, name, *ret_name;
+{
+ int more_dims = 0;
+ char *string;
+
+ /* Eventually get more dims */
+ string = IDENTIFIER_POINTER (name);
+ while (string [more_dims] == '[')
+ more_dims++;
+
+ /* If we have, then craft a new type for this variable */
+ if (more_dims)
+ {
+ name = get_identifier (&string [more_dims]);
+
+ /* If we have a pointer, use its type */
+ if (TREE_CODE (type) == POINTER_TYPE)
+ type = TREE_TYPE (type);
+
+ /* Building the first dimension of a primitive type uses this
+ function */
+ if (JPRIMITIVE_TYPE_P (type))
+ {
+ type = build_java_array_type (type, -1);
+ CLASS_LOADED_P (type) = 1;
+ more_dims--;
+ }
+ /* Otherwise, if we have a WFL for this type, use it (the type
+ is already an array on an unresolved type, and we just keep
+ on adding dimensions) */
+ else if (type_wfl)
+ type = type_wfl;
+
+ /* Add all the dimensions */
+ while (more_dims--)
+ type = build_unresolved_array_type (type);
+
+ /* The type may have been incomplete in the first place */
+ if (type_wfl)
+ type = obtain_incomplete_type (type);
+ }
+
+ *ret_name = name;
+ return type;
+}
+
+/* Build something that the type identifier resolver will identify as
+ being an array to an unresolved type. TYPE_WFL is a WFL on a
+ identifier. */
+
+static tree
+build_unresolved_array_type (type_or_wfl)
+ tree type_or_wfl;
+{
+ char *ptr;
+
+ /* TYPE_OR_WFL might be an array on a resolved type. In this case,
+ just create a array type */
+ if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
+ {
+ tree type = build_java_array_type (type_or_wfl, -1);
+ CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
+ return type;
+ }
+
+ obstack_1grow (&temporary_obstack, '[');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
+ ptr = obstack_finish (&temporary_obstack);
+ return build_expr_wfl (get_identifier (ptr),
+ EXPR_WFL_FILENAME (type_or_wfl),
+ EXPR_WFL_LINENO (type_or_wfl),
+ EXPR_WFL_COLNO (type_or_wfl));
+}
+
+/* Check modifiers. If one doesn't fit, retrieve it in its declaration line
+ and point it out. */
+
+static void
+check_modifiers (message, value, mask)
+ char *message;
+ int value;
+ int mask;
+{
+ /* Should point out the one that don't fit. ASCII/unicode,
+ going backward. FIXME */
+ if (value & ~mask)
+ {
+ int i, remainder = value & ~mask;
+ for (i = 0; i <= 10; i++)
+ if ((1 << i) & remainder)
+ parse_error_context (ctxp->modifier_ctx [i], message,
+ java_accstring_lookup (1 << i));
+ }
+}
+
+static void
+parser_add_interface (class_decl, interface_decl, wfl)
+ tree class_decl, interface_decl, wfl;
+{
+ if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
+ parse_error_context (wfl, "Interface `%s' repeated",
+ IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
+}
+
+/* Bulk of common class/interface checks. Return 1 if an error was
+ encountered. TAG is 0 for a class, 1 for an interface. */
+
+static int
+check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
+ int is_interface, flags;
+ tree raw_name, qualified_name, decl, cl;
+{
+ tree node;
+
+ if (!quiet_flag)
+ fprintf (stderr, " %s %s", (is_interface ? "interface" : "class"),
+ IDENTIFIER_POINTER (qualified_name));
+
+ /* Scope of an interface/class type name:
+ - Can't be imported by a single type import
+ - Can't already exists in the package */
+ if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
+ && (node = find_name_in_single_imports (raw_name)))
+ {
+ parse_error_context
+ (cl, "%s name `%s' clashes with imported type `%s'",
+ (is_interface ? "Interface" : "Class"),
+ IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
+ return 1;
+ }
+ if (decl && CLASS_COMPLETE_P (decl))
+ {
+ classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
+ qualified_name, decl, cl);
+ return 1;
+ }
+
+ /* If public, file name should match class/interface name */
+ if (flags & ACC_PUBLIC)
+ {
+ char *f;
+
+ /* Contains OS dependent assumption on path separator. FIXME */
+ for (f = &input_filename [strlen (input_filename)];
+ f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR;
+ f--)
+ ;
+ if (f[0] == '/' || f[0] == DIR_SEPARATOR)
+ f++;
+ if (strncmp (IDENTIFIER_POINTER (raw_name),
+ f , IDENTIFIER_LENGTH (raw_name)) ||
+ f [IDENTIFIER_LENGTH (raw_name)] != '.')
+ parse_error_context (cl, "Public %s `%s' must be defined in a file "
+ "called `%s.java'",
+ (is_interface ? "interface" : "class"),
+ IDENTIFIER_POINTER (qualified_name),
+ IDENTIFIER_POINTER (raw_name));
+ }
+
+ check_modifiers ((is_interface ?
+ "Illegal modifier `%s' for interface declaration" :
+ "Illegal modifier `%s' for class declaration"), flags,
+ (is_interface ? INTERFACE_MODIFIERS : CLASS_MODIFIERS));
+ return 0;
+}
+
+/* If DECL is NULL, create and push a new DECL, record the current
+ line CL and do other maintenance things. */
+
+static tree
+maybe_create_class_interface_decl (decl, qualified_name, cl)
+ tree decl, qualified_name, cl;
+{
+ if (!decl)
+ decl = push_class (make_class (), qualified_name);
+
+ /* Take care of the file and line business */
+ DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
+ /* If we're emiting xrefs, store the line/col number information */
+ if (flag_emit_xref)
+ DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
+ else
+ DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
+ CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
+ CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (TREE_TYPE (decl)) =
+ IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
+
+ ctxp->current_parsed_class = decl;
+
+ /* Link the declaration to the already seen ones */
+ TREE_CHAIN (decl) = ctxp->class_list;
+ ctxp->class_list = decl;
+
+ /* Create a new nodes in the global lists */
+ ctxp->gclass_list = tree_cons (NULL_TREE, decl, ctxp->gclass_list);
+ all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
+
+ /* Install a new dependency list element */
+ create_jdep_list (ctxp);
+
+ SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
+ IDENTIFIER_POINTER (qualified_name)));
+ return decl;
+}
+
+static void
+add_superinterfaces (decl, interface_list)
+ tree decl, interface_list;
+{
+ tree node;
+ /* Superinterface(s): if present and defined, parser_check_super_interface ()
+ takes care of ensuring that:
+ - This is an accessible interface type,
+ - Circularity detection.
+ parser_add_interface is then called. If present but not defined,
+ the check operation is delayed until the super interface gets
+ defined. */
+ for (node = interface_list; node; node = TREE_CHAIN (node))
+ {
+ tree current = TREE_PURPOSE (node);
+ tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
+ if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
+ {
+ if (!parser_check_super_interface (idecl, decl, current))
+ parser_add_interface (decl, idecl, current);
+ }
+ else
+ register_incomplete_type (JDEP_INTERFACE,
+ current, decl, NULL_TREE);
+ }
+}
+
+/* Create an interface in pass1 and return its decl. Return the
+ interface's decl in pass 2. */
+
+static tree
+create_interface (flags, id, super)
+ int flags;
+ tree id, super;
+{
+ tree raw_name = EXPR_WFL_NODE (id);
+ tree q_name = parser_qualified_classname (id);
+ tree decl = IDENTIFIER_CLASS_VALUE (q_name);
+
+ EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
+
+ /* Basic checks: scope, redefinition, modifiers */
+ if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
+ return NULL_TREE;
+
+ /* Interface modifiers check
+ - public/abstract allowed (already done at that point)
+ - abstract is obsolete (comes first, it's a warning, or should be)
+ - Can't use twice the same (checked in the modifier rule) */
+ if ((flags & ACC_ABSTRACT) && flag_redundant)
+ parse_warning_context
+ (MODIFIER_WFL (ABSTRACT_TK),
+ "Redundant use of `abstract' modifier. Interface `%s' is implicitely "
+ "abstract", IDENTIFIER_POINTER (raw_name));
+
+ /* Create a new decl if DECL is NULL, otherwise fix it */
+ decl = maybe_create_class_interface_decl (decl, q_name, id);
+
+ /* Set super info and mark the class a complete */
+ set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
+ object_type_node, ctxp->interface_number);
+ ctxp->interface_number = 0;
+ CLASS_COMPLETE_P (decl) = 1;
+ add_superinterfaces (decl, super);
+
+ return decl;
+}
+
+/* Create an class in pass1 and return its decl. Return class
+ interface's decl in pass 2. */
+
+static tree
+create_class (flags, id, super, interfaces)
+ int flags;
+ tree id, super, interfaces;
+{
+ tree raw_name = EXPR_WFL_NODE (id);
+ tree class_id, decl;
+ tree super_decl_type;
+
+ class_id = parser_qualified_classname (id);
+ decl = IDENTIFIER_CLASS_VALUE (class_id);
+ ctxp->current_parsed_class_un = EXPR_WFL_NODE (id);
+ EXPR_WFL_NODE (id) = class_id;
+
+ /* Basic check: scope, redefinition, modifiers */
+ if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
+ return NULL_TREE;
+
+ /* Class modifier check:
+ - Allowed modifier (already done at that point)
+ - abstract AND final forbidden
+ - Public classes defined in the correct file */
+ if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
+ parse_error_context (id, "Class `%s' can't be declared both abstract "
+ "and final", IDENTIFIER_POINTER (raw_name));
+
+ /* Create a new decl if DECL is NULL, otherwise fix it */
+ decl = maybe_create_class_interface_decl (decl, class_id, id);
+
+ /* If SUPER exists, use it, otherwise use Object */
+ if (super)
+ {
+ /* Can't extend java.lang.Object */
+ if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
+ {
+ parse_error_context (id, "Can't extend `java.lang.Object'");
+ return NULL_TREE;
+ }
+
+ super_decl_type =
+ register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
+ }
+ else if (TREE_TYPE (decl) != object_type_node)
+ super_decl_type = object_type_node;
+ /* We're defining java.lang.Object */
+ else
+ super_decl_type = NULL_TREE;
+
+ /* Set super info and mark the class a complete */
+ set_super_info (flags, TREE_TYPE (decl), super_decl_type,
+ ctxp->interface_number);
+ ctxp->interface_number = 0;
+ CLASS_COMPLETE_P (decl) = 1;
+ add_superinterfaces (decl, interfaces);
+
+ /* If doing xref, store the location at which the inherited class
+ (if any) was seen. */
+ if (flag_emit_xref && super)
+ DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
+
+ /* Eventually sets the @deprecated tag flag */
+ CHECK_DEPRECATED (decl);
+
+ return decl;
+}
+
+/* Can't use lookup_field () since we don't want to load the class and
+ can't set the CLASS_LOADED_P flag */
+
+static tree
+find_field (class, name)
+ tree class;
+ tree name;
+{
+ tree decl;
+ for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
+ {
+ if (DECL_NAME (decl) == name)
+ return decl;
+ }
+ return NULL_TREE;
+}
+
+/* Wrap around lookup_field that doesn't potentially upset the value
+ of CLASS */
+
+static tree
+lookup_field_wrapper (class, name)
+ tree class, name;
+{
+ tree type = class;
+ tree decl;
+ java_parser_context_save_global ();
+ decl = lookup_field (&type, name);
+ java_parser_context_restore_global ();
+ return decl == error_mark_node ? NULL : decl;
+}
+
+/* Find duplicate field within the same class declarations and report
+ the error. Returns 1 if a duplicated field was found, 0
+ otherwise. */
+
+static int
+duplicate_declaration_error_p (new_field_name, new_type, cl)
+ tree new_field_name, new_type, cl;
+{
+ /* This might be modified to work with method decl as well */
+ tree decl = find_field (TREE_TYPE (ctxp->current_parsed_class),
+ new_field_name);
+ if (decl)
+ {
+ char *t1 = strdup (purify_type_name
+ ((TREE_CODE (new_type) == POINTER_TYPE
+ && TREE_TYPE (new_type) == NULL_TREE) ?
+ IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
+ lang_printable_name (new_type, 1)));
+ /* The type may not have been completed by the time we report
+ the error */
+ char *t2 = strdup (purify_type_name
+ ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
+ && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
+ IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
+ lang_printable_name (TREE_TYPE (decl), 1)));
+ parse_error_context
+ (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
+ t1, IDENTIFIER_POINTER (new_field_name),
+ t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ free (t1);
+ free (t2);
+ return 1;
+ }
+ return 0;
+}
+
+/* Field registration routine. If TYPE doesn't exist, field
+ declarations are linked to the undefined TYPE dependency list, to
+ be later resolved in java_complete_class () */
+
+static void
+register_fields (flags, type, variable_list)
+ int flags;
+ tree type, variable_list;
+{
+ tree current, saved_type;
+ tree class_type = TREE_TYPE (ctxp->current_parsed_class);
+ int saved_lineno = lineno;
+ int must_chain = 0;
+ tree wfl = NULL_TREE;
+
+ /* If we're adding fields to interfaces, those fields are public,
+ static, final */
+ if (CLASS_INTERFACE (TYPE_NAME (class_type)))
+ {
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
+ flags, ACC_PUBLIC,
+ "%s", "interface field(s)");
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
+ flags, ACC_STATIC,
+ "%s", "interface field(s)");
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
+ flags, ACC_FINAL, "%s", "interface field(s)");
+ check_modifiers ("Illegal interface member modifier `%s'", flags,
+ INTERFACE_FIELD_MODIFIERS);
+ flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
+ }
+
+ /* Obtain a suitable type for resolution, if necessary */
+ SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
+
+ /* If TYPE is fully resolved and we don't have a reference, make one */
+ PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
+
+ for (current = variable_list, saved_type = type; current;
+ current = TREE_CHAIN (current), type = saved_type)
+ {
+ tree real_type;
+ tree field_decl;
+ tree cl = TREE_PURPOSE (current);
+ tree init = TREE_VALUE (current);
+ tree current_name = EXPR_WFL_NODE (cl);
+
+ /* Process NAME, as it may specify extra dimension(s) for it */
+ type = build_array_from_name (type, wfl, current_name, &current_name);
+
+ /* Type adjustment. We may have just readjusted TYPE because
+ the variable specified more dimensions. Make sure we have
+ a reference if we can and don't have one already. Also
+ change the name if we have an init. */
+ if (type != saved_type)
+ {
+ PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
+ if (init)
+ EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
+ }
+
+ real_type = GET_REAL_TYPE (type);
+ /* Check for redeclarations */
+ if (duplicate_declaration_error_p (current_name, real_type, cl))
+ continue;
+
+ /* Set lineno to the line the field was found and create a
+ declaration for it. Eventually sets the @deprecated tag flag. */
+ if (flag_emit_xref)
+ lineno = EXPR_WFL_LINECOL (cl);
+ else
+ lineno = EXPR_WFL_LINENO (cl);
+ field_decl = add_field (class_type, current_name, real_type, flags);
+ CHECK_DEPRECATED (field_decl);
+
+ /* Check if we must chain. */
+ if (must_chain)
+ register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
+
+ /* If we have an initialization value tied to the field */
+ if (init)
+ {
+ /* The field is declared static */
+ if (flags & ACC_STATIC)
+ {
+ /* We include the field and its initialization part into
+ a list used to generate <clinit>. After <clinit> is
+ walked, field initializations will be processed and
+ fields initialized with known constants will be taken
+ out of <clinit> and have their DECL_INITIAL set
+ appropriately. */
+ TREE_CHAIN (init) = ctxp->static_initialized;
+ ctxp->static_initialized = init;
+ if (TREE_OPERAND (init, 1)
+ && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
+ TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
+ }
+ /* A non-static field declared with an immediate initialization is
+ to be initialized in <init>, if any. This field is remembered
+ to be processed at the time of the generation of <init>. */
+ else
+ {
+ TREE_CHAIN (init) = ctxp->non_static_initialized;
+ ctxp->non_static_initialized = init;
+ }
+ MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
+ DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
+ }
+ }
+ lineno = saved_lineno;
+}
+
+/* Generate the method $finit$ that initializes fields initialized
+ upon declaration. */
+
+static void
+maybe_generate_finit ()
+{
+ tree mdecl, current;
+
+ if (!ctxp->non_static_initialized || java_error_count)
+ return;
+
+ mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class),
+ ACC_PRIVATE, void_type_node,
+ finit_identifier_node, end_params_node);
+ start_artificial_method_body (mdecl);
+
+ ctxp->non_static_initialized = nreverse (ctxp->non_static_initialized);
+ for (current = ctxp->non_static_initialized; current;
+ current = TREE_CHAIN (current))
+ java_method_add_stmt (mdecl,
+ build_debugable_stmt (EXPR_WFL_LINECOL (current),
+ current));
+
+ end_artificial_method_body (mdecl);
+ CLASS_HAS_FINIT_P (TREE_TYPE (ctxp->current_parsed_class)) = 1;
+ ctxp->non_static_initialized = NULL_TREE;
+}
+
+/* Check whether it is necessary to generate a <clinit> for the class
+ we just parsed. */
+
+static void
+maybe_generate_clinit ()
+{
+ tree mdecl, c;
+
+ if (!ctxp->static_initialized || java_error_count)
+ return;
+
+ mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class),
+ ACC_STATIC, void_type_node,
+ clinit_identifier_node, end_params_node);
+ start_artificial_method_body (mdecl);
+
+ /* Keep initialization in order to enforce 8.5 */
+ ctxp->static_initialized = nreverse (ctxp->static_initialized);
+
+ /* We process the list of assignment we produced as the result of
+ the declaration of initialized static field and add them as
+ statement to the <clinit> method. */
+ for (c = ctxp->static_initialized; c; c = TREE_CHAIN (c))
+ {
+ /* We build the assignment expression that will initialize the
+ field to its value. There are strict rules on static
+ initializers (8.5). FIXME */
+ java_method_add_stmt (mdecl,
+ build_debugable_stmt (EXPR_WFL_LINECOL (c), c));
+ }
+
+ end_artificial_method_body (mdecl);
+ ctxp->static_initialized = NULL_TREE;
+}
+
+/* Shared accros method_declarator and method_header to remember the
+ patch stage that was reached during the declaration of the method.
+ A method DECL is built differently is there is no patch
+ (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
+ pending on the currently defined method. */
+
+static int patch_stage;
+
+/* Check the method declaration and add the method to its current
+ class. If the argument list is known to contain incomplete types,
+ the method is partially added and the registration will be resume
+ once the method arguments resolved. If TYPE is NULL, we're dealing
+ with a constructor. */
+
+static tree
+method_header (flags, type, mdecl, throws)
+ int flags;
+ tree type, mdecl, throws;
+{
+ tree meth = TREE_VALUE (mdecl);
+ tree id = TREE_PURPOSE (mdecl);
+ tree this_class = TREE_TYPE (ctxp->current_parsed_class);
+ tree type_wfl = NULL_TREE;
+ tree meth_name = NULL_TREE, current, orig_arg;
+ int saved_lineno;
+ int constructor_ok = 0, must_chain;
+
+ check_modifiers_consistency (flags);
+
+ /* There are some forbidden modifiers for an abstract method and its
+ class must be abstract as well. */
+ if (type && (flags & ACC_ABSTRACT))
+ {
+ ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
+ ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
+ ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
+ ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
+ ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
+ if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
+ && !CLASS_INTERFACE (TYPE_NAME (this_class)))
+ parse_error_context
+ (id, "Class `%s' must be declared abstract to define abstract "
+ "method `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
+ }
+ /* Things to be checked when declaring a constructor */
+ if (!type)
+ {
+ int ec = java_error_count;
+ /* 8.6: Constructor declarations: we might be trying to define a
+ method without specifying a return type. */
+ if (EXPR_WFL_NODE (id) != ctxp->current_parsed_class_un)
+ parse_error_context
+ (id, "Invalid method declaration, return type required");
+ /* 8.6.3: Constructor modifiers */
+ else
+ {
+ JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
+ JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
+ JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
+ JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
+ JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
+ }
+ /* If we found error here, we don't consider it's OK to tread
+ the method definition as a constructor, for the rest of this
+ function */
+ if (ec == java_error_count)
+ constructor_ok = 1;
+ }
+
+ /* Method declared within the scope of an interface are implicitly
+ abstract and public. Conflicts with other erroneously provided
+ modifiers are checked right after. */
+
+ if (CLASS_INTERFACE (TYPE_NAME (this_class)))
+ {
+ /* If FLAGS isn't set because of a modifier, turn the
+ corresponding modifier WFL to NULL so we issue a warning on
+ the obsolete use of the modifier */
+ if (!(flags & ACC_PUBLIC))
+ MODIFIER_WFL (PUBLIC_TK) = NULL;
+ if (!(flags & ACC_ABSTRACT))
+ MODIFIER_WFL (ABSTRACT_TK) = NULL;
+ flags |= ACC_PUBLIC;
+ flags |= ACC_ABSTRACT;
+ }
+
+ /* Modifiers context reset moved up, so abstract method declaration
+ modifiers can be later checked. */
+
+ /* Set constructor returned type to void and method name to <init>,
+ unless we found an error identifier the constructor (in which
+ case we retain the original name) */
+ if (!type)
+ {
+ type = void_type_node;
+ if (constructor_ok)
+ meth_name = init_identifier_node;
+ }
+ else
+ meth_name = EXPR_WFL_NODE (id);
+
+ /* Do the returned type resolution and registration if necessary */
+ SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
+
+ if (meth_name)
+ type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
+ EXPR_WFL_NODE (id) = meth_name;
+ PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
+
+ if (must_chain)
+ {
+ patch_stage = JDEP_METHOD_RETURN;
+ register_incomplete_type (patch_stage, type_wfl, id, type);
+ TREE_TYPE (meth) = GET_REAL_TYPE (type);
+ }
+ else
+ TREE_TYPE (meth) = type;
+
+ saved_lineno = lineno;
+ /* When defining an abstract or interface method, the curly
+ bracket at level 1 doesn't exist because there is no function
+ body */
+ lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
+ EXPR_WFL_LINENO (id));
+
+ /* Remember the original argument list */
+ orig_arg = TYPE_ARG_TYPES (meth);
+
+ if (patch_stage) /* includes ret type and/or all args */
+ {
+ jdep *jdep;
+ meth = add_method_1 (this_class, flags, meth_name, meth);
+ /* Patch for the return type */
+ if (patch_stage == JDEP_METHOD_RETURN)
+ {
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
+ }
+ /* This is the stop JDEP. METH allows the function's signature
+ to be computed. */
+ register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
+ }
+ else
+ meth = add_method (this_class, flags, meth_name,
+ build_java_signature (meth));
+
+ /* Fix the method argument list so we have the argument name
+ information */
+ fix_method_argument_names (orig_arg, meth);
+
+ /* Register the parameter number and re-install the current line
+ number */
+ DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
+ lineno = saved_lineno;
+
+ /* Register exception specified by the `throws' keyword for
+ resolution and set the method decl appropriate field to the list.
+ Note: the grammar ensures that what we get here are class
+ types. */
+ if (throws)
+ {
+ throws = nreverse (throws);
+ for (current = throws; current; current = TREE_CHAIN (current))
+ {
+ register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
+ NULL_TREE, NULL_TREE);
+ JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
+ &TREE_VALUE (current);
+ }
+ DECL_FUNCTION_THROWS (meth) = throws;
+ }
+
+ /* We set the DECL_NAME to ID so we can track the location where
+ the function was declared. This allow us to report
+ redefinition error accurately. When method are verified,
+ DECL_NAME is reinstalled properly (using the content of the
+ WFL node ID) (see check_method_redefinition). We don't do that
+ when Object is being defined. Constructor <init> names will be
+ reinstalled the same way. */
+ if (TREE_TYPE (ctxp->current_parsed_class) != object_type_node)
+ DECL_NAME (meth) = id;
+
+ /* Set the flag if we correctly processed a constructor */
+ if (constructor_ok)
+ DECL_CONSTRUCTOR_P (meth) = 1;
+
+ /* Eventually set the @deprecated tag flag */
+ CHECK_DEPRECATED (meth);
+
+ /* If doing xref, store column and line number information instead
+ of the line number only. */
+ if (flag_emit_xref)
+ DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
+
+ return meth;
+}
+
+static void
+fix_method_argument_names (orig_arg, meth)
+ tree orig_arg, meth;
+{
+ tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
+ if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
+ {
+ TREE_PURPOSE (arg) = this_identifier_node;
+ arg = TREE_CHAIN (arg);
+ }
+ while (orig_arg != end_params_node)
+ {
+ TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
+ orig_arg = TREE_CHAIN (orig_arg);
+ arg = TREE_CHAIN (arg);
+ }
+}
+
+/* Complete the method declaration with METHOD_BODY. */
+
+static void
+finish_method_declaration (method_body)
+ tree method_body;
+{
+ int flags = get_access_flags_from_decl (current_function_decl);
+
+ /* 8.4.5 Method Body */
+ if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
+ {
+ tree wfl = DECL_NAME (current_function_decl);
+ parse_error_context (wfl,
+ "%s method `%s' can't have a body defined",
+ (METHOD_NATIVE (current_function_decl) ?
+ "Native" : "Abstract"),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ method_body = NULL_TREE;
+ }
+ else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
+ {
+ tree wfl = DECL_NAME (current_function_decl);
+ parse_error_context (wfl,
+ "Non native and non abstract method `%s' must "
+ "have a body defined",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ method_body = NULL_TREE;
+ }
+
+ if (flag_emit_class_files && method_body
+ && TREE_CODE (method_body) == NOP_EXPR
+ && TREE_TYPE (current_function_decl)
+ && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
+ method_body = build1 (RETURN_EXPR, void_type_node, NULL);
+
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
+ maybe_absorb_scoping_blocks ();
+ /* Exit function's body */
+ exit_block ();
+ /* Merge last line of the function with first line, directly in the
+ function decl. It will be used to emit correct debug info. */
+ if (!flag_emit_xref)
+ DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
+ /* So we don't have an irrelevant function declaration context for
+ the next static block we'll see. */
+ current_function_decl = NULL_TREE;
+}
+
+/* Build a an error message for constructor circularity errors. */
+
+static char *
+constructor_circularity_msg (from, to)
+ tree from, to;
+{
+ static char string [4096];
+ char *t = strdup (lang_printable_name (from, 0));
+ sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
+ free (t);
+ return string;
+}
+
+/* Verify a circular call to METH. Return 1 if an error is found, 0
+ otherwise. */
+
+static int
+verify_constructor_circularity (meth, current)
+ tree meth, current;
+{
+ static tree list = NULL_TREE;
+ tree c;
+ for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
+ {
+ if (TREE_VALUE (c) == meth)
+ {
+ char *t;
+ if (list)
+ {
+ tree liste;
+ list = nreverse (list);
+ for (liste = list; liste; liste = TREE_CHAIN (liste))
+ {
+ parse_error_context
+ (TREE_PURPOSE (TREE_PURPOSE (liste)),
+ constructor_circularity_msg
+ (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
+ java_error_count--;
+ }
+ }
+ t = strdup (lang_printable_name (meth, 0));
+ parse_error_context (TREE_PURPOSE (c),
+ "%s: recursive invocation of constructor `%s'",
+ constructor_circularity_msg (current, meth), t);
+ free (t);
+ list = NULL_TREE;
+ return 1;
+ }
+ }
+ for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
+ {
+ list = tree_cons (c, current, list);
+ if (verify_constructor_circularity (meth, TREE_VALUE (c)))
+ return 1;
+ list = TREE_CHAIN (list);
+ }
+ return 0;
+}
+
+/* Check modifiers that can be declared but exclusively */
+
+static void
+check_modifiers_consistency (flags)
+ int flags;
+{
+ int acc_count = 0;
+ tree cl = NULL_TREE;
+
+ THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, 0, acc_count, cl);
+ THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, 1, acc_count, cl);
+ THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, 2, acc_count, cl);
+ if (acc_count > 1)
+ parse_error_context
+ (cl, "Inconsistent member declaration. At most one of `public', "
+ "`private', or `protected' may be specified");
+}
+
+/* Check the methode header METH for abstract specifics features */
+
+static void
+check_abstract_method_header (meth)
+ tree meth;
+{
+ int flags = get_access_flags_from_decl (meth);
+ /* DECL_NAME might still be a WFL node */
+ tree name = GET_METHOD_NAME (meth);
+
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (ABSTRACT_TK), flags,
+ ACC_ABSTRACT, "abstract method `%s'",
+ IDENTIFIER_POINTER (name));
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK), flags,
+ ACC_PUBLIC, "abstract method `%s'",
+ IDENTIFIER_POINTER (name));
+
+ check_modifiers ("Illegal modifier `%s' for interface method",
+ flags, INTERFACE_METHOD_MODIFIERS);
+}
+
+/* Create a FUNCTION_TYPE node and start augmenting it with the
+ declared function arguments. Arguments type that can't be resolved
+ are left as they are, but the returned node is marked as containing
+ incomplete types. */
+
+static tree
+method_declarator (id, list)
+ tree id, list;
+{
+ tree arg_types = NULL_TREE, current, node;
+ tree meth = make_node (FUNCTION_TYPE);
+ jdep *jdep;
+
+ patch_stage = JDEP_NO_PATCH;
+
+ for (current = list; current; current = TREE_CHAIN (current))
+ {
+ int must_chain = 0;
+ tree wfl_name = TREE_PURPOSE (current);
+ tree type = TREE_VALUE (current);
+ tree name = EXPR_WFL_NODE (wfl_name);
+ tree already, arg_node;
+ tree type_wfl = NULL_TREE;
+ tree real_type;
+
+ /* Obtain a suitable type for resolution, if necessary */
+ SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
+
+ /* Process NAME, as it may specify extra dimension(s) for it */
+ type = build_array_from_name (type, type_wfl, name, &name);
+ EXPR_WFL_NODE (wfl_name) = name;
+
+ real_type = GET_REAL_TYPE (type);
+ if (TREE_CODE (real_type) == RECORD_TYPE)
+ {
+ real_type = promote_type (real_type);
+ if (TREE_CODE (type) == TREE_LIST)
+ TREE_PURPOSE (type) = real_type;
+ }
+
+ /* Check redefinition */
+ for (already = arg_types; already; already = TREE_CHAIN (already))
+ if (TREE_PURPOSE (already) == name)
+ {
+ parse_error_context
+ (wfl_name, "Variable `%s' is used more than once in the "
+ "argument list of method `%s'", IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
+ break;
+ }
+
+ /* If we've an incomplete argument type, we know there is a location
+ to patch when the type get resolved, later. */
+ jdep = NULL;
+ if (must_chain)
+ {
+ patch_stage = JDEP_METHOD;
+ type = register_incomplete_type (patch_stage,
+ type_wfl, wfl_name, type);
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_MISC (jdep) = id;
+ }
+
+ /* The argument node: a name and a (possibly) incomplete type */
+ arg_node = build_tree_list (name, real_type);
+ if (jdep)
+ JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
+ TREE_CHAIN (arg_node) = arg_types;
+ arg_types = arg_node;
+ }
+ TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
+ node = build_tree_list (id, meth);
+ return node;
+}
+
+static int
+unresolved_type_p (wfl, returned)
+ tree wfl;
+ tree *returned;
+
+{
+ if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
+ {
+ tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
+ if (returned)
+ *returned = (decl ? TREE_TYPE (decl) : NULL_TREE);
+ return 1;
+ }
+ if (returned)
+ *returned = wfl;
+ return 0;
+}
+
+/* From NAME, build a qualified identifier node using the
+ qualification from the current package definition. */
+
+static tree
+parser_qualified_classname (name)
+ tree name;
+{
+ if (ctxp->package)
+ return merge_qualified_name (ctxp->package, EXPR_WFL_NODE (name));
+ else
+ return EXPR_WFL_NODE (name);
+}
+
+/* Called once the type a interface extends is resolved. Returns 0 if
+ everything is OK. */
+
+static int
+parser_check_super_interface (super_decl, this_decl, this_wfl)
+ tree super_decl, this_decl, this_wfl;
+{
+ tree super_type = TREE_TYPE (super_decl);
+
+ /* Has to be an interface */
+ if (!CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (super_decl))))
+ {
+ parse_error_context
+ (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
+ (TYPE_ARRAY_P (super_type) ? "array" : "class"),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)),
+ (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
+ "interface" : "class"),
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)));
+ return 1;
+ }
+
+ /* Check scope: same package OK, other package: OK if public */
+ if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
+ return 1;
+
+ SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl))));
+ return 0;
+}
+
+/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
+ 0 if everthing is OK. */
+
+static int
+parser_check_super (super_decl, this_decl, wfl)
+ tree super_decl, this_decl, wfl;
+{
+ tree super_type = TREE_TYPE (super_decl);
+
+ /* SUPER should be a CLASS (neither an array nor an interface) */
+ if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
+ {
+ parse_error_context
+ (wfl, "Class `%s' can't subclass %s `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)));
+ return 1;
+ }
+
+ if (CLASS_FINAL (TYPE_NAME (super_type)))
+ {
+ parse_error_context (wfl, "Can't subclass final classes: %s",
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)));
+ return 1;
+ }
+
+ /* Check scope: same package OK, other package: OK if public */
+ if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
+ return 1;
+
+ SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl))));
+ return 0;
+}
+
+/* Create a new dependency list and link it (in a LIFO manner) to the
+ CTXP list of type dependency list. */
+
+static void
+create_jdep_list (ctxp)
+ struct parser_ctxt *ctxp;
+{
+ jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
+ new->first = new->last = NULL;
+ new->next = ctxp->classd_list;
+ ctxp->classd_list = new;
+}
+
+static jdeplist *
+reverse_jdep_list (ctxp)
+ struct parser_ctxt *ctxp;
+{
+ register jdeplist *prev = NULL, *current, *next;
+ for (current = ctxp->classd_list; current; current = next)
+ {
+ next = current->next;
+ current->next = prev;
+ prev = current;
+ }
+ return prev;
+}
+
+/* Create a fake pointer based on the ID stored in
+ TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
+ registered again. */
+
+static tree
+obtain_incomplete_type (type_name)
+ tree type_name;
+{
+ tree ptr, name;
+
+ if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
+ name = EXPR_WFL_NODE (type_name);
+ else if (INCOMPLETE_TYPE_P (type_name))
+ name = TYPE_NAME (type_name);
+ else
+ fatal ("invalid type name - obtain_incomplete_type");
+
+ for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
+ if (TYPE_NAME (ptr) == name)
+ break;
+
+ if (!ptr)
+ {
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ BUILD_PTR_FROM_NAME (ptr, name);
+ layout_type (ptr);
+ pop_obstacks ();
+ TREE_CHAIN (ptr) = ctxp->incomplete_class;
+ ctxp->incomplete_class = ptr;
+ }
+
+ return ptr;
+}
+
+/* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
+ non NULL instead of computing a new fake type based on WFL. The new
+ dependency is inserted in the current type dependency list, in FIFO
+ manner. */
+
+static tree
+register_incomplete_type (kind, wfl, decl, ptr)
+ int kind;
+ tree wfl, decl, ptr;
+{
+ jdep *new = (jdep *)xmalloc (sizeof (jdep));
+
+ if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
+ ptr = obtain_incomplete_type (wfl);
+
+ JDEP_KIND (new) = kind;
+ JDEP_DECL (new) = decl;
+ JDEP_SOLV (new) = ptr;
+ JDEP_WFL (new) = wfl;
+ JDEP_CHAIN (new) = NULL;
+ JDEP_MISC (new) = NULL_TREE;
+ JDEP_GET_PATCH (new) = (tree *)NULL;
+
+ JDEP_INSERT (ctxp->classd_list, new);
+
+ return ptr;
+}
+
+void
+java_check_circular_reference ()
+{
+ tree current;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ tree type = TREE_TYPE (current);
+ if (CLASS_INTERFACE (TYPE_NAME (type)))
+ {
+ /* Check all interfaces this class extends */
+ tree basetype_vec = TYPE_BINFO_BASETYPES (type);
+ int n, i;
+
+ if (!basetype_vec)
+ return;
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
+ && interface_of_p (type, BINFO_TYPE (vec_elt)))
+ parse_error_context (lookup_cl (current),
+ "Cyclic interface inheritance");
+ }
+ }
+ else
+ if (inherits_from_p (CLASSTYPE_SUPER (type), type))
+ parse_error_context (lookup_cl (current),
+ "Cyclic class inheritance");
+ }
+}
+
+/* safe_layout_class just makes sure that we can load a class without
+ disrupting the current_class, input_file, lineno, etc, information
+ about the class processed currently. */
+
+void
+safe_layout_class (class)
+ tree class;
+{
+ tree save_current_class = current_class;
+ char *save_input_filename = input_filename;
+ int save_lineno = lineno;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+
+ layout_class (class);
+ pop_obstacks ();
+
+ current_class = save_current_class;
+ input_filename = save_input_filename;
+ lineno = save_lineno;
+ CLASS_LOADED_P (class) = 1;
+}
+
+static tree
+jdep_resolve_class (dep)
+ jdep *dep;
+{
+ tree decl;
+
+ if (JDEP_RESOLVED_P (dep))
+ decl = JDEP_RESOLVED_DECL (dep);
+ else
+ {
+ decl = resolve_class (JDEP_TO_RESOLVE (dep),
+ JDEP_DECL (dep), JDEP_WFL (dep));
+ JDEP_RESOLVED (dep, decl);
+ }
+
+ if (!decl)
+ complete_class_report_errors (dep);
+
+ return decl;
+}
+
+/* Complete unsatisfied class declaration and their dependencies */
+
+void
+java_complete_class ()
+{
+ tree cclass;
+ jdeplist *cclassd;
+ int error_found;
+ tree type;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+
+ /* Process imports and reverse the import on demand list */
+ process_imports ();
+ if (ctxp->import_demand_list)
+ ctxp->import_demand_list = nreverse (ctxp->import_demand_list);
+
+ /* Rever things so we have the right order */
+ ctxp->class_list = nreverse (ctxp->class_list);
+ ctxp->classd_list = reverse_jdep_list (ctxp);
+
+ for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
+ cclass && cclassd;
+ cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
+ {
+ jdep *dep;
+ for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
+ {
+ tree decl;
+ if (!(decl = jdep_resolve_class (dep)))
+ continue;
+
+ /* Now it's time to patch */
+ switch (JDEP_KIND (dep))
+ {
+ case JDEP_SUPER:
+ /* Simply patch super */
+ if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
+ continue;
+ BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
+ (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
+ break;
+
+ case JDEP_FIELD:
+ {
+ /* We do part of the job done in add_field */
+ tree field_decl = JDEP_DECL (dep);
+ tree field_type = TREE_TYPE (decl);
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ if (TREE_CODE (field_type) == RECORD_TYPE)
+ field_type = promote_type (field_type);
+ pop_obstacks ();
+ TREE_TYPE (field_decl) = field_type;
+ DECL_ALIGN (field_decl) = 0;
+ layout_decl (field_decl, 0);
+ SOURCE_FRONTEND_DEBUG
+ (("Completed field/var decl `%s' with `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ break;
+ }
+ case JDEP_METHOD: /* We start patching a method */
+ case JDEP_METHOD_RETURN:
+ error_found = 0;
+ while (1)
+ {
+ if (decl)
+ {
+ type = TREE_TYPE(decl);
+ if (TREE_CODE (type) == RECORD_TYPE)
+ type = promote_type (type);
+ JDEP_APPLY_PATCH (dep, type);
+ SOURCE_FRONTEND_DEBUG
+ (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
+ "Completing fct `%s' with ret type `%s'":
+ "Completing arg `%s' with type `%s'"),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE
+ (JDEP_DECL_WFL (dep))),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ }
+ else
+ error_found = 1;
+ dep = JDEP_CHAIN (dep);
+ if (JDEP_KIND (dep) == JDEP_METHOD_END)
+ break;
+ else
+ decl = jdep_resolve_class (dep);
+ }
+ if (!error_found)
+ {
+ tree mdecl = JDEP_DECL (dep), signature;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ /* Recompute and reset the signature */
+ signature = build_java_signature (TREE_TYPE (mdecl));
+ set_java_signature (TREE_TYPE (mdecl), signature);
+ pop_obstacks ();
+ }
+ else
+ continue;
+ break;
+
+ case JDEP_INTERFACE:
+ if (parser_check_super_interface (decl, JDEP_DECL (dep),
+ JDEP_WFL (dep)))
+ continue;
+ parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
+ break;
+
+ case JDEP_PARM:
+ case JDEP_VARIABLE:
+ type = TREE_TYPE(decl);
+ if (TREE_CODE (type) == RECORD_TYPE)
+ type = promote_type (type);
+ JDEP_APPLY_PATCH (dep, type);
+ break;
+
+ case JDEP_TYPE:
+ JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing a random type dependency on a '%s' node",
+ tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
+ break;
+
+ case JDEP_EXCEPTION:
+ JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing `%s' `throws' argument node",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
+ break;
+
+ default:
+ fatal ("Can't handle patch code %d - java_complete_class",
+ JDEP_KIND (dep));
+ }
+ }
+ }
+ pop_obstacks ();
+ return;
+}
+
+/* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
+ array. */
+
+static tree
+resolve_class (class_type, decl, cl)
+ tree class_type, decl, cl;
+{
+ char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
+ char *base = name;
+ tree resolved_type = TREE_TYPE (class_type);
+ tree resolved_type_decl;
+
+ if (resolved_type != NULL_TREE)
+ {
+ tree resolved_type_decl = TYPE_NAME (resolved_type);
+ if (resolved_type_decl == NULL_TREE
+ || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
+ {
+ resolved_type_decl = build_decl (TYPE_DECL,
+ TYPE_NAME (class_type),
+ resolved_type);
+ }
+ return resolved_type_decl;
+ }
+
+ /* 1- Check to see if we have an array. If true, find what we really
+ want to resolve */
+ while (name[0] == '[')
+ name++;
+ if (base != name)
+ TYPE_NAME (class_type) = get_identifier (name);
+
+ /* 2- Resolve the bare type */
+ if (!(resolved_type_decl = do_resolve_class (class_type, decl, cl)))
+ return NULL_TREE;
+ resolved_type = TREE_TYPE (resolved_type_decl);
+
+ /* 3- If we have and array, reconstruct the array down to its nesting */
+ if (base != name)
+ {
+ while (base != name)
+ {
+ if (TREE_CODE (resolved_type) == RECORD_TYPE)
+ resolved_type = promote_type (resolved_type);
+ resolved_type = build_java_array_type (resolved_type, -1);
+ CLASS_LOADED_P (resolved_type) = 1;
+ name--;
+ }
+ /* Build a fake decl for this, since this is what is expected to
+ be returned. */
+ resolved_type_decl =
+ build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
+ /* Figure how those two things are important for error report. FIXME */
+ DECL_SOURCE_LINE (resolved_type_decl) = 0;
+ DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
+ TYPE_NAME (class_type) = TYPE_NAME (resolved_type);
+ }
+ TREE_TYPE (class_type) = resolved_type;
+ return resolved_type_decl;
+}
+
+/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
+ are used to report error messages. */
+
+tree
+do_resolve_class (class_type, decl, cl)
+ tree class_type;
+ tree decl;
+ tree cl;
+{
+ tree new_class_decl;
+ tree original_name = NULL_TREE;
+
+ /* Do not try to replace TYPE_NAME (class_type) by a variable, since
+ its is changed by find_in_imports{_on_demand} */
+
+ /* 1- Check for the type in single imports */
+ if (find_in_imports (class_type))
+ return NULL_TREE;
+
+ /* 2- And check for the type in the current compilation unit. If it fails,
+ try with a name qualified with the package name if appropriate. */
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ {
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
+ !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
+ load_class (TYPE_NAME (class_type), 0);
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ }
+
+ original_name = TYPE_NAME (class_type);
+ if (!QUALIFIED_P (TYPE_NAME (class_type)) && ctxp->package)
+ TYPE_NAME (class_type) = merge_qualified_name (ctxp->package,
+ TYPE_NAME (class_type));
+#if 1
+ if (!(new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ load_class (TYPE_NAME (class_type), 0);
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ {
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
+ !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
+ load_class (TYPE_NAME (class_type), 0);
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ }
+#else
+ new_name = TYPE_NAME (class_type);
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_name)) != NULL_TREE)
+ {
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
+ !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
+ load_class (new_name, 0);
+ return IDENTIFIER_CLASS_VALUE (new_name);
+ }
+ else
+ {
+ tree class = read_class (new_name);
+ if (class != NULL_TREE)
+ {
+ tree decl = IDENTIFIER_CLASS_VALUE (new_name);
+ if (decl == NULL_TREE)
+ decl = push_class (class, new_name);
+ return decl;
+ }
+ }
+#endif
+ TYPE_NAME (class_type) = original_name;
+
+ /* 3- Check an other compilation unit that bears the name of type */
+ load_class (TYPE_NAME (class_type), 0);
+ if (check_pkg_class_access (TYPE_NAME (class_type),
+ (cl ? cl : lookup_cl (decl))))
+ return NULL_TREE;
+
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ return new_class_decl;
+
+ /* 4- Check the import on demands. Don't allow bar.baz to be
+ imported from foo.* */
+ if (!QUALIFIED_P (TYPE_NAME (class_type)))
+ if (find_in_imports_on_demand (class_type))
+ return NULL_TREE;
+
+ /* 5- Last call for a resolution */
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+}
+
+/* Resolve NAME and lay it out (if not done and if not the current
+ parsed class). Return a decl node. This function is meant to be
+ called when type resolution is necessary during the walk pass. */
+
+static tree
+resolve_and_layout (something, cl)
+ tree something;
+ tree cl;
+{
+ tree decl;
+
+ /* Don't do that on the current class */
+ if (something == current_class)
+ return TYPE_NAME (current_class);
+
+ /* Don't do anything for void and other primitive types */
+ if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
+ return NULL_TREE;
+
+ /* Pointer types can be reall pointer types or fake pointers. When
+ finding a real pointer, recheck for primitive types */
+ if (TREE_CODE (something) == POINTER_TYPE)
+ {
+ if (TREE_TYPE (something))
+ {
+ something = TREE_TYPE (something);
+ if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
+ return NULL_TREE;
+ }
+ else
+ something = TYPE_NAME (something);
+ }
+
+ /* Don't do anything for arrays of primitive types */
+ if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
+ && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
+ return NULL_TREE;
+
+ /* If something is not and IDENTIFIER_NODE, it can be a a TYPE_DECL
+ or a real TYPE */
+ if (TREE_CODE (something) != IDENTIFIER_NODE)
+ something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
+ DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
+
+ if (!(decl = resolve_no_layout (something, cl)))
+ return NULL_TREE;
+
+ /* Resolve and layout if necessary */
+ layout_class_methods (TREE_TYPE (decl));
+ if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl)))
+ CHECK_METHODS (decl);
+ if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl)))
+ safe_layout_class (TREE_TYPE (decl));
+
+ return decl;
+}
+
+/* Resolve a class, returns its decl but doesn't perform any
+ layout. The current parsing context is saved and restored */
+
+static tree
+resolve_no_layout (name, cl)
+ tree name, cl;
+{
+ tree ptr, decl;
+ BUILD_PTR_FROM_NAME (ptr, name);
+ java_parser_context_save_global ();
+ decl = resolve_class (ptr, NULL_TREE, cl);
+ java_parser_context_restore_global ();
+
+ return decl;
+}
+
+/* Called when reporting errors. Skip leader '[' in a complex array
+ type description that failed to be resolved. */
+
+static char *
+purify_type_name (name)
+ char *name;
+{
+ while (*name && *name == '[')
+ name++;
+ return name;
+}
+
+/* The type CURRENT refers to can't be found. We print error messages. */
+
+static void
+complete_class_report_errors (dep)
+ jdep *dep;
+{
+ char *name;
+
+ if (!JDEP_WFL (dep))
+ return;
+
+ name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
+ switch (JDEP_KIND (dep))
+ {
+ case JDEP_SUPER:
+ parse_error_context
+ (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
+ purify_type_name (name),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_FIELD:
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
+ purify_type_name (name),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_METHOD: /* Covers arguments */
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "argument `%s' of method `%s'",
+ purify_type_name (name),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
+ break;
+ case JDEP_METHOD_RETURN: /* Covers return type */
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "return type of method `%s'",
+ purify_type_name (name),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
+ break;
+ case JDEP_INTERFACE:
+ parse_error_context
+ (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_VARIABLE:
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "local variable `%s'",
+ purify_type_name (IDENTIFIER_POINTER
+ (EXPR_WFL_NODE (JDEP_WFL (dep)))),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_EXCEPTION: /* As specified by `throws' */
+ parse_error_context
+ (JDEP_WFL (dep), "Class `%s' not found in `throws'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
+ break;
+ default:
+ /* Fix for -Wall. Just break doing nothing. The error will be
+ caught later */
+ break;
+ }
+}
+
+/* Check uninitialized final. */
+
+void
+java_check_final ()
+{
+}
+
+/* Return a static string containing the DECL prototype string. If
+ DECL is a constructor, use the class name instead of the form
+ <init> */
+
+static char *
+get_printable_method_name (decl)
+ tree decl;
+{
+ char *to_return;
+ tree name = NULL_TREE;
+
+ if (DECL_CONSTRUCTOR_P (decl))
+ {
+ name = DECL_NAME (decl);
+ DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
+ }
+
+ to_return = lang_printable_name (decl, 0);
+ if (DECL_CONSTRUCTOR_P (decl))
+ DECL_NAME (decl) = name;
+
+ return to_return;
+}
+
+/* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
+ nevertheless needs to be verfied, 1 otherwise. */
+
+static int
+reset_method_name (method)
+ tree method;
+{
+ if (!IS_CLINIT (method) && DECL_NAME (method) != finit_identifier_node)
+ {
+ /* NAME is just the plain name when Object is being defined */
+ if (DECL_CONTEXT (method) != object_type_node)
+ DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ?
+ init_identifier_node : GET_METHOD_NAME (method));
+ return 0;
+ }
+ else
+ return 1;
+}
+
+/* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
+
+tree
+java_get_real_method_name (method_decl)
+ tree method_decl;
+{
+ tree method_name = DECL_NAME (method_decl);
+ if (DECL_CONSTRUCTOR_P (method_decl))
+ return init_identifier_node;
+
+ /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
+ and still can be a constructor. FIXME */
+
+ /* Don't confuse method only bearing the name of their class as
+ constructors */
+ else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl))
+ && ctxp
+ && ctxp->current_parsed_class_un == EXPR_WFL_NODE (method_name)
+ && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED
+ && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node)
+ return init_identifier_node;
+ else
+ return EXPR_WFL_NODE (method_name);
+}
+
+/* Track method being redefined inside the same class. As a side
+ effect, set DECL_NAME to an IDENTIFIER (prior entering this
+ function it's a FWL, so we can track errors more accurately */
+
+static int
+check_method_redefinition (class, method)
+ tree class, method;
+{
+ tree redef, name;
+ tree cl = DECL_NAME (method);
+ tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
+ /* decl name of artificial <clinit> and $finit$ doesn't need to be
+ fixed and checked */
+
+ /* Reset the method name before running the check. If it returns 1,
+ the method doesn't need to be verified with respect to method
+ redeclaration and we return 0 */
+ if (reset_method_name (method))
+ return 0;
+
+ name = DECL_NAME (method);
+ for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
+ {
+ if (redef == method)
+ break;
+ if (DECL_NAME (redef) == name
+ && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef)))
+ {
+ parse_error_context
+ (cl, "Duplicate %s declaration `%s'",
+ (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
+ get_printable_method_name (redef));
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* Check all the methods of CLASS. Methods are first completed then
+ checked according to regular method existance rules.
+ If no constructor were encountered, then build its declaration. */
+
+static void
+java_check_regular_methods (class_decl)
+ tree class_decl;
+{
+ int saw_constructor = 0;
+ tree method;
+ tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
+ tree super_class = CLASSTYPE_SUPER (class);
+ tree saved_found_wfl = NULL_TREE, found = NULL_TREE;
+ tree mthrows;
+
+ /* It is not necessary to check methods defined in java.lang.Object */
+ if (class == object_type_node)
+ return;
+
+ if (!TYPE_NVIRTUALS (class))
+ TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
+
+ /* Should take interfaces into account. FIXME */
+ for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
+ {
+ tree sig;
+ tree method_wfl = DECL_NAME (method);
+ int aflags;
+
+ /* If we previously found something and its name was saved,
+ reinstall it now */
+ if (found && saved_found_wfl)
+ {
+ DECL_NAME (found) = saved_found_wfl;
+ saved_found_wfl = NULL_TREE;
+ }
+
+ /* Check for redefinitions */
+ if (check_method_redefinition (class, method))
+ continue;
+
+ /* If we see one constructor a mark so we don't generate the
+ default one. Also skip other verifications: constructors
+ can't be inherited hence hiden or overriden */
+ if (DECL_CONSTRUCTOR_P (method))
+ {
+ saw_constructor = 1;
+ continue;
+ }
+
+ /* We verify things thrown by the method. They must inherits from
+ java.lang.Throwable */
+ for (mthrows = DECL_FUNCTION_THROWS (method);
+ mthrows; mthrows = TREE_CHAIN (mthrows))
+ {
+ if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
+ parse_error_context
+ (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be "
+ "a subclass of class `java.lang.Throwable'",
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
+ }
+
+ sig = build_java_argument_signature (TREE_TYPE (method));
+ found = lookup_argument_method (super_class, DECL_NAME (method), sig);
+
+ /* Nothing overrides or it's a private method. */
+ if (!found)
+ continue;
+ if (METHOD_PRIVATE (found))
+ {
+ found = NULL_TREE;
+ continue;
+ }
+
+ /* If found wasn't verified, it's DECL_NAME won't be set properly.
+ We set it temporarily for the sake of the error report. */
+ saved_found_wfl = DECL_NAME (found);
+ reset_method_name (found);
+
+ /* Can't override a method with the same name and different return
+ types. */
+ if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
+ {
+ char *t = strdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)),
+ 0));
+ parse_error_context
+ (method_wfl,
+ "Method `%s' was defined with return type `%s' in class `%s'",
+ lang_printable_name (found, 0), t,
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ free (t);
+ }
+
+ aflags = get_access_flags_from_decl (found);
+ /* If the method has default, access in an other package, then
+ issue a warning that the current method doesn't override the
+ one that was found elsewhere. Do not issue this warning when
+ the match was found in java.lang.Object. */
+ if (DECL_CONTEXT (found) != object_type_node
+ && ((aflags & 0x7) == 0)
+ && !class_in_current_package (DECL_CONTEXT (found))
+ && DECL_NAME (found) != clinit_identifier_node
+ && flag_not_overriding)
+ {
+ parse_warning_context
+ (method_wfl, "Method `%s' in class `%s' does not "
+ "override the corresponding method in class `%s', which is "
+ "private to a different package",
+ lang_printable_name (found, 0),
+ IDENTIFIER_POINTER (DECL_NAME (class_decl)),
+ IDENTIFIER_POINTER (DECL_NAME
+ (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+
+ /* Can't override final. Can't override static. */
+ if (METHOD_FINAL (found) || METHOD_STATIC (found))
+ {
+ /* Static *can* override static */
+ if (METHOD_STATIC (found) && METHOD_STATIC (method))
+ continue;
+ parse_error_context
+ (method_wfl,
+ "%s methods can't be overriden. Method `%s' is %s in class `%s'",
+ (METHOD_FINAL (found) ? "Final" : "Static"),
+ lang_printable_name (found, 0),
+ (METHOD_FINAL (found) ? "final" : "static"),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+
+ /* Static method can't override instance method. */
+ if (METHOD_STATIC (method))
+ {
+ parse_error_context
+ (method_wfl,
+ "Instance methods can't be overriden by a static method. Method "
+ "`%s' is an instance method in class `%s'",
+ lang_printable_name (found, 0),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+
+ /* - Overriding/hiding public must be public
+ - Overriding/hiding protected must be protected or public
+ - If the overriden or hidden method has default (package)
+ access, then the overriding or hiding method must not be
+ private; otherwise, a compile-time error occurs */
+ if ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
+ || (METHOD_PROTECTED (found)
+ && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
+ || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
+ && METHOD_PRIVATE (method)))
+ {
+ parse_error_context
+ (method_wfl,
+ "Methods can't be overridden to be more private. Method `%s' is "
+ "not %s in class `%s'", lang_printable_name (method, 0),
+ (METHOD_PUBLIC (method) ? "public" :
+ (METHOD_PRIVATE (method) ? "private" : "protected")),
+ IDENTIFIER_POINTER (DECL_NAME
+ (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+
+ /* Overriding methods must have compatible `throws' clauses on checked
+ exceptions, if any */
+ check_throws_clauses (method, method_wfl, found);
+
+ /* Inheriting multiple methods with the same signature. FIXME */
+ }
+
+ /* Don't forget eventual pending found and saved_found_wfl. Take
+ into account that we might have exited because we saw an
+ aritifical method as the last entry. */
+
+ if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl)
+ DECL_NAME (found) = saved_found_wfl;
+
+ if (!TYPE_NVIRTUALS (class))
+ TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
+
+ if (!saw_constructor)
+ {
+ /* No constructor seen, we craft one, at line 0. Since this
+ operation takes place after we laid methods out
+ (layout_class_methods), we prepare the its DECL
+ appropriately. */
+ int flags;
+ tree decl;
+
+ /* If the class is declared PUBLIC, the default constructor is
+ PUBLIC otherwise it has default access implied by no access
+ modifiers. */
+ flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
+ ACC_PUBLIC : 0);
+ decl = create_artificial_method (class, flags, void_type_node,
+ init_identifier_node, end_params_node);
+ DECL_CONSTRUCTOR_P (decl) = 1;
+ layout_class_method (TREE_TYPE (class_decl), NULL_TREE, decl, NULL_TREE);
+ }
+}
+
+/* Return a non zero value if the `throws' clause of METHOD (if any)
+ is incompatible with the `throws' clause of FOUND (if any). */
+
+static void
+check_throws_clauses (method, method_wfl, found)
+ tree method, method_wfl, found;
+{
+ tree mthrows, fthrows;
+
+ /* Can't check these things with class loaded from bytecode. FIXME */
+ if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
+ return;
+
+ for (mthrows = DECL_FUNCTION_THROWS (method);
+ mthrows; mthrows = TREE_CHAIN (mthrows))
+ {
+ /* We don't verify unchecked expressions */
+ if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
+ continue;
+ /* Checked expression must be compatible */
+ for (fthrows = DECL_FUNCTION_THROWS (found);
+ fthrows; fthrows = TREE_CHAIN (fthrows))
+ if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
+ break;
+ if (!fthrows)
+ {
+ parse_error_context
+ (method_wfl, "Invalid checked exception class `%s' in "
+ "`throws' clause. The exception must be a subclass of an "
+ "exception thrown by `%s' from class `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
+ lang_printable_name (found, 0),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ }
+ }
+}
+
+/* Check abstract method of interface INTERFACE */
+
+static void
+java_check_abstract_methods (interface_decl)
+ tree interface_decl;
+{
+ int i, n;
+ tree method, basetype_vec, found;
+ tree interface = TREE_TYPE (interface_decl);
+
+ for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
+ {
+ tree method_wfl = DECL_NAME (method);
+
+ /* 2- Check for double definition inside the defining interface */
+ if (check_method_redefinition (interface, method))
+ continue;
+
+ /* 3- Overriding is OK as far as we preserve the return type and
+ the thrown exceptions (FIXME) */
+ found = lookup_java_interface_method2 (interface, method);
+ if (found)
+ {
+ char *t;
+ tree saved_found_wfl = DECL_NAME (found);
+ reset_method_name (found);
+ t = strdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
+ parse_error_context
+ (method_wfl,
+ "Method `%s' was defined with return type `%s' in class `%s'",
+ lang_printable_name (found, 0), t,
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ free (t);
+ continue;
+
+ DECL_NAME (found) = saved_found_wfl;
+ }
+ }
+
+ /* 4- Inherited methods can't differ by their returned types */
+ if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
+ return;
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree sub_interface_method, sub_interface;
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (!vec_elt)
+ continue;
+ sub_interface = BINFO_TYPE (vec_elt);
+ for (sub_interface_method = TYPE_METHODS (sub_interface);
+ sub_interface_method;
+ sub_interface_method = TREE_CHAIN (sub_interface_method))
+ {
+ found = lookup_java_interface_method2 (interface,
+ sub_interface_method);
+ if (found && (found != sub_interface_method))
+ {
+ tree saved_found_wfl = DECL_NAME (found);
+ reset_method_name (found);
+ parse_error_context
+ (lookup_cl (sub_interface_method),
+ "Interface `%s' inherits method `%s' from interface `%s'. "
+ "This method is redefined with a different return type in "
+ "interface `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
+ lang_printable_name (found, 0),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME
+ (DECL_CONTEXT (sub_interface_method)))),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ DECL_NAME (found) = saved_found_wfl;
+ }
+ }
+ }
+}
+
+/* Lookup methods in interfaces using their name and partial
+ signature. Return a matching method only if their types differ. */
+
+static tree
+lookup_java_interface_method2 (class, method_decl)
+ tree class, method_decl;
+{
+ int i, n;
+ tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
+
+ if (!basetype_vec)
+ return NULL_TREE;
+
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
+ if ((BINFO_TYPE (vec_elt) != object_type_node)
+ && (to_return =
+ lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
+ return to_return;
+ }
+ for (i = 0; i < n; i++)
+ {
+ to_return = lookup_java_interface_method2
+ (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
+ if (to_return)
+ return to_return;
+ }
+
+ return NULL_TREE;
+}
+
+/* Lookup method using their name and partial signature. Return a
+ matching method only if their types differ. */
+
+static tree
+lookup_java_method2 (clas, method_decl, do_interface)
+ tree clas, method_decl;
+ int do_interface;
+{
+ tree method, method_signature, method_name, method_type, name;
+
+ method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
+ name = DECL_NAME (method_decl);
+ method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
+ EXPR_WFL_NODE (name) : name);
+ method_type = TREE_TYPE (TREE_TYPE (method_decl));
+
+ while (clas != NULL_TREE)
+ {
+ for (method = TYPE_METHODS (clas);
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree method_sig = build_java_argument_signature (TREE_TYPE (method));
+ tree name = DECL_NAME (method);
+ if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
+ EXPR_WFL_NODE (name) : name) == method_name
+ && method_sig == method_signature
+ && TREE_TYPE (TREE_TYPE (method)) != method_type)
+ return method;
+ }
+ clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
+ }
+ return NULL_TREE;
+}
+
+/* Return the line that matches DECL line number. Used during error
+ report */
+
+static tree
+lookup_cl (decl)
+ tree decl;
+{
+ static tree cl = NULL_TREE;
+
+ if (!decl)
+ return NULL_TREE;
+
+ if (cl == NULL_TREE)
+ cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
+
+ EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
+ EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
+
+ return cl;
+}
+
+/* Look for a simple name in the single-type import list */
+
+static tree
+find_name_in_single_imports (name)
+ tree name;
+{
+ tree node;
+
+ for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
+ if (TREE_VALUE (node) == name)
+ return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
+
+ return NULL_TREE;
+}
+
+/* Process all single-type import. */
+
+static int
+process_imports ()
+{
+ tree import;
+ int error_found;
+
+ for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
+ {
+ tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
+
+ /* Don't load twice something already defined. */
+ if (IDENTIFIER_CLASS_VALUE (to_be_found))
+ continue;
+ QUALIFIED_P (to_be_found) = 1;
+ load_class (to_be_found, 0);
+ error_found =
+ check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
+ if (!IDENTIFIER_CLASS_VALUE (to_be_found))
+ {
+ parse_error_context (TREE_PURPOSE (import),
+ "Class or interface `%s' not found in import",
+ IDENTIFIER_POINTER (to_be_found));
+ return 1;
+ }
+ if (error_found)
+ return 1;
+ }
+ return 0;
+}
+
+/* Possibly find a class imported by a single-type import statement. Return
+ 1 if an error occured, 0 otherwise. */
+
+static int
+find_in_imports (class_type)
+ tree class_type;
+{
+ tree import;
+
+ for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
+ if (TREE_VALUE (import) == TYPE_NAME (class_type))
+ {
+ TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
+ QUALIFIED_P (TYPE_NAME (class_type)) = 1;
+ }
+ return 0;
+}
+
+static int
+note_possible_classname (name, len)
+ char *name;
+ int len;
+{
+ tree node;
+ if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
+ len = len - 5;
+ else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
+ len = len - 6;
+ else
+ return 0;
+ node = ident_subst (name, len, "", '/', '.', "");
+ IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
+ QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
+ return 1;
+}
+
+/* Read a import directory, gathering potential match for further type
+ references. Indifferently reads a filesystem or a ZIP archive
+ directory. */
+
+static void
+read_import_dir (wfl)
+ tree wfl;
+{
+ tree package_id = EXPR_WFL_NODE (wfl);
+ char *package_name = IDENTIFIER_POINTER (package_id);
+ int package_length = IDENTIFIER_LENGTH (package_id);
+ DIR *dirp = NULL;
+ JCF *saved_jcf = current_jcf;
+
+ int found = 0;
+ int k;
+ void *entry;
+ struct buffer filename[1];
+
+
+ if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
+ return;
+ IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
+
+ BUFFER_INIT (filename);
+ buffer_grow (filename, package_length + 100);
+
+ for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
+ {
+ char *entry_name = jcf_path_name (entry);
+ int entry_length = strlen (entry_name);
+ if (jcf_path_is_zipfile (entry))
+ {
+ ZipFile *zipf;
+ buffer_grow (filename, entry_length);
+ memcpy (filename->data, entry_name, entry_length - 1);
+ filename->data[entry_length-1] = '\0';
+ zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
+ if (zipf == NULL)
+ error ("malformed .zip archive in CLASSPATH: %s", entry_name);
+ else
+ {
+ ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
+ BUFFER_RESET (filename);
+ for (k = 0; k < package_length; k++)
+ {
+ char ch = package_name[k];
+ *filename->ptr++ = ch == '.' ? '/' : ch;
+ }
+ *filename->ptr++ = '/';
+
+ for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
+ {
+ char *current_entry = ZIPDIR_FILENAME (zipd);
+ int current_entry_len = zipd->filename_length;
+
+ if (current_entry_len >= BUFFER_LENGTH (filename)
+ && strncmp (filename->data, current_entry,
+ BUFFER_LENGTH (filename)) != 0)
+ continue;
+ found |= note_possible_classname (current_entry,
+ current_entry_len);
+ }
+ }
+ }
+ else
+ {
+ BUFFER_RESET (filename);
+ buffer_grow (filename, entry_length + package_length + 4);
+ strcpy (filename->data, entry_name);
+ filename->ptr = filename->data + entry_length;
+ for (k = 0; k < package_length; k++)
+ {
+ char ch = package_name[k];
+ *filename->ptr++ = ch == '.' ? '/' : ch;
+ }
+ *filename->ptr = '\0';
+
+ dirp = opendir (filename->data);
+ if (dirp == NULL)
+ continue;
+ *filename->ptr++ = '/';
+ for (;;)
+ {
+ int len;
+ char *d_name;
+ struct dirent *direntp = readdir (dirp);
+ if (!direntp)
+ break;
+ d_name = direntp->d_name;
+ len = strlen (direntp->d_name);
+ buffer_grow (filename, len+1);
+ strcpy (filename->ptr, d_name);
+ found |= note_possible_classname (filename->data + entry_length,
+ package_length+len+1);
+ }
+ if (dirp)
+ closedir (dirp);
+ }
+ }
+
+ free (filename->data);
+
+ /* Here we should have a unified way of retrieving an entry, to be
+ indexed. */
+ if (!found)
+ {
+ static int first = 1;
+ if (first)
+ {
+ char buffer [256];
+ sprintf (buffer, "Can't find default package `%s'. Check "
+ "the CLASSPATH environment variable and the access to the "
+ "archives.", package_name);
+ error (buffer);
+ java_error_count++;
+ first = 0;
+ }
+ else
+ parse_error_context (wfl, "Package `%s' not found in import",
+ package_name);
+ current_jcf = saved_jcf;
+ return;
+ }
+ current_jcf = saved_jcf;
+}
+
+/* Possibly find a type in the import on demands specified
+ types. Returns 1 if an error occured, 0 otherwise. Run throught the
+ entire list, to detected potential double definitions. */
+
+static int
+find_in_imports_on_demand (class_type)
+ tree class_type;
+{
+ tree node, import, node_to_use = NULL_TREE;
+ int seen_once = -1;
+ tree cl = NULL_TREE;
+
+ for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
+ {
+ char *id_name;
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
+ obstack_1grow (&temporary_obstack, '.');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (TYPE_NAME (class_type)),
+ IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
+ id_name = obstack_finish (&temporary_obstack);
+
+ node = maybe_get_identifier (id_name);
+ if (node && IS_A_CLASSFILE_NAME (node))
+ {
+ if (seen_once < 0)
+ {
+ cl = TREE_PURPOSE (import);
+ seen_once = 1;
+ node_to_use = node;
+ }
+ else
+ {
+ seen_once++;
+ parse_error_context
+ (import, "Type `%s' also potentially defined in package `%s'",
+ IDENTIFIER_POINTER (TYPE_NAME (class_type)),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
+ }
+ }
+ }
+
+ if (seen_once == 1)
+ {
+ /* Setup lineno so that it refers to the line of the import (in
+ case we parse a class file and encounter errors */
+ tree decl;
+ int saved_lineno = lineno;
+ lineno = EXPR_WFL_LINENO (cl);
+ TYPE_NAME (class_type) = node_to_use;
+ QUALIFIED_P (TYPE_NAME (class_type)) = 1;
+ decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ /* If there is no DECL set for the class or if the class isn't
+ loaded and not seen in source yet, the load */
+ if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
+ && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
+ load_class (node_to_use, 0);
+ lineno = saved_lineno;
+ return check_pkg_class_access (TYPE_NAME (class_type), cl);
+ }
+ else
+ return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
+}
+
+static tree
+resolve_package (pkg, next)
+ tree pkg, *next;
+{
+ tree current;
+ tree type_name = NULL_TREE;
+ char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg));
+
+ /* The trick is to determine when the package name stops and were
+ the name of something contained in the package starts. Then we
+ return a fully qualified name of what we want to get. */
+
+ /* Do a quick search on well known package names */
+ if (!strncmp (name, "java.lang.reflect", 17))
+ {
+ *next =
+ TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))));
+ type_name = lookup_package_type (name, 17);
+ }
+ else if (!strncmp (name, "java.lang", 9))
+ {
+ *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)));
+ type_name = lookup_package_type (name, 9);
+ }
+
+ /* If we found something here, return */
+ if (type_name)
+ return type_name;
+
+ *next = EXPR_WFL_QUALIFICATION (pkg);
+
+ /* Try the current package. */
+ if (ctxp->package && !strncmp (name, IDENTIFIER_POINTER (ctxp->package),
+ IDENTIFIER_LENGTH (ctxp->package)))
+ {
+ type_name =
+ lookup_package_type_and_set_next (name,
+ IDENTIFIER_LENGTH (ctxp->package),
+ next );
+ if (type_name)
+ return type_name;
+ }
+
+ /* Search in imported package */
+ for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
+ {
+ tree current_pkg_name = EXPR_WFL_NODE (TREE_PURPOSE (current));
+ int len = IDENTIFIER_LENGTH (current_pkg_name);
+ if (!strncmp (name, IDENTIFIER_POINTER (current_pkg_name), len))
+ {
+ tree left, dummy;
+
+ breakdown_qualified (&left, &dummy, current_pkg_name);
+ len = IDENTIFIER_LENGTH (left);
+ type_name = lookup_package_type_and_set_next (name, len, next);
+ if (type_name)
+ break;
+ }
+ }
+
+ return type_name;
+}
+
+static tree
+lookup_package_type_and_set_next (name, len, next)
+ char *name;
+ int len;
+ tree *next;
+{
+ char *ptr;
+ tree type_name = lookup_package_type (name, len);
+
+ if (!type_name)
+ return NULL;
+
+ ptr = IDENTIFIER_POINTER (type_name);
+ while (ptr && (ptr = strchr (ptr, '.')))
+ {
+ *next = TREE_CHAIN (*next);
+ ptr++;
+ }
+ return type_name;
+}
+
+static tree
+lookup_package_type (name, from)
+ char *name;
+ int from;
+{
+ char subname [128];
+ char *sub = &name[from+1];
+ while (*sub != '.' && *sub)
+ sub++;
+ strncpy (subname, name, sub-name);
+ subname [sub-name] = '\0';
+ return get_identifier (subname);
+}
+
+/* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
+ access violations were found, 1 otherwise. */
+
+static int
+check_pkg_class_access (class_name, cl)
+ tree class_name;
+ tree cl;
+{
+ tree type;
+
+ if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
+ return 0;
+
+ if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
+ return 0;
+
+ if (!CLASS_PUBLIC (TYPE_NAME (type)))
+ {
+ /* Access to a private class within the same package is
+ allowed. */
+ tree l, r;
+ breakdown_qualified (&l, &r, class_name);
+ if (l == ctxp->package)
+ return 0;
+
+ parse_error_context
+ (cl, "Can't access %s `%s'. Only public classes and interfaces in "
+ "other packages can be accessed",
+ (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
+ IDENTIFIER_POINTER (class_name));
+ return 1;
+ }
+ return 0;
+}
+
+/* Local variable declaration. */
+
+static void
+declare_local_variables (modifier, type, vlist)
+ int modifier;
+ tree type;
+ tree vlist;
+{
+ tree decl, current, saved_type;
+ tree type_wfl = NULL_TREE;
+ int must_chain = 0;
+
+ /* Push a new block if statements were seen between the last time we
+ pushed a block and now. Keep a cound of block to close */
+ if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
+ {
+ tree body = GET_CURRENT_BLOCK (current_function_decl);
+ tree b = enter_block ();
+ BLOCK_EXPR_ORIGIN (b) = body;
+ }
+
+ if (modifier)
+ {
+ int i;
+ for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
+ if (modifier == ACC_FINAL)
+ {
+ if (flag_static_local_jdk1_1)
+ parse_warning_context (ctxp->modifier_ctx [i],
+ "Unsupported JDK1.1 `final' local variable "
+ "(treated as non final)");
+ }
+ else
+ {
+ parse_error_context
+ (ctxp->modifier_ctx [i],
+ "Only `final' is allowed as a local variables modifier");
+ return;
+ }
+ }
+
+ /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
+ hold the TYPE value if a new incomplete has to be created (as
+ opposed to being found already existing and reused). */
+ SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
+
+ /* If TYPE is fully resolved and we don't have a reference, make one */
+ PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
+
+ /* Go through all the declared variables */
+ for (current = vlist, saved_type = type; current;
+ current = TREE_CHAIN (current), type = saved_type)
+ {
+ tree other, real_type;
+ tree wfl = TREE_PURPOSE (current);
+ tree name = EXPR_WFL_NODE (wfl);
+ tree init = TREE_VALUE (current);
+
+ /* Process NAME, as it may specify extra dimension(s) for it */
+ type = build_array_from_name (type, type_wfl, name, &name);
+
+ /* Variable redefinition check */
+ if ((other = lookup_name_in_blocks (name)))
+ {
+ variable_redefinition_error (wfl, name, TREE_TYPE (other),
+ DECL_SOURCE_LINE (other));
+ continue;
+ }
+
+ /* Type adjustment. We may have just readjusted TYPE because
+ the variable specified more dimensions. Make sure we have
+ a reference if we can and don't have one already. */
+ PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
+
+ real_type = GET_REAL_TYPE (type);
+ /* Never layout this decl. This will be done when its scope
+ will be entered */
+ decl = build_decl (VAR_DECL, name, real_type);
+ BLOCK_CHAIN_DECL (decl);
+
+ /* If doing xreferencing, replace the line number with the WFL
+ compound value */
+ if (flag_emit_xref)
+ DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
+
+ /* Don't try to use an INIT statement when an error was found */
+ if (init && java_error_count)
+ init = NULL_TREE;
+
+ /* Add the initialization function to the current function's code */
+ if (init)
+ {
+ /* Name might have been readjusted */
+ EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
+ MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
+ java_method_add_stmt (current_function_decl,
+ build_debugable_stmt (EXPR_WFL_LINECOL (init),
+ init));
+ }
+
+ /* Setup dependency the type of the decl */
+ if (must_chain)
+ {
+ jdep *dep;
+ register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
+ dep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
+ }
+ }
+ SOURCE_FRONTEND_DEBUG (("Defined locals"));
+}
+
+/* Called during parsing. Build decls from argument list. */
+
+static void
+source_start_java_method (fndecl)
+ tree fndecl;
+{
+ tree tem;
+ tree parm_decl;
+ int i;
+
+ current_function_decl = fndecl;
+
+ /* New scope for the function */
+ enter_block ();
+ for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
+ tem != end_params_node; tem = TREE_CHAIN (tem), i++)
+ {
+ tree type = TREE_VALUE (tem);
+ tree name = TREE_PURPOSE (tem);
+
+ /* If type is incomplete. Create an incomplete decl and ask for
+ the decl to be patched later */
+ if (INCOMPLETE_TYPE_P (type))
+ {
+ jdep *jdep;
+ tree real_type = GET_REAL_TYPE (type);
+ parm_decl = build_decl (PARM_DECL, name, real_type);
+ type = obtain_incomplete_type (type);
+ register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_MISC (jdep) = name;
+ JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
+ }
+ else
+ parm_decl = build_decl (PARM_DECL, name, type);
+
+ BLOCK_CHAIN_DECL (parm_decl);
+ }
+ tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
+ nreverse (tem);
+ DECL_ARG_SLOT_COUNT (current_function_decl) = i;
+}
+
+/* Called during parsing. Creates an artificial method declaration. */
+
+static tree
+create_artificial_method (class, flags, type, name, args)
+ tree class;
+ int flags;
+ tree type, name, args;
+{
+ int saved_lineno = lineno;
+ tree mdecl;
+
+ lineno = 0;
+ mdecl = make_node (FUNCTION_TYPE);
+ TREE_TYPE (mdecl) = type;
+ TYPE_ARG_TYPES (mdecl) = args;
+ mdecl = add_method (class, flags, name, build_java_signature (mdecl));
+ lineno = saved_lineno;
+ DECL_ARTIFICIAL (mdecl) = 1;
+ return mdecl;
+}
+
+/* Starts the body if an artifical method. */
+
+static void
+start_artificial_method_body (mdecl)
+ tree mdecl;
+{
+ DECL_SOURCE_LINE (mdecl) = 1;
+ DECL_SOURCE_LINE_MERGE (mdecl, 1);
+ source_start_java_method (mdecl);
+ enter_block ();
+}
+
+static void
+end_artificial_method_body (mdecl)
+ tree mdecl;
+{
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
+ exit_block ();
+}
+
+/* Called during expansion. Push decls formerly built from argument
+ list so they're usable during expansion. */
+
+static void
+expand_start_java_method (fndecl)
+ tree fndecl;
+{
+ tree tem, *ptr;
+
+ current_function_decl = fndecl;
+
+ announce_function (fndecl);
+ pushlevel (1); /* Push parameters */
+ ptr = &DECL_ARGUMENTS (fndecl);
+ tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
+ while (tem)
+ {
+ tree next = TREE_CHAIN (tem);
+ tree type = TREE_TYPE (tem);
+#ifdef PROMOTE_PROTOTYPES
+ if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
+ && INTEGRAL_TYPE_P (type))
+ type = integer_type_node;
+#endif
+ DECL_ARG_TYPE (tem) = type;
+ layout_decl (tem, 0);
+ pushdecl (tem);
+ *ptr = tem;
+ ptr = &TREE_CHAIN (tem);
+ tem = next;
+ }
+ *ptr = NULL_TREE;
+ pushdecl_force_head (DECL_ARGUMENTS (fndecl));
+ lineno = DECL_SOURCE_LINE_FIRST (fndecl);
+}
+
+/* Terminate a function and expand its body. */
+
+static void
+source_end_java_method ()
+{
+ tree fndecl = current_function_decl;
+ int flag_asynchronous_exceptions = asynchronous_exceptions;
+
+ java_parser_context_save_global ();
+ lineno = ctxp->last_ccb_indent1;
+
+ /* Set EH language codes */
+ java_set_exception_lang_code ();
+
+ /* Turn function bodies with only a NOP expr null, so they don't get
+ generated at all and we won't get warnings when using the -W
+ -Wall flags. */
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
+
+ /* Generate function's code */
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
+ && ! flag_emit_class_files
+ && ! flag_emit_xref)
+ expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
+
+ /* pop out of its parameters */
+ pushdecl_force_head (DECL_ARGUMENTS (fndecl));
+ poplevel (1, 0, 1);
+ BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
+
+ /* Generate rtl for function exit. */
+ if (! flag_emit_class_files && ! flag_emit_xref)
+ {
+ lineno = DECL_SOURCE_LINE_LAST (fndecl);
+ /* Emit catch-finally clauses */
+ emit_handlers ();
+ expand_function_end (input_filename, lineno, 0);
+
+ /* FIXME: If the current method contains any exception handlers,
+ force asynchronous_exceptions: this is necessary because signal
+ handlers in libjava may throw exceptions. This is far from being
+ a perfect solution, but it's better than doing nothing at all.*/
+ if (catch_clauses)
+ asynchronous_exceptions = 1;
+
+ /* Run the optimizers and output assembler code for this function. */
+ rest_of_compilation (fndecl);
+ }
+
+ current_function_decl = NULL_TREE;
+ /* permanent_allocation (1); */
+ java_parser_context_restore_global ();
+ asynchronous_exceptions = flag_asynchronous_exceptions;
+}
+
+/* Record EXPR in the current function block. Complements compound
+ expression second operand if necessary. */
+
+tree
+java_method_add_stmt (fndecl, expr)
+ tree fndecl, expr;
+{
+ return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
+}
+
+static tree
+add_stmt_to_block (b, type, stmt)
+ tree b, type, stmt;
+{
+ tree body = BLOCK_EXPR_BODY (b), c;
+
+ if (java_error_count)
+ return body;
+
+ if ((c = add_stmt_to_compound (body, type, stmt)) == body)
+ return body;
+
+ BLOCK_EXPR_BODY (b) = c;
+ TREE_SIDE_EFFECTS (c) = 1;
+ return c;
+}
+
+/* Add STMT to EXISTING if possible, otherwise create a new
+ COMPOUND_EXPR and add STMT to it. */
+
+static tree
+add_stmt_to_compound (existing, type, stmt)
+ tree existing, type, stmt;
+{
+ if (existing)
+ return build (COMPOUND_EXPR, type, existing, stmt);
+ else
+ return stmt;
+}
+
+/* Hold THIS for the scope of the current public method decl. */
+static tree current_this;
+
+void java_layout_seen_class_methods ()
+{
+ tree previous_list = all_class_list;
+ tree end = NULL_TREE;
+ tree current;
+
+ while (1)
+ {
+ for (current = previous_list;
+ current != end; current = TREE_CHAIN (current))
+ layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
+
+ if (previous_list != all_class_list)
+ {
+ end = previous_list;
+ previous_list = all_class_list;
+ }
+ else
+ break;
+ }
+}
+
+/* Layout the methods of all classes loaded in one way on an
+ other. Check methods of source parsed classes. Then reorder the
+ fields and layout the classes or the type of all source parsed
+ classes */
+
+void
+java_layout_classes ()
+{
+ tree current;
+ int save_error_count = java_error_count;
+
+ /* Layout the methods of all classes seen so far */
+ java_layout_seen_class_methods ();
+ java_parse_abort_on_error ();
+ all_class_list = NULL_TREE;
+
+ /* Then check the methods of all parsed classes */
+ for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
+ if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
+ CHECK_METHODS (TREE_VALUE (current));
+ java_parse_abort_on_error ();
+
+ for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
+ {
+ current_class = TREE_TYPE (TREE_VALUE (current));
+
+ /* Reverse the fields, but leave the dummy field in front.
+ Fields are already ordered for Object and Class */
+ if (TYPE_FIELDS (current_class) && current_class != object_type_node
+ && current_class != class_type_node)
+ {
+ /* If the dummy field is there, reverse the right fields and
+ just layout the type for proper fields offset */
+ if (!DECL_NAME (TYPE_FIELDS (current_class)))
+ {
+ tree fields = TYPE_FIELDS (current_class);
+ TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
+ TYPE_SIZE (current_class) = NULL_TREE;
+ layout_type (current_class);
+ }
+ /* We don't have a dummy field, we need to layout the class,
+ after having reversed the fields */
+ else
+ {
+ TYPE_FIELDS (current_class) =
+ nreverse (TYPE_FIELDS (current_class));
+ TYPE_SIZE (current_class) = NULL_TREE;
+ layout_class (current_class);
+ }
+ }
+ else
+ layout_class (current_class);
+
+ /* From now on, the class is considered completely loaded */
+ CLASS_LOADED_P (current_class) = 1;
+
+ /* Error reported by the caller */
+ if (java_error_count)
+ return;
+ }
+
+ /* We might have reloaded classes durign the process of laying out
+ classes for code generation. We must layout the methods of those
+ late additions, as constructor checks might use them */
+ java_layout_seen_class_methods ();
+ java_parse_abort_on_error ();
+}
+
+/* Expand all methods in all registered classes. */
+
+void
+java_complete_expand_methods ()
+{
+ tree current;
+
+ do_not_fold = flag_emit_xref;
+
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ int is_interface;
+ tree class_type = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current));
+ tree decl;
+
+ current_class = TREE_TYPE (current);
+ is_interface = CLASS_INTERFACE (TYPE_NAME (current_class));
+
+ /* Initialize a new constant pool */
+ init_outgoing_cpool ();
+
+ /* We want <clinit> (if any) to be processed first. */
+ decl = tree_last (TYPE_METHODS (class_type));
+ if (IS_CLINIT (decl))
+ {
+ tree fbody = DECL_FUNCTION_BODY (decl);
+ tree list;
+ if (fbody != NULL_TREE)
+ {
+ /* First check if we can ignore empty <clinit> */
+ tree block_body = BLOCK_EXPR_BODY (fbody);
+
+ current_this = NULL_TREE;
+ current_function_decl = decl;
+ if (block_body != NULL_TREE)
+ {
+ /* Prevent the use of `this' inside <clinit> */
+ ctxp->explicit_constructor_p = 1;
+
+ block_body = java_complete_tree (block_body);
+ ctxp->explicit_constructor_p = 0;
+ BLOCK_EXPR_BODY (fbody) = block_body;
+ if (block_body != NULL_TREE
+ && TREE_CODE (block_body) == BLOCK
+ && BLOCK_EXPR_BODY (block_body) == empty_stmt_node)
+ decl = NULL_TREE;
+ }
+ }
+ list = nreverse (TREE_CHAIN (nreverse (TYPE_METHODS (class_type))));
+ if (decl != NULL_TREE)
+ {
+ TREE_CHAIN (decl) = list;
+ TYPE_METHODS (class_type) = decl;
+ }
+ else
+ TYPE_METHODS (class_type) = list;
+ }
+
+ for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
+ {
+ current_function_decl = decl;
+ /* Don't generate debug info on line zero when expanding a
+ generated constructor. */
+ if (DECL_CONSTRUCTOR_P (decl) && !DECL_FUNCTION_BODY (decl))
+ {
+ /* If we found errors, it's too dangerous to try to
+ generate and expand a constructor */
+ if (!java_error_count)
+ {
+ restore_line_number_status (1);
+ java_complete_expand_method (decl);
+ restore_line_number_status (0);
+ }
+ }
+ else if (METHOD_ABSTRACT (decl) || METHOD_NATIVE (decl))
+ continue;
+ else
+ java_complete_expand_method (decl);
+ }
+
+ /* Now verify constructor circularity (stop after the first one
+ we find) */
+ if (!is_interface)
+ for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
+ if (DECL_CONSTRUCTOR_P (decl) &&
+ verify_constructor_circularity (decl, decl))
+ break;
+
+ /* Make the class data, register it and run the rest of decl
+ compilation on it */
+ if (!java_error_count)
+ {
+ if (flag_emit_class_files)
+ write_classfile (current_class);
+ if (flag_emit_xref)
+ expand_xref (current_class);
+ else if (! flag_syntax_only)
+ finish_class (current_class);
+ }
+ }
+}
+
+/* Hold a list of catch clauses list. The first element of this list is
+ the list of the catch clauses of the currently analysed try block. */
+static tree currently_caught_type_list;
+
+/* Complete and expand a method. */
+
+static void
+java_complete_expand_method (mdecl)
+ tree mdecl;
+{
+ /* Fix constructors before expanding them */
+ if (DECL_CONSTRUCTOR_P (mdecl))
+ fix_constructors (mdecl);
+
+ /* Expand functions that have a body */
+ if (DECL_FUNCTION_BODY (mdecl))
+ {
+ tree fbody = DECL_FUNCTION_BODY (mdecl);
+ tree block_body = BLOCK_EXPR_BODY (fbody);
+ tree exception_copy;
+ expand_start_java_method (mdecl);
+ build_result_decl (mdecl);
+
+ current_this
+ = (!METHOD_STATIC (mdecl) ?
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
+
+ /* Purge the `throws' list of unchecked exceptions. If we're
+ doing xref, save a copy of the list and re-install it
+ later. */
+ if (flag_emit_xref)
+ exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
+
+ purge_unchecked_exceptions (mdecl);
+
+ /* Install exceptions thrown with `throws' */
+ PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
+
+ if (block_body != NULL_TREE)
+ {
+ block_body = java_complete_tree (block_body);
+ if (!flag_emit_xref)
+ check_for_initialization (block_body);
+ ctxp->explicit_constructor_p = 0;
+ }
+ BLOCK_EXPR_BODY (fbody) = block_body;
+
+ if ((block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
+ && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
+ && !flag_emit_xref)
+ missing_return_error (current_function_decl);
+
+ complete_start_java_method (mdecl);
+
+ /* Don't go any further if we've found error(s) during the
+ expansion */
+ if (!java_error_count)
+ source_end_java_method ();
+ else
+ {
+ pushdecl_force_head (DECL_ARGUMENTS (mdecl));
+ poplevel (1, 0, 1);
+ }
+
+ /* Pop the exceptions and sanity check */
+ POP_EXCEPTIONS();
+ if (currently_caught_type_list)
+ fatal ("Exception list non empty - java_complete_expand_method");
+
+ if (flag_emit_xref)
+ DECL_FUNCTION_THROWS (mdecl) = exception_copy;
+ }
+}
+
+/* Craft a body for default constructor. Patch existing constructor
+ bodies with call to super() and field initialization statements if
+ necessary. */
+
+static void
+fix_constructors (mdecl)
+ tree mdecl;
+{
+ tree body = DECL_FUNCTION_BODY (mdecl);
+
+ if (!body)
+ {
+ /* The constructor body must be crafted by hand. It's the
+ constructor we defined when we realize we didn't have the
+ CLASSNAME() constructor */
+
+ tree compound;
+
+ /* It is an error for the compiler to generate a default
+ constructor if the superclass doesn't have a constructor that
+ takes no argument */
+ if (verify_constructor_super ())
+ {
+ tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (current_class));
+ char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
+ parse_error_context (lookup_cl (TYPE_NAME (current_class)),
+ "No constructor matching `%s()' found in "
+ "class `%s'", n, n);
+ }
+
+ start_artificial_method_body (mdecl);
+
+ /* We don't generate a super constructor invocation if we're
+ compiling java.lang.Object. build_super_invocation takes care
+ of that. */
+ compound = java_method_add_stmt (mdecl, build_super_invocation ());
+
+ end_artificial_method_body (mdecl);
+ }
+ /* Search for an explicit constructor invocation */
+ else
+ {
+ int found = 0;
+ tree main_block = BLOCK_EXPR_BODY (body);
+ tree compound = NULL_TREE;
+
+ while (body)
+ switch (TREE_CODE (body))
+ {
+ case CALL_EXPR:
+ found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
+ body = NULL_TREE;
+ break;
+ case COMPOUND_EXPR:
+ case EXPR_WITH_FILE_LOCATION:
+ body = TREE_OPERAND (body, 0);
+ break;
+ case BLOCK:
+ body = BLOCK_EXPR_BODY (body);
+ break;
+ default:
+ found = 0;
+ body = NULL_TREE;
+ }
+ /* The constructor is missing an invocation of super() */
+ if (!found)
+ compound = add_stmt_to_compound (compound, NULL_TREE,
+ build_super_invocation ());
+
+ /* Fix the constructor main block if we're adding extra stmts */
+ if (compound)
+ {
+ compound = add_stmt_to_compound (compound, NULL_TREE,
+ BLOCK_EXPR_BODY (main_block));
+ BLOCK_EXPR_BODY (main_block) = compound;
+ }
+ }
+}
+
+/* Browse constructors in the super class, searching for a constructor
+ that doesn't take any argument. Return 0 if one is found, 1
+ otherwise. */
+
+static int
+verify_constructor_super ()
+{
+ tree class = CLASSTYPE_SUPER (current_class);
+ if (!class)
+ return 0;
+
+ if (class)
+ {
+ tree mdecl;
+ for (mdecl = TYPE_METHODS (class); mdecl; mdecl = TREE_CHAIN (mdecl))
+ {
+ if (DECL_CONSTRUCTOR_P (mdecl)
+ && TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (mdecl))) == end_params_node)
+ return 0;
+ }
+ }
+ return 1;
+}
+
+/* Expand finals. */
+
+void
+java_expand_finals ()
+{
+}
+
+/* Generate code for all context remembered for code generation. */
+
+void
+java_expand_classes ()
+{
+ int save_error_count = 0;
+ java_parse_abort_on_error ();
+ if (!(ctxp = ctxp_for_generation))
+ return;
+ java_layout_classes ();
+ java_parse_abort_on_error ();
+
+ for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
+ {
+ ctxp = ctxp_for_generation;
+ lang_init_source (2); /* Error msgs have method prototypes */
+ java_complete_expand_methods (); /* Complete and expand method bodies */
+ java_parse_abort_on_error ();
+ java_expand_finals (); /* Expand and check the finals */
+ java_parse_abort_on_error ();
+ java_check_final (); /* Check unitialized final */
+ java_parse_abort_on_error ();
+ }
+}
+
+/* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
+ a tree list node containing RIGHT. Fore coming RIGHTs will be
+ chained to this hook. LOCATION contains the location of the
+ separating `.' operator. */
+
+static tree
+make_qualified_primary (primary, right, location)
+ tree primary, right;
+ int location;
+{
+ tree wfl;
+
+ /* We want to process THIS . xxx symbolicaly, to keep it consistent
+ with the way we're processing SUPER. A THIS from a primary as a
+ different form than a SUPER. Turn THIS into something symbolic */
+ if (TREE_CODE (primary) == THIS_EXPR)
+ {
+ wfl = build_wfl_node (this_identifier_node);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
+ wfl = make_qualified_name (wfl, right, location);
+ PRIMARY_P (wfl) = 1;
+ return wfl;
+ }
+ /* Other non WFL node are wrapped around a WFL */
+ else if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
+ {
+ wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
+ EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (primary, NULL_TREE);
+ }
+ else
+ {
+ wfl = primary;
+ if (!EXPR_WFL_QUALIFICATION (primary))
+ EXPR_WFL_QUALIFICATION (primary) =
+ build_tree_list (primary, NULL_TREE);
+ }
+
+ EXPR_WFL_LINECOL (right) = location;
+ chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
+ PRIMARY_P (wfl) = 1;
+ return wfl;
+}
+
+/* Simple merge of two name separated by a `.' */
+
+static tree
+merge_qualified_name (left, right)
+ tree left, right;
+{
+ tree node;
+ obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
+ IDENTIFIER_LENGTH (left));
+ obstack_1grow (&temporary_obstack, '.');
+ obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
+ IDENTIFIER_LENGTH (right));
+ node = get_identifier (obstack_base (&temporary_obstack));
+ obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
+ QUALIFIED_P (node) = 1;
+ return node;
+}
+
+/* Merge the two parts of a qualified name into LEFT. Set the
+ location information of the resulting node to LOCATION, usually
+ inherited from the location information of the `.' operator. */
+
+static tree
+make_qualified_name (left, right, location)
+ tree left, right;
+ int location;
+{
+#ifdef USE_COMPONENT_REF
+ tree node = build (COMPONENT_REF, NULL_TREE, left, right);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+#else
+ tree left_id = EXPR_WFL_NODE (left);
+ tree right_id = EXPR_WFL_NODE (right);
+ tree wfl, merge;
+
+ merge = merge_qualified_name (left_id, right_id);
+
+ /* Left wasn't qualified and is now qualified */
+ if (!QUALIFIED_P (left_id))
+ {
+ tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
+ EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
+ }
+
+ wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = location;
+ chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
+
+ EXPR_WFL_NODE (left) = merge;
+ return left;
+#endif
+}
+
+/* Extract the last identifier component of the qualified in WFL. The
+ last identifier is removed from the linked list */
+
+static tree
+cut_identifier_in_qualified (wfl)
+ tree wfl;
+{
+ tree q;
+ tree previous = NULL_TREE;
+ for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
+ if (!TREE_CHAIN (q))
+ {
+ if (!previous)
+ fatal ("Operating on a non qualified qualified WFL - "
+ "cut_identifier_in_qualified");
+ TREE_CHAIN (previous) = NULL_TREE;
+ return TREE_PURPOSE (q);
+ }
+}
+
+/* Resolve the expression name NAME. Return its decl. */
+
+static tree
+resolve_expression_name (id, orig)
+ tree id;
+ tree *orig;
+{
+ tree name = EXPR_WFL_NODE (id);
+ tree decl;
+
+ /* 6.5.5.1: Simple expression names */
+ if (!PRIMARY_P (id) && !QUALIFIED_P (name))
+ {
+ /* 15.13.1: NAME can appear within the scope of a local variable
+ declaration */
+ if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
+ return decl;
+
+ /* 15.13.1: NAME can appear within a class declaration */
+ else
+ {
+ decl = lookup_field_wrapper (current_class, name);
+ if (decl)
+ {
+ int fs = FIELD_STATIC (decl);
+ /* Instance variable (8.3.1.1) can't appear within
+ static method, static initializer or initializer for
+ a static variable. */
+ if (!fs && METHOD_STATIC (current_function_decl))
+ {
+ static_ref_err (id, name, current_class);
+ return error_mark_node;
+ }
+ /* Instance variables can't appear as an argument of
+ an explicit constructor invocation */
+ if (!fs && ctxp->explicit_constructor_p)
+ {
+ parse_error_context
+ (id, "Can't reference `%s' before the superclass "
+ "constructor has been called", IDENTIFIER_POINTER (name));
+ return error_mark_node;
+ }
+
+ /* Otherwise build what it takes to access the field */
+ decl = build_field_ref ((fs ? NULL_TREE : current_this),
+ DECL_CONTEXT (decl), name);
+ if (fs && !flag_emit_class_files && !flag_emit_xref)
+ decl = build_class_init (DECL_CONTEXT (decl), decl);
+ /* We may be asked to save the real field access node */
+ if (orig)
+ *orig = decl;
+ /* And we return what we got */
+ return decl;
+ }
+ /* Fall down to error report on undefined variable */
+ }
+ }
+ /* 6.5.5.2 Qualified Expression Names */
+ else
+ {
+ if (orig)
+ *orig = NULL_TREE;
+ qualify_ambiguous_name (id);
+ /* 15.10.1 Field Access Using a Primary and/or Expression Name */
+ /* 15.10.2: Accessing Superclass Members using super */
+ return resolve_field_access (id, NULL, NULL);
+ }
+
+ /* We've got an error here */
+ parse_error_context (id, "Undefined variable `%s'",
+ IDENTIFIER_POINTER (name));
+
+ return error_mark_node;
+}
+
+static void
+static_ref_err (wfl, field_id, class_type)
+ tree wfl, field_id, class_type;
+{
+ parse_error_context
+ (wfl,
+ "Can't make a static reference to nonstatic variable `%s' in class `%s'",
+ IDENTIFIER_POINTER (field_id),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
+}
+
+/* 15.10.1 Field Acess Using a Primary and/or Expression Name.
+ We return something suitable to generate the field access. We also
+ return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
+ recipient's address can be null. */
+
+static tree
+resolve_field_access (qual_wfl, field_decl, field_type)
+ tree qual_wfl;
+ tree *field_decl, *field_type;
+{
+ int is_static = 0;
+ tree field_ref;
+ tree decl, where_found, type_found;
+
+ if (resolve_qualified_expression_name (qual_wfl, &decl,
+ &where_found, &type_found))
+ return error_mark_node;
+
+ /* Resolve the LENGTH field of an array here */
+ if (DECL_NAME (decl) == length_identifier_node && TYPE_ARRAY_P (type_found)
+ && ! flag_emit_class_files && ! flag_emit_xref)
+ {
+ tree length = build_java_array_length_access (where_found);
+ field_ref =
+ build_java_arraynull_check (type_found, length, int_type_node);
+ }
+ /* We might have been trying to resolve field.method(). In which
+ case, the resolution is over and decl is the answer */
+ else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
+ field_ref = decl;
+ else if (JDECL_P (decl))
+ {
+ int static_final_found = 0;
+ if (!type_found)
+ type_found = DECL_CONTEXT (decl);
+ is_static = JDECL_P (decl) && FIELD_STATIC (decl);
+ if (FIELD_FINAL (decl)
+ && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))
+ && DECL_LANG_SPECIFIC (decl)
+ && DECL_INITIAL (decl))
+ {
+ field_ref = DECL_INITIAL (decl);
+ static_final_found = 1;
+ }
+ else
+ field_ref = build_field_ref ((is_static && !flag_emit_xref?
+ NULL_TREE : where_found),
+ type_found, DECL_NAME (decl));
+ if (field_ref == error_mark_node)
+ return error_mark_node;
+ if (is_static && !static_final_found
+ && !flag_emit_class_files && !flag_emit_xref)
+ {
+ field_ref = build_class_init (type_found, field_ref);
+ /* If the static field was identified by an expression that
+ needs to be generated, make the field access a compound
+ expression whose first part is the evaluation of the
+ field selector part. */
+ if (where_found && TREE_CODE (where_found) != TYPE_DECL
+ && TREE_CODE (where_found) != RECORD_TYPE)
+ {
+ tree type = QUAL_DECL_TYPE (field_ref);
+ if (TREE_CODE (type) == RECORD_TYPE)
+ type = build_pointer_type (type);
+ field_ref = build (COMPOUND_EXPR, type, where_found, field_ref);
+ }
+ }
+ }
+ else
+ field_ref = decl;
+
+ if (field_decl)
+ *field_decl = decl;
+ if (field_type)
+ *field_type = (QUAL_DECL_TYPE (decl) ?
+ QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
+ return field_ref;
+}
+
+/* If NODE is an access to f static field, strip out the class
+ initialization part and return the field decl, otherwise, return
+ NODE. */
+
+static tree
+strip_out_static_field_access_decl (node)
+ tree node;
+{
+ if (TREE_CODE (node) == COMPOUND_EXPR)
+ {
+ tree op1 = TREE_OPERAND (node, 1);
+ if (TREE_CODE (op1) == COMPOUND_EXPR)
+ {
+ tree call = TREE_OPERAND (op1, 0);
+ if (TREE_CODE (call) == CALL_EXPR
+ && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
+ && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
+ == soft_initclass_node)
+ return TREE_OPERAND (op1, 1);
+ }
+ }
+ return node;
+}
+
+/* 6.5.5.2: Qualified Expression Names */
+
+static int
+resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
+ tree wfl;
+ tree *found_decl, *type_found, *where_found;
+{
+ int from_type = 0; /* Field search initiated from a type */
+ int from_super = 0, from_cast = 0;
+ int previous_call_static = 0;
+ int is_static;
+ tree decl = NULL_TREE, type = NULL_TREE, q;
+ *type_found = *where_found = NULL_TREE;
+
+ for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
+ {
+ tree qual_wfl = QUAL_WFL (q);
+
+ /* 15.10.1 Field Access Using a Primary */
+ switch (TREE_CODE (qual_wfl))
+ {
+ case CALL_EXPR:
+ case NEW_CLASS_EXPR:
+ /* If the access to the function call is a non static field,
+ build the code to access it. */
+ if (JDECL_P (decl) && !FIELD_STATIC (decl))
+ {
+ decl = maybe_access_field (decl, *where_found,
+ DECL_CONTEXT (decl));
+ if (decl == error_mark_node)
+ return 1;
+ }
+ /* And code for the function call */
+ if (complete_function_arguments (qual_wfl))
+ return 1;
+ if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
+ CALL_USING_SUPER (qual_wfl) = 1;
+ *where_found =
+ patch_method_invocation (qual_wfl, decl, type, &is_static, NULL);
+ if (*where_found == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (*where_found);
+
+ /* If the previous call was static and this one is too,
+ build a compound expression to hold the two (because in
+ that case, previous function calls aren't transported as
+ forcoming function's argument. */
+ if (previous_call_static && is_static)
+ {
+ decl = build (COMPOUND_EXPR, type, decl, *where_found);
+ TREE_SIDE_EFFECTS (decl) = 1;
+ }
+ else
+ {
+ previous_call_static = is_static;
+ decl = *where_found;
+ }
+ continue;
+
+ case NEW_ARRAY_EXPR:
+ *where_found = decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ CLASS_LOADED_P (type) = 1;
+ continue;
+
+ case CONVERT_EXPR:
+ *where_found = decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ from_cast = 1;
+ continue;
+
+ case CONDITIONAL_EXPR:
+ case STRING_CST:
+ *where_found = decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ continue;
+
+ case ARRAY_REF:
+ /* If the access to the function call is a non static field,
+ build the code to access it. */
+ if (JDECL_P (decl) && !FIELD_STATIC (decl))
+ {
+ decl = maybe_access_field (decl, *where_found, type);
+ if (decl == error_mark_node)
+ return 1;
+ }
+ /* And code for the array reference expression */
+ decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ type = QUAL_DECL_TYPE (decl);
+ continue;
+
+ default:
+ /* Fix for -Wall Just go to the next statement. Don't
+ continue */
+ break;
+ }
+
+ /* If we fall here, we weren't processing a (static) function call. */
+ previous_call_static = 0;
+
+ /* It can be the keyword THIS */
+ if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
+ {
+ if (!current_this)
+ {
+ parse_error_context
+ (wfl, "Keyword `this' used outside allowed context");
+ return 1;
+ }
+ /* We have to generate code for intermediate acess */
+ *where_found = decl = current_this;
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ continue;
+ }
+
+ /* 15.10.2 Accessing Superclass Members using SUPER */
+ if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
+ {
+ tree node;
+ /* Check on the restricted use of SUPER */
+ if (METHOD_STATIC (current_function_decl)
+ || current_class == object_type_node)
+ {
+ parse_error_context
+ (wfl, "Keyword `super' used outside allowed context");
+ return 1;
+ }
+ /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
+ node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
+ CLASSTYPE_SUPER (current_class),
+ build_this (EXPR_WFL_LINECOL (qual_wfl)));
+ *where_found = decl = java_complete_tree (node);
+ if (decl == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ from_super = from_type = 1;
+ continue;
+ }
+
+ /* 15.13.1: Can't search for field name in packages, so we
+ assume a variable/class name was meant. */
+ if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ {
+ tree name = resolve_package (wfl, &q);
+ if (name)
+ {
+ *where_found = decl = resolve_no_layout (name, qual_wfl);
+ /* We wan't to be absolutely that the class is laid
+ out. We're going to search something inside it. */
+ *type_found = type = TREE_TYPE (decl);
+ layout_class (type);
+ from_type = 1;
+ /* Should be a list, really. FIXME */
+ RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 1;
+ RESOLVE_PACKAGE_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 0;
+ }
+ else
+ {
+ if (from_super || from_cast)
+ parse_error_context
+ ((from_cast ? qual_wfl : wfl),
+ "No variable `%s' defined in class `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ lang_printable_name (type, 0));
+ else
+ parse_error_context
+ (qual_wfl, "Undefined variable or class name: `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
+ return 1;
+ }
+ }
+
+ /* We have a type name. It's been already resolved when the
+ expression was qualified. */
+ else if (RESOLVE_TYPE_NAME_P (qual_wfl))
+ {
+ if (!(decl = QUAL_RESOLUTION (q)))
+ return 1; /* Error reported already */
+
+ if (not_accessible_p (TREE_TYPE (decl), decl, 0))
+ {
+ parse_error_context
+ (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
+ java_accstring_lookup (get_access_flags_from_decl (decl)),
+ GET_TYPE_NAME (type),
+ IDENTIFIER_POINTER (DECL_NAME (decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ return 1;
+ }
+ check_deprecation (qual_wfl, decl);
+
+ type = TREE_TYPE (decl);
+ from_type = 1;
+ }
+ /* We resolve and expression name */
+ else
+ {
+ tree field_decl;
+
+ /* If there exists an early resolution, use it. That occurs
+ only once and we know that there are more things to
+ come. Don't do that when processing something after SUPER
+ (we need more thing to be put in place below */
+ if (!from_super && QUAL_RESOLUTION (q))
+ {
+ decl = QUAL_RESOLUTION (q);
+ if (!type)
+ {
+ if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
+ {
+ if (current_this)
+ *where_found = current_this;
+ else
+ {
+ static_ref_err (qual_wfl, DECL_NAME (decl),
+ current_class);
+ return 1;
+ }
+ }
+ else
+ {
+ *where_found = TREE_TYPE (decl);
+ if (TREE_CODE (*where_found) == POINTER_TYPE)
+ *where_found = TREE_TYPE (*where_found);
+ }
+ }
+ }
+
+ /* We have to search for a field, knowing the type of its
+ container. The flag FROM_TYPE indicates that we resolved
+ the last member of the expression as a type name, which
+ means that for the resolution of this field, we'll look
+ for other errors than if it was resolved as a member of
+ an other field. */
+ else
+ {
+ int is_static;
+ tree field_decl_type; /* For layout */
+
+ if (!from_type && !JREFERENCE_TYPE_P (type))
+ {
+ parse_error_context
+ (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ lang_printable_name (type, 0),
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)));
+ return 1;
+ }
+
+ field_decl = lookup_field_wrapper (type,
+ EXPR_WFL_NODE (qual_wfl));
+ if (field_decl == NULL_TREE)
+ {
+ parse_error_context
+ (qual_wfl, "No variable `%s' defined in type `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ GET_TYPE_NAME (type));
+ return 1;
+ }
+ if (field_decl == error_mark_node)
+ return 1;
+
+ /* Layout the type of field_decl, since we may need
+ it. Don't do primitive types or loaded classes. The
+ situation of non primitive arrays may not handled
+ properly here. FIXME */
+ if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
+ field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
+ else
+ field_decl_type = TREE_TYPE (field_decl);
+ if (!JPRIMITIVE_TYPE_P (field_decl_type)
+ && !CLASS_LOADED_P (field_decl_type)
+ && !TYPE_ARRAY_P (field_decl_type))
+ resolve_and_layout (field_decl_type, NULL_TREE);
+ if (TYPE_ARRAY_P (field_decl_type))
+ CLASS_LOADED_P (field_decl_type) = 1;
+
+ /* Check on accessibility here */
+ if (not_accessible_p (type, field_decl, from_super))
+ {
+ parse_error_context
+ (qual_wfl,
+ "Can't access %s field `%s.%s' from `%s'",
+ java_accstring_lookup
+ (get_access_flags_from_decl (field_decl)),
+ GET_TYPE_NAME (type),
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (current_class))));
+ return 1;
+ }
+ check_deprecation (qual_wfl, field_decl);
+
+ /* There are things to check when fields are accessed
+ from type. There are no restrictions on a static
+ declaration of the field when it is accessed from an
+ interface */
+ is_static = FIELD_STATIC (field_decl);
+ if (!from_super && from_type
+ && !TYPE_INTERFACE_P (type) && !is_static)
+ {
+ static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
+ return 1;
+ }
+ from_cast = from_super = 0;
+
+ /* If we need to generate something to get a proper
+ handle on what this field is accessed from, do it
+ now. */
+ if (!is_static)
+ {
+ decl = maybe_access_field (decl, *where_found, *type_found);
+ if (decl == error_mark_node)
+ return 1;
+ }
+
+ /* We want to keep the location were found it, and the type
+ we found. */
+ *where_found = decl;
+ *type_found = type;
+
+ /* This is the decl found and eventually the next one to
+ search from */
+ decl = field_decl;
+ }
+ from_type = 0;
+ type = QUAL_DECL_TYPE (decl);
+ }
+ }
+ *found_decl = decl;
+ return 0;
+}
+
+/* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
+ can't be accessed from REFERENCE (a record type). */
+
+int not_accessible_p (reference, member, from_super)
+ tree reference, member;
+ int from_super;
+{
+ int access_flag = get_access_flags_from_decl (member);
+
+ /* Access always granted for members declared public */
+ if (access_flag & ACC_PUBLIC)
+ return 0;
+
+ /* Check access on protected members */
+ if (access_flag & ACC_PROTECTED)
+ {
+ /* Access granted if it occurs from within the package
+ containing the class in which the protected member is
+ declared */
+ if (class_in_current_package (DECL_CONTEXT (member)))
+ return 0;
+
+ /* If accessed with the form `super.member', then access is granted */
+ if (from_super)
+ return 0;
+
+ /* Otherwise, access is granted if occuring from the class where
+ member is declared or a subclass of it */
+ if (inherits_from_p (reference, current_class))
+ return 0;
+ return 1;
+ }
+
+ /* Check access on private members. Access is granted only if it
+ occurs from within the class in witch it is declared */
+ if (access_flag & ACC_PRIVATE)
+ return (current_class == DECL_CONTEXT (member) ? 0 : 1);
+
+ /* Default access are permitted only when occuring within the
+ package in which the type (REFERENCE) is declared. In other words,
+ REFERENCE is defined in the current package */
+ if (ctxp->package)
+ return !class_in_current_package (reference);
+
+ /* Otherwise, access is granted */
+ return 0;
+}
+
+/* Test deprecated decl access. */
+static void
+check_deprecation (wfl, decl)
+ tree wfl, decl;
+{
+ char *file = DECL_SOURCE_FILE (decl);
+ /* Complain if the field is deprecated and the file it was defined
+ in isn't compiled at the same time the file which contains its
+ use is */
+ if (DECL_DEPRECATED (decl)
+ && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
+ {
+ char the [20];
+ switch (TREE_CODE (decl))
+ {
+ case FUNCTION_DECL:
+ strcpy (the, "method");
+ break;
+ case FIELD_DECL:
+ strcpy (the, "field");
+ break;
+ case TYPE_DECL:
+ strcpy (the, "class");
+ break;
+ default:
+ fatal ("unexpected DECL code - check_deprecation");
+ }
+ parse_warning_context
+ (wfl, "The %s `%s' in class `%s' has been deprecated",
+ the, lang_printable_name (decl, 0),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
+ }
+}
+
+/* Returns 1 if class was declared in the current package, 0 otherwise */
+
+static int
+class_in_current_package (class)
+ tree class;
+{
+ static tree cache = NULL_TREE;
+ int qualified_flag;
+ tree left;
+
+ if (cache == class)
+ return 1;
+
+ qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
+
+ /* If the current package is empty and the name of CLASS is
+ qualified, class isn't in the current package. If there is a
+ current package and the name of the CLASS is not qualified, class
+ isn't in the current package */
+ if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
+ return 0;
+
+ /* If there is not package and the name of CLASS isn't qualified,
+ they belong to the same unnamed package */
+ if (!ctxp->package && !qualified_flag)
+ return 1;
+
+ /* Compare the left part of the name of CLASS with the package name */
+ breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
+ if (ctxp->package == left)
+ {
+ cache = class;
+ return 1;
+ }
+ return 0;
+}
+
+/* This function may generate code to access DECL from WHERE. This is
+ done only if certain conditions meet. */
+
+static tree
+maybe_access_field (decl, where, type)
+ tree decl, where, type;
+{
+ if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
+ && !FIELD_STATIC (decl))
+ decl = build_field_ref (where ? where : current_this,
+ (type ? type : DECL_CONTEXT (decl)),
+ DECL_NAME (decl));
+ return decl;
+}
+
+/* Build a method invocation, by patching PATCH. If non NULL
+ and according to the situation, PRIMARY and WHERE may be
+ used. IS_STATIC is set to 1 if the invoked function is static. */
+
+static tree
+patch_method_invocation (patch, primary, where, is_static, ret_decl)
+ tree patch, primary, where;
+ int *is_static;
+ tree *ret_decl;
+{
+ tree wfl = TREE_OPERAND (patch, 0);
+ tree args = TREE_OPERAND (patch, 1);
+ tree name = EXPR_WFL_NODE (wfl);
+ tree list;
+ int is_static_flag = 0;
+ int is_super_init = 0;
+ tree this_arg = NULL_TREE;
+
+ /* Should be overriden if everything goes well. Otherwise, if
+ something fails, it should keep this value. It stop the
+ evaluation of a bogus assignment. See java_complete_tree,
+ MODIFY_EXPR: for the reasons why we sometimes want to keep on
+ evaluating an assignment */
+ TREE_TYPE (patch) = error_mark_node;
+
+ /* Since lookup functions are messing with line numbers, save the
+ context now. */
+ java_parser_context_save_global ();
+
+ /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
+
+ /* Resolution of qualified name, excluding constructors */
+ if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
+ {
+ tree class_decl, identifier, identifier_wfl;
+ /* Extract the last IDENTIFIER of the qualified
+ expression. This is a wfl and we will use it's location
+ data during error report. */
+ identifier_wfl = cut_identifier_in_qualified (wfl);
+ identifier = EXPR_WFL_NODE (identifier_wfl);
+
+ /* Given the context, IDENTIFIER is syntactically qualified
+ as a MethodName. We need to qualify what's before */
+ qualify_ambiguous_name (wfl);
+
+ /* Package resolution */
+ if (RESOLVE_PACKAGE_NAME_P (wfl))
+ {
+ tree next, decl, name = resolve_package (wfl, &next);
+
+ if (!name)
+ {
+ tree remainder;
+ breakdown_qualified (&remainder, NULL, EXPR_WFL_NODE (wfl));
+ parse_error_context (wfl, "Can't search method `%s' in package "
+ "`%s'",IDENTIFIER_POINTER (identifier),
+ IDENTIFIER_POINTER (remainder));
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+ RESOLVE_PACKAGE_NAME_P (wfl) = 0;
+ if ((decl = resolve_no_layout (name, QUAL_WFL (next))))
+ {
+ QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl)) = decl;
+ RESOLVE_EXPRESSION_NAME_P (wfl) = 0;
+ RESOLVE_TYPE_NAME_P (wfl) = 1;
+ }
+ else
+ {
+ RESOLVE_EXPRESSION_NAME_P (wfl) = 1;
+ RESOLVE_TYPE_NAME_P (wfl) = 0;
+ }
+ }
+
+ /* We're resolving a call from a type */
+ if (RESOLVE_TYPE_NAME_P (wfl))
+ {
+ tree decl = QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl));
+ tree name = DECL_NAME (decl);
+ tree type;
+
+ class_decl = resolve_and_layout (name, wfl);
+ if (CLASS_INTERFACE (decl))
+ {
+ parse_error_context
+ (identifier_wfl, "Can't make static reference to method "
+ "`%s' in interface `%s'", IDENTIFIER_POINTER (identifier),
+ IDENTIFIER_POINTER (name));
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+ /* Look the method up in the type selector. The method ought
+ to be static. */
+ type = TREE_TYPE (class_decl);
+ list = lookup_method_invoke (0, wfl, type, identifier, args);
+ if (list && !METHOD_STATIC (list))
+ {
+ char *fct_name = strdup (lang_printable_name (list, 0));
+ parse_error_context
+ (identifier_wfl,
+ "Can't make static reference to method `%s %s' in class `%s'",
+ lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
+ fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ free (fct_name);
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+ args = nreverse (args);
+ }
+ /* We're resolving an expression name */
+ else
+ {
+ tree field, type;
+
+ /* 1- Find the field to which the call applies */
+ field = resolve_field_access (wfl, NULL, &type);
+ if (field == error_mark_node)
+ PATCH_METHOD_RETURN_ERROR ();
+ /* field is used in lieu of a primary. It alows us not to
+ report errors on erroneous use of `this' in
+ constructors. */
+ primary = field;
+
+ /* 2- Do the layout of the class where the last field
+ was found, so we can search it. */
+ class_decl = resolve_and_layout (type, NULL_TREE);
+ if (class_decl != NULL_TREE)
+ type = TREE_TYPE (class_decl);
+
+ /* 3- Retrieve a filtered list of method matches, Refine
+ if necessary. In any cases, point out errors. */
+ list = lookup_method_invoke (0, identifier_wfl, type,
+ identifier, args);
+
+ /* 4- Add the field as an argument */
+ args = nreverse (args);
+ this_arg = field;
+ }
+
+ /* IDENTIFIER_WFL will be used to report any problem further */
+ wfl = identifier_wfl;
+ }
+ /* Resolution of simple names, names generated after a primary: or
+ constructors */
+ else
+ {
+ tree class_to_search;
+ int lc; /* Looking for Constructor */
+
+ /* We search constructor in their target class */
+ if (CALL_CONSTRUCTOR_P (patch))
+ {
+ if (TREE_CODE (patch) == NEW_CLASS_EXPR)
+ class_to_search = EXPR_WFL_NODE (wfl);
+ else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
+ this_identifier_node)
+ class_to_search = NULL_TREE;
+ else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
+ super_identifier_node)
+ {
+ is_super_init = 1;
+ if (CLASSTYPE_SUPER (current_class))
+ class_to_search =
+ DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
+ else
+ {
+ parse_error_context (wfl, "Can't invoke super constructor "
+ "on java.lang.Object");
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+ }
+
+ /* Class to search is NULL if we're searching the current one */
+ if (class_to_search)
+ {
+ class_to_search = resolve_and_layout (class_to_search,
+ NULL_TREE);
+ if (!class_to_search)
+ {
+ parse_error_context
+ (wfl, "Class `%s' not found in type declaration",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+
+ /* Can't instantiate an abstract class, but we can
+ invoke it's constructor. It's use within the `new'
+ context is denied here. */
+ if (CLASS_ABSTRACT (class_to_search)
+ && TREE_CODE (patch) == NEW_CLASS_EXPR)
+ {
+ parse_error_context
+ (wfl, "Class `%s' is an abstract class. It can't be "
+ "instantiated", IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+ class_to_search = TREE_TYPE (class_to_search);
+ }
+ else
+ class_to_search = current_class;
+ lc = 1;
+ }
+ /* This is a regular search in the local class, unless an
+ alternate class is specified. */
+ else
+ {
+ class_to_search = (where ? where : current_class);
+ lc = 0;
+ }
+
+ /* NAME is a simple identifier or comes from a primary. Search
+ in the class whose declaration contain the method being
+ invoked. */
+ resolve_and_layout (class_to_search, NULL_TREE);
+ list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
+
+ /* Don't continue if no method were found, as the next statement
+ can't be executed then. */
+ if (!list)
+ PATCH_METHOD_RETURN_ERROR ();
+
+ /* Check for static reference if non static methods */
+ if (check_for_static_method_reference (wfl, patch, list,
+ class_to_search, primary))
+ PATCH_METHOD_RETURN_ERROR ();
+
+ /* Non static methods are called with the current object extra
+ argument. If patch a `new TYPE()', the argument is the value
+ returned by the object allocator. If method is resolved as a
+ primary, use the primary otherwise use the current THIS. */
+ args = nreverse (args);
+ if (TREE_CODE (patch) != NEW_CLASS_EXPR)
+ this_arg = primary ? primary : current_this;
+ }
+
+ /* Merge point of all resolution schemes. If we have nothing, this
+ is an error, already signaled */
+ if (!list)
+ PATCH_METHOD_RETURN_ERROR ();
+
+ /* Check accessibility, position the is_static flag, build and
+ return the call */
+ if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0))
+ {
+ char *fct_name = strdup (lang_printable_name (list, 0));
+ parse_error_context
+ (wfl, "Can't access %s method `%s %s.%s' from `%s'",
+ java_accstring_lookup (get_access_flags_from_decl (list)),
+ lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))),
+ fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ free (fct_name);
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+ check_deprecation (wfl, list);
+
+ is_static_flag = METHOD_STATIC (list);
+ if (! METHOD_STATIC (list) && this_arg != NULL_TREE)
+ args = tree_cons (NULL_TREE, this_arg, args);
+
+ /* In the context of an explicit constructor invocation, we can't
+ invoke any method relying on `this'. Exceptions are: we're
+ invoking a static function, primary exists and is not the current
+ this, we're creating a new object. */
+ if (ctxp->explicit_constructor_p
+ && !is_static_flag
+ && (!primary || primary == current_this)
+ && (TREE_CODE (patch) != NEW_CLASS_EXPR))
+ {
+ parse_error_context
+ (wfl, "Can't reference `this' before the superclass constructor has "
+ "been called");
+ PATCH_METHOD_RETURN_ERROR ();
+ }
+ java_parser_context_restore_global ();
+ if (is_static)
+ *is_static = is_static_flag;
+ /* Sometimes, we want the decl of the selected method. Such as for
+ EH checking */
+ if (ret_decl)
+ *ret_decl = list;
+ patch = patch_invoke (patch, list, args);
+ if (is_super_init && CLASS_HAS_FINIT_P (current_class))
+ {
+ /* Generate the code used to initialize fields declared with an
+ initialization statement. For now, it returns a call the the
+ artificial function $finit$, if required. */
+
+ tree finit_call =
+ build_method_invocation (build_expr_wfl (finit_identifier_node,
+ input_filename, 0, 0),
+ NULL_TREE);
+ patch = build (COMPOUND_EXPR, void_type_node, patch,
+ java_complete_tree (finit_call));
+ CAN_COMPLETE_NORMALLY (patch) = 1;
+ }
+ return patch;
+}
+
+/* Check that we're not trying to do a static reference to a method in
+ non static method. Return 1 if it's the case, 0 otherwise. */
+
+static int
+check_for_static_method_reference (wfl, node, method, where, primary)
+ tree wfl, node, method, where, primary;
+{
+ if (METHOD_STATIC (current_function_decl)
+ && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
+ {
+ char *fct_name = strdup (lang_printable_name (method, 0));
+ parse_error_context
+ (wfl, "Can't make static reference to method `%s %s' in class `%s'",
+ lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
+ free (fct_name);
+ return 1;
+ }
+ return 0;
+}
+
+/* Patch an invoke expression METHOD and ARGS, based on its invocation
+ mode. */
+
+static tree
+patch_invoke (patch, method, args)
+ tree patch, method, args;
+{
+ tree dtable, func;
+ tree original_call, t, ta;
+
+ /* Last step for args: convert build-in types. If we're dealing with
+ a new TYPE() type call, the first argument to the constructor
+ isn't found in the incomming argument list, but delivered by
+ `new' */
+ t = TYPE_ARG_TYPES (TREE_TYPE (method));
+ if (TREE_CODE (patch) == NEW_CLASS_EXPR)
+ t = TREE_CHAIN (t);
+ for (ta = args; t != end_params_node && ta;
+ t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
+ if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
+ TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
+ TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
+
+ if (flag_emit_class_files || flag_emit_xref)
+ func = method;
+ else
+ {
+ tree signature = build_java_signature (TREE_TYPE (method));
+ switch (invocation_mode (method, CALL_USING_SUPER (patch)))
+ {
+ case INVOKE_VIRTUAL:
+ dtable = invoke_build_dtable (0, args);
+ func = build_invokevirtual (dtable, method);
+ break;
+
+ case INVOKE_SUPER:
+ case INVOKE_STATIC:
+ func = build_known_method_ref (method, TREE_TYPE (method),
+ DECL_CONTEXT (method),
+ signature, args);
+ break;
+
+ case INVOKE_INTERFACE:
+ dtable = invoke_build_dtable (1, args);
+ func = build_invokeinterface (dtable, DECL_NAME (method), signature);
+ break;
+
+ default:
+ fatal ("internal error - unknown invocation_mode result");
+ }
+
+ /* Ensure self_type is initialized, (invokestatic). FIXME */
+ func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
+ }
+
+ TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
+ TREE_OPERAND (patch, 0) = func;
+ TREE_OPERAND (patch, 1) = args;
+ original_call = patch;
+
+ /* We're processing a `new TYPE ()' form. New is called an its
+ returned value is the first argument to the constructor. We build
+ a COMPOUND_EXPR and use saved expression so that the overall NEW
+ expression value is a pointer to a newly created and initialized
+ class. */
+ if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
+ {
+ tree class = DECL_CONTEXT (method);
+ tree c1, saved_new, size, new;
+ if (flag_emit_class_files || flag_emit_xref)
+ {
+ TREE_TYPE (patch) = build_pointer_type (class);
+ return patch;
+ }
+ if (!TYPE_SIZE (class))
+ safe_layout_class (class);
+ size = size_in_bytes (class);
+ new = build (CALL_EXPR, promote_type (class),
+ build_address_of (alloc_object_node),
+ tree_cons (NULL_TREE, build_class_ref (class),
+ build_tree_list (NULL_TREE,
+ size_in_bytes (class))),
+ NULL_TREE);
+ saved_new = save_expr (new);
+ c1 = build_tree_list (NULL_TREE, saved_new);
+ TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
+ TREE_OPERAND (original_call, 1) = c1;
+ TREE_SET_CODE (original_call, CALL_EXPR);
+ patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
+ }
+ return patch;
+}
+
+static int
+invocation_mode (method, super)
+ tree method;
+ int super;
+{
+ int access = get_access_flags_from_decl (method);
+
+ if (super)
+ return INVOKE_SUPER;
+
+ if (access & ACC_STATIC || access & ACC_FINAL || access & ACC_PRIVATE)
+ return INVOKE_STATIC;
+
+ if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
+ return INVOKE_STATIC;
+
+ if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
+ return INVOKE_INTERFACE;
+
+ if (DECL_CONSTRUCTOR_P (method))
+ return INVOKE_STATIC;
+
+ return INVOKE_VIRTUAL;
+}
+
+/* Retrieve a refined list of matching methods. It covers the step
+ 15.11.2 (Compile-Time Step 2) */
+
+static tree
+lookup_method_invoke (lc, cl, class, name, arg_list)
+ int lc;
+ tree cl;
+ tree class, name, arg_list;
+{
+ tree atl = end_params_node; /* Arg Type List */
+ tree method, signature, list, node;
+ char *candidates; /* Used for error report */
+
+ /* Fix the arguments */
+ for (node = arg_list; node; node = TREE_CHAIN (node))
+ {
+ tree current_arg = TREE_TYPE (TREE_VALUE (node));
+ /* Non primitive type may have to be resolved */
+ if (!JPRIMITIVE_TYPE_P (current_arg))
+ resolve_and_layout (current_arg, NULL_TREE);
+ /* And promoted */
+ if (TREE_CODE (current_arg) == RECORD_TYPE)
+ current_arg = promote_type (current_arg);
+ atl = tree_cons (NULL_TREE, current_arg, atl);
+ }
+
+ /* Find all candidates and then refine the list, searching for the
+ most specific method. */
+ list = find_applicable_accessible_methods_list (lc, class, name, atl);
+ list = find_most_specific_methods_list (list);
+ if (list && !TREE_CHAIN (list))
+ return TREE_VALUE (list);
+
+ /* Issue an error. List candidates if any. Candidates are listed
+ only if accessible (non accessible methods may end-up here for
+ the sake of a better error report). */
+ candidates = NULL;
+ if (list)
+ {
+ tree current;
+ obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
+ for (current = list; current; current = TREE_CHAIN (current))
+ {
+ tree cm = TREE_VALUE (current);
+ char string [4096];
+ if (!cm || not_accessible_p (class, cm, 0))
+ continue;
+ sprintf
+ (string, " `%s' in `%s'%s",
+ get_printable_method_name (cm),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
+ (TREE_CHAIN (current) ? "\n" : ""));
+ obstack_grow (&temporary_obstack, string, strlen (string));
+ }
+ obstack_1grow (&temporary_obstack, '\0');
+ candidates = obstack_finish (&temporary_obstack);
+ }
+ /* Issue the error message */
+ method = make_node (FUNCTION_TYPE);
+ TYPE_ARG_TYPES (method) = atl;
+ signature = build_java_argument_signature (method);
+ parse_error_context (cl, "Can't find %s `%s(%s)' in class `%s'%s",
+ (lc ? "constructor" : "method"),
+ (lc ?
+ IDENTIFIER_POINTER(DECL_NAME (TYPE_NAME (class))) :
+ IDENTIFIER_POINTER (name)),
+ IDENTIFIER_POINTER (signature),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class))),
+ (candidates ? candidates : ""));
+ return NULL_TREE;
+}
+
+/* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
+ when we're looking for a constructor. */
+
+static tree
+find_applicable_accessible_methods_list (lc, class, name, arglist)
+ int lc;
+ tree class, name, arglist;
+{
+ tree list = NULL_TREE, all_list = NULL_TREE;
+
+ /* Search interfaces */
+ if (CLASS_INTERFACE (TYPE_NAME (class)))
+ {
+ static tree searched_interfaces = NULL_TREE;
+ static int search_not_done = 0;
+ int i, n;
+ tree basetype_vec = TYPE_BINFO_BASETYPES (class);
+
+ /* Have we searched this interface already? */
+ if (searched_interfaces)
+ {
+ tree current;
+ for (current = searched_interfaces;
+ current; current = TREE_CHAIN (current))
+ if (TREE_VALUE (current) == class)
+ return NULL;
+ }
+ searched_interfaces = tree_cons (NULL_TREE, class, searched_interfaces);
+
+ search_applicable_methods_list
+ (lc, TYPE_METHODS (class), name, arglist, &list, &all_list);
+
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
+ tree rlist;
+
+ /* Skip java.lang.Object (we'll search it once later.) */
+ if (t == object_type_node)
+ continue;
+
+ search_not_done++;
+ rlist = find_applicable_accessible_methods_list (lc, t, name,
+ arglist);
+ all_list = chainon (rlist, (list ? list : all_list));
+ search_not_done--;
+ }
+
+ /* We're done. Reset the searched interfaces list and finally search
+ java.lang.Object */
+ if (!search_not_done)
+ {
+ searched_interfaces = NULL_TREE;
+ search_applicable_methods_list (lc, TYPE_METHODS (object_type_node),
+ name, arglist, &list, &all_list);
+ }
+ }
+ /* Search classes */
+ else
+ while (class != NULL_TREE)
+ {
+ search_applicable_methods_list
+ (lc, TYPE_METHODS (class), name, arglist, &list, &all_list);
+ class = (lc ? NULL_TREE : CLASSTYPE_SUPER (class));
+ }
+
+ /* Either return the list obtained or all selected (but
+ inaccessible) methods for better error report. */
+ return (!list ? all_list : list);
+}
+
+/* Effectively search for the approriate method in method */
+
+static void
+search_applicable_methods_list(lc, method, name, arglist, list, all_list)
+ int lc;
+ tree method, name, arglist;
+ tree *list, *all_list;
+{
+ for (; method; method = TREE_CHAIN (method))
+ {
+ /* When dealing with constructor, stop here, otherwise search
+ other classes */
+ if (lc && !DECL_CONSTRUCTOR_P (method))
+ continue;
+ else if (!lc && (DECL_CONSTRUCTOR_P (method)
+ || (GET_METHOD_NAME (method) != name)))
+ continue;
+
+ if (argument_types_convertible (method, arglist))
+ {
+ /* Retain accessible methods only */
+ if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
+ method, 0))
+ *list = tree_cons (NULL_TREE, method, *list);
+ else
+ /* Also retain all selected method here */
+ *all_list = tree_cons (NULL_TREE, method, *list);
+ }
+ }
+}
+
+/* 15.11.2.2 Choose the Most Specific Method */
+
+static tree
+find_most_specific_methods_list (list)
+ tree list;
+{
+ int max = 0;
+ tree current, new_list = NULL_TREE;
+ for (current = list; current; current = TREE_CHAIN (current))
+ {
+ tree method;
+ DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
+
+ for (method = list; method; method = TREE_CHAIN (method))
+ {
+ /* Don't test a method against itself */
+ if (method == current)
+ continue;
+
+ /* Compare arguments and location where method where declared */
+ if (argument_types_convertible (TREE_VALUE (method),
+ TREE_VALUE (current))
+ && valid_method_invocation_conversion_p
+ (DECL_CONTEXT (TREE_VALUE (method)),
+ DECL_CONTEXT (TREE_VALUE (current))))
+ {
+ int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current));
+ max = (v > max ? v : max);
+ }
+ }
+ }
+
+ /* Review the list and select the maximally specific methods */
+ for (current = list; current; current = TREE_CHAIN (current))
+ if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
+ new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
+
+ /* If we can't find one, lower expectations and try to gather multiple
+ maximally specific methods */
+ while (!new_list)
+ {
+ while (--max > 0)
+ {
+ if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
+ new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
+ }
+ return new_list;
+ }
+
+ return new_list;
+}
+
+/* Make sure that the type of each M2_OR_ARGLIST arguments can be
+ converted by method invocation conversion (5.3) to the type of the
+ corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
+ to change less often than M1. */
+
+static int
+argument_types_convertible (m1, m2_or_arglist)
+ tree m1, m2_or_arglist;
+{
+ static tree m2_arg_value = NULL_TREE;
+ static tree m2_arg_cache = NULL_TREE;
+
+ register tree m1_arg, m2_arg;
+
+ m1_arg = TYPE_ARG_TYPES (TREE_TYPE (m1));
+ if (!METHOD_STATIC (m1))
+ m1_arg = TREE_CHAIN (m1_arg);
+
+ if (m2_arg_value == m2_or_arglist)
+ m2_arg = m2_arg_cache;
+ else
+ {
+ /* M2_OR_ARGLIST can be a function DECL or a raw list of
+ argument types */
+ if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
+ {
+ m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
+ if (!METHOD_STATIC (m2_or_arglist))
+ m2_arg = TREE_CHAIN (m2_arg);
+ }
+ else
+ m2_arg = m2_or_arglist;
+
+ m2_arg_value = m2_or_arglist;
+ m2_arg_cache = m2_arg;
+ }
+
+ while (m1_arg != end_params_node && m2_arg != end_params_node)
+ {
+ resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
+ if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
+ TREE_VALUE (m2_arg)))
+ break;
+ m1_arg = TREE_CHAIN (m1_arg);
+ m2_arg = TREE_CHAIN (m2_arg);
+ }
+ return m1_arg == end_params_node && m2_arg == end_params_node;
+}
+
+/* Qualification routines */
+
+static void
+qualify_ambiguous_name (id)
+ tree id;
+{
+ tree qual, qual_wfl, name, decl, ptr_type, saved_current_class;
+ int again, super_found = 0, this_found = 0, new_array_found = 0;
+ int code;
+
+ /* We first qualify the first element, then derive qualification of
+ others based on the first one. If the first element is qualified
+ by a resolution (field or type), this resolution is stored in the
+ QUAL_RESOLUTION of the qual element being examined. We need to
+ save the current_class since the use of SUPER might change the
+ its value. */
+ saved_current_class = current_class;
+ qual = EXPR_WFL_QUALIFICATION (id);
+ do {
+
+ /* Simple qualified expression feature a qual_wfl that is a
+ WFL. Expression derived from a primary feature more complicated
+ things like a CALL_EXPR. Expression from primary need to be
+ worked out to extract the part on which the qualification will
+ take place. */
+ qual_wfl = QUAL_WFL (qual);
+ switch (TREE_CODE (qual_wfl))
+ {
+ case CALL_EXPR:
+ qual_wfl = TREE_OPERAND (qual_wfl, 0);
+ if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
+ {
+ qual = EXPR_WFL_QUALIFICATION (qual_wfl);
+ qual_wfl = QUAL_WFL (qual);
+ }
+ break;
+ case NEW_ARRAY_EXPR:
+ qual = TREE_CHAIN (qual);
+ new_array_found = 1;
+ continue;
+ case NEW_CLASS_EXPR:
+ case CONVERT_EXPR:
+ qual_wfl = TREE_OPERAND (qual_wfl, 0);
+ break;
+ case ARRAY_REF:
+ while (TREE_CODE (qual_wfl) == ARRAY_REF)
+ qual_wfl = TREE_OPERAND (qual_wfl, 0);
+ break;
+ case STRING_CST:
+ qual = TREE_CHAIN (qual);
+ qual_wfl = QUAL_WFL (qual);
+ break;
+ default:
+ /* Fix for -Wall. Just break doing nothing */
+ break;
+ }
+
+ ptr_type = current_class;
+ again = 0;
+ code = TREE_CODE (qual_wfl);
+
+ /* Pos evaluation: non WFL leading expression nodes */
+ if (code == CONVERT_EXPR
+ && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
+ name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
+
+ else if (code == ARRAY_REF &&
+ TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
+ name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
+
+ else if (code == CALL_EXPR &&
+ TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
+ name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
+
+ else if (code == STRING_CST || code == CONDITIONAL_EXPR)
+ {
+ qual = TREE_CHAIN (qual);
+ qual_wfl = QUAL_WFL (qual);
+ again = 1;
+ }
+ else
+ name = EXPR_WFL_NODE (qual_wfl);
+
+ /* If we have a THIS (from a primary), we set the context accordingly */
+ if (name == this_identifier_node)
+ {
+ qual = TREE_CHAIN (qual);
+ qual_wfl = QUAL_WFL (qual);
+ if (TREE_CODE (qual_wfl) == CALL_EXPR)
+ again = 1;
+ else
+ name = EXPR_WFL_NODE (qual_wfl);
+ this_found = 1;
+ }
+ /* If we have a SUPER, we set the context accordingly */
+ if (name == super_identifier_node)
+ {
+ current_class = CLASSTYPE_SUPER (ptr_type);
+ /* Check that there is such a thing as a super class. If not,
+ return. The error will be caught later on, during the
+ resolution */
+ if (!current_class)
+ {
+ current_class = saved_current_class;
+ return;
+ }
+ qual = TREE_CHAIN (qual);
+ /* Do one more interation to set things up */
+ super_found = again = 1;
+ }
+ } while (again);
+
+ /* If name appears within the scope of a location variable
+ declaration or parameter declaration, then it is an expression
+ name. We don't carry this test out if we're in the context of the
+ use of SUPER or THIS */
+ if (!this_found && !super_found && (decl = IDENTIFIER_LOCAL_VALUE (name)))
+ {
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* If within the class/interface NAME was found to be used there
+ exists a (possibly inherited) field named NAME, then this is an
+ expression name. If we saw a NEW_ARRAY_EXPR before and want to
+ address length, it is OK. */
+ else if ((decl = lookup_field_wrapper (ptr_type, name))
+ || (new_array_found && name == length_identifier_node))
+ {
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
+ }
+
+ /* We reclassify NAME as a type name if:
+ - NAME is a class/interface declared within the compilation
+ unit containing NAME,
+ - NAME is imported via a single-type-import declaration,
+ - NAME is declared in an another compilation unit of the package
+ of the compilation unit containing NAME,
+ - NAME is declared by exactly on type-import-on-demand declaration
+ of the compilation unit containing NAME. */
+ else if ((decl = resolve_and_layout (name, NULL_TREE)))
+ {
+ RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* Method call are expression name */
+ else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
+ || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
+ || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR)
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+
+ /* Check here that NAME isn't declared by more than one
+ type-import-on-demand declaration of the compilation unit
+ containing NAME. FIXME */
+
+ /* Otherwise, NAME is reclassified as a package name */
+ else
+ RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
+
+ /* Propagate the qualification accross other components of the
+ qualified name */
+ for (qual = TREE_CHAIN (qual); qual;
+ qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
+ {
+ if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
+ else
+ RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
+ }
+
+ /* Store the global qualification for the ambiguous part of ID back
+ into ID fields */
+ if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
+ RESOLVE_EXPRESSION_NAME_P (id) = 1;
+ else if (RESOLVE_TYPE_NAME_P (qual_wfl))
+ RESOLVE_TYPE_NAME_P (id) = 1;
+ else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ RESOLVE_PACKAGE_NAME_P (id) = 1;
+
+ /* Restore the current class */
+ current_class = saved_current_class;
+}
+
+static int
+breakdown_qualified (left, right, source)
+ tree *left, *right, source;
+{
+ char *p = IDENTIFIER_POINTER (source), *base;
+ int l = IDENTIFIER_LENGTH (source);
+
+ /* Breakdown NAME into REMAINDER . IDENTIFIER */
+ base = p;
+ p += (l-1);
+ while (*p != '.' && p != base)
+ p--;
+
+ /* We didn't find a '.'. Return an error */
+ if (p == base)
+ return 1;
+
+ *p = '\0';
+ if (right)
+ *right = get_identifier (p+1);
+ *left = get_identifier (IDENTIFIER_POINTER (source));
+ *p = '.';
+
+ return 0;
+}
+
+/* Patch tree nodes in a function body. When a BLOCK is found, push
+ local variable decls if present.
+ Same as java_complete_lhs, but does resolve static finals to values. */
+
+static tree
+java_complete_tree (node)
+ tree node;
+{
+ node = java_complete_lhs (node);
+ if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node)
+ && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE
+ && !flag_emit_xref)
+ {
+ tree value = DECL_INITIAL (node);
+ DECL_INITIAL (node) = NULL_TREE;
+ value = fold_constant_for_init (value, node);
+ DECL_INITIAL (node) = value;
+ if (value != NULL_TREE)
+ return value;
+ }
+ return node;
+}
+
+static tree
+java_stabilize_reference (node)
+ tree node;
+{
+ if (TREE_CODE (node) == COMPOUND_EXPR)
+ {
+ tree op0 = TREE_OPERAND (node, 0);
+ tree op1 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 0) = save_expr (op0);
+ TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
+ return node;
+ }
+ else
+ return stabilize_reference (node);
+}
+
+/* Patch tree nodes in a function body. When a BLOCK is found, push
+ local variable decls if present.
+ Same as java_complete_tree, but does not resolve static finals to values. */
+
+static tree
+java_complete_lhs (node)
+ tree node;
+{
+ tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
+ int flag;
+
+ /* CONVERT_EXPR always has its type set, even though it needs to be
+ worked out. */
+ if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
+ return node;
+
+ /* The switch block implements cases processing container nodes
+ first. Contained nodes are always written back. Leaves come
+ next and return a value. */
+ switch (TREE_CODE (node))
+ {
+ case BLOCK:
+
+ /* 1- Block section.
+ Set the local values on decl names so we can identify them
+ faster when they're referenced. At that stage, identifiers
+ are legal so we don't check for declaration errors. */
+ for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
+ {
+ DECL_CONTEXT (cn) = current_function_decl;
+ IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
+ }
+ if (BLOCK_EXPR_BODY (node) == NULL_TREE)
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ else
+ {
+ tree stmt = BLOCK_EXPR_BODY (node);
+ tree *ptr;
+ int error_seen = 0;
+ if (TREE_CODE (stmt) == COMPOUND_EXPR)
+ {
+ /* Re-order from (((A; B); C); ...; Z) to
+ (A; (B; (C ; (...; Z)))).
+ This makes it easier to scan the statements left-to-right
+ without using recursion (which might overflow the stack
+ if the block has many statements. */
+ for (;;)
+ {
+ tree left = TREE_OPERAND (stmt, 0);
+ if (TREE_CODE (left) != COMPOUND_EXPR)
+ break;
+ TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
+ TREE_OPERAND (left, 1) = stmt;
+ stmt = left;
+ }
+ BLOCK_EXPR_BODY (node) = stmt;
+ }
+
+ /* Now do the actual complete, without deep recursion for
+ long blocks. */
+ ptr = &BLOCK_EXPR_BODY (node);
+ while (TREE_CODE (*ptr) == COMPOUND_EXPR
+ && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
+ {
+ tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
+ tree *next = &TREE_OPERAND (*ptr, 1);
+ TREE_OPERAND (*ptr, 0) = cur;
+ if (cur == empty_stmt_node)
+ {
+ /* Optimization; makes it easier to detect empty bodies.
+ Most useful for <clinit> with all-constant initializer. */
+ *ptr = *next;
+ continue;
+ }
+ if (TREE_CODE (cur) == ERROR_MARK)
+ error_seen++;
+ else if (! CAN_COMPLETE_NORMALLY (cur))
+ {
+ wfl_op2 = *next;
+ for (;;)
+ {
+ if (TREE_CODE (wfl_op2) == BLOCK)
+ wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
+ else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
+ wfl_op2 = TREE_OPERAND (wfl_op2, 0);
+ else
+ break;
+ }
+ if (TREE_CODE (wfl_op2) != CASE_EXPR
+ && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
+ unreachable_stmt_error (*ptr);
+ }
+ ptr = next;
+ }
+ *ptr = java_complete_tree (*ptr);
+
+ if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
+ return error_mark_node;
+ CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
+ }
+ /* Turn local bindings to null */
+ for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
+ IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
+
+ TREE_TYPE (node) = void_type_node;
+ break;
+
+ /* 2- They are expressions but ultimately deal with statements */
+
+ case THROW_EXPR:
+ wfl_op1 = TREE_OPERAND (node, 0);
+ COMPLETE_CHECK_OP_0 (node);
+ /* CAN_COMPLETE_NORMALLY (node) = 0; */
+ return patch_throw_statement (node, wfl_op1);
+
+ case SYNCHRONIZED_EXPR:
+ wfl_op1 = TREE_OPERAND (node, 0);
+ return patch_synchronized_statement (node, wfl_op1);
+
+ case TRY_EXPR:
+ return patch_try_statement (node);
+
+ case TRY_FINALLY_EXPR:
+ COMPLETE_CHECK_OP_0 (node);
+ COMPLETE_CHECK_OP_1 (node);
+ CAN_COMPLETE_NORMALLY (node)
+ = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
+ && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
+ TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
+ return node;
+
+ case CLEANUP_POINT_EXPR:
+ COMPLETE_CHECK_OP_0 (node);
+ TREE_TYPE (node) = void_type_node;
+ CAN_COMPLETE_NORMALLY (node) =
+ CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
+ return node;
+
+ case WITH_CLEANUP_EXPR:
+ COMPLETE_CHECK_OP_0 (node);
+ COMPLETE_CHECK_OP_2 (node);
+ CAN_COMPLETE_NORMALLY (node) =
+ CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
+ TREE_TYPE (node) = void_type_node;
+ return node;
+
+ case LABELED_BLOCK_EXPR:
+ PUSH_LABELED_BLOCK (node);
+ if (LABELED_BLOCK_BODY (node))
+ COMPLETE_CHECK_OP_1 (node);
+ TREE_TYPE (node) = void_type_node;
+ POP_LABELED_BLOCK ();
+
+ if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
+ {
+ LABELED_BLOCK_BODY (node) = NULL_TREE;
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ }
+ else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ return node;
+
+ case EXIT_BLOCK_EXPR:
+ /* We don't complete operand 1, because it's the return value of
+ the EXIT_BLOCK_EXPR which doesn't exist it Java */
+ return patch_bc_statement (node);
+
+ case CASE_EXPR:
+ cn = java_complete_tree (TREE_OPERAND (node, 0));
+ if (cn == error_mark_node)
+ return cn;
+
+ /* First, the case expression must be constant. Values of final
+ fields are accepted. */
+ cn = fold (cn);
+ if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
+ && JDECL_P (TREE_OPERAND (cn, 1))
+ && FIELD_FINAL (TREE_OPERAND (cn, 1))
+ && DECL_INITIAL (TREE_OPERAND (cn, 1)))
+ cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
+ TREE_OPERAND (cn, 1));
+
+ if (!TREE_CONSTANT (cn) && !flag_emit_xref)
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context (node, "Constant expression required");
+ return error_mark_node;
+ }
+
+ nn = ctxp->current_loop;
+
+ /* It must be assignable to the type of the switch expression. */
+ if (!try_builtin_assignconv (NULL_TREE,
+ TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context
+ (wfl_operator,
+ "Incompatible type for case. Can't convert `%s' to `int'",
+ lang_printable_name (TREE_TYPE (cn), 0));
+ return error_mark_node;
+ }
+
+ cn = fold (convert (int_type_node, cn));
+
+ /* Multiple instance of a case label bearing the same
+ value is checked during code generation. The case
+ expression is allright so far. */
+ TREE_OPERAND (node, 0) = cn;
+ TREE_TYPE (node) = void_type_node;
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ TREE_SIDE_EFFECTS (node) = 1;
+ break;
+
+ case DEFAULT_EXPR:
+ nn = ctxp->current_loop;
+ /* Only one default label is allowed per switch statement */
+ if (SWITCH_HAS_DEFAULT (nn))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context (wfl_operator,
+ "Duplicate case label: `default'");
+ return error_mark_node;
+ }
+ else
+ SWITCH_HAS_DEFAULT (nn) = 1;
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ break;
+
+ case SWITCH_EXPR:
+ case LOOP_EXPR:
+ PUSH_LOOP (node);
+ /* Check whether the loop was enclosed in a labeled
+ statement. If not, create one, insert the loop in it and
+ return the node */
+ nn = patch_loop_statement (node);
+
+ /* Anyways, walk the body of the loop */
+ if (TREE_CODE (node) == LOOP_EXPR)
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ /* Switch statement: walk the switch expression and the cases */
+ else
+ node = patch_switch_statement (node);
+
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ nn = error_mark_node;
+ else
+ {
+ TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
+ /* If we returned something different, that's because we
+ inserted a label. Pop the label too. */
+ if (nn != node)
+ {
+ if (CAN_COMPLETE_NORMALLY (node))
+ CAN_COMPLETE_NORMALLY (nn) = 1;
+ POP_LABELED_BLOCK ();
+ }
+ }
+ POP_LOOP ();
+ return nn;
+
+ case EXIT_EXPR:
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ return patch_exit_expr (node);
+
+ case COND_EXPR:
+ /* Condition */
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ /* then-else branches */
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
+ if (TREE_OPERAND (node, 2) == error_mark_node)
+ return error_mark_node;
+ return patch_if_else_statement (node);
+ break;
+
+ case CONDITIONAL_EXPR:
+ /* Condition */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ COMPLETE_CHECK_OP_0 (node);
+ wfl_op2 = TREE_OPERAND (node, 1);
+ COMPLETE_CHECK_OP_1 (node);
+ wfl_op3 = TREE_OPERAND (node, 2);
+ COMPLETE_CHECK_OP_2 (node);
+ return patch_conditional_expr (node, wfl_op1, wfl_op2);
+
+ /* 3- Expression section */
+ case COMPOUND_EXPR:
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 0) = nn =
+ java_complete_tree (TREE_OPERAND (node, 0));
+ if (wfl_op2 == empty_stmt_node)
+ CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
+ else
+ {
+ if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
+ {
+ /* An unreachable condition in a do-while statement
+ is *not* (technically) an unreachable statement. */
+ nn = wfl_op2;
+ if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
+ nn = EXPR_WFL_NODE (nn);
+ if (TREE_CODE (nn) != EXIT_EXPR)
+ {
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
+ parse_error_context (wfl_operator, "Unreachable statement");
+ }
+ }
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ CAN_COMPLETE_NORMALLY (node)
+ = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
+ }
+ TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
+ break;
+
+ case RETURN_EXPR:
+ /* CAN_COMPLETE_NORMALLY (node) = 0; */
+ return patch_return (node);
+
+ case EXPR_WITH_FILE_LOCATION:
+ if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
+ || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
+ {
+ tree wfl = node;
+ node = resolve_expression_name (node, NULL);
+ if (node == error_mark_node)
+ return node;
+ /* Keep line number information somewhere were it doesn't
+ disrupt the completion process. */
+ if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
+ {
+ EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 1) = wfl;
+ }
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ }
+ else
+ {
+ tree body;
+ int save_lineno = lineno;
+ lineno = EXPR_WFL_LINENO (node);
+ body = java_complete_tree (EXPR_WFL_NODE (node));
+ lineno = save_lineno;
+ EXPR_WFL_NODE (node) = body;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
+ CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
+ if (body == empty_stmt_node)
+ {
+ /* Optimization; makes it easier to detect empty bodies. */
+ return body;
+ }
+ if (body == error_mark_node)
+ {
+ /* Its important for the evaluation of assignment that
+ this mark on the TREE_TYPE is propagated. */
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ else
+ TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
+
+ }
+ break;
+
+ case NEW_ARRAY_EXPR:
+ /* Patch all the dimensions */
+ flag = 0;
+ for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
+ {
+ int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
+ tree dim = java_complete_tree (TREE_VALUE (cn));
+ if (dim == error_mark_node)
+ {
+ flag = 1;
+ continue;
+ }
+ else
+ {
+ TREE_VALUE (cn) = dim;
+ /* Setup the location of the current dimension, for
+ later error report. */
+ TREE_PURPOSE (cn) =
+ build_expr_wfl (NULL_TREE, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
+ }
+ }
+ /* They complete the array creation expression, if no errors
+ were found. */
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ return (flag ? error_mark_node
+ : force_evaluation_order (patch_newarray (node)));
+
+ case NEW_CLASS_EXPR:
+ case CALL_EXPR:
+ /* Complete function's argument(s) first */
+ if (complete_function_arguments (node))
+ return error_mark_node;
+ else
+ {
+ tree decl, wfl = TREE_OPERAND (node, 0);
+ int in_this = CALL_THIS_CONSTRUCTOR_P (node);
+
+ node = patch_method_invocation (node, NULL_TREE,
+ NULL_TREE, 0, &decl);
+ if (node == error_mark_node)
+ return error_mark_node;
+
+ check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
+ /* If we call this(...), register signature and positions */
+ if (in_this)
+ DECL_CONSTRUCTOR_CALLS (current_function_decl) =
+ tree_cons (wfl, decl,
+ DECL_CONSTRUCTOR_CALLS (current_function_decl));
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ return force_evaluation_order (node);
+ }
+
+ case MODIFY_EXPR:
+ /* Save potential wfls */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
+ if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
+ && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
+ && DECL_INITIAL (nn) != NULL_TREE)
+ {
+ tree value = fold_constant_for_init (nn, nn);
+ if (value != NULL_TREE)
+ {
+ tree type = TREE_TYPE (value);
+ if (JPRIMITIVE_TYPE_P (type) || type == string_ptr_type_node)
+ return empty_stmt_node;
+ }
+ DECL_INITIAL (nn) = NULL_TREE;
+ }
+ wfl_op2 = TREE_OPERAND (node, 1);
+
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+
+ if (COMPOUND_ASSIGN_P (wfl_op2))
+ {
+ tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
+
+ /* Hand stablize the lhs on both places */
+ TREE_OPERAND (node, 0) = lvalue;
+ TREE_OPERAND (TREE_OPERAND (node, 1), 0) = lvalue;
+
+ /* Now complete the RHS. We write it back later on. */
+ nn = java_complete_tree (TREE_OPERAND (node, 1));
+
+ if ((cn = patch_string (nn)))
+ nn = cn;
+
+ /* The last part of the rewrite for E1 op= E2 is to have
+ E1 = (T)(E1 op E2), with T being the type of E1. */
+ nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
+ TREE_TYPE (lvalue), nn));
+ }
+
+ /* If we're about to patch a NEW_ARRAY_INIT, we call a special
+ function to complete this RHS */
+ else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT)
+ nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
+ TREE_OPERAND (node, 1));
+ /* Otherwise we simply complete the RHS */
+ else
+ nn = java_complete_tree (TREE_OPERAND (node, 1));
+
+ if (nn == error_mark_node)
+ return error_mark_node;
+
+ /* Write back the RHS as we evaluated it. */
+ TREE_OPERAND (node, 1) = nn;
+
+ /* In case we're handling = with a String as a RHS, we need to
+ produce a String out of the RHS (it might still be a
+ STRING_CST or a StringBuffer at this stage */
+ if ((nn = patch_string (TREE_OPERAND (node, 1))))
+ TREE_OPERAND (node, 1) = nn;
+ node = patch_assignment (node, wfl_op1, wfl_op2);
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ return node;
+
+ case MULT_EXPR:
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ case TRUNC_MOD_EXPR:
+ case RDIV_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case EQ_EXPR:
+ case NE_EXPR:
+ case GT_EXPR:
+ case GE_EXPR:
+ case LT_EXPR:
+ case LE_EXPR:
+ /* Operands 0 and 1 are WFL in certain cases only. patch_binop
+ knows how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ wfl_op2 = TREE_OPERAND (node, 1);
+
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ /* Don't complete string nodes if dealing with the PLUS operand. */
+ if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
+ {
+ nn = java_complete_tree (wfl_op1);
+ if (nn == error_mark_node)
+ return error_mark_node;
+ if ((cn = patch_string (nn)))
+ nn = cn;
+ TREE_OPERAND (node, 0) = nn;
+ }
+ if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
+ {
+ nn = java_complete_tree (wfl_op2);
+ if (nn == error_mark_node)
+ return error_mark_node;
+ if ((cn = patch_string (nn)))
+ nn = cn;
+ TREE_OPERAND (node, 1) = nn;
+ }
+ return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
+
+ case INSTANCEOF_EXPR:
+ wfl_op1 = TREE_OPERAND (node, 0);
+ COMPLETE_CHECK_OP_0 (node);
+ if (flag_emit_xref)
+ {
+ TREE_TYPE (node) = boolean_type_node;
+ return node;
+ }
+ return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
+
+ case UNARY_PLUS_EXPR:
+ case NEGATE_EXPR:
+ case TRUTH_NOT_EXPR:
+ case BIT_NOT_EXPR:
+ case PREDECREMENT_EXPR:
+ case PREINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
+ case POSTINCREMENT_EXPR:
+ case CONVERT_EXPR:
+ /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
+ how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ node = patch_unaryop (node, wfl_op1);
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ break;
+
+ case ARRAY_REF:
+ /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
+ how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ if (!flag_emit_class_files && !flag_emit_xref)
+ TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
+ /* The same applies to wfl_op2 */
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ if (!flag_emit_class_files && !flag_emit_xref)
+ TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
+ return patch_array_ref (node);
+
+ case RECORD_TYPE:
+ return node;;
+
+ case COMPONENT_REF:
+ /* The first step in the re-write of qualified name handling. FIXME.
+ So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
+ {
+ tree name = TREE_OPERAND (node, 1);
+ tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
+ if (field == NULL_TREE)
+ {
+ error ("missing static field `%s'", IDENTIFIER_POINTER (name));
+ return error_mark_node;
+ }
+ if (! FIELD_STATIC (field))
+ {
+ error ("not a static field `%s'", IDENTIFIER_POINTER (name));
+ return error_mark_node;
+ }
+ return field;
+ }
+ else
+ fatal ("unimplemented java_complete_tree for COMPONENT_REF");
+ break;
+
+ case THIS_EXPR:
+ /* Can't use THIS in a static environment */
+ if (!current_this)
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context (wfl_operator, "Keyword `this' used outside "
+ "allowed context");
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ if (ctxp->explicit_constructor_p)
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context
+ (wfl_operator, "Can't reference `this' or `super' before the "
+ "superclass constructor has been called");
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ return current_this;
+
+ default:
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
+ and it's time to turn it into the appropriate String object
+ */
+ if ((node = patch_string (node)))
+ return node;
+ fatal ("No case for tree code `%s' - java_complete_tree\n",
+ tree_code_name [TREE_CODE (node)]);
+ }
+ return node;
+}
+
+/* Complete function call's argument. Return a non zero value is an
+ error was found. */
+
+static int
+complete_function_arguments (node)
+ tree node;
+{
+ int flag = 0;
+ tree cn;
+
+ ctxp->explicit_constructor_p += (CALL_THIS_CONSTRUCTOR_P (node) ? 1 : 0);
+ for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
+ {
+ tree wfl = TREE_VALUE (cn), parm, temp;
+ parm = java_complete_tree (wfl);
+ if (parm == error_mark_node)
+ {
+ flag = 1;
+ continue;
+ }
+ /* If have a string literal that we haven't transformed yet or a
+ crafted string buffer, as a result of use of the the String
+ `+' operator. Build `parm.toString()' and expand it. */
+ if ((temp = patch_string (parm)))
+ parm = temp;
+ /* Inline PRIMTYPE.TYPE read access */
+ parm = maybe_build_primttype_type_ref (parm, wfl);
+
+ TREE_VALUE (cn) = parm;
+ }
+ ctxp->explicit_constructor_p -= (CALL_THIS_CONSTRUCTOR_P (node) ? 1 : 0);
+ return flag;
+}
+
+/* Sometimes (for loops and variable initialized during their
+ declaration), we want to wrap a statement around a WFL and turn it
+ debugable. */
+
+static tree
+build_debugable_stmt (location, stmt)
+ int location;
+ tree stmt;
+{
+ if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
+ {
+ stmt = build_expr_wfl (stmt, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (stmt) = location;
+ }
+ JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
+ return stmt;
+}
+
+static tree
+build_expr_block (body, decls)
+ tree body, decls;
+{
+ tree node = make_node (BLOCK);
+ BLOCK_EXPR_DECLS (node) = decls;
+ BLOCK_EXPR_BODY (node) = body;
+ if (body)
+ TREE_TYPE (node) = TREE_TYPE (body);
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Create a new function block and link it approriately to current
+ function block chain */
+
+static tree
+enter_block ()
+{
+ return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE)));
+}
+
+/* Link block B supercontext to the previous block. The current
+ function DECL is used as supercontext when enter_a_block is called
+ for the first time for a given function. The current function body
+ (DECL_FUNCTION_BODY) is set to be block B. */
+
+static tree
+enter_a_block (b)
+ tree b;
+{
+ tree fndecl = current_function_decl;
+
+ if (!fndecl) {
+ BLOCK_SUPERCONTEXT (b) = current_static_block;
+ current_static_block = b;
+ }
+
+ else if (!DECL_FUNCTION_BODY (fndecl))
+ {
+ BLOCK_SUPERCONTEXT (b) = fndecl;
+ DECL_FUNCTION_BODY (fndecl) = b;
+ }
+ else
+ {
+ BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
+ DECL_FUNCTION_BODY (fndecl) = b;
+ }
+ return b;
+}
+
+/* Exit a block by changing the current function body
+ (DECL_FUNCTION_BODY) to the current block super context, only if
+ the block being exited isn't the method's top level one. */
+
+static tree
+exit_block ()
+{
+ tree b;
+ if (current_function_decl)
+ {
+ b = DECL_FUNCTION_BODY (current_function_decl);
+ if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
+ DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
+ }
+ else
+ {
+ b = current_static_block;
+
+ if (BLOCK_SUPERCONTEXT (b))
+ current_static_block = BLOCK_SUPERCONTEXT (b);
+ }
+ return b;
+}
+
+/* Lookup for NAME in the nested function's blocks, all the way up to
+ the current toplevel one. It complies with Java's local variable
+ scoping rules. */
+
+static tree
+lookup_name_in_blocks (name)
+ tree name;
+{
+ tree b = GET_CURRENT_BLOCK (current_function_decl);
+
+ while (b != current_function_decl)
+ {
+ tree current;
+
+ /* Paranoid sanity check. To be removed */
+ if (TREE_CODE (b) != BLOCK)
+ fatal ("non block expr function body - lookup_name_in_blocks");
+
+ for (current = BLOCK_EXPR_DECLS (b); current;
+ current = TREE_CHAIN (current))
+ if (DECL_NAME (current) == name)
+ return current;
+ b = BLOCK_SUPERCONTEXT (b);
+ }
+ return NULL_TREE;
+}
+
+static void
+maybe_absorb_scoping_blocks ()
+{
+ while (BLOCK_EXPR_ORIGIN (GET_CURRENT_BLOCK (current_function_decl)))
+ {
+ tree b = exit_block ();
+ java_method_add_stmt (current_function_decl, b);
+ SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
+ }
+}
+
+
+/* This section of the source is reserved to build_* functions that
+ are building incomplete tree nodes and the patch_* functions that
+ are completing them. */
+
+/* Build a super() constructor invocation. Returns empty_stmt_node if
+ we're currently dealing with the class java.lang.Object. */
+
+static tree
+build_super_invocation ()
+{
+ if (current_class == object_type_node)
+ return empty_stmt_node;
+ else
+ {
+ tree super_wfl = build_wfl_node (super_identifier_node);
+ return build_method_invocation (super_wfl, NULL_TREE);
+ }
+}
+
+/* Build a SUPER/THIS qualified method invocation. */
+
+static tree
+build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
+ int use_this;
+ tree name, args;
+ int lloc, rloc;
+
+{
+ tree invok;
+ tree wfl =
+ build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
+ EXPR_WFL_LINECOL (wfl) = lloc;
+ invok = build_method_invocation (name, args);
+ return make_qualified_primary (wfl, invok, rloc);
+}
+
+/* Build an incomplete CALL_EXPR node. */
+
+static tree
+build_method_invocation (name, args)
+ tree name;
+ tree args;
+{
+ tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+ EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
+ return call;
+}
+
+/* Build an incomplete new xxx(...) node. */
+
+static tree
+build_new_invocation (name, args)
+ tree name, args;
+{
+ tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+ EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
+ return call;
+}
+
+/* Build an incomplete assignment expression. */
+
+static tree
+build_assignment (op, op_location, lhs, rhs)
+ int op, op_location;
+ tree lhs, rhs;
+{
+ tree assignment;
+ /* Build the corresponding binop if we deal with a Compound
+ Assignment operator. Mark the binop sub-tree as part of a
+ Compound Assignment expression */
+ if (op != ASSIGN_TK)
+ {
+ rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
+ COMPOUND_ASSIGN_P (rhs) = 1;
+ }
+ assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
+ TREE_SIDE_EFFECTS (assignment) = 1;
+ EXPR_WFL_LINECOL (assignment) = op_location;
+ return assignment;
+}
+
+/* Print an INTEGER_CST node in a static buffer, and return the buffer. */
+
+char *
+print_int_node (node)
+ tree node;
+{
+ static char buffer [80];
+ if (TREE_CONSTANT_OVERFLOW (node))
+ sprintf (buffer, "<overflow>");
+
+ if (TREE_INT_CST_HIGH (node) == 0)
+ sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
+ TREE_INT_CST_LOW (node));
+ else if (TREE_INT_CST_HIGH (node) == -1
+ && TREE_INT_CST_LOW (node) != 0)
+ {
+ buffer [0] = '-';
+ sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
+ -TREE_INT_CST_LOW (node));
+ }
+ else
+ sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+ TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
+
+ return buffer;
+}
+
+/* Return 1 if an assignment to a FINAL is attempted in a non suitable
+ context. */
+
+static int
+check_final_assignment (lvalue, wfl)
+ tree lvalue, wfl;
+{
+ if (JDECL_P (lvalue)
+ && FIELD_FINAL (lvalue) && !IS_CLINIT (current_function_decl))
+ {
+ parse_error_context
+ (wfl, "Can't assign a value to the final variable `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ return 1;
+ }
+ return 0;
+}
+
+/* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
+ read. This is needed to avoid circularities in the implementation
+ of these fields in libjava. */
+
+static tree
+maybe_build_primttype_type_ref (rhs, wfl)
+ tree rhs, wfl;
+{
+ tree to_return = NULL_TREE;
+ tree rhs_type = TREE_TYPE (rhs);
+ if (TREE_CODE (rhs) == COMPOUND_EXPR)
+ {
+ tree n = TREE_OPERAND (rhs, 1);
+ if (TREE_CODE (n) == VAR_DECL
+ && DECL_NAME (n) == TYPE_identifier_node
+ && rhs_type == class_ptr_type)
+ {
+ char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
+ if (!strncmp (self_name, "java.lang.", 10))
+ to_return = build_primtype_type_ref (self_name);
+ }
+ }
+ return (to_return ? to_return : rhs );
+}
+
+/* 15.25 Assignment operators. */
+
+static tree
+patch_assignment (node, wfl_op1, wfl_op2)
+ tree node;
+ tree wfl_op1;
+ tree wfl_op2;
+{
+ tree rhs = TREE_OPERAND (node, 1);
+ tree lvalue = TREE_OPERAND (node, 0), llvalue;
+ tree lhs_type, rhs_type, new_rhs = NULL_TREE;
+ int error_found = 0;
+ int lvalue_from_array = 0;
+
+ /* Can't assign to a final. */
+ if (check_final_assignment (lvalue, wfl_op1))
+ error_found = 1;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Lhs can be a named variable */
+ if (JDECL_P (lvalue))
+ {
+ lhs_type = TREE_TYPE (lvalue);
+ }
+ /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
+ comment on reason why */
+ else if (TREE_CODE (wfl_op1) == ARRAY_REF)
+ {
+ lhs_type = TREE_TYPE (lvalue);
+ lvalue_from_array = 1;
+ }
+ /* Or a field access */
+ else if (TREE_CODE (lvalue) == COMPONENT_REF)
+ lhs_type = TREE_TYPE (lvalue);
+ /* Or a function return slot */
+ else if (TREE_CODE (lvalue) == RESULT_DECL)
+ lhs_type = TREE_TYPE (lvalue);
+ /* Otherwise, we might want to try to write into an optimized static
+ final, this is an of a different nature, reported further on. */
+ else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
+ && resolve_expression_name (wfl_op1, &llvalue))
+ {
+ if (check_final_assignment (llvalue, wfl_op1))
+ {
+ /* What we should do instead is resetting the all the flags
+ previously set, exchange lvalue for llvalue and continue. */
+ error_found = 1;
+ return error_mark_node;
+ }
+ else
+ lhs_type = TREE_TYPE (lvalue);
+ }
+ else
+ {
+ parse_error_context (wfl_op1, "Invalid left hand side of assignment");
+ error_found = 1;
+ }
+
+ rhs_type = TREE_TYPE (rhs);
+ /* 5.1 Try the assignment conversion for builtin type. */
+ new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
+
+ /* 5.2 If it failed, try a reference conversion */
+ if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
+ lhs_type = promote_type (rhs_type);
+
+ /* 15.25.2 If we have a compound assignment, convert RHS into the
+ type of the LHS */
+ else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
+ new_rhs = convert (lhs_type, rhs);
+
+ /* Explicit cast required. This is an error */
+ if (!new_rhs)
+ {
+ char *t1 = strdup (lang_printable_name (TREE_TYPE (rhs), 0));
+ char *t2 = strdup (lang_printable_name (lhs_type, 0));
+ tree wfl;
+ char operation [32]; /* Max size known */
+
+ /* If the assignment is part of a declaration, we use the WFL of
+ the declared variable to point out the error and call it a
+ declaration problem. If the assignment is a genuine =
+ operator, we call is a operator `=' problem, otherwise we
+ call it an assignment problem. In both of these last cases,
+ we use the WFL of the operator to indicate the error. */
+
+ if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
+ {
+ wfl = wfl_op1;
+ strcpy (operation, "declaration");
+ }
+ else
+ {
+ wfl = wfl_operator;
+ if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
+ strcpy (operation, "assignment");
+ else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
+ strcpy (operation, "`return'");
+ else
+ strcpy (operation, "`='");
+ }
+
+ parse_error_context
+ (wfl, (!valid_cast_to_p (rhs_type, lhs_type) ?
+ "Incompatible type for %s. Can't convert `%s' to `%s'" :
+ "Incompatible type for %s. Explicit cast "
+ "needed to convert `%s' to `%s'"), operation, t1, t2);
+ free (t1); free (t2);
+ error_found = 1;
+ }
+
+ /* Inline read access to java.lang.PRIMTYPE.TYPE */
+ if (new_rhs)
+ new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2);
+
+ if (error_found)
+ return error_mark_node;
+
+ /* 10.10: Array Store Exception runtime check */
+ if (!flag_emit_class_files
+ && !flag_emit_xref
+ && lvalue_from_array
+ && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type))
+ && !CLASS_FINAL (TYPE_NAME (GET_SKIP_TYPE (rhs_type))))
+ {
+ tree check;
+ tree base = lvalue;
+
+ /* We need to retrieve the right argument for _Jv_CheckArrayStore */
+ if (TREE_CODE (lvalue) == COMPOUND_EXPR)
+ base = TREE_OPERAND (lvalue, 0);
+ else
+ {
+ if (flag_bounds_check)
+ base = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (base, 0), 1), 0);
+ else
+ base = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
+ }
+
+ /* Build the invocation of _Jv_CheckArrayStore */
+ new_rhs = save_expr (new_rhs);
+ check = build (CALL_EXPR, void_type_node,
+ build_address_of (soft_checkarraystore_node),
+ tree_cons (NULL_TREE, base,
+ build_tree_list (NULL_TREE, new_rhs)),
+ NULL_TREE);
+ TREE_SIDE_EFFECTS (check) = 1;
+
+ /* We have to decide on an insertion point */
+ if (TREE_CODE (lvalue) == COMPOUND_EXPR)
+ {
+ tree t;
+ if (flag_bounds_check)
+ {
+ t = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0);
+ TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0) =
+ build (COMPOUND_EXPR, void_type_node, t, check);
+ }
+ else
+ TREE_OPERAND (lvalue, 1) = build (COMPOUND_EXPR, lhs_type,
+ check, TREE_OPERAND (lvalue, 1));
+ }
+ else
+ {
+ /* Make sure the bound check will happen before the store check */
+ if (flag_bounds_check)
+ TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0) =
+ build (COMPOUND_EXPR, void_type_node,
+ TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0), check);
+ else
+ lvalue = build (COMPOUND_EXPR, lhs_type, check, lvalue);
+ }
+ }
+
+ TREE_OPERAND (node, 0) = lvalue;
+ TREE_OPERAND (node, 1) = new_rhs;
+ TREE_TYPE (node) = lhs_type;
+ return node;
+}
+
+/* Check that type SOURCE can be cast into type DEST. If the cast
+ can't occur at all, return 0 otherwise 1. This function is used to
+ produce accurate error messages on the reasons why an assignment
+ failed. */
+
+static tree
+try_reference_assignconv (lhs_type, rhs)
+ tree lhs_type, rhs;
+{
+ tree new_rhs = NULL_TREE;
+ tree rhs_type = TREE_TYPE (rhs);
+
+ if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
+ {
+ /* `null' may be assigned to any reference type */
+ if (rhs == null_pointer_node)
+ new_rhs = null_pointer_node;
+ /* Try the reference assignment conversion */
+ else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
+ new_rhs = rhs;
+ /* This is a magic assignment that we process differently */
+ else if (rhs == soft_exceptioninfo_call_node)
+ new_rhs = rhs;
+ }
+ return new_rhs;
+}
+
+/* Check that RHS can be converted into LHS_TYPE by the assignment
+ conversion (5.2), for the cases of RHS being a builtin type. Return
+ NULL_TREE if the conversion fails or if because RHS isn't of a
+ builtin type. Return a converted RHS if the conversion is possible. */
+
+static tree
+try_builtin_assignconv (wfl_op1, lhs_type, rhs)
+ tree wfl_op1, lhs_type, rhs;
+{
+ tree new_rhs = NULL_TREE;
+ tree rhs_type = TREE_TYPE (rhs);
+
+ /* Zero accepted everywhere */
+ if (TREE_CODE (rhs) == INTEGER_CST
+ && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0
+ && JPRIMITIVE_TYPE_P (rhs_type))
+ new_rhs = convert (lhs_type, rhs);
+
+ /* 5.1.1 Try Identity Conversion,
+ 5.1.2 Try Widening Primitive Conversion */
+ else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
+ new_rhs = convert (lhs_type, rhs);
+
+ /* Try a narrowing primitive conversion (5.1.3):
+ - expression is a constant expression of type int AND
+ - variable is byte, short or char AND
+ - The value of the expression is representable in the type of the
+ variable */
+ else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
+ && (lhs_type == byte_type_node || lhs_type == char_type_node
+ || lhs_type == short_type_node))
+ {
+ if (int_fits_type_p (rhs, lhs_type))
+ new_rhs = convert (lhs_type, rhs);
+ else if (wfl_op1) /* Might be called with a NULL */
+ parse_warning_context
+ (wfl_op1, "Constant expression `%s' to wide for narrowing "
+ "primitive conversion to `%s'",
+ print_int_node (rhs), lang_printable_name (lhs_type, 0));
+ /* Reported a warning that will turn into an error further
+ down, so we don't return */
+ }
+
+ return new_rhs;
+}
+
+/* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
+ conversion (5.1.1) or widening primitve conversion (5.1.2). Return
+ 0 is the conversion test fails. This implements parts the method
+ invocation convertion (5.3). */
+
+static int
+valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
+ tree lhs_type, rhs_type;
+{
+ /* 5.1.1: This is the identity conversion part. */
+ if (lhs_type == rhs_type)
+ return 1;
+
+ /* Reject non primitive types */
+ if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type))
+ return 0;
+
+ /* 5.1.2: widening primitive conversion. byte, even if it's smaller
+ than a char can't be converted into a char. Short can't too, but
+ the < test below takes care of that */
+ if (lhs_type == char_type_node && rhs_type == byte_type_node)
+ return 0;
+
+ /* Accept all promoted type here. Note, we can't use <= in the test
+ below, because we still need to bounce out assignments of short
+ to char and the likes */
+ if (lhs_type == int_type_node
+ && (rhs_type == promoted_byte_type_node
+ || rhs_type == promoted_short_type_node
+ || rhs_type == promoted_char_type_node
+ || rhs_type == promoted_boolean_type_node))
+ return 1;
+
+ /* From here, an integral is widened if its precision is smaller
+ than the precision of the LHS or if the LHS is a floating point
+ type, or the RHS is a float and the RHS a double. */
+ if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
+ && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
+ || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
+ || (rhs_type == float_type_node && lhs_type == double_type_node))
+ return 1;
+
+ return 0;
+}
+
+/* Check that something of SOURCE type can be assigned or cast to
+ something of DEST type at runtime. Return 1 if the operation is
+ valid, 0 otherwise. If CAST is set to 1, we're treating the case
+ were SOURCE is cast into DEST, which borrows a lot of the
+ assignment check. */
+
+static int
+valid_ref_assignconv_cast_p (source, dest, cast)
+ tree source;
+ tree dest;
+ int cast;
+{
+ /* SOURCE or DEST might be null if not from a declared entity. */
+ if (!source || !dest)
+ return 0;
+ if (JNULLP_TYPE_P (source))
+ return 1;
+ if (TREE_CODE (source) == POINTER_TYPE)
+ source = TREE_TYPE (source);
+ if (TREE_CODE (dest) == POINTER_TYPE)
+ dest = TREE_TYPE (dest);
+ /* Case where SOURCE is a class type */
+ if (TYPE_CLASS_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ return source == dest || inherits_from_p (source, dest)
+ || (cast && inherits_from_p (dest, source));
+ if (TYPE_INTERFACE_P (dest))
+ {
+ /* If doing a cast and SOURCE is final, the operation is
+ always correct a compile time (because even if SOURCE
+ does not implement DEST, a subclass of SOURCE might). */
+ if (cast && !CLASS_FINAL (TYPE_NAME (source)))
+ return 1;
+ /* Otherwise, SOURCE must implement DEST */
+ return interface_of_p (dest, source);
+ }
+ /* DEST is an array, cast permited if SOURCE is of Object type */
+ return (cast && source == object_type_node ? 1 : 0);
+ }
+ if (TYPE_INTERFACE_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ {
+ /* If not casting, DEST must be the Object type */
+ if (!cast)
+ return dest == object_type_node;
+ /* We're doing a cast. The cast is always valid is class
+ DEST is not final, otherwise, DEST must implement SOURCE */
+ else if (!CLASS_FINAL (TYPE_NAME (dest)))
+ return 1;
+ else
+ return interface_of_p (source, dest);
+ }
+ if (TYPE_INTERFACE_P (dest))
+ {
+ /* If doing a cast, then if SOURCE and DEST contain method
+ with the same signature but different return type, then
+ this is a (compile time) error */
+ if (cast)
+ {
+ tree method_source, method_dest;
+ tree source_type;
+ tree source_sig;
+ tree source_name;
+ for (method_source = TYPE_METHODS (source); method_source;
+ method_source = TREE_CHAIN (method_source))
+ {
+ source_sig =
+ build_java_argument_signature (TREE_TYPE (method_source));
+ source_type = TREE_TYPE (TREE_TYPE (method_source));
+ source_name = DECL_NAME (method_source);
+ for (method_dest = TYPE_METHODS (dest);
+ method_dest; method_dest = TREE_CHAIN (method_dest))
+ if (source_sig ==
+ build_java_argument_signature (TREE_TYPE (method_dest))
+ && source_name == DECL_NAME (method_dest)
+ && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
+ return 0;
+ }
+ return 1;
+ }
+ else
+ return source == dest || interface_of_p (dest, source);
+ }
+ else /* Array */
+ return (cast ?
+ (DECL_NAME (TYPE_NAME (source)) == java_lang_cloneable) : 0);
+ }
+ if (TYPE_ARRAY_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ return dest == object_type_node;
+ /* Can't cast an array to an interface unless the interface is
+ java.lang.Cloneable */
+ if (TYPE_INTERFACE_P (dest))
+ return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0);
+ else /* Arrays */
+ {
+ tree source_element_type = TYPE_ARRAY_ELEMENT (source);
+ tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
+
+ /* In case of severe errors, they turn out null */
+ if (!dest_element_type || !source_element_type)
+ return 0;
+ if (source_element_type == dest_element_type)
+ return 1;
+ return valid_ref_assignconv_cast_p (source_element_type,
+ dest_element_type, cast);
+ }
+ return 0;
+ }
+ return 0;
+}
+
+static int
+valid_cast_to_p (source, dest)
+ tree source;
+ tree dest;
+{
+ if (TREE_CODE (source) == POINTER_TYPE)
+ source = TREE_TYPE (source);
+ if (TREE_CODE (dest) == POINTER_TYPE)
+ dest = TREE_TYPE (dest);
+
+ if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
+ return valid_ref_assignconv_cast_p (source, dest, 1);
+
+ else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
+ return 1;
+
+ return 0;
+}
+
+/* Method invocation conversion test. Return 1 if type SOURCE can be
+ converted to type DEST through the methond invocation conversion
+ process (5.3) */
+
+static tree
+do_unary_numeric_promotion (arg)
+ tree arg;
+{
+ tree type = TREE_TYPE (arg);
+ if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32
+ : TREE_CODE (type) == CHAR_TYPE)
+ arg = convert (int_type_node, arg);
+ return arg;
+}
+
+/* Return a non zero value if SOURCE can be converted into DEST using
+ the method invocation conversion rule (5.3). */
+static int
+valid_method_invocation_conversion_p (dest, source)
+ tree dest, source;
+{
+ return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
+ && valid_builtin_assignconv_identity_widening_p (dest, source))
+ || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
+ && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
+ && valid_ref_assignconv_cast_p (source, dest, 0)));
+}
+
+/* Build an incomplete binop expression. */
+
+static tree
+build_binop (op, op_location, op1, op2)
+ enum tree_code op;
+ int op_location;
+ tree op1, op2;
+{
+ tree binop = build (op, NULL_TREE, op1, op2);
+ TREE_SIDE_EFFECTS (binop) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (binop) = op_location;
+ return binop;
+}
+
+/* Build the string of the operator retained by NODE. If NODE is part
+ of a compound expression, add an '=' at the end of the string. This
+ function is called when an error needs to be reported on an
+ operator. The string is returned as a pointer to a static character
+ buffer. */
+
+static char *
+operator_string (node)
+ tree node;
+{
+#define BUILD_OPERATOR_STRING(S) \
+ { \
+ sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
+ return buffer; \
+ }
+
+ static char buffer [10];
+ switch (TREE_CODE (node))
+ {
+ case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
+ case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
+ case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
+ case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
+ case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
+ case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
+ case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
+ case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
+ case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
+ case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
+ case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
+ case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
+ case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
+ case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
+ case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
+ case GT_EXPR: BUILD_OPERATOR_STRING (">");
+ case GE_EXPR: BUILD_OPERATOR_STRING (">=");
+ case LT_EXPR: BUILD_OPERATOR_STRING ("<");
+ case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
+ case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
+ case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
+ case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
+ case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
+ case PREINCREMENT_EXPR: /* Fall through */
+ case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
+ case PREDECREMENT_EXPR: /* Fall through */
+ case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
+ default:
+ fatal ("unregistered operator %s - operator_string",
+ tree_code_name [TREE_CODE (node)]);
+ }
+ return NULL;
+#undef BUILD_OPERATOR_STRING
+}
+
+/* Binary operators (15.16 up to 15.18). We return error_mark_node on
+ errors but we modify NODE so that it contains the type computed
+ according to the expression, when it's fixed. Otherwise, we write
+ error_mark_node as the type. It allows us to further the analysis
+ of remaining nodes and detects more errors in certain cases. */
+
+static tree
+patch_binop (node, wfl_op1, wfl_op2)
+ tree node;
+ tree wfl_op1;
+ tree wfl_op2;
+{
+ tree op1 = TREE_OPERAND (node, 0);
+ tree op2 = TREE_OPERAND (node, 1);
+ tree op1_type = TREE_TYPE (op1);
+ tree op2_type = TREE_TYPE (op2);
+ tree prom_type = NULL_TREE;
+ int code = TREE_CODE (node);
+
+ /* If 1, tell the routine that we have to return error_mark_node
+ after checking for the initialization of the RHS */
+ int error_found = 0;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ switch (code)
+ {
+ /* 15.16 Multiplicative operators */
+ case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
+ case RDIV_EXPR: /* 15.16.2 Division Operator / */
+ case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
+ if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
+ {
+ if (!JPRIMITIVE_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ /* Change the division operator if necessary */
+ if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
+ TREE_SET_CODE (node, TRUNC_DIV_EXPR);
+
+ /* This one is more complicated. FLOATs are processed by a
+ function call to soft_fmod. Duplicate the value of the
+ COMPOUND_ASSIGN_P flag. */
+ if (code == TRUNC_MOD_EXPR)
+ {
+ tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
+ COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
+ TREE_SIDE_EFFECTS (mod)
+ = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
+ return mod;
+ }
+ break;
+
+ /* 15.17 Additive Operators */
+ case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
+
+ /* Operation is valid if either one argument is a string
+ constant, a String object or a StringBuffer crafted for the
+ purpose of the a previous usage of the String concatenation
+ operator */
+
+ if (TREE_CODE (op1) == STRING_CST
+ || TREE_CODE (op2) == STRING_CST
+ || JSTRING_TYPE_P (op1_type)
+ || JSTRING_TYPE_P (op2_type)
+ || IS_CRAFTED_STRING_BUFFER_P (op1)
+ || IS_CRAFTED_STRING_BUFFER_P (op2))
+ return build_string_concatenation (op1, op2);
+
+ case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
+ Numeric Types */
+ if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
+ {
+ if (!JPRIMITIVE_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ break;
+
+ /* 15.18 Shift Operators */
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
+ {
+ if (!JINTEGRAL_TYPE_P (op1_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
+ else
+ parse_error_context
+ (wfl_operator, (JPRIMITIVE_TYPE_P (op2_type) ?
+ "Incompatible type for `%s'. Explicit cast needed to convert "
+ "shift distance from `%s' to integral" :
+ "Incompatible type for `%s'. Can't convert shift distance from "
+ "`%s' to integral"),
+ operator_string (node), lang_printable_name (op2_type, 0));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+
+ /* Unary numeric promotion (5.6.1) is performed on each operand
+ separatly */
+ op1 = do_unary_numeric_promotion (op1);
+ op2 = do_unary_numeric_promotion (op2);
+
+ /* The type of the shift expression is the type of the promoted
+ type of the left-hand operand */
+ prom_type = TREE_TYPE (op1);
+
+ /* Shift int only up to 0x1f and long up to 0x3f */
+ if (prom_type == int_type_node)
+ op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
+ build_int_2 (0x1f, 0)));
+ else
+ op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
+ build_int_2 (0x3f, 0)));
+
+ /* The >>> operator is a >> operating on unsigned quantities */
+ if (code == URSHIFT_EXPR && ! flag_emit_class_files)
+ {
+ tree to_return;
+ tree utype = unsigned_type (prom_type);
+ op1 = convert (utype, op1);
+ TREE_SET_CODE (node, RSHIFT_EXPR);
+ TREE_OPERAND (node, 0) = op1;
+ TREE_OPERAND (node, 1) = op2;
+ TREE_TYPE (node) = utype;
+ to_return = convert (prom_type, node);
+ /* Copy the original value of the COMPOUND_ASSIGN_P flag */
+ COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
+ TREE_SIDE_EFFECTS (to_return)
+ = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
+ return to_return;
+ }
+ break;
+
+ /* 15.19.1 Type Comparison Operator instaceof */
+ case INSTANCEOF_EXPR:
+
+ TREE_TYPE (node) = boolean_type_node;
+
+ if (!(op2_type = resolve_type_during_patch (op2)))
+ return error_mark_node;
+
+ /* The first operand must be a reference type or the null type */
+ if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
+ error_found = 1; /* Error reported further below */
+
+ /* The second operand must be a reference type */
+ if (!JREFERENCE_TYPE_P (op2_type))
+ {
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
+ parse_error_context
+ (wfl_operator, "Invalid argument `%s' for `instanceof'",
+ lang_printable_name (op2_type, 0));
+ error_found = 1;
+ }
+
+ if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
+ {
+ /* If the first operand is null, the result is always false */
+ if (op1 == null_pointer_node)
+ return boolean_false_node;
+ else if (flag_emit_class_files)
+ {
+ TREE_OPERAND (node, 1) = op2_type;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
+ return node;
+ }
+ /* Otherwise we have to invoke instance of to figure it out */
+ else
+ {
+ tree call =
+ build (CALL_EXPR, boolean_type_node,
+ build_address_of (soft_instanceof_node),
+ tree_cons
+ (NULL_TREE, op1,
+ build_tree_list (NULL_TREE,
+ build_class_ref (op2_type))),
+ NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = TREE_SIDE_EFFECTS (op1);
+ return call;
+ }
+ }
+ /* There is no way the expression operand can be an instance of
+ the type operand. This is a compile time error. */
+ else
+ {
+ char *t1 = strdup (lang_printable_name (op1_type, 0));
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
+ parse_error_context
+ (wfl_operator, "Impossible for `%s' to be instance of `%s'",
+ t1, lang_printable_name (op2_type, 0));
+ free (t1);
+ error_found = 1;
+ }
+
+ break;
+
+ /* 15.21 Bitwise and Logical Operators */
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
+ /* Binary numeric promotion is performed on both operand and the
+ expression retain that type */
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+
+ else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
+ && TREE_CODE (op1_type) == BOOLEAN_TYPE)
+ /* The type of the bitwise operator expression is BOOLEAN */
+ prom_type = boolean_type_node;
+ else
+ {
+ if (!JINTEGRAL_TYPE_P (op1_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
+ if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ /* Insert a break here if adding thing before the switch's
+ break for this case */
+ }
+ break;
+
+ /* 15.22 Conditional-And Operator */
+ case TRUTH_ANDIF_EXPR:
+ /* 15.23 Conditional-Or Operator */
+ case TRUTH_ORIF_EXPR:
+ /* Operands must be of BOOLEAN type */
+ if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
+ TREE_CODE (op2_type) != BOOLEAN_TYPE)
+ {
+ if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
+ if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ /* The type of the conditional operators is BOOLEAN */
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
+ case LT_EXPR:
+ case GT_EXPR:
+ case LE_EXPR:
+ case GE_EXPR:
+ /* The type of each of the operands must be a primitive numeric
+ type */
+ if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
+ {
+ if (!JNUMERIC_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ /* Binary numeric promotion is performed on the operands */
+ binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ /* The type of the relation expression is always BOOLEAN */
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.20 Equality Operator */
+ case EQ_EXPR:
+ case NE_EXPR:
+ /* 15.20.1 Numerical Equality Operators == and != */
+ /* Binary numeric promotion is performed on the operands */
+ if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
+ binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+
+ /* 15.20.2 Boolean Equality Operators == and != */
+ else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
+ TREE_CODE (op2_type) == BOOLEAN_TYPE)
+ ; /* Nothing to do here */
+
+ /* 15.20.3 Reference Equality Operators == and != */
+ /* Types have to be either references or the null type. If
+ they're references, it must be possible to convert either
+ type to the other by casting conversion. */
+ else if (op1 == null_pointer_node || op2 == null_pointer_node
+ || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
+ && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
+ || valid_ref_assignconv_cast_p (op2_type,
+ op1_type, 1))))
+ ; /* Nothing to do here */
+
+ /* Else we have an error figure what can't be converted into
+ what and report the error */
+ else
+ {
+ char *t1;
+ t1 = strdup (lang_printable_name (op1_type, 0));
+ parse_error_context
+ (wfl_operator, "Incompatible type for `%s'. Can't convert `%s' "
+ "to `%s'", operator_string (node), t1,
+ lang_printable_name (op2_type, 0));
+ free (t1);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = boolean_type_node;
+ break;
+ }
+
+ if (error_found)
+ return error_mark_node;
+
+ TREE_OPERAND (node, 0) = op1;
+ TREE_OPERAND (node, 1) = op2;
+ TREE_TYPE (node) = prom_type;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
+
+ if (flag_emit_xref)
+ return node;
+
+ /* fold does not respect side-effect order as required for Java but not C.
+ * Also, it sometimes create SAVE_EXPRs which are bad when emitting
+ * bytecode.
+ */
+ if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
+ : ! TREE_SIDE_EFFECTS (node))
+ node = fold (node);
+ return node;
+}
+
+/* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
+ zero value, the value of CSTE comes after the valude of STRING */
+
+static tree
+do_merge_string_cste (cste, string, string_len, after)
+ tree cste;
+ char *string;
+ int string_len, after;
+{
+ int len = TREE_STRING_LENGTH (cste) + string_len;
+ char *old = TREE_STRING_POINTER (cste);
+ TREE_STRING_LENGTH (cste) = len;
+ TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1);
+ if (after)
+ {
+ strcpy (TREE_STRING_POINTER (cste), string);
+ strcat (TREE_STRING_POINTER (cste), old);
+ }
+ else
+ {
+ strcpy (TREE_STRING_POINTER (cste), old);
+ strcat (TREE_STRING_POINTER (cste), string);
+ }
+ return cste;
+}
+
+/* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
+ new STRING_CST on success, NULL_TREE on failure */
+
+static tree
+merge_string_cste (op1, op2, after)
+ tree op1, op2;
+ int after;
+{
+ /* Handle two string constants right away */
+ if (TREE_CODE (op2) == STRING_CST)
+ return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
+ TREE_STRING_LENGTH (op2), after);
+
+ /* Reasonable integer constant can be treated right away */
+ if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
+ {
+ static char *boolean_true = "true";
+ static char *boolean_false = "false";
+ static char *null_pointer = "null";
+ char ch[3];
+ char *string;
+
+ if (op2 == boolean_true_node)
+ string = boolean_true;
+ else if (op2 == boolean_false_node)
+ string = boolean_false;
+ else if (op2 == null_pointer_node)
+ string = null_pointer;
+ else if (TREE_TYPE (op2) == char_type_node)
+ {
+ ch[0] = (char )TREE_INT_CST_LOW (op2);
+ ch[1] = '\0';
+ string = ch;
+ }
+ else
+ string = print_int_node (op2);
+
+ return do_merge_string_cste (op1, string, strlen (string), after);
+ }
+ return NULL_TREE;
+}
+
+/* Tries to statically concatenate OP1 and OP2 if possible. Either one
+ has to be a STRING_CST and the other part must be a STRING_CST or a
+ INTEGRAL constant. Return a new STRING_CST if the operation
+ succeed, NULL_TREE otherwise.
+
+ If the case we want to optimize for space, we might want to return
+ NULL_TREE for each invocation of this routine. FIXME */
+
+static tree
+string_constant_concatenation (op1, op2)
+ tree op1, op2;
+{
+ if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
+ {
+ tree string, rest;
+ int invert;
+
+ string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
+ rest = (string == op1 ? op2 : op1);
+ invert = (string == op1 ? 0 : 1 );
+
+ /* Walk REST, only if it looks reasonable */
+ if (TREE_CODE (rest) != STRING_CST
+ && !IS_CRAFTED_STRING_BUFFER_P (rest)
+ && !JSTRING_TYPE_P (TREE_TYPE (rest))
+ && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
+ {
+ rest = java_complete_tree (rest);
+ if (rest == error_mark_node)
+ return error_mark_node;
+ rest = fold (rest);
+ }
+ return merge_string_cste (string, rest, invert);
+ }
+ return NULL_TREE;
+}
+
+/* Implement the `+' operator. Does static optimization if possible,
+ otherwise create (if necessary) and append elements to a
+ StringBuffer. The StringBuffer will be carried around until it is
+ used for a function call or an assignment. Then toString() will be
+ called on it to turn it into a String object. */
+
+static tree
+build_string_concatenation (op1, op2)
+ tree op1, op2;
+{
+ tree result;
+ int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
+
+ if (flag_emit_xref)
+ return build (PLUS_EXPR, string_type_node, op1, op2);
+
+ /* Try to do some static optimization */
+ if ((result = string_constant_concatenation (op1, op2)))
+ return result;
+
+ /* Discard empty strings on either side of the expression */
+ if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
+ {
+ op1 = op2;
+ op2 = NULL_TREE;
+ }
+ else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
+ op2 = NULL_TREE;
+
+ /* If operands are string constant, turn then into object references */
+ if (TREE_CODE (op1) == STRING_CST)
+ op1 = patch_string_cst (op1);
+ if (op2 && TREE_CODE (op2) == STRING_CST)
+ op2 = patch_string_cst (op2);
+
+ /* If either one of the constant is null and the other non null
+ operand is a String object, return it. */
+ if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
+ return op1;
+
+ /* If OP1 isn't already a StringBuffer, create and
+ initialize a new one */
+ if (!IS_CRAFTED_STRING_BUFFER_P (op1))
+ {
+ /* Two solutions here:
+ 1) OP1 is a string reference, we call new StringBuffer(OP1)
+ 2) OP1 is something else, we call new StringBuffer().append(OP1). */
+ if (JSTRING_TYPE_P (TREE_TYPE (op1)))
+ op1 = BUILD_STRING_BUFFER (op1);
+ else
+ {
+ tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
+ op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
+ }
+ }
+
+ if (op2)
+ {
+ /* OP1 is no longer the last node holding a crafted StringBuffer */
+ IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
+ /* Create a node for `{new...,xxx}.append (op2)' */
+ if (op2)
+ op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
+ }
+
+ /* Mark the last node holding a crafted StringBuffer */
+ IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
+
+ TREE_SIDE_EFFECTS (op1) = side_effects;
+ return op1;
+}
+
+/* Patch the string node NODE. NODE can be a STRING_CST of a crafted
+ StringBuffer. If no string were found to be patched, return
+ NULL. */
+
+static tree
+patch_string (node)
+ tree node;
+{
+ if (node == error_mark_node)
+ return error_mark_node;
+ if (TREE_CODE (node) == STRING_CST)
+ return patch_string_cst (node);
+ else if (IS_CRAFTED_STRING_BUFFER_P (node))
+ {
+ int saved = ctxp->explicit_constructor_p;
+ tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
+ tree ret;
+ /* Temporary disable forbid the use of `this'. */
+ ctxp->explicit_constructor_p = 0;
+ ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
+ /* Restore it at its previous value */
+ ctxp->explicit_constructor_p = saved;
+ return ret;
+ }
+ return NULL_TREE;
+}
+
+/* Build the internal representation of a string constant. */
+
+static tree
+patch_string_cst (node)
+ tree node;
+{
+ int location;
+ if (! flag_emit_class_files)
+ {
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ node = get_identifier (TREE_STRING_POINTER (node));
+ location = alloc_name_constant (CONSTANT_String, node);
+ node = build_ref_from_constant_pool (location);
+ }
+ TREE_TYPE (node) = string_ptr_type_node;
+ TREE_CONSTANT (node) = 1;
+ return node;
+}
+
+/* Build an incomplete unary operator expression. */
+
+static tree
+build_unaryop (op_token, op_location, op1)
+ int op_token, op_location;
+ tree op1;
+{
+ enum tree_code op;
+ tree unaryop;
+ switch (op_token)
+ {
+ case PLUS_TK: op = UNARY_PLUS_EXPR; break;
+ case MINUS_TK: op = NEGATE_EXPR; break;
+ case NEG_TK: op = TRUTH_NOT_EXPR; break;
+ case NOT_TK: op = BIT_NOT_EXPR; break;
+ default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
+ op_token);
+ }
+
+ unaryop = build1 (op, NULL_TREE, op1);
+ TREE_SIDE_EFFECTS (unaryop) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (unaryop) = op_location;
+ return unaryop;
+}
+
+/* Special case for the ++/-- operators, since they require an extra
+ argument to build, which is set to NULL and patched
+ later. IS_POST_P is 1 if the operator, 0 otherwise. */
+
+static tree
+build_incdec (op_token, op_location, op1, is_post_p)
+ int op_token, op_location;
+ tree op1;
+ int is_post_p;
+{
+ static enum tree_code lookup [2][2] =
+ {
+ { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
+ { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
+ };
+ tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
+ NULL_TREE, op1, NULL_TREE);
+ TREE_SIDE_EFFECTS (node) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (node) = op_location;
+ return node;
+}
+
+/* Build an incomplete cast operator, based on the use of the
+ CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
+ set. java_complete_tree is trained to walk a CONVERT_EXPR even
+ though its type is already set. */
+
+static tree
+build_cast (location, type, exp)
+ int location;
+ tree type, exp;
+{
+ tree node = build1 (CONVERT_EXPR, type, exp);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 15.14 Unary operators. We return error_mark_node in case of error,
+ but preserve the type of NODE if the type is fixed. */
+
+static tree
+patch_unaryop (node, wfl_op)
+ tree node;
+ tree wfl_op;
+{
+ tree op = TREE_OPERAND (node, 0);
+ tree op_type = TREE_TYPE (op);
+ tree prom_type = NULL_TREE, value, decl;
+ int code = TREE_CODE (node);
+ int error_found = 0;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ switch (code)
+ {
+ /* 15.13.2 Postfix Increment Operator ++ */
+ case POSTINCREMENT_EXPR:
+ /* 15.13.3 Postfix Increment Operator -- */
+ case POSTDECREMENT_EXPR:
+ /* 15.14.1 Prefix Increment Operator ++ */
+ case PREINCREMENT_EXPR:
+ /* 15.14.2 Prefix Decrement Operator -- */
+ case PREDECREMENT_EXPR:
+ decl = strip_out_static_field_access_decl (op);
+ /* We really should have a JAVA_ARRAY_EXPR to avoid this */
+ if (!JDECL_P (decl)
+ && TREE_CODE (decl) != COMPONENT_REF
+ && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
+ && TREE_CODE (decl) != INDIRECT_REF
+ && !(TREE_CODE (decl) == COMPOUND_EXPR
+ && TREE_OPERAND (decl, 1)
+ && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
+ {
+ tree lvalue;
+ /* Before screaming, check that we're not in fact trying to
+ increment a optimized static final access, in which case
+ we issue an different error message. */
+ if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION
+ && resolve_expression_name (wfl_op, &lvalue)
+ && check_final_assignment (lvalue, wfl_op)))
+ parse_error_context (wfl_operator, "Invalid argument to `%s'",
+ operator_string (node));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else if (check_final_assignment (op, wfl_op))
+ error_found = 1;
+
+ /* From now on, we know that op if a variable and that it has a
+ valid wfl. We use wfl_op to locate errors related to the
+ ++/-- operand. */
+ else if (!JNUMERIC_TYPE_P (op_type))
+ {
+ parse_error_context
+ (wfl_op, "Invalid argument type `%s' to `%s'",
+ lang_printable_name (op_type, 0), operator_string (node));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ {
+ /* Before the addition, binary numeric promotion is performed on
+ both operands */
+ value = build_int_2 (1, 0);
+ TREE_TYPE (node) =
+ binary_numeric_promotion (op_type, TREE_TYPE (value), &op, &value);
+ /* And write the promoted incremented and increment */
+ TREE_OPERAND (node, 0) = op;
+ TREE_OPERAND (node, 1) = value;
+ /* Convert the overall back into its original type. */
+ return fold (convert (op_type, node));
+ }
+ break;
+
+ /* 15.14.3 Unary Plus Operator + */
+ case UNARY_PLUS_EXPR:
+ /* 15.14.4 Unary Minus Operator - */
+ case NEGATE_EXPR:
+ if (!JNUMERIC_TYPE_P (op_type))
+ {
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ /* Unary numeric promotion is performed on operand */
+ else
+ {
+ op = do_unary_numeric_promotion (op);
+ prom_type = TREE_TYPE (op);
+ if (code == UNARY_PLUS_EXPR)
+ return fold (op);
+ }
+ break;
+
+ /* 15.14.5 Bitwise Complement Operator ~ */
+ case BIT_NOT_EXPR:
+ if (!JINTEGRAL_TYPE_P (op_type))
+ {
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ {
+ op = do_unary_numeric_promotion (op);
+ prom_type = TREE_TYPE (op);
+ }
+ break;
+
+ /* 15.14.6 Logical Complement Operator ! */
+ case TRUTH_NOT_EXPR:
+ if (TREE_CODE (op_type) != BOOLEAN_TYPE)
+ {
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
+ /* But the type is known. We will report an error if further
+ attempt of a assignment is made with this rhs */
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ }
+ else
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.15 Cast Expression */
+ case CONVERT_EXPR:
+ value = patch_cast (node, wfl_operator);
+ if (value == error_mark_node)
+ {
+ /* If this cast is part of an assignment, we tell the code
+ that deals with it not to complain about a mismatch,
+ because things have been cast, anyways */
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ {
+ value = fold (value);
+ TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
+ return value;
+ }
+ break;
+ }
+
+ if (error_found)
+ return error_mark_node;
+
+ /* There are cases where node has been replaced by something else
+ and we don't end up returning here: UNARY_PLUS_EXPR,
+ CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
+ TREE_OPERAND (node, 0) = fold (op);
+ TREE_TYPE (node) = prom_type;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
+ return fold (node);
+}
+
+/* Generic type resolution that sometimes takes place during node
+ patching. Returned the resolved type or generate an error
+ message. Return the resolved type or NULL_TREE. */
+
+static tree
+resolve_type_during_patch (type)
+ tree type;
+{
+ if (unresolved_type_p (type, NULL))
+ {
+ tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
+ if (!type_decl)
+ {
+ parse_error_context (type,
+ "Class `%s' not found in type declaration",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
+ return NULL_TREE;
+ }
+ else
+ {
+ CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1;
+ return TREE_TYPE (type_decl);
+ }
+ }
+ return type;
+}
+/* 5.5 Casting Conversion. error_mark_node is returned if an error is
+ found. Otherwise NODE or something meant to replace it is returned. */
+
+static tree
+patch_cast (node, wfl_operator)
+ tree node;
+ tree wfl_operator;
+{
+ tree op = TREE_OPERAND (node, 0);
+ tree op_type = TREE_TYPE (op);
+ tree cast_type = TREE_TYPE (node);
+ char *t1;
+
+ /* First resolve OP_TYPE if unresolved */
+ if (!(cast_type = resolve_type_during_patch (cast_type)))
+ return error_mark_node;
+
+ /* Check on cast that are proven correct at compile time */
+ if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
+ {
+ static tree convert_narrow ();
+ /* Same type */
+ if (cast_type == op_type)
+ return node;
+
+ /* float and double type are converted to the original type main
+ variant and then to the target type. */
+ if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
+ op = convert (integer_type_node, op);
+
+ /* Try widening/narowwing convertion. Potentially, things need
+ to be worked out in gcc so we implement the extreme cases
+ correctly. fold_convert() needs to be fixed. */
+ return convert (cast_type, op);
+ }
+
+ /* It's also valid to cast a boolean into a boolean */
+ if (op_type == boolean_type_node && cast_type == boolean_type_node)
+ return node;
+
+ /* null can be casted to references */
+ if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
+ return build_null_of_type (cast_type);
+
+ /* The remaining legal casts involve conversion between reference
+ types. Check for their compile time correctness. */
+ if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
+ && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
+ {
+ TREE_TYPE (node) = promote_type (cast_type);
+ /* Now, the case can be determined correct at compile time if
+ OP_TYPE can be converted into CAST_TYPE by assignment
+ conversion (5.2) */
+
+ if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
+ {
+ TREE_SET_CODE (node, NOP_EXPR);
+ return node;
+ }
+
+ if (flag_emit_class_files)
+ {
+ TREE_SET_CODE (node, CONVERT_EXPR);
+ return node;
+ }
+
+ /* The cast requires a run-time check */
+ return build (CALL_EXPR, promote_type (cast_type),
+ build_address_of (soft_checkcast_node),
+ tree_cons (NULL_TREE, build_class_ref (cast_type),
+ build_tree_list (NULL_TREE, op)),
+ NULL_TREE);
+ }
+
+ /* Any other casts are proven incorrect at compile time */
+ t1 = strdup (lang_printable_name (op_type, 0));
+ parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
+ t1, lang_printable_name (cast_type, 0));
+ free (t1);
+ return error_mark_node;
+}
+
+/* Build a null constant and give it the type TYPE. */
+
+static tree
+build_null_of_type (type)
+ tree type;
+{
+ tree node = build_int_2 (0, 0);
+ TREE_TYPE (node) = promote_type (type);
+ return node;
+}
+
+/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
+ a list of indices. */
+static tree
+build_array_ref (location, array, index)
+ int location;
+ tree array, index;
+{
+ tree node = build (ARRAY_REF, NULL_TREE, array, index);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 15.12 Array Access Expression */
+
+static tree
+patch_array_ref (node)
+ tree node;
+{
+ tree array = TREE_OPERAND (node, 0);
+ tree array_type = TREE_TYPE (array);
+ tree index = TREE_OPERAND (node, 1);
+ tree index_type = TREE_TYPE (index);
+ int error_found = 0;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ if (TREE_CODE (array_type) == POINTER_TYPE)
+ array_type = TREE_TYPE (array_type);
+
+ /* The array reference must be an array */
+ if (!TYPE_ARRAY_P (array_type))
+ {
+ parse_error_context
+ (wfl_operator, "`[]' can only be applied to arrays. It can't be "
+ "applied to `%s'", lang_printable_name (array_type, 0));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+
+ /* The array index underdoes unary numeric promotion. The promoted
+ type must be int */
+ index = do_unary_numeric_promotion (index);
+ if (TREE_TYPE (index) != int_type_node)
+ {
+ int could_cast = valid_cast_to_p (index_type, int_type_node);
+ parse_error_context
+ (wfl_operator,
+ (could_cast ? "Incompatible type for `[]'. Explicit cast needed to "
+ "convert `%s' to `int'" : "Incompatible type for `[]'. "
+ "Can't convert `%s' to `int'"),
+ lang_printable_name (index_type, 0));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+
+ array_type = TYPE_ARRAY_ELEMENT (array_type);
+
+ if (flag_emit_class_files || flag_emit_xref)
+ {
+ TREE_OPERAND (node, 0) = array;
+ TREE_OPERAND (node, 1) = index;
+ }
+ else
+ {
+ /* The save_expr is for correct evaluation order. It would be cleaner
+ to use force_evaluation_order (see comment there), but that is
+ difficult when we also have to deal with bounds checking. */
+ if (TREE_SIDE_EFFECTS (index))
+ array = save_expr (array);
+ node = build_java_arrayaccess (array, array_type, index);
+ if (TREE_SIDE_EFFECTS (index))
+ node = build (COMPOUND_EXPR, array_type, array, node);
+ }
+ TREE_TYPE (node) = array_type;
+ return node;
+}
+
+/* 15.9 Array Creation Expressions */
+
+static tree
+build_newarray_node (type, dims, extra_dims)
+ tree type;
+ tree dims;
+ int extra_dims;
+{
+ tree node =
+ build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
+ build_int_2 (extra_dims, 0));
+ return node;
+}
+
+static tree
+patch_newarray (node)
+ tree node;
+{
+ tree type = TREE_OPERAND (node, 0);
+ tree dims = TREE_OPERAND (node, 1);
+ tree cdim, array_type;
+ int error_found = 0;
+ int ndims = 0;
+ int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
+
+ /* Dimension types are verified. It's better for the types to be
+ verified in order. */
+ for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
+ {
+ int dim_error = 0;
+ tree dim = TREE_VALUE (cdim);
+
+ /* Dim might have been saved during its evaluation */
+ dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
+
+ /* The type of each specified dimension must be an integral type. */
+ if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
+ dim_error = 1;
+
+ /* Each expression undergoes an unary numeric promotion (5.6.1) and the
+ promoted type must be int. */
+ else
+ {
+ dim = do_unary_numeric_promotion (dim);
+ if (TREE_TYPE (dim) != int_type_node)
+ dim_error = 1;
+ }
+
+ /* Report errors on types here */
+ if (dim_error)
+ {
+ parse_error_context
+ (TREE_PURPOSE (cdim),
+ "Incompatible type for dimension in array creation expression. "
+ "%s convert `%s' to `int'",
+ (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
+ "Explicit cast needed to" : "Can't"),
+ lang_printable_name (TREE_TYPE (dim), 0));
+ error_found = 1;
+ }
+
+ TREE_PURPOSE (cdim) = NULL_TREE;
+ }
+
+ /* Resolve array base type if unresolved */
+ if (!(type = resolve_type_during_patch (type)))
+ error_found = 1;
+
+ if (error_found)
+ {
+ /* We don't want further evaluation of this bogus array creation
+ operation */
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+
+ /* Set array_type to the actual (promoted) array type of the result. */
+ if (TREE_CODE (type) == RECORD_TYPE)
+ type = build_pointer_type (type);
+ while (--xdims >= 0)
+ {
+ type = promote_type (build_java_array_type (type, -1));
+ }
+ dims = nreverse (dims);
+ array_type = type;
+ for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
+ {
+ type = array_type;
+ array_type = build_java_array_type (type,
+ TREE_CODE (cdim) == INTEGER_CST ?
+ TREE_INT_CST_LOW (cdim) : -1);
+ array_type = promote_type (array_type);
+ }
+ dims = nreverse (dims);
+
+ /* The node is transformed into a function call. Things are done
+ differently according to the number of dimensions. If the number
+ of dimension is equal to 1, then the nature of the base type
+ (primitive or not) matters. */
+ if (ndims == 1)
+ return build_new_array (type, TREE_VALUE (dims));
+
+ /* Can't reuse what's already written in expr.c because it uses the
+ JVM stack representation. Provide a build_multianewarray. FIXME */
+ return build (CALL_EXPR, array_type,
+ build_address_of (soft_multianewarray_node),
+ tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
+ tree_cons (NULL_TREE,
+ build_int_2 (ndims, 0), dims )),
+ NULL_TREE);
+}
+
+/* 10.6 Array initializer. */
+
+/* Build a wfl for array element that don't have one, so we can
+ pin-point errors. */
+
+static tree
+maybe_build_array_element_wfl (node)
+ tree node;
+{
+ if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
+ return build_expr_wfl (NULL_TREE, ctxp->filename,
+ ctxp->elc.line, ctxp->elc.prev_col);
+ else
+ return NULL_TREE;
+}
+
+/* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
+ identification of initialized arrays easier to detect during walk
+ and expansion. */
+
+static tree
+build_new_array_init (location, values)
+ int location;
+ tree values;
+{
+ tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
+ tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
+ EXPR_WFL_LINECOL (to_return) = location;
+ return to_return;
+}
+
+/* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
+ occurred. Otherwise return NODE after having set its type
+ appropriately. */
+
+static tree
+patch_new_array_init (type, node)
+ tree type, node;
+{
+ int error_seen = 0;
+ tree current, element_type;
+ HOST_WIDE_INT length;
+ int all_constant = 1;
+ tree init = TREE_OPERAND (node, 0);
+
+ if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
+ {
+ parse_error_context (node,
+ "Invalid array initializer for non-array type `%s'",
+ lang_printable_name (type, 1));
+ return error_mark_node;
+ }
+ type = TREE_TYPE (type);
+ element_type = TYPE_ARRAY_ELEMENT (type);
+
+ CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
+
+ for (length = 0, current = CONSTRUCTOR_ELTS (init);
+ current; length++, current = TREE_CHAIN (current))
+ {
+ tree elt = TREE_VALUE (current);
+ if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
+ {
+ error_seen |= array_constructor_check_entry (element_type, current);
+ elt = TREE_VALUE (current);
+ /* When compiling to native code, STRING_CST is converted to
+ INDIRECT_REF, but still with a TREE_CONSTANT flag. */
+ if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
+ all_constant = 0;
+ }
+ else
+ {
+ TREE_VALUE (current) = patch_new_array_init (element_type, elt);
+ TREE_PURPOSE (current) = NULL_TREE;
+ all_constant = 0;
+ }
+ if (elt && TREE_VALUE (elt) == error_mark_node)
+ error_seen = 1;
+ }
+
+ if (error_seen)
+ return error_mark_node;
+
+ /* Create a new type. We can't reuse the one we have here by
+ patching its dimension because it originally is of dimension -1
+ hence reused by gcc. This would prevent triangular arrays. */
+ type = build_java_array_type (element_type, length);
+ TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
+ TREE_TYPE (node) = promote_type (type);
+ TREE_CONSTANT (init) = all_constant;
+ TREE_CONSTANT (node) = all_constant;
+ return node;
+}
+
+/* Verify that one entry of the initializer element list can be
+ assigned to the array base type. Report 1 if an error occurred, 0
+ otherwise. */
+
+static int
+array_constructor_check_entry (type, entry)
+ tree type, entry;
+{
+ char *array_type_string = NULL; /* For error reports */
+ tree value, type_value, new_value, wfl_value, patched;
+ int error_seen = 0;
+
+ new_value = NULL_TREE;
+ wfl_value = TREE_VALUE (entry);
+
+ value = java_complete_tree (TREE_VALUE (entry));
+ /* patch_string return error_mark_node if arg is error_mark_node */
+ if ((patched = patch_string (value)))
+ value = patched;
+ if (value == error_mark_node)
+ return 1;
+
+ type_value = TREE_TYPE (value);
+
+ /* At anytime, try_builtin_assignconv can report a warning on
+ constant overflow during narrowing. */
+ SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
+ new_value = try_builtin_assignconv (wfl_operator, type, value);
+ if (!new_value && (new_value = try_reference_assignconv (type, value)))
+ type_value = promote_type (type);
+
+ /* Check and report errors */
+ if (!new_value)
+ {
+ char *msg = (!valid_cast_to_p (type_value, type) ?
+ "Can't" : "Explicit cast needed to");
+ if (!array_type_string)
+ array_type_string = strdup (lang_printable_name (type, 1));
+ parse_error_context
+ (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
+ msg, lang_printable_name (type_value, 1), array_type_string);
+ error_seen = 1;
+ }
+
+ if (new_value)
+ {
+ new_value = maybe_build_primttype_type_ref (new_value, wfl_operator);
+ TREE_VALUE (entry) = new_value;
+ }
+
+ if (array_type_string)
+ free (array_type_string);
+
+ TREE_PURPOSE (entry) = NULL_TREE;
+ return error_seen;
+}
+
+static tree
+build_this (location)
+ int location;
+{
+ tree node = build_wfl_node (this_identifier_node);
+ TREE_SET_CODE (node, THIS_EXPR);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 14.15 The return statement. It builds a modify expression that
+ assigns the returned value to the RESULT_DECL that hold the value
+ to be returned. */
+
+static tree
+build_return (location, op)
+ int location;
+ tree op;
+{
+ tree node = build1 (RETURN_EXPR, NULL_TREE, op);
+ EXPR_WFL_LINECOL (node) = location;
+ node = build_debugable_stmt (location, node);
+ return node;
+}
+
+static tree
+patch_return (node)
+ tree node;
+{
+ tree return_exp = TREE_OPERAND (node, 0);
+ tree meth = current_function_decl;
+ tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
+ int error_found = 0;
+
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* It's invalid to have a return value within a function that is
+ declared with the keyword void or that is a constructor */
+ if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
+ error_found = 1;
+
+ /* It's invalid to use a return statement in a static block */
+ if (IS_CLINIT (current_function_decl))
+ error_found = 1;
+
+ /* It's invalid to have a no return value within a function that
+ isn't declared with the keyword `void' */
+ if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
+ error_found = 2;
+
+ if (error_found)
+ {
+ if (IS_CLINIT (current_function_decl))
+ parse_error_context (wfl_operator,
+ "`return' inside static initializer.");
+
+ else if (!DECL_CONSTRUCTOR_P (meth))
+ {
+ char *t = strdup (lang_printable_name (mtype, 0));
+ parse_error_context (wfl_operator,
+ "`return' with%s value from `%s %s'",
+ (error_found == 1 ? "" : "out"),
+ t, lang_printable_name (meth, 0));
+ free (t);
+ }
+ else
+ parse_error_context (wfl_operator,
+ "`return' with value from constructor `%s'",
+ lang_printable_name (meth, 0));
+ return error_mark_node;
+ }
+
+ /* If we have a return_exp, build a modify expression and expand
+ it. Note: at that point, the assignment is declared valid, but we
+ may want to carry some more hacks */
+ if (return_exp)
+ {
+ tree exp = java_complete_tree (return_exp);
+ tree modify, patched;
+
+ /* If the function returned value and EXP are booleans, EXP has
+ to be converted into the type of DECL_RESULT, which is integer
+ (see complete_start_java_method) */
+ if (TREE_TYPE (exp) == boolean_type_node &&
+ TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node)
+ exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp);
+
+ /* `null' can be assigned to a function returning a reference */
+ if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) &&
+ exp == null_pointer_node)
+ exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth)));
+
+ if ((patched = patch_string (exp)))
+ exp = patched;
+
+ modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
+ EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
+ modify = java_complete_tree (modify);
+
+ if (modify != error_mark_node)
+ {
+ TREE_SIDE_EFFECTS (modify) = 1;
+ TREE_OPERAND (node, 0) = modify;
+ }
+ else
+ return error_mark_node;
+ }
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* 14.8 The if Statement */
+
+static tree
+build_if_else_statement (location, expression, if_body, else_body)
+ int location;
+ tree expression, if_body, else_body;
+{
+ tree node;
+ if (!else_body)
+ else_body = empty_stmt_node;
+ node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
+ EXPR_WFL_LINECOL (node) = location;
+ node = build_debugable_stmt (location, node);
+ return node;
+}
+
+static tree
+patch_if_else_statement (node)
+ tree node;
+{
+ tree expression = TREE_OPERAND (node, 0);
+
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* The type of expression must be boolean */
+ if (TREE_TYPE (expression) != boolean_type_node
+ && TREE_TYPE (expression) != promoted_boolean_type_node)
+ {
+ parse_error_context
+ (wfl_operator,
+ "Incompatible type for `if'. Can't convert `%s' to `boolean'",
+ lang_printable_name (TREE_TYPE (expression), 0));
+ return error_mark_node;
+ }
+
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ CAN_COMPLETE_NORMALLY (node)
+ = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
+ | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2));
+ return node;
+}
+
+/* 14.6 Labeled Statements */
+
+/* Action taken when a lableled statement is parsed. a new
+ LABELED_BLOCK_EXPR is created. No statement is attached to the
+ label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
+
+static tree
+build_labeled_block (location, label)
+ int location;
+ tree label;
+{
+ tree label_name ;
+ tree label_decl, node;
+ if (label == NULL_TREE || label == continue_identifier_node)
+ label_name = label;
+ else
+ {
+ label_name = merge_qualified_name (label_id, label);
+ /* Issue an error if we try to reuse a label that was previously
+ declared */
+ if (IDENTIFIER_LOCAL_VALUE (label_name))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = location;
+ parse_error_context (wfl_operator, "Declaration of `%s' shadows "
+ "a previous label declaration",
+ IDENTIFIER_POINTER (label));
+ EXPR_WFL_LINECOL (wfl_operator) =
+ EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
+ parse_error_context (wfl_operator, "This is the location of the "
+ "previous declaration of label `%s'",
+ IDENTIFIER_POINTER (label));
+ java_error_count--;
+ }
+ }
+
+ label_decl = create_label_decl (label_name);
+ node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
+ EXPR_WFL_LINECOL (node) = location;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* A labeled statement LBE is attached a statement. */
+
+static tree
+finish_labeled_statement (lbe, statement)
+ tree lbe; /* Labeled block expr */
+ tree statement;
+{
+ /* In anyways, tie the loop to its statement */
+ LABELED_BLOCK_BODY (lbe) = statement;
+ pop_labeled_block ();
+ POP_LABELED_BLOCK ();
+ return lbe;
+}
+
+/* 14.10, 14.11, 14.12 Loop Statements */
+
+/* Create an empty LOOP_EXPR and make it the last in the nested loop
+ list. */
+
+static tree
+build_new_loop (loop_body)
+ tree loop_body;
+{
+ tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
+ TREE_SIDE_EFFECTS (loop) = 1;
+ PUSH_LOOP (loop);
+ return loop;
+}
+
+/* Create a loop body according to the following structure:
+ COMPOUND_EXPR
+ COMPOUND_EXPR (loop main body)
+ EXIT_EXPR (this order is for while/for loops.
+ LABELED_BLOCK_EXPR the order is reversed for do loops)
+ LABEL_DECL (a continue occuring here branches at the
+ BODY end of this labeled block)
+ INCREMENT (if any)
+
+ REVERSED, if non zero, tells that the loop condition expr comes
+ after the body, like in the do-while loop.
+
+ To obtain a loop, the loop body structure described above is
+ encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
+
+ LABELED_BLOCK_EXPR
+ LABEL_DECL (use this label to exit the loop)
+ LOOP_EXPR
+ <structure described above> */
+
+static tree
+build_loop_body (location, condition, reversed)
+ int location;
+ tree condition;
+ int reversed;
+{
+ tree first, second, body;
+
+ condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
+ EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
+ condition = build_debugable_stmt (location, condition);
+ TREE_SIDE_EFFECTS (condition) = 1;
+
+ body = build_labeled_block (0, continue_identifier_node);
+ first = (reversed ? body : condition);
+ second = (reversed ? condition : body);
+ return
+ build (COMPOUND_EXPR, NULL_TREE,
+ build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
+}
+
+/* Install CONDITION (if any) and loop BODY (using REVERSED to tell
+ their order) on the current loop. Unlink the current loop from the
+ loop list. */
+
+static tree
+finish_loop_body (location, condition, body, reversed)
+ int location;
+ tree condition, body;
+ int reversed;
+{
+ tree to_return = ctxp->current_loop;
+ tree loop_body = LOOP_EXPR_BODY (to_return);
+ if (condition)
+ {
+ tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
+ /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
+ The real EXIT_EXPR is one operand further. */
+ EXPR_WFL_LINECOL (cnode) = location;
+ /* This one is for accurate error reports */
+ EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
+ TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
+ }
+ LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
+ POP_LOOP ();
+ return to_return;
+}
+
+/* Tailored version of finish_loop_body for FOR loops, when FOR
+ loops feature the condition part */
+
+static tree
+finish_for_loop (location, condition, update, body)
+ int location;
+ tree condition, update, body;
+{
+ /* Put the condition and the loop body in place */
+ tree loop = finish_loop_body (location, condition, body, 0);
+ /* LOOP is the current loop which has been now popped of the loop
+ stack. Install the update block */
+ LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
+ return loop;
+}
+
+/* If the loop isn't surrounded by a labeled statement, create one and
+ insert LOOP as its body. */
+
+static tree
+patch_loop_statement (loop)
+ tree loop;
+{
+ tree loop_label;
+ tree block = ctxp->current_labeled_block;
+ TREE_TYPE (loop) = void_type_node;
+ if (block != NULL_TREE)
+ {
+ tree block_body = LABELED_BLOCK_BODY (block);
+ if (IS_FOR_LOOP_P (loop))
+ {
+ if (TREE_CODE (block_body) == BLOCK)
+ {
+ block_body = BLOCK_EXPR_BODY (block_body);
+ if (block_body == loop
+ || (TREE_CODE (block_body) == COMPOUND_EXPR
+ && TREE_OPERAND (block_body, 1) == loop))
+ return loop;
+ }
+ }
+ else
+ {
+ if (block_body == loop)
+ return loop;
+ }
+ }
+ loop_label = build_labeled_block (0, NULL_TREE);
+ LABELED_BLOCK_BODY (loop_label) = loop;
+ PUSH_LABELED_BLOCK (loop_label);
+ loop = loop_label;
+ return loop;
+}
+
+/* 14.13, 14.14: break and continue Statements */
+
+/* Build a break or a continue statement. a null NAME indicates an
+ unlabeled break/continue statement. */
+
+static tree
+build_bc_statement (location, is_break, name)
+ int location, is_break;
+ tree name;
+{
+ tree break_continue, label_block_expr = NULL_TREE;
+
+ if (name)
+ {
+ if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
+ (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
+ /* Null means that we don't have a target for this named
+ break/continue. In this case, we make the target to be the
+ label name, so that the error can be reported accuratly in
+ patch_bc_statement. */
+ label_block_expr = EXPR_WFL_NODE (name);
+ }
+ /* Unlabeled break/continue will be handled during the
+ break/continue patch operation */
+ break_continue
+ = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
+
+ IS_BREAK_STMT_P (break_continue) = is_break;
+ TREE_SIDE_EFFECTS (break_continue) = 1;
+ EXPR_WFL_LINECOL (break_continue) = location;
+ break_continue = build_debugable_stmt (location, break_continue);
+ return break_continue;
+}
+
+/* Verification of a break/continue statement. */
+
+static tree
+patch_bc_statement (node)
+ tree node;
+{
+ tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
+ tree labeled_block = ctxp->current_labeled_block;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Having an identifier here means that the target is unknown. */
+ if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
+ {
+ parse_error_context (wfl_operator, "No label definition found for `%s'",
+ IDENTIFIER_POINTER (bc_label));
+ return error_mark_node;
+ }
+ if (! IS_BREAK_STMT_P (node))
+ {
+ /* It's a continue statement. */
+ for (;; labeled_block = TREE_CHAIN (labeled_block))
+ {
+ if (labeled_block == NULL_TREE)
+ {
+ if (bc_label == NULL_TREE)
+ parse_error_context (wfl_operator,
+ "`continue' must be in loop");
+ else
+ parse_error_context
+ (wfl_operator, "continue label `%s' does not name a loop",
+ IDENTIFIER_POINTER (bc_label));
+ return error_mark_node;
+ }
+ if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
+ == continue_identifier_node)
+ && (bc_label == NULL_TREE
+ || TREE_CHAIN (labeled_block) == bc_label))
+ {
+ bc_label = labeled_block;
+ break;
+ }
+ }
+ }
+ else if (!bc_label)
+ {
+ for (;; labeled_block = TREE_CHAIN (labeled_block))
+ {
+ if (labeled_block == NULL_TREE)
+ {
+ parse_error_context (wfl_operator,
+ "`break' must be in loop or switch");
+ return error_mark_node;
+ }
+ target_stmt = LABELED_BLOCK_BODY (labeled_block);
+ if (TREE_CODE (target_stmt) == SWITCH_EXPR
+ || TREE_CODE (target_stmt) == LOOP_EXPR)
+ {
+ bc_label = labeled_block;
+ break;
+ }
+ }
+ }
+
+ EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
+ CAN_COMPLETE_NORMALLY (bc_label) = 1;
+
+ /* Our break/continue don't return values. */
+ TREE_TYPE (node) = void_type_node;
+ /* Encapsulate the break within a compound statement so that it's
+ expanded all the times by expand_expr (and not clobered
+ sometimes, like after a if statement) */
+ node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Process the exit expression belonging to a loop. Its type must be
+ boolean. */
+
+static tree
+patch_exit_expr (node)
+ tree node;
+{
+ tree expression = TREE_OPERAND (node, 0);
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* The type of expression must be boolean */
+ if (TREE_TYPE (expression) != boolean_type_node)
+ {
+ parse_error_context
+ (wfl_operator,
+ "Incompatible type for loop conditional. Can't convert `%s' to "
+ "`boolean'",
+ lang_printable_name (TREE_TYPE (expression), 0));
+ return error_mark_node;
+ }
+ /* Now we know things are allright, invert the condition, fold and
+ return */
+ TREE_OPERAND (node, 0) =
+ fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
+
+ if (! integer_zerop (TREE_OPERAND (node, 0))
+ && ctxp->current_loop != NULL_TREE
+ && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
+ CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
+ if (! integer_onep (TREE_OPERAND (node, 0)))
+ CAN_COMPLETE_NORMALLY (node) = 1;
+
+
+ TREE_TYPE (node) = void_type_node;
+ return node;
+}
+
+/* 14.9 Switch statement */
+
+static tree
+patch_switch_statement (node)
+ tree node;
+{
+ tree se = TREE_OPERAND (node, 0), se_type;
+
+ /* Complete the switch expression */
+ se = TREE_OPERAND (node, 0) = java_complete_tree (se);
+ se_type = TREE_TYPE (se);
+ /* The type of the switch expression must be char, byte, short or
+ int */
+ if (!JINTEGRAL_TYPE_P (se_type))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context (wfl_operator, "Incompatible type for `switch'. "
+ "Can't convert `%s' to `int'",
+ lang_printable_name (se_type, 0));
+ /* This is what java_complete_tree will check */
+ TREE_OPERAND (node, 0) = error_mark_node;
+ return error_mark_node;
+ }
+
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+
+ /* Ready to return */
+ if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
+ {
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ CAN_COMPLETE_NORMALLY (node)
+ = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
+ || ! SWITCH_HAS_DEFAULT (node);
+ return node;
+}
+
+/* 14.18 The try statement */
+
+static tree
+build_try_statement (location, try_block, catches)
+ int location;
+ tree try_block, catches;
+{
+ tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+static tree
+build_try_finally_statement (location, try_block, finally)
+ int location;
+ tree try_block, finally;
+{
+ tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+static tree
+patch_try_statement (node)
+ tree node;
+{
+ int error_found = 0;
+ tree try = TREE_OPERAND (node, 0);
+ /* Exception handlers are considered in left to right order */
+ tree catch = nreverse (TREE_OPERAND (node, 1));
+ tree current, caught_type_list = NULL_TREE;
+
+ /* Check catch clauses, if any. Every time we find an error, we try
+ to process the next catch clause. We process the catch clause before
+ the try block so that when processing the try block we can check thrown
+ exceptions againts the caught type list. */
+ for (current = catch; current; current = TREE_CHAIN (current))
+ {
+ tree carg_decl, carg_type;
+ tree sub_current, catch_block, catch_clause;
+ int unreachable;
+
+ /* At this point, the structure of the catch clause is
+ CATCH_EXPR (catch node)
+ BLOCK (with the decl of the parameter)
+ COMPOUND_EXPR
+ MODIFY_EXPR (assignment of the catch parameter)
+ BLOCK (catch clause block)
+ */
+ catch_clause = TREE_OPERAND (current, 0);
+ carg_decl = BLOCK_EXPR_DECLS (catch_clause);
+ carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
+
+ /* Catch clauses can't have more than one parameter declared,
+ but it's already enforced by the grammar. Make sure that the
+ only parameter of the clause statement in of class Throwable
+ or a subclass of Throwable, but that was done earlier. The
+ catch clause parameter type has also been resolved. */
+
+ /* Just make sure that the catch clause parameter type inherits
+ from java.lang.Throwable */
+ if (!inherits_from_p (carg_type, throwable_type_node))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
+ parse_error_context (wfl_operator,
+ "Can't catch class `%s'. Catch clause "
+ "parameter type must be a subclass of "
+ "class `java.lang.Throwable'",
+ lang_printable_name (carg_type, 0));
+ error_found = 1;
+ continue;
+ }
+
+ /* Partial check for unreachable catch statement: The catch
+ clause is reachable iff is no earlier catch block A in
+ the try statement such that the type of the catch
+ clause's parameter is the same as or a subclass of the
+ type of A's parameter */
+ unreachable = 0;
+ for (sub_current = catch;
+ sub_current != current; sub_current = TREE_CHAIN (sub_current))
+ {
+ tree sub_catch_clause, decl;
+ sub_catch_clause = TREE_OPERAND (sub_current, 0);
+ decl = BLOCK_EXPR_DECLS (sub_catch_clause);
+
+ if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
+ parse_error_context
+ (wfl_operator, "`catch' not reached because of the catch "
+ "clause at line %d", EXPR_WFL_LINENO (sub_current));
+ unreachable = error_found = 1;
+ break;
+ }
+ }
+ /* Complete the catch clause block */
+ catch_block = java_complete_tree (TREE_OPERAND (current, 0));
+ if (catch_block == error_mark_node)
+ {
+ error_found = 1;
+ continue;
+ }
+ if (CAN_COMPLETE_NORMALLY (catch_block))
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ TREE_OPERAND (current, 0) = catch_block;
+
+ if (unreachable)
+ continue;
+
+ /* Things to do here: the exception must be thrown */
+
+ /* Link this type to the caught type list */
+ caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
+ }
+
+ PUSH_EXCEPTIONS (caught_type_list);
+ if ((try = java_complete_tree (try)) == error_mark_node)
+ error_found = 1;
+ if (CAN_COMPLETE_NORMALLY (try))
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ POP_EXCEPTIONS ();
+
+ /* Verification ends here */
+ if (error_found)
+ return error_mark_node;
+
+ TREE_OPERAND (node, 0) = try;
+ TREE_OPERAND (node, 1) = catch;
+ TREE_TYPE (node) = void_type_node;
+ return node;
+}
+
+/* 14.17 The synchronized Statement */
+
+static tree
+patch_synchronized_statement (node, wfl_op1)
+ tree node, wfl_op1;
+{
+ tree expr = java_complete_tree (TREE_OPERAND (node, 0));
+ tree block = TREE_OPERAND (node, 1);
+
+ tree enter, exit, expr_decl, assignment;
+
+ if (expr == error_mark_node)
+ {
+ block = java_complete_tree (block);
+ return expr;
+ }
+
+ /* The TYPE of expr must be a reference type */
+ if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
+ {
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
+ parse_error_context (wfl_operator, "Incompatible type for `synchronized'"
+ ". Can't convert `%s' to `java.lang.Object'",
+ lang_printable_name (TREE_TYPE (expr), 0));
+ return error_mark_node;
+ }
+
+ if (flag_emit_xref)
+ {
+ TREE_OPERAND (node, 0) = expr;
+ TREE_OPERAND (node, 1) = java_complete_tree (block);
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ return node;
+ }
+
+ /* Generate a try-finally for the synchronized statement, except
+ that the handler that catches all throw exception calls
+ _Jv_MonitorExit and then rethrow the exception.
+ The synchronized statement is then implemented as:
+ TRY
+ {
+ _Jv_MonitorEnter (expression)
+ synchronized_block
+ _Jv_MonitorExit (expression)
+ }
+ CATCH_ALL
+ {
+ e = _Jv_exception_info ();
+ _Jv_MonitorExit (expression)
+ Throw (e);
+ } */
+
+ expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
+ BUILD_MONITOR_ENTER (enter, expr_decl);
+ BUILD_MONITOR_EXIT (exit, expr_decl);
+ CAN_COMPLETE_NORMALLY (enter) = 1;
+ CAN_COMPLETE_NORMALLY (exit) = 1;
+ assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
+ TREE_SIDE_EFFECTS (assignment) = 1;
+ node = build1 (CLEANUP_POINT_EXPR, NULL_TREE,
+ build (COMPOUND_EXPR, NULL_TREE,
+ build (WITH_CLEANUP_EXPR, NULL_TREE,
+ build (COMPOUND_EXPR, NULL_TREE,
+ assignment, enter),
+ NULL_TREE, exit),
+ block));
+ node = build_expr_block (node, expr_decl);
+
+ return java_complete_tree (node);
+}
+
+/* 14.16 The throw Statement */
+
+static tree
+patch_throw_statement (node, wfl_op1)
+ tree node, wfl_op1;
+{
+ tree expr = TREE_OPERAND (node, 0);
+ tree type = TREE_TYPE (expr);
+ int unchecked_ok = 0, tryblock_throws_ok = 0;
+
+ /* Thrown expression must be assignable to java.lang.Throwable */
+ if (!try_reference_assignconv (throwable_type_node, expr))
+ {
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
+ parse_error_context (wfl_operator, "Can't throw `%s'; it must be a "
+ "subclass of class `java.lang.Throwable'",
+ lang_printable_name (type, 0));
+ /* If the thrown expression was a reference, we further the
+ compile-time check. */
+ if (!JREFERENCE_TYPE_P (type))
+ return error_mark_node;
+ }
+
+ /* At least one of the following must be true */
+
+ /* The type of the throw expression is a not checked exception,
+ i.e. is a unchecked expression. */
+ unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
+
+ /* Throw is contained in a try statement and at least one catch
+ clause can receive the thrown expression or the current method is
+ declared to throw such an exception. Or, the throw statement is
+ contained in a method or constructor declaration and the type of
+ the Expression is assignable to at least one type listed in the
+ throws clause the declaration. */
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
+ if (!unchecked_ok)
+ tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
+ if (!(unchecked_ok || tryblock_throws_ok))
+ {
+ /* If there is a surrounding try block that has no matching
+ clatch clause, report it first. A surrounding try block exits
+ only if there is something after the list of checked
+ exception thrown by the current function (if any). */
+ if (IN_TRY_BLOCK_P ())
+ parse_error_context (wfl_operator, "Checked exception `%s' can't be "
+ "caught by any of the catch clause(s) "
+ "of the surrounding `try' block",
+ lang_printable_name (type, 0));
+ /* If we have no surrounding try statement and the method doesn't have
+ any throws, report it now. FIXME */
+
+ /* We report that the exception can't be throw from a try block
+ in all circumstances but when the `throw' is inside a static
+ block. */
+ else if (!EXCEPTIONS_P (currently_caught_type_list)
+ && !tryblock_throws_ok)
+ {
+ if (IS_CLINIT (current_function_decl))
+ parse_error_context (wfl_operator, "Checked exception `%s' can't "
+ "be thrown in initializer",
+ lang_printable_name (type, 0));
+ else
+ parse_error_context (wfl_operator, "Checked exception `%s' isn't "
+ "thrown from a `try' block",
+ lang_printable_name (type, 0));
+ }
+ /* Otherwise, the current method doesn't have the appropriate
+ throws declaration */
+ else
+ parse_error_context (wfl_operator, "Checked exception `%s' doesn't "
+ "match any of current method's `throws' "
+ "declaration(s)",
+ lang_printable_name (type, 0));
+ return error_mark_node;
+ }
+
+ if (! flag_emit_class_files && ! flag_emit_xref)
+ BUILD_THROW (node, expr);
+
+ /* If doing xrefs, keep the location where the `throw' was seen. */
+ if (flag_emit_xref)
+ EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
+ return node;
+}
+
+/* Check that exception said to be thrown by method DECL can be
+ effectively caught from where DECL is invoked. */
+
+static void
+check_thrown_exceptions (location, decl)
+ int location;
+ tree decl;
+{
+ tree throws;
+ /* For all the unchecked exceptions thrown by DECL */
+ for (throws = DECL_FUNCTION_THROWS (decl); throws;
+ throws = TREE_CHAIN (throws))
+ if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
+ {
+#if 1
+ /* Temporary hack to suppresses errors about cloning arrays. FIXME */
+ if (DECL_NAME (decl) == get_identifier ("clone"))
+ continue;
+#endif
+ EXPR_WFL_LINECOL (wfl_operator) = location;
+ parse_error_context
+ (wfl_operator, "Exception `%s' must be caught, or it must be "
+ "declared in the `throws' clause of `%s'",
+ lang_printable_name (TREE_VALUE (throws), 0),
+ IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
+ }
+}
+
+/* Return 1 if checked EXCEPTION is caught at the current nesting level of
+ try-catch blocks, OR is listed in the `throws' clause of the
+ current method. */
+
+static int
+check_thrown_exceptions_do (exception)
+ tree exception;
+{
+ tree list = currently_caught_type_list;
+ resolve_and_layout (exception, NULL_TREE);
+ /* First, all the nested try-catch-finally at that stage. The
+ last element contains `throws' clause exceptions, if any. */
+ if (IS_UNCHECKED_EXCEPTION_P (exception))
+ return 1;
+ while (list)
+ {
+ tree caught;
+ for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
+ if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
+ return 1;
+ list = TREE_CHAIN (list);
+ }
+ return 0;
+}
+
+static void
+purge_unchecked_exceptions (mdecl)
+ tree mdecl;
+{
+ tree throws = DECL_FUNCTION_THROWS (mdecl);
+ tree new = NULL_TREE;
+
+ while (throws)
+ {
+ tree next = TREE_CHAIN (throws);
+ if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
+ {
+ TREE_CHAIN (throws) = new;
+ new = throws;
+ }
+ throws = next;
+ }
+ /* List is inverted here, but it doesn't matter */
+ DECL_FUNCTION_THROWS (mdecl) = new;
+}
+
+/* 15.24 Conditional Operator ?: */
+
+static tree
+patch_conditional_expr (node, wfl_cond, wfl_op1)
+ tree node, wfl_cond, wfl_op1;
+{
+ tree cond = TREE_OPERAND (node, 0);
+ tree op1 = TREE_OPERAND (node, 1);
+ tree op2 = TREE_OPERAND (node, 2);
+ tree resulting_type = NULL_TREE;
+ tree t1, t2, patched;
+ int error_found = 0;
+
+ /* Operands of ?: might be StringBuffers crafted as a result of a
+ string concatenation. Obtain a descent operand here. */
+ if ((patched = patch_string (op1)))
+ TREE_OPERAND (node, 1) = op1 = patched;
+ if ((patched = patch_string (op2)))
+ TREE_OPERAND (node, 2) = op2 = patched;
+
+ t1 = TREE_TYPE (op1);
+ t2 = TREE_TYPE (op2);
+
+ /* The first expression must be a boolean */
+ if (TREE_TYPE (cond) != boolean_type_node)
+ {
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
+ parse_error_context (wfl_operator, "Incompatible type for `?:'. Can't "
+ "convert `%s' to `boolean'",
+ lang_printable_name (TREE_TYPE (cond), 0));
+ error_found = 1;
+ }
+
+ /* Second and third can be numeric, boolean (i.e. primitive),
+ references or null. Anything else results in an error */
+ if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
+ || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
+ && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
+ || (t1 == boolean_type_node && t2 == boolean_type_node)))
+ error_found = 1;
+
+ /* Determine the type of the conditional expression. Same types are
+ easy to deal with */
+ else if (t1 == t2)
+ resulting_type = t1;
+
+ /* There are different rules for numeric types */
+ else if (JNUMERIC_TYPE_P (t1))
+ {
+ /* if byte/short found, the resulting type is short */
+ if ((t1 == byte_type_node && t2 == short_type_node)
+ || (t1 == short_type_node && t2 == byte_type_node))
+ resulting_type = short_type_node;
+
+ /* If t1 is a constant int and t2 is of type byte, short or char
+ and t1's value fits in t2, then the resulting type is t2 */
+ else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
+ && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
+ resulting_type = t2;
+
+ /* If t2 is a constant int and t1 is of type byte, short or char
+ and t2's value fits in t1, then the resulting type is t1 */
+ else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
+ && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
+ resulting_type = t1;
+
+ /* Otherwise, binary numeric promotion is applied and the
+ resulting type is the promoted type of operand 1 and 2 */
+ else
+ resulting_type = binary_numeric_promotion (t1, t2,
+ &TREE_OPERAND (node, 1),
+ &TREE_OPERAND (node, 2));
+ }
+
+ /* Cases of a reference and a null type */
+ else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
+ resulting_type = t1;
+
+ else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
+ resulting_type = t2;
+
+ /* Last case: different reference types. If a type can be converted
+ into the other one by assignment conversion, the latter
+ determines the type of the expression */
+ else if ((resulting_type = try_reference_assignconv (t1, op2)))
+ resulting_type = promote_type (t1);
+
+ else if ((resulting_type = try_reference_assignconv (t2, op1)))
+ resulting_type = promote_type (t2);
+
+ /* If we don't have any resulting type, we're in trouble */
+ if (!resulting_type)
+ {
+ char *t = strdup (lang_printable_name (t1, 0));
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
+ parse_error_context (wfl_operator, "Incompatible type for `?:'. Can't "
+ "convert `%s' to `%s'", t,
+ lang_printable_name (t2, 0));
+ free (t);
+ error_found = 1;
+ }
+
+ if (error_found)
+ {
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+
+ TREE_TYPE (node) = resulting_type;
+ TREE_SET_CODE (node, COND_EXPR);
+ CAN_COMPLETE_NORMALLY (node) = 1;
+ return node;
+}
+
+/* Try to constant fold NODE.
+ If NODE is not a constant expression, return NULL_EXPR.
+ CONTEXT is a static final VAR_DECL whose initializer we are folding. */
+
+static tree
+fold_constant_for_init (node, context)
+ tree node;
+ tree context;
+{
+ tree op0, op1, val;
+ enum tree_code code = TREE_CODE (node);
+
+ if (code == STRING_CST)
+ return node;
+
+ if (code == INTEGER_CST || code == REAL_CST)
+ return convert (TREE_TYPE (context), node);
+ if (TREE_TYPE (node) != NULL_TREE && code != VAR_DECL && code != FIELD_DECL)
+ return NULL_TREE;
+
+ switch (code)
+ {
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ case MULT_EXPR:
+ case TRUNC_MOD_EXPR:
+ case RDIV_EXPR:
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case EQ_EXPR:
+ case NE_EXPR:
+ case GT_EXPR:
+ case GE_EXPR:
+ case LT_EXPR:
+ case LE_EXPR:
+ op0 = TREE_OPERAND (node, 0);
+ op1 = TREE_OPERAND (node, 1);
+ val = fold_constant_for_init (op0, context);
+ if (val == NULL_TREE || ! TREE_CONSTANT (val))
+ return NULL_TREE;
+ TREE_OPERAND (node, 0) = val;
+ val = fold_constant_for_init (op1, context);
+ if (val == NULL_TREE || ! TREE_CONSTANT (val))
+ return NULL_TREE;
+ TREE_OPERAND (node, 1) = val;
+ return patch_binop (node, op0, op1);
+
+ case UNARY_PLUS_EXPR:
+ case NEGATE_EXPR:
+ case TRUTH_NOT_EXPR:
+ case BIT_NOT_EXPR:
+ case CONVERT_EXPR:
+ op0 = TREE_OPERAND (node, 0);
+ val = fold_constant_for_init (op0, context);
+ if (val == NULL_TREE || ! TREE_CONSTANT (val))
+ return NULL_TREE;
+ TREE_OPERAND (node, 0) = val;
+ return patch_unaryop (node, op0);
+ break;
+
+ case COND_EXPR:
+ val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
+ if (val == NULL_TREE || ! TREE_CONSTANT (val))
+ return NULL_TREE;
+ TREE_OPERAND (node, 0) = val;
+ val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
+ if (val == NULL_TREE || ! TREE_CONSTANT (val))
+ return NULL_TREE;
+ TREE_OPERAND (node, 1) = val;
+ val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
+ if (val == NULL_TREE || ! TREE_CONSTANT (val))
+ return NULL_TREE;
+ TREE_OPERAND (node, 2) = val;
+ return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
+ : TREE_OPERAND (node, 2);
+
+ case VAR_DECL:
+ case FIELD_DECL:
+ if (! FIELD_FINAL (node)
+ || DECL_INITIAL (node) == NULL_TREE)
+ return NULL_TREE;
+ val = DECL_INITIAL (node);
+ /* Guard against infinite recursion. */
+ DECL_INITIAL (node) = NULL_TREE;
+ val = fold_constant_for_init (val, node);
+ DECL_INITIAL (node) = val;
+ return val;
+
+ case EXPR_WITH_FILE_LOCATION:
+ /* Compare java_complete_tree and resolve_expression_name. */
+ if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
+ || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
+ {
+ tree name = EXPR_WFL_NODE (node);
+ tree decl;
+ if (PRIMARY_P (node))
+ return NULL_TREE;
+ else if (! QUALIFIED_P (name))
+ {
+ decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
+ if (decl == NULL_TREE
+ || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
+ return NULL_TREE;
+ return fold_constant_for_init (decl, decl);
+ }
+ else
+ {
+ /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
+ qualify_ambiguous_name (node);
+ if (resolve_field_access (node, &decl, NULL)
+ && decl != NULL_TREE)
+ return fold_constant_for_init (decl, decl);
+ return NULL_TREE;
+ }
+ }
+ else
+ {
+ op0 = TREE_OPERAND (node, 0);
+ val = fold_constant_for_init (op0, context);
+ if (val == NULL_TREE || ! TREE_CONSTANT (val))
+ return NULL_TREE;
+ TREE_OPERAND (node, 0) = val;
+ return val;
+ }
+
+#ifdef USE_COMPONENT_REF
+ case IDENTIFIER:
+ case COMPONENT_REF:
+ ?;
+#endif
+
+ default:
+ return NULL_TREE;
+ }
+}
+
+#ifdef USE_COMPONENT_REF
+/* Context is 'T' for TypeName, 'P' for PackageName,
+ 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
+
+tree
+resolve_simple_name (name, context)
+ tree name;
+ int context;
+{
+}
+
+tree
+resolve_qualified_name (name, context)
+ tree name;
+ int context;
+{
+}
+#endif