diff options
| author | mrg <mrg@NetBSD.org> | 2006-06-02 22:17:11 +0000 |
|---|---|---|
| committer | mrg <mrg@NetBSD.org> | 2006-06-02 22:17:11 +0000 |
| commit | bd88defe28db0f3e04ee650d86c5bbc95f9a481e (patch) | |
| tree | f3e56ee9f07cf1d11f0dd395f7a0029f700cbc62 /gnu/dist/toolchain/gcc/java/parse.y | |
| parent | db19e89e04ef4a31ce779771479fada19bccde62 (diff) | |
delete GCC2.95.3 sources.
Diffstat (limited to 'gnu/dist/toolchain/gcc/java/parse.y')
| -rw-r--r-- | gnu/dist/toolchain/gcc/java/parse.y | 11775 |
1 files changed, 0 insertions, 11775 deletions
diff --git a/gnu/dist/toolchain/gcc/java/parse.y b/gnu/dist/toolchain/gcc/java/parse.y deleted file mode 100644 index 8abd4a7c079..00000000000 --- a/gnu/dist/toolchain/gcc/java/parse.y +++ /dev/null @@ -1,11775 +0,0 @@ -/* 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, ¤t_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 |
