/* Source code parsing and tree node generation for the GNU compiler
for the Java(TM) language.
- Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
#include "ggc.h"
#include "debug.h"
#include "tree-inline.h"
+#include "cgraph.h"
+#include "target.h"
/* Local function prototypes */
static char *java_accstring_lookup (int);
+static const char *accessibility_string (int);
static void classitf_redefinition_error (const char *,tree, tree, tree);
static void variable_redefinition_error (tree, tree, tree, int);
static tree create_class (int, tree, tree, tree);
static int find_in_imports_on_demand (tree, tree);
static void find_in_imports (tree, tree);
static void check_inner_class_access (tree, tree, tree);
-static int check_pkg_class_access (tree, tree, bool);
+static int check_pkg_class_access (tree, tree, bool, tree);
static void register_package (tree);
static tree resolve_package (tree, tree *, tree *);
static tree resolve_class (tree, tree, tree, tree);
static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
static int check_class_interface_creation (int, int, tree, tree, tree, tree);
static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
-static int breakdown_qualified (tree *, tree *, tree);
-static int in_same_package (tree, tree);
static tree resolve_and_layout (tree, tree);
static tree qualify_and_find (tree, tree, tree);
static tree resolve_no_layout (tree, tree);
static int class_in_current_package (tree);
static tree build_if_else_statement (int, tree, tree, tree);
static tree patch_if_else_statement (tree);
-static tree add_stmt_to_compound (tree, tree, tree);
static tree add_stmt_to_block (tree, tree, tree);
static tree patch_exit_expr (tree);
static tree build_labeled_block (int, tree);
static tree patch_try_statement (tree);
static tree patch_synchronized_statement (tree, tree);
static tree patch_throw_statement (tree, tree);
-static void check_thrown_exceptions (int, tree);
+static void check_thrown_exceptions (int, tree, tree);
static int check_thrown_exceptions_do (tree);
static void purge_unchecked_exceptions (tree);
static bool ctors_unchecked_throws_clause_p (tree);
+static void check_concrete_throws_clauses (tree, tree, tree, tree);
static void check_throws_clauses (tree, tree, tree);
static void finish_method_declaration (tree);
static tree build_super_invocation (tree);
static void end_artificial_method_body (tree);
static int check_method_redefinition (tree, tree);
static int check_method_types_complete (tree);
+static bool hack_is_accessible_p (tree, tree);
static void java_check_regular_methods (tree);
+static void check_interface_throws_clauses (tree, tree);
static void java_check_abstract_methods (tree);
static void unreachable_stmt_error (tree);
+static int not_accessible_field_error (tree, tree);
static tree find_expr_with_wfl (tree);
static void missing_return_error (tree);
static tree build_new_array_init (int, tree);
static tree maybe_make_nested_class_name (tree);
static int make_nested_class_name (tree);
-static void set_nested_class_simple_name_value (tree, int);
static void link_nested_class_to_enclosing (void);
static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
static tree find_as_inner_class (tree, tree, tree);
static tree outer_field_access_fix (tree, tree, tree);
static tree build_incomplete_class_ref (int, tree);
static tree patch_incomplete_class_ref (tree);
-static tree create_anonymous_class (int, tree);
+static tree create_anonymous_class (tree);
static void patch_anonymous_class (tree, tree, tree);
static void add_inner_class_fields (tree, tree);
static tree build_dot_class_method (tree);
-static tree build_dot_class_method_invocation (tree);
+static tree build_dot_class_method_invocation (tree, tree);
static void create_new_parser_context (int);
static tree maybe_build_class_init_for_field (tree, tree);
binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
/* This is the end index for binary operators that can also be used
- in compound assignements. */
+ in compound assignments. */
#define BINOP_COMPOUND_CANDIDATES 11
/* The "$L" identifier we use to create labels. */
static GTY(()) tree current_this;
/* 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. */
+ the list of the catch clauses of the currently analyzed try block. */
static GTY(()) tree currently_caught_type_list;
/* This holds a linked list of all the case labels for the current
| constructor_declaration
| block /* Added, JDK1.1, instance initializer */
{
- if ($1 != empty_stmt_node)
+ if (!IS_EMPTY_STMT ($1))
{
TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
addition (super invocation and field initialization) */
block_begin constructor_block_end
{
- BLOCK_EXPR_BODY ($2) = empty_stmt_node;
+ BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
$$ = $2;
}
| block_begin explicit_constructor_invocation constructor_block_end
/* 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_end
+ { $$ = $2; }
| block_begin block_statements block_end
{ $$ = $3; }
;
EXPR_WFL_ADD_COL ($1.location, 1);
$$ = exit_block ();
if (!BLOCK_SUBBLOCKS ($$))
- BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
+ BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
}
;
(DECL_CONTEXT (current_function_decl)))))
{
- EXPR_WFL_SET_LINECOL (wfl_operator, lineno, -1);
+ EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
}
- $$ = empty_stmt_node;
+ $$ = build_java_empty_stmt ();
}
;
{
/* We have a statement. Generate a WFL around it so
we can debug it */
- $$ = build_expr_wfl ($1, input_filename, lineno, 0);
+ $$ = build_expr_wfl ($1, input_filename, input_line, 0);
/* We know we have a statement, so set the debug
info to be eventually generate here. */
$$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
switch_expression:
SWITCH_TK OP_TK expression CP_TK
{
- $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
+ $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE, NULL_TREE);
EXPR_WFL_LINECOL ($$) = $2.location;
}
| SWITCH_TK error
}
| DEFAULT_TK REL_CL_TK
{
- tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
+ tree lab = make_node (DEFAULT_EXPR);
EXPR_WFL_LINECOL (lab) = $1.location;
java_method_add_stmt (current_function_decl, lab);
}
$$ = 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;
+ build_java_empty_stmt ();
}
| for_begin SC_TK error
{yyerror ("Invalid control expression"); RECOVER;}
$$ = 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;
+ build_java_empty_stmt ();
}
;
}
;
for_init: /* Can be empty */
- { $$ = empty_stmt_node; }
+ { $$ = build_java_empty_stmt (); }
| statement_expression_list
{
/* Init statement recorded within the previously
;
for_update: /* Can be empty */
- {$$ = empty_stmt_node;}
+ {$$ = build_java_empty_stmt ();}
| statement_expression_list
{ $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
;
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),
- build (JAVA_EXC_OBJ_EXPR, ptr_type_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;
+ tree ccpb;
+ tree init;
+ if ($3)
+ {
+ ccpb = enter_block ();
+ init = build_assignment
+ (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
+ build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
+ declare_local_variables (0, TREE_VALUE ($3),
+ build_tree_list
+ (TREE_PURPOSE ($3), init));
+ $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
+ EXPR_WFL_LINECOL ($$) = $1.location;
+ }
+ else
+ {
+ $$ = error_mark_node;
+ }
}
| CATCH_TK error
{yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
/* Created after JDK1.1 rules originally added to
class_instance_creation_expression, but modified to use
- 'class_type' instead of 'TypeName' (type_name) which is mentionned
+ 'class_type' instead of 'TypeName' (type_name) which is mentioned
in the documentation but doesn't exist. */
anonymous_class_creation:
NEW_TK class_type OP_TK argument_list CP_TK
- { create_anonymous_class ($1.location, $2); }
+ { create_anonymous_class ($2); }
class_body
{
tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
}
| NEW_TK class_type OP_TK CP_TK
- { create_anonymous_class ($1.location, $2); }
+ { create_anonymous_class ($2); }
class_body
{
tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
if (copy_from_previous)
{
memcpy (new, ctxp, sizeof (struct parser_ctxt));
- new->saved_data_ctx = 1;
+ /* This flag, indicating the context saves global values,
+ should only be set by java_parser_context_save_global. */
+ new->saved_data_ctx = 0;
}
else
memset (new, 0, sizeof (struct parser_ctxt));
next = ctxp->next;
if (next)
{
- lineno = ctxp->lineno;
+ input_line = ctxp->lineno;
current_class = ctxp->class_type;
}
/* If this context already stores data, create a new one suitable
for data storage. */
else if (ctxp->saved_data)
- create_new_parser_context (1);
+ {
+ create_new_parser_context (1);
+ ctxp->saved_data_ctx = 1;
+ }
- ctxp->lineno = lineno;
+ ctxp->lineno = input_line;
ctxp->class_type = current_class;
ctxp->filename = input_filename;
ctxp->function_decl = current_function_decl;
void
java_parser_context_restore_global (void)
{
- lineno = ctxp->lineno;
+ input_line = ctxp->lineno;
current_class = ctxp->class_type;
input_filename = ctxp->filename;
if (wfl_operator)
- {
- tree s;
- BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
- EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
- }
+ EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
current_function_decl = ctxp->function_decl;
ctxp->saved_data = 0;
if (ctxp->saved_data_ctx)
current_class = saver->class_type;
current_function_decl = saver->function_decl;
- /* Retrive the restored context */
+ /* Retrieve the restored context */
ctxp = restored;
/* Re-installed the data for the parsing to carry on */
{
sorry (": `%s' JDK1.1(TM) feature", msg);
java_error_count++;
- return empty_stmt_node;
+ return build_java_empty_stmt ();
}
static int do_warning = 0;
int save_lineno;
char *remainder, *code_from_source;
- if (!force_error && prev_lineno == lineno)
+ if (!force_error && prev_lineno == input_line)
return;
/* Save current error location but report latter, when the context is
elc.line = ctxp->p_line->lineno;
}
- save_lineno = lineno;
- prev_lineno = lineno = elc.line;
+ save_lineno = input_line;
+ prev_lineno = input_line = elc.line;
prev_msg = msg;
code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
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;
+ ctxp->prevent_ese = input_line = save_lineno;
}
static void
static void
missing_return_error (tree method)
{
- EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
+ EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
parse_error_context (wfl_operator, "Missing return statement");
}
abort ();
}
+static int
+not_accessible_field_error (tree wfl, tree decl)
+{
+ parse_error_context
+ (wfl, "Can't access %s field `%s.%s' from `%s'",
+ accessibility_string (get_access_flags_from_decl (decl)),
+ GET_TYPE_NAME (DECL_CONTEXT (decl)),
+ IDENTIFIER_POINTER (DECL_NAME (decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ return 1;
+}
+
int
java_report_errors (void)
{
#undef COPY_RETURN
}
+/* Returns a string denoting the accessibility of a class or a member as
+ indicated by FLAGS. We need a separate function from
+ java_accstring_lookup, as the latter can return spurious "static", etc.
+ if package-private access is defined (in which case none of the
+ relevant access control bits in FLAGS is set). */
+
+static const char *
+accessibility_string (int flags)
+{
+ if (flags & ACC_PRIVATE) return "private";
+ if (flags & ACC_PROTECTED) return "protected";
+ if (flags & ACC_PUBLIC) return "public";
+
+ return "package-private";
+}
+
/* Issuing error messages upon redefinition of classes, interfaces or
variables. */
return decl;
}
- /* Now go to the upper classes, bail out if necessary. We will
+ /* Now go to the upper classes, bail out if necessary. We will
analyze the returned SUPER and act accordingly (see
- do_resolve_class.) */
+ do_resolve_class). */
+ if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
+ || TREE_TYPE (local_enclosing) == void_type_node)
+ {
+ parse_error_context (cl, "Qualifier must be a reference");
+ local_enclosing = NULL_TREE;
+ break;
+ }
local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
if (!local_super || local_super == object_type_node)
break;
return (!qual && enclosing ? enclosing : NULL_TREE);
}
-/* Reach all inner classes and tie their unqualified name to a
- DECL. */
-
-static void
-set_nested_class_simple_name_value (tree outer, int set)
-{
- tree l;
-
- for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
- IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
- TREE_PURPOSE (l) : NULL_TREE);
-}
-
static void
link_nested_class_to_enclosing (void)
{
/* 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 we're emitting xrefs, store the line/col number information */
if (flag_emit_xref)
DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
else
/* Create a new decl if DECL is NULL, otherwise fix it */
decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
+ /* Interfaces are always abstract. */
+ flags |= ACC_ABSTRACT;
+
+ /* Inner interfaces are always static. */
+ if (INNER_CLASS_DECL_P (decl))
+ flags |= ACC_STATIC;
+
/* Set super info and mark the class a complete */
set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
object_type_node, ctxp->interface_number);
CLASS_COMPLETE_P (decl) = 1;
add_superinterfaces (decl, super);
+ /* Eventually sets the @deprecated tag flag */
+ CHECK_DEPRECATED (decl);
+
return decl;
}
/* If it's an interface, implement it */
if (CLASS_INTERFACE (type_decl))
{
- tree s_binfo;
- int length;
-
if (parser_check_super_interface (type_decl, class_decl, wfl))
return;
- s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
- length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
- TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
- TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
+ if (VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
+ {
+ /* Extend the binfo - by reallocating and copying it. */
+ tree new_binfo;
+ tree base_binfo;
+ int i;
+
+ new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
+ for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
+ BINFO_BASE_APPEND (new_binfo, base_binfo);
+ CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
+ BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
+ TYPE_BINFO (class) = new_binfo;
+ }
+
/* And add the interface */
parser_add_interface (class_decl, type_decl, wfl);
}
{
if (parser_check_super (type_decl, class_decl, wfl))
return;
- BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
+ BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
}
}
+/* Create an anonymous class which extends/implements TYPE_NAME, and return
+ its decl. */
+
static tree
-create_anonymous_class (int location, tree type_name)
+create_anonymous_class (tree type_name)
{
char buffer [80];
tree super = NULL_TREE, itf = NULL_TREE;
/* The unqualified name of the anonymous class. It's just a number. */
sprintf (buffer, "%d", anonymous_class_counter++);
id = build_wfl_node (get_identifier (buffer));
- EXPR_WFL_LINECOL (id) = location;
+ EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
/* We know about the type to extend/implement. We go ahead */
if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
{
/* Create a class which either implements on extends the designated
- class. The class bears an innacessible name. */
+ class. The class bears an inaccessible name. */
if (CLASS_INTERFACE (type_decl))
{
/* It's OK to modify it here. It's been already used and
/* If SUPER exists, use it, otherwise use Object */
if (super)
{
- /* Can't extend java.lang.Object */
+ /* java.lang.Object can't extend anything. */
if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
{
- parse_error_context (id, "Can't extend `java.lang.Object'");
+ parse_error_context (id, "`java.lang.Object' can't extend anything");
return NULL_TREE;
}
CLASS_COMPLETE_P (decl) = 1;
add_superinterfaces (decl, interfaces);
+ /* TYPE_VFIELD' is a compiler-generated field used to point to
+ virtual function tables. In gcj, every class has a common base
+ virtual function table in java.lang.object. */
+ TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
+
/* Add the private this$<n> field, Replicate final locals still in
scope as private final fields mangled like val$<local_name>.
- This doesn't not occur for top level (static) inner classes. */
+ This does not occur for top level (static) inner classes. */
if (PURE_INNER_CLASS_DECL_P (decl))
add_inner_class_fields (decl, current_function_decl);
methods first, then finit$ to get a picture of what's
used. It works with the exception that we would have to
go back on all constructor invoked in regular methods to
- have their invokation reworked (to include the right amount
+ have their invocation reworked (to include the right amount
of alias initializer parameters.)
The only real way around, I think, is a first pass to
On the other hand, it only affect local inner classes,
whose constructors (and finit$ call) will be featuring
- unecessary arguments. It's easy for a developper to keep
+ unnecessary arguments. It's easy for a developer to keep
this number of parameter down by using the `final'
keyword only when necessary. For the time being, we can
- issue a warning on unecessary finals. FIXME */
+ issue a warning on unnecessary finals. FIXME */
init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
wfl, init);
return;
/* If we ever registered an alias field, insert and marker to
- remeber where the list ends. The second part of the list (the one
+ remember where the list ends. The second part of the list (the one
featuring initialized fields) so it can be later reversed to
enforce 8.5. The marker will be removed during that operation. */
marker = build_tree_list (NULL_TREE, NULL_TREE);
{
tree current, saved_type;
tree class_type = NULL_TREE;
- int saved_lineno = lineno;
+ int saved_lineno = input_line;
int must_chain = 0;
tree wfl = NULL_TREE;
if (duplicate_declaration_error_p (current_name, real_type, cl))
continue;
- /* Set lineno to the line the field was found and create a
+ /* Set input_line 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);
+ input_line = EXPR_WFL_LINECOL (cl);
else
- lineno = EXPR_WFL_LINENO (cl);
+ input_line = EXPR_WFL_LINENO (cl);
field_decl = add_field (class_type, current_name, real_type, flags);
CHECK_DEPRECATED_NO_RESET (field_decl);
}
CLEAR_DEPRECATED;
- lineno = saved_lineno;
+ input_line = saved_lineno;
}
/* Generate finit$, using the list of initialized fields to populate
return to_return;
}
-/* Shared accros method_declarator and method_header to remember the
+/* Shared across 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)
else
TREE_TYPE (meth) = type;
- saved_lineno = lineno;
+ saved_lineno = input_line;
/* 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 :
+ input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
EXPR_WFL_LINENO (id));
/* Remember the original argument list */
/* Register the parameter number and re-install the current line
number */
DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
- lineno = saved_lineno;
+ input_line = saved_lineno;
/* Register exception specified by the `throws' keyword for
resolution and set the method decl appropriate field to the list.
/* 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);
+ DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
/* Since function's argument's list are shared, reset the
ARG_FINAL_P parameter that might have been set on some of this
/* The argument node: a name and a (possibly) incomplete type. */
arg_node = build_tree_list (name, real_type);
- /* Remeber arguments declared final. */
+ /* Remember arguments declared final. */
ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
if (jdep)
static int
unresolved_type_p (tree wfl, tree *returned)
-
{
if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
{
access rules (6.6.1). */
if (! INNER_CLASS_P (super_type)
&& check_pkg_class_access (DECL_NAME (super_decl),
- lookup_cl (this_decl), true))
+ NULL_TREE, true, this_decl))
return 1;
SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
}
/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
- 0 if everthing is OK. */
+ 0 if everything is OK. */
static int
parser_check_super (tree super_decl, tree this_decl, tree wfl)
/* Check top-level class scope. Inner classes are subject to member access
rules (6.6.1). */
if (! INNER_CLASS_P (super_type)
- && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
+ && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
return 1;
SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
static jdeplist *
reverse_jdep_list (struct parser_ctxt *ctxp)
{
- register jdeplist *prev = NULL, *current, *next;
+ jdeplist *prev = NULL, *current, *next;
for (current = ctxp->classd_list; current; current = next)
{
next = current->next;
JDEP_MISC (new) = NULL_TREE;
/* For some dependencies, set the enclosing class of the current
class to be the enclosing context */
- if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS)
+ if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
&& GET_ENCLOSING_CPC ())
JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
- else if (kind == JDEP_SUPER)
- JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
- TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
else
JDEP_ENCLOSING (new) = GET_CPC ();
JDEP_GET_PATCH (new) = (tree *)NULL;
static tree
check_inner_circular_reference (tree source, tree target)
{
- tree basetype_vec = TYPE_BINFO_BASETYPES (source);
+ tree base_binfo;
tree ctx, cl;
int i;
- if (!basetype_vec)
- return NULL_TREE;
-
- for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
+ for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
{
tree su;
/* We can end up with a NULL_TREE or an incomplete type here if
we encountered previous type resolution errors. It's safe to
simply ignore these cases. */
- if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
- continue;
- su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
+ su = BINFO_TYPE (base_binfo);
if (INCOMPLETE_TYPE_P (su))
continue;
static tree
check_circular_reference (tree type)
{
- tree basetype_vec = TYPE_BINFO_BASETYPES (type);
+ tree base_binfo;
int i;
- if (!basetype_vec)
+ if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
return NULL_TREE;
if (! CLASS_INTERFACE (TYPE_NAME (type)))
return NULL_TREE;
}
- for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
+ for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); 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)))
- return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
+ if (BINFO_TYPE (base_binfo) != object_type_node
+ && interface_of_p (type, BINFO_TYPE (base_binfo)))
+ return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
}
return NULL_TREE;
}
break;
case AIPL_FUNCTION_CTOR_INVOCATION:
- /* There are two case: the constructor invokation happends
+ /* There are two case: the constructor invocation happens
outside the local inner, in which case, locales from the outer
context are directly used.
{
tree class_type = TREE_TYPE (class_decl);
tree parm = NULL_TREE;
- int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
- ACC_PUBLIC : 0);
+ /* Inherit access flags for the constructor from its enclosing class. */
+ int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
+ int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
int i = 0, artificial = 0;
tree decl, ctor_name;
char buffer [80];
/* Now, mark the artificial parameters. */
DECL_FUNCTION_NAP (decl) = artificial;
DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
+ DECL_INLINE (decl) = 1;
return decl;
}
if (CLASS_INTERFACE (TYPE_NAME (class_type)))
continue;
- current_class = class_type;
+ output_class = current_class = class_type;
for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
{
if (DECL_CONSTRUCTOR_P (decl))
}
/* safe_layout_class just makes sure that we can load a class without
- disrupting the current_class, input_file, lineno, etc, information
+ disrupting the current_class, input_file, input_line, etc, information
about the class processed currently. */
void
safe_layout_class (tree class)
{
tree save_current_class = current_class;
- const char *save_input_filename = input_filename;
- int save_lineno = lineno;
+ location_t save_location = input_location;
layout_class (class);
current_class = save_current_class;
- input_filename = save_input_filename;
- lineno = save_lineno;
+ input_location = save_location;
}
static tree
JDEP_RESOLVED (dep, decl);
/* If there is no WFL, that's ok. We generate this warning
elsewhere. */
- if (JDEP_WFL (dep) != NULL_TREE)
+ if (decl && JDEP_WFL (dep) != NULL_TREE)
check_deprecation (JDEP_WFL (dep), decl);
}
if (!decl)
complete_class_report_errors (dep);
- else if (PURE_INNER_CLASS_DECL_P (decl))
+ else if (INNER_CLASS_DECL_P (decl))
{
tree inner = TREE_TYPE (decl);
if (! CLASS_LOADED_P (inner))
/* 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);
+ BINFO_TYPE (BINFO_BASE_BINFO
+ (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
+ = TREE_TYPE (decl);
break;
case JDEP_FIELD:
return resolved_type_decl;
}
-/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
- are used to report error messages. Do not try to replace TYPE_NAME
- (class_type) by a variable, since it is changed by
- find_in_imports{_on_demand} and (but it doesn't really matter)
- qualify_and_find. */
+/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
+ are used to report error messages; CL must either be NULL_TREE or a
+ WFL wrapping a class. Do not try to replace TYPE_NAME (class_type)
+ by a variable, since it is changed by find_in_imports{_on_demand}
+ and (but it doesn't really matter) qualify_and_find. */
tree
do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
class and then treat Id as a member type. If we can't find Q
as a class then we fall through. */
tree q, left, left_type, right;
- breakdown_qualified (&left, &right, TYPE_NAME (class_type));
- BUILD_PTR_FROM_NAME (left_type, left);
- q = do_resolve_class (enclosing, left_type, decl, cl);
- if (q)
+ if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
{
- enclosing = q;
- saved_enclosing_type = TREE_TYPE (q);
- BUILD_PTR_FROM_NAME (class_type, right);
+ BUILD_PTR_FROM_NAME (left_type, left);
+ q = do_resolve_class (enclosing, left_type, decl, cl);
+ if (q)
+ {
+ enclosing = q;
+ saved_enclosing_type = TREE_TYPE (q);
+ BUILD_PTR_FROM_NAME (class_type, right);
+ }
}
}
/* 2- And check for the type in the current compilation unit */
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)))
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
load_class (TYPE_NAME (class_type), 0);
return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
}
by the caller. */
if (cl)
{
- if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
+ if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
return NULL_TREE;
}
load_class (new_qualified, 0);
if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
{
- if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
- !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
- load_class (new_qualified, 0);
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
+ load_class (TREE_TYPE (new_class_decl), 0);
TYPE_NAME (class_type) = new_qualified;
return IDENTIFIER_CLASS_VALUE (new_qualified);
}
{
/* Check for implemented interfaces. */
int i;
- tree vector = TYPE_BINFO_BASETYPES (type);
- for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
- {
- tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
- ok = check_abstract_method_definitions (1, class_decl, super);
- }
+ tree base_binfo;
+
+ for (i = 1;
+ ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
+ i++)
+ ok = check_abstract_method_definitions (1, class_decl,
+ BINFO_TYPE (base_binfo));
}
return ok;
java_check_abstract_method_definitions (tree class_decl)
{
tree class = TREE_TYPE (class_decl);
- tree super, vector;
+ tree super, base_binfo;
int i;
if (CLASS_ABSTRACT (class_decl))
} while (super != object_type_node);
/* Check for implemented interfaces. */
- vector = TYPE_BINFO_BASETYPES (class);
- for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
- {
- super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
- check_abstract_method_definitions (1, class_decl, super);
- }
+ for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
+ check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
}
/* Check all the types method DECL uses and return 1 if all of them
CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
}
+/* Like not_accessible_p, but doesn't refer to the current class at
+ all. */
+static bool
+hack_is_accessible_p (tree member, tree from_where)
+{
+ int flags = get_access_flags_from_decl (member);
+
+ if (from_where == DECL_CONTEXT (member)
+ || (flags & ACC_PUBLIC))
+ return true;
+
+ if ((flags & ACC_PROTECTED))
+ {
+ if (inherits_from_p (from_where, DECL_CONTEXT (member)))
+ return true;
+ }
+
+ if ((flags & ACC_PRIVATE))
+ return false;
+
+ /* Package private, or protected. */
+ return in_same_package (TYPE_NAME (from_where),
+ TYPE_NAME (DECL_CONTEXT (member)));
+}
+
/* Check all the methods of CLASS_DECL. Methods are first completed
then checked according to regular method existence rules. If no
constructor for CLASS_DECL were encountered, then build its
declaration. */
-
static void
java_check_regular_methods (tree class_decl)
{
}
sig = build_java_argument_signature (TREE_TYPE (method));
- found = lookup_argument_method2 (class, DECL_NAME (method), sig);
+ found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
+ SEARCH_SUPER | SEARCH_INTERFACE);
/* Inner class can't declare static methods */
if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
continue;
parse_error_context
(method_wfl,
- "%s methods can't be overriden. Method `%s' is %s in class `%s'",
+ "%s methods can't be overridden. Method `%s' is %s in class `%s'",
(METHOD_FINAL (found) ? "Final" : "Static"),
lang_printable_name (found, 0),
(METHOD_FINAL (found) ? "final" : "static"),
{
parse_error_context
(method_wfl,
- "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
+ "Instance methods can't be overridden 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)))));
/* - Overriding/hiding public must be public
- Overriding/hiding protected must be protected or public
- - If the overriden or hidden method has default (package)
+ - If the overridden or hidden method has default (package)
access, then the overriding or hiding method must not be
private; otherwise, a compile-time error occurs. If
`found' belongs to an interface, things have been already
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 */
+ /* Check this method against all the other implementations it
+ overrides. Here we only check the class hierarchy; the rest
+ of the checking is done later. If this method is just a
+ Miranda method, we can skip the check. */
+ if (! METHOD_INVISIBLE (method))
+ check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
}
+ /* The above throws clause check only looked at superclasses. Now
+ we must also make sure that all methods declared in interfaces
+ have compatible throws clauses. FIXME: there are more efficient
+ ways to organize this checking; we should implement one. */
+ check_interface_throws_clauses (class, class);
+
if (!TYPE_NVIRTUALS (class))
TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
abort ();
}
-/* Return a nonzero value if the `throws' clause of METHOD (if any)
- is incompatible with the `throws' clause of FOUND (if any). */
+/* Check to make sure that all the methods in all the interfaces
+ implemented by CLASS_DECL are compatible with the concrete
+ implementations available in CHECK_CLASS_DECL. */
+static void
+check_interface_throws_clauses (tree check_class_decl, tree class_decl)
+{
+ for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
+ {
+ int i;
+
+ if (! CLASS_LOADED_P (class_decl))
+ {
+ if (CLASS_FROM_SOURCE_P (class_decl))
+ safe_layout_class (class_decl);
+ else
+ load_class (class_decl, 1);
+ }
+
+ for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
+ {
+ tree interface
+ = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
+ tree iface_method;
+
+ for (iface_method = TYPE_METHODS (interface);
+ iface_method != NULL_TREE;
+ iface_method = TREE_CHAIN (iface_method))
+ {
+ tree sig, method;
+
+ /* First look for a concrete method implemented or
+ inherited by this class. No need to search
+ interfaces here, since we're already looking through
+ all of them. */
+ sig = build_java_argument_signature (TREE_TYPE (iface_method));
+ method
+ = lookup_argument_method_generic (check_class_decl,
+ DECL_NAME (iface_method),
+ sig, SEARCH_VISIBLE);
+ /* If we don't find an implementation, that is ok. Any
+ potential errors from that are diagnosed elsewhere.
+ Also, multiple inheritance with conflicting throws
+ clauses is fine in the absence of a concrete
+ implementation. */
+ if (method != NULL_TREE && !METHOD_ABSTRACT (method)
+ && !METHOD_INVISIBLE (iface_method))
+ {
+ tree method_wfl = DECL_FUNCTION_WFL (method);
+ check_throws_clauses (method, method_wfl, iface_method);
+ }
+ }
+ /* Now check superinterfaces. */
+ check_interface_throws_clauses (check_class_decl, interface);
+ }
+ }
+}
+
+/* Check throws clauses of a method against the clauses of all the
+ methods it overrides. We do this by searching up the class
+ hierarchy, examining all matching accessible methods. */
+static void
+check_concrete_throws_clauses (tree class, tree self_method,
+ tree name, tree signature)
+{
+ tree method = lookup_argument_method_generic (class, name, signature,
+ SEARCH_SUPER | SEARCH_VISIBLE);
+ while (method != NULL_TREE)
+ {
+ if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
+ check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
+ method);
+
+ method = lookup_argument_method_generic (DECL_CONTEXT (method),
+ name, signature,
+ SEARCH_SUPER | SEARCH_VISIBLE);
+ }
+}
+
+/* Generate an error if the `throws' clause of METHOD (if any) is
+ incompatible with the `throws' clause of FOUND (if any). */
static void
check_throws_clauses (tree method, tree method_wfl, tree found)
{
- tree mthrows, fthrows;
+ tree mthrows;
/* Can't check these things with class loaded from bytecode. FIXME */
if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
for (mthrows = DECL_FUNCTION_THROWS (method);
mthrows; mthrows = TREE_CHAIN (mthrows))
{
+ tree fthrows;
+
/* 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 (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'",
+ (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)))));
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
}
}
}
/* Check abstract method of interface INTERFACE */
-
static void
java_check_abstract_methods (tree interface_decl)
{
- int i, n;
- tree method, basetype_vec, found;
+ int i;
+ tree method, found;
tree interface = TREE_TYPE (interface_decl);
+ tree base_binfo;
for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
{
if (check_method_redefinition (interface, method))
continue;
- /* 3- Overriding is OK as far as we preserve the return type and
- the thrown exceptions (FIXME) */
+ /* 3- Overriding is OK as far as we preserve the return type. */
found = lookup_java_interface_method2 (interface, method);
if (found)
{
}
/* 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++)
+ for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); 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);
+
+ sub_interface = BINFO_TYPE (base_binfo);
for (sub_interface_method = TYPE_METHODS (sub_interface);
sub_interface_method;
sub_interface_method = TREE_CHAIN (sub_interface_method))
static tree
lookup_java_interface_method2 (tree class, tree method_decl)
{
- int i, n;
- tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
-
- if (!basetype_vec)
- return NULL_TREE;
+ int i;
+ tree base_binfo;
+ tree to_return;
- n = TREE_VEC_LENGTH (basetype_vec);
- for (i = 0; i < n; i++)
+ for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
{
- tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
- if ((BINFO_TYPE (vec_elt) != object_type_node)
+ if ((BINFO_TYPE (base_binfo) != object_type_node)
&& (to_return =
- lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
+ lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
return to_return;
}
- for (i = 0; i < n; i++)
+ for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
{
to_return = lookup_java_interface_method2
- (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
+ (BINFO_TYPE (base_binfo), method_decl);
if (to_return)
return to_return;
}
}
EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
- EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE_FIRST (decl), -1);
+ EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
QUALIFIED_P (to_be_found) = 1;
load_class (to_be_found, 0);
error_found =
- check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
+ check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
/* We found it, we can bail out */
if (IDENTIFIER_CLASS_VALUE (to_be_found))
inner class. The only way for us to know is to try again
after having dropped a qualifier. If we can't break it further,
we have an error. */
- if (breakdown_qualified (&left, NULL, to_be_found))
+ if (split_qualified_name (&left, NULL, to_be_found))
break;
to_be_found = left;
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));
+ zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
if (zipf == NULL)
error ("malformed .zip archive in CLASSPATH: %s", entry_name);
else
int current_entry_len = zipd->filename_length;
if (current_entry_len >= BUFFER_LENGTH (filename)
- && strncmp (filename->data, current_entry,
+ && strncmp ((const char *) filename->data, current_entry,
BUFFER_LENGTH (filename)) != 0)
continue;
found |= note_possible_classname (current_entry,
{
BUFFER_RESET (filename);
buffer_grow (filename, entry_length + package_length + 4);
- strcpy (filename->data, entry_name);
+ strcpy ((char *) filename->data, entry_name);
filename->ptr = filename->data + entry_length;
for (k = 0; k < package_length; k++)
{
}
*filename->ptr = '\0';
- dirp = opendir (filename->data);
+ dirp = opendir ((const char *) filename->data);
if (dirp == NULL)
continue;
*filename->ptr++ = '/';
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,
+ strcpy ((char *) filename->ptr, d_name);
+ found |= note_possible_classname ((const char *) filename->data + entry_length,
package_length+len+1);
}
if (dirp)
for (; import; import = TREE_CHAIN (import))
{
- int saved_lineno = lineno;
+ int saved_lineno = input_line;
int access_check;
const char *id_name;
tree decl, type_name_copy;
if (! (node = maybe_get_identifier (id_name)))
continue;
- /* Setup lineno so that it refers to the line of the import (in
+ /* Setup input_line so that it refers to the line of the import (in
case we parse a class file and encounter errors */
- lineno = EXPR_WFL_LINENO (TREE_PURPOSE (import));
+ input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
type_name_copy = TYPE_NAME (class_type);
TYPE_NAME (class_type) = node;
access_check = -1;
/* If there is no DECL set for the class or if the class isn't
loaded and not seen in source yet, then load */
- if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
- && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
+ if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
{
load_class (node, 0);
decl = IDENTIFIER_CLASS_VALUE (node);
}
if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
- false);
+ false, NULL_TREE);
else
/* 6.6.1: Inner classes are subject to member access rules. */
access_check = 0;
- lineno = saved_lineno;
+ input_line = saved_lineno;
/* If the loaded class is not accessible or couldn't be loaded,
we restore the original TYPE_NAME and process the next
/* Accessibility check for top-level classes. If CLASS_NAME is in a
foreign package, it must be PUBLIC. Return 0 if no access
violations were found, 1 otherwise. If VERBOSE is true and an error
- was found, it is reported and accounted for. */
+ was found, it is reported and accounted for. If CL is NULL then
+ look it up with THIS_DECL. */
static int
-check_pkg_class_access (tree class_name, tree cl, bool verbose)
+check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
{
tree type;
/* Access to a private class within the same package is
allowed. */
tree l, r;
- breakdown_qualified (&l, &r, class_name);
+ split_qualified_name (&l, &r, class_name);
if (!QUALIFIED_P (class_name) && !ctxp->package)
/* Both in the empty package. */
return 0;
if (verbose)
parse_error_context
- (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
+ (cl == NULL ? lookup_cl (this_decl): 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;
if (init && java_error_count)
init = NULL_TREE;
+ /* Remember it if this is an initialized-upon-declaration final
+ variable. */
+ if (init && final_p)
+ {
+ DECL_LOCAL_FINAL_IUD (decl) = 1;
+ }
+
/* Add the initialization function to the current function's code */
if (init)
{
tree mdecl;
java_parser_context_save_global ();
- lineno = 0;
+ input_line = 0;
mdecl = make_node (FUNCTION_TYPE);
TREE_TYPE (mdecl) = type;
TYPE_ARG_TYPES (mdecl) = args;
start_artificial_method_body (tree mdecl)
{
DECL_SOURCE_LINE (mdecl) = 1;
- DECL_SOURCE_LINE_MERGE (mdecl, 1);
+ DECL_FUNCTION_LAST_LINE (mdecl) = 1;
source_start_java_method (mdecl);
enter_block ();
}
return;
java_parser_context_save_global ();
- lineno = ctxp->last_ccb_indent1;
+ input_line = ctxp->last_ccb_indent1;
/* 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)
+ if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
- /* We've generated all the trees for this function, and it has been
- patched. Dump it to a file if the user requested it. */
- dump_java_tree (TDI_original, fndecl);
-
- java_optimize_inline (fndecl);
-
- /* 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);
- expand_function_end (input_filename, lineno, 0);
-
- DECL_SOURCE_LINE (fndecl) = DECL_SOURCE_LINE_FIRST (fndecl);
-
- /* Run the optimizers and output assembler code for this function. */
- rest_of_compilation (fndecl);
- }
+ finish_method (fndecl);
current_function_decl = NULL_TREE;
java_parser_context_restore_global ();
+ current_function_decl = NULL_TREE;
}
/* Record EXPR in the current function block. Complements compound
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 (tree existing, tree type, tree stmt)
-{
- /* Keep track of this for inlining. */
- if (current_function_decl)
- ++DECL_NUM_STMTS (current_function_decl);
-
- if (existing)
- return build (COMPOUND_EXPR, type, existing, stmt);
- else
- return stmt;
-}
+/* Lays out the methods for the classes seen so far. */
-void java_layout_seen_class_methods (void)
+void
+java_layout_seen_class_methods (void)
{
tree previous_list = all_class_list;
tree end = NULL_TREE;
{
for (current = previous_list;
current != end; current = TREE_CHAIN (current))
- layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
+ {
+ tree cls = TREE_TYPE (TREE_VALUE (current));
+
+ if (! CLASS_LOADED_P (cls))
+ load_class (cls, 0);
+
+ layout_class_methods (cls);
+ }
+
+ /* Note that new classes might have been added while laying out
+ methods, changing the value of all_class_list. */
if (previous_list != all_class_list)
{
for (current = gclass_list; current; current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (TREE_VALUE (current));
+ output_class = current_class = TREE_TYPE (TREE_VALUE (current));
if (current_class == stop_reordering)
break;
for (current = gclass_list; current; current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (TREE_VALUE (current));
+ output_class = current_class = TREE_TYPE (TREE_VALUE (current));
layout_class (current_class);
/* Error reported by the caller */
java_parse_abort_on_error ();
}
-/* Expand methods in the current set of classes rememebered for
+/* Expand methods in the current set of classes remembered for
generation. */
static void
{
tree inner_list;
- set_nested_class_simple_name_value (outer, 1); /* Set */
-
/* We need to go after all inner classes and start expanding them,
starting with most nested ones. We have to do that because nested
classes might add functions to outer classes */
java_complete_expand_class (TREE_PURPOSE (inner_list));
java_complete_expand_methods (outer);
- set_nested_class_simple_name_value (outer, 0); /* Reset */
}
/* Expand methods registered in CLASS_DECL. The general idea is that
{
tree clinit, decl, first_decl;
- current_class = TREE_TYPE (class_decl);
-
- /* Initialize a new constant pool */
- init_outgoing_cpool ();
+ output_class = current_class = TREE_TYPE (class_decl);
/* Pre-expand <clinit> to figure whether we really need it or
not. If we do need it, we pre-expand the static fields so they're
/* Now do the constructors */
for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
{
- int no_body;
-
if (!DECL_CONSTRUCTOR_P (decl))
continue;
-
- no_body = !DECL_FUNCTION_BODY (decl);
- /* Don't generate debug info on line zero when expanding a
- generated constructor. */
- if (no_body)
- restore_line_number_status (1);
-
java_complete_expand_method (decl);
-
- if (no_body)
- restore_line_number_status (0);
}
/* First, do the ordinary methods. */
if (DECL_CONSTRUCTOR_P (decl)
&& verify_constructor_circularity (decl, decl))
break;
-
- /* Save the constant pool. We'll need to restore it later. */
- TYPE_CPOOL (current_class) = outgoing_cpool;
}
/* Attempt to create <clinit>. Pre-expand static fields so they can be
/* We build the assignment expression that will initialize the
field to its value. There are strict rules on static
initializers (8.5). FIXME */
- if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
+ if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
java_method_add_stmt (mdecl, stmt);
}
bbody = BLOCK_EXPR_BODY (bbody);
else
return 0;
- if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
+ if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
return 0;
type = DECL_CONTEXT (mdecl);
/* Now we analyze the method body and look for something that
isn't a MODIFY_EXPR */
- if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
+ if (!IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
return 0;
/* Get rid of <clinit> in the class' list of methods */
/* Install the argument from MDECL. Suitable to completion and
expansion of mdecl's body. */
-static void
+void
start_complete_expand_method (tree mdecl)
{
tree tem;
/* TREE_CHAIN (tem) will change after pushdecl. */
tree next = TREE_CHAIN (tem);
tree type = TREE_TYPE (tem);
- if (PROMOTE_PROTOTYPES
+ if (targetm.calls.promote_prototypes (type)
&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
&& INTEGRAL_TYPE_P (type))
type = integer_type_node;
TREE_CHAIN (tem) = next;
}
pushdecl_force_head (DECL_ARGUMENTS (mdecl));
- lineno = DECL_SOURCE_LINE_FIRST (mdecl);
+ input_line = DECL_SOURCE_LINE (mdecl);
build_result_decl (mdecl);
}
tree decl;
for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
{
- if (!DECL_FUNCTION_BODY (decl))
+ tree block;
+
+ if (! DECL_FUNCTION_BODY (decl))
continue;
current_function_decl = decl;
- /* Save the function for inlining. */
- if (flag_inline_trees)
- DECL_SAVED_TREE (decl) =
- BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
+ block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
+
+ /* Save the function body for gimplify and inlining. */
+ DECL_SAVED_TREE (decl) = block;
/* It's time to assign the variable flagging static class
initialization based on which classes invoked static methods
}
}
- /* Prepare the function for RTL expansion */
- start_complete_expand_method (decl);
-
- /* Expand function start, generate initialization flag
- assignment, and handle synchronized methods. */
- complete_start_java_method (decl);
-
- /* Expand the rest of the function body and terminate
- expansion. */
+ /* Expand the function body. */
source_end_java_method ();
}
}
return 0;
/* If the inner class extends the declaration context of the field
- we're try to acces, then this isn't an outer field access */
+ we're trying to access, then this isn't an outer field access */
if (inherits_from_p (type, DECL_CONTEXT (decl)))
return 0;
/* There is a potential bug here. We should be able to use
fix_method_argument_names, but then arg names get mixed up and
eventually a constructor will have its this$0 altered and the
- outer context won't be assignment properly. The test case is
+ outer context won't be assignment properly. The testcase is
stub.java FIXME */
TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
return saved_thisn;
}
-/* Return the assignement to the hidden enclosing context `this$<n>'
+/* Return the assignment to the hidden enclosing context `this$<n>'
by the second incoming parameter to the innerclass constructor. The
form used is `this.this$<n> = this$<n>;'. */
tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
build_wfl_node (thisn), 0);
tree rhs = build_wfl_node (thisn);
- EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
+ EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
}
return NULL_TREE;
{
#define BWF(S) build_wfl_node (get_identifier ((S)))
#define MQN(X,Y) make_qualified_name ((X), (Y), 0)
- tree args, tmp, saved_current_function_decl, mdecl;
+ tree args, tmp, saved_current_function_decl, mdecl, qual_name;
tree stmt, throw_stmt;
if (!get_message_wfl)
/* Build the qualified name java.lang.Class.forName */
tmp = MQN (MQN (MQN (BWF ("java"),
BWF ("lang")), BWF ("Class")), BWF ("forName"));
- load_class (class_not_found_type_node, 1);
- load_class (no_class_def_found_type_node, 1);
/* Create the "class$" function */
mdecl = create_artificial_method (class, ACC_STATIC,
build_pointer_type (class_type_node),
classdollar_identifier_node, args);
- DECL_FUNCTION_THROWS (mdecl) =
- build_tree_list (NULL_TREE, no_class_def_found_type_node);
+ qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
+ BWF ("NoClassDefFoundError"));
+ DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
+ register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
+ JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
+ &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
/* We start by building the try block. We need to build:
return (java.lang.Class.forName (type)); */
throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
/* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
- stmt = encapsulate_with_try_catch (0, class_not_found_type_node,
- stmt, throw_stmt);
+ qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
+ BWF ("ClassNotFoundException"));
+ stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
fix_method_argument_names (args, mdecl);
layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
}
static tree
-build_dot_class_method_invocation (tree type)
+build_dot_class_method_invocation (tree this_class, tree type)
{
- tree sig_id, s;
+ tree dot_class_method = TYPE_DOT_CLASS (this_class);
+ tree sig_id, s, t;
if (TYPE_ARRAY_P (type))
sig_id = build_java_signature (type);
s = build_string (IDENTIFIER_LENGTH (sig_id),
IDENTIFIER_POINTER (sig_id));
- return build_method_invocation (build_wfl_node (classdollar_identifier_node),
- build_tree_list (NULL_TREE, s));
+ t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
+ build_tree_list (NULL_TREE, s));
+ if (DECL_CONTEXT (dot_class_method) != this_class)
+ {
+ tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
+ t = make_qualified_primary (build_wfl_node (class_name), t, 0);
+ }
+ return t;
}
/* This section of the code deals with constructor. */
if (!found)
compound = add_stmt_to_compound (compound, NULL_TREE,
build_super_invocation (mdecl));
- /* Explicit super() invokation should take place before the
+ /* Explicit super() invocation should take place before the
instance initializer blocks. */
else
{
compound = add_stmt_to_compound (compound, NULL_TREE,
TREE_OPERAND (found_call, 0));
- TREE_OPERAND (found_call, 0) = empty_stmt_node;
+ TREE_OPERAND (found_call, 0) = build_java_empty_stmt ();
}
DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
{
+ tree current;
+ for (current = cur_ctxp->class_list;
+ current;
+ current = TREE_CHAIN (current))
+ gen_indirect_dispatch_tables (TREE_TYPE (current));
+ }
+
+ for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
+ {
ctxp = cur_ctxp;
input_filename = ctxp->filename;
lang_init_source (2); /* Error msgs have method prototypes */
}
input_filename = main_input_filename;
-
/* Find anonymous classes and expand their constructor. This extra pass is
- neccessary because the constructor itself is only generated when the
+ necessary because the constructor itself is only generated when the
method in which it is defined is expanded. */
for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
{
ctxp = cur_ctxp;
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (current);
+ output_class = current_class = TREE_TYPE (current);
if (ANONYMOUS_CLASS_P (current_class))
{
tree d;
{
if (DECL_CONSTRUCTOR_P (d))
{
- restore_line_number_status (1);
java_complete_expand_method (d);
- restore_line_number_status (0);
break; /* There is only one constructor. */
}
}
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
{
tree d;
- current_class = TREE_TYPE (current);
+ output_class = current_class = TREE_TYPE (current);
for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
{
if (DECL_RESULT (d) == NULL_TREE)
- {
- restore_line_number_status (1);
- java_complete_expand_method (d);
- restore_line_number_status (0);
- }
+ java_complete_expand_method (d);
}
}
}
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
{
tree d;
- current_class = TREE_TYPE (current);
+ output_class = current_class = TREE_TYPE (current);
for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
{
if (DECL_RESULT (d) == NULL_TREE)
{
something_changed = 1;
- restore_line_number_status (1);
java_complete_expand_method (d);
- restore_line_number_status (0);
}
}
}
/* Now things are stable, go for generation of the class data. */
- /* We pessimistically marked all fields external until we knew
- what set of classes we were planning to compile. Now mark
+ /* We pessimistically marked all methods and fields external until
+ we knew what set of classes we were planning to compile. Now mark
those that will be generated locally as not external. */
for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
{
tree current;
ctxp = cur_ctxp;
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
- {
- tree class = TREE_TYPE (current);
- tree field;
- for (field = TYPE_FIELDS (class); field ; field = TREE_CHAIN (field))
- if (FIELD_STATIC (field))
- DECL_EXTERNAL (field) = 0;
- }
+ java_mark_class_local (TREE_TYPE (current));
}
/* Compile the classes. */
current;
current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (TREE_VALUE (current));
- outgoing_cpool = TYPE_CPOOL (current_class);
+ output_class = current_class = TREE_TYPE (TREE_VALUE (current));
if (flag_emit_class_files)
write_classfile (current_class);
if (flag_emit_xref)
expand_xref (current_class);
else if (! flag_syntax_only)
- {
- java_expand_method_bodies (current_class);
- finish_class ();
- }
+ java_expand_method_bodies (current_class);
+ }
+ }
+}
+
+void
+java_finish_classes (void)
+{
+ static struct parser_ctxt *cur_ctxp = NULL;
+ for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
+ {
+ tree current;
+ ctxp = cur_ctxp;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ output_class = current_class = TREE_TYPE (current);
+ finish_class ();
}
}
}
make_qualified_name (tree left, tree right, int location)
{
#ifdef USE_COMPONENT_REF
- tree node = build (COMPONENT_REF, NULL_TREE, left, right);
+ tree node = build (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
EXPR_WFL_LINECOL (node) = location;
return node;
#else
/* We may be asked to save the real field access node */
if (orig)
*orig = access;
+ /* Last check: can we access the field? */
+ if (not_accessible_p (current_class, decl, NULL_TREE, 0))
+ {
+ not_accessible_field_error (id, decl);
+ return error_mark_node;
+ }
/* And we return what we got */
return access;
}
{
int is_static = 0;
tree field_ref;
- tree decl, where_found, type_found;
+ tree decl = NULL_TREE, where_found, type_found;
if (resolve_qualified_expression_name (qual_wfl, &decl,
&where_found, &type_found))
return error_mark_node;
if (is_static)
field_ref = maybe_build_class_init_for_field (decl, field_ref);
+
+ /* If we're looking at a static field, we may need to generate a
+ class initialization for it. This can happen when the access
+ looks like `field.ref', where `field' is a static field in an
+ interface we implement. */
+ if (!flag_emit_class_files
+ && !flag_emit_xref
+ && TREE_CODE (where_found) == VAR_DECL
+ && FIELD_STATIC (where_found))
+ {
+ build_static_field_ref (where_found);
+ field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
+ }
}
else
field_ref = decl;
instantiation using a primary qualified by a `new' */
RESTORE_THIS_AND_CURRENT_CLASS;
- /* EH check. No check on access$<n> functions */
- if (location
- && !OUTER_FIELD_ACCESS_IDENTIFIER_P
- (DECL_NAME (current_function_decl)))
- check_thrown_exceptions (location, ret_decl);
+ if (location)
+ {
+ tree arguments = NULL_TREE;
+ if (TREE_CODE (qual_wfl) == CALL_EXPR
+ && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
+ arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
+ check_thrown_exceptions (location, ret_decl, arguments);
+ }
/* If the previous call was static and this one is too,
build a compound expression to hold the two (because in
tree list;
*where_found = decl;
+ check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
+
/* We want to be absolutely sure that the class is laid
out. We're going to search something inside it. */
*type_found = type = TREE_TYPE (decl);
list = TREE_CHAIN (q);
while (list)
{
- RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
list = TREE_CHAIN (list);
}
decl = QUAL_RESOLUTION (q);
/* Sneak preview. If next we see a `new', we're facing a
- qualification with resulted in a type being selected
- instead of a field. Report the error */
+ qualification which resulted in a type being selected
+ instead of a field. Report the error. */
if(TREE_CHAIN (q)
&& TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
{
return 1;
}
- if (not_accessible_p (TREE_TYPE (decl), decl, type, 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_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
+
check_deprecation (qual_wfl, decl);
type = TREE_TYPE (decl);
}
}
- /* Report and error if we're using a numerical litteral as a
+ /* Report and error if we're using a numerical literal as a
qualifier. It can only be an INTEGER_CST. */
else if (TREE_CODE (qual_wfl) == INTEGER_CST)
{
/* Check on accessibility here */
if (not_accessible_p (current_class, field_decl,
- DECL_CONTEXT (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;
- }
+ *type_found, from_super))
+ return not_accessible_field_error (qual_wfl,field_decl);
check_deprecation (qual_wfl, field_decl);
/* There are things to check when fields are accessed
not_accessible_p (tree reference, tree member, tree where, int from_super)
{
int access_flag = get_access_flags_from_decl (member);
-
- /* Inner classes are processed by check_inner_class_access */
- if (INNER_CLASS_TYPE_P (reference))
- return 0;
+ bool is_static = false;
+
+ if (TREE_CODE (member) == FIELD_DECL ||
+ TREE_CODE (member) == VAR_DECL)
+ is_static = FIELD_STATIC (member);
+ else
+ is_static = METHOD_STATIC (member);
/* Access always granted for members declared public */
if (access_flag & ACC_PUBLIC)
if (from_super)
return 0;
- /* If where is active, access was made through a
- qualifier. Access is granted if the type of the qualifier is
- or is a sublass of the type the access made from (6.6.2.1.) */
- if (where && !inherits_from_p (reference, where))
- return 1;
-
- /* Otherwise, access is granted if occurring from the class where
- member is declared or a subclass of it. Find the right
- context to perform the check */
- if (PURE_INNER_CLASS_TYPE_P (reference))
+ /* If WHERE is active, access was made through a qualifier. For
+ non-static members, access is granted if the type of the qualifier
+ is or is a sublass of the type the access is made from (6.6.2.1.) */
+ if (where && !is_static)
{
- while (INNER_CLASS_TYPE_P (reference))
+ while (reference)
{
- if (inherits_from_p (reference, DECL_CONTEXT (member)))
- return 0;
- reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
- }
+ if (inherits_from_p (where, reference))
+ return 0;
+ if (PURE_INNER_CLASS_TYPE_P (reference))
+ reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
+ else
+ break;
+ }
+ return 1;
+ }
+
+ /* Otherwise, access is granted if occurring from within the class
+ where member is declared, or a subclass of it. */
+ while (reference)
+ {
+ if (inherits_from_p (reference, DECL_CONTEXT (member)))
+ return 0;
+ if (PURE_INNER_CLASS_TYPE_P (reference))
+ reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
+ else
+ break;
}
- if (inherits_from_p (reference, DECL_CONTEXT (member)))
- return 0;
return 1;
}
it for innerclasses too. */
if (access_flag & ACC_PRIVATE)
{
- if (reference == DECL_CONTEXT (member))
- return 0;
- if (enclosing_context_p (reference, DECL_CONTEXT (member)))
+ if (reference == DECL_CONTEXT (member) ||
+ common_enclosing_context_p (DECL_CONTEXT (member), reference))
return 0;
return 1;
}
- /* Default access are permitted only when occurring 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;
+ /* Default access is permitted only when occurring from within the
+ package in which the context (MEMBER) is declared. */
+ return !class_in_current_package (DECL_CONTEXT (member));
}
/* Test deprecated decl access. */
return 1;
/* Compare the left part of the name of CLASS with the package name */
- breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
+ split_qualified_name (&left, NULL, DECL_NAME (TYPE_NAME (class)));
if (ctxp->package == left)
{
cicp_cache = class;
tree this_arg = NULL_TREE;
int is_array_clone_call = 0;
- /* Should be overriden if everything goes well. Otherwise, if
+ /* Should be overridden 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
this_arg = primary ? primary : current_this;
/* If we're using an access method, things are different.
- There are two familly of cases:
+ There are two family of cases:
1) We're not generating bytecodes:
- LIST is static. It's invocation is transformed from
x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
- Of course, this$<n> can be abitrary complex, ranging from
+ Of course, this$<n> can be arbitrarily complex, ranging from
this$0 (the immediate outer context) to
access$0(access$0(...(this$0))).
{
const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
const char *const access =
- java_accstring_lookup (get_access_flags_from_decl (list));
+ accessibility_string (get_access_flags_from_decl (list));
const char *const klass =
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
const char *const refklass =
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
const char *const what = (DECL_CONSTRUCTOR_P (list)
? "constructor" : "method");
- /* FIXME: WFL yields the wrong message here but I don't know
- what else to use. */
parse_error_context (wfl,
"Can't access %s %s `%s.%s' from `%s'",
access, what, klass, fct_name, refklass);
*mdecl = md;
*this_arg = ta;
- /* Returnin a nonzero value indicates we were doing a non static
- method invokation that is now a static invocation. It will have
+ /* Returning a nonzero value indicates we were doing a non static
+ method invocation that is now a static invocation. It will have
callee displace `this' to insert it in the regular argument
list. */
return (non_static_context && to_return);
TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
- /* Resolve unresolved returned type isses */
+ /* Resolve unresolved returned type issues */
t = TREE_TYPE (TREE_TYPE (method));
if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
resolve_and_layout (TREE_TYPE (t), NULL);
(class_has_finalize_method (class) ? alloc_object_node
: alloc_no_finalizer_node);
new = build (CALL_EXPR, promote_type (class),
- build_address_of (alloc_node),
- tree_cons (NULL_TREE, build_class_ref (class),
- build_tree_list (NULL_TREE,
- size_in_bytes (class))),
- NULL_TREE);
+ build_address_of (alloc_node),
+ build_tree_list (NULL_TREE, build_class_ref (class)),
+ NULL_TREE);
saved_new = save_expr (new);
c1 = build_tree_list (NULL_TREE, saved_new);
TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
/* We have to call force_evaluation_order now because creating a
COMPOUND_EXPR wraps the arg list in a way that makes it
unrecognizable by force_evaluation_order later. Yuk. */
- tree save = save_expr (force_evaluation_order (patch));
+ tree save = force_evaluation_order (patch);
tree type = TREE_TYPE (patch);
- patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
+ patch = build (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
list = tree_cons (method, patch,
DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
static htab_t searched_classes;
static int search_not_done = 0;
tree list = NULL_TREE, all_list = NULL_TREE;
+ tree base_binfo;
+ int i;
/* Check the hash table to determine if this class has been searched
already. */
search_not_done++;
*htab_find_slot (searched_classes, class, INSERT) = class;
- if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
+ if (!CLASS_LOADED_P (class))
{
load_class (class, 1);
safe_layout_class (class);
if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
&& CLASS_INTERFACE (TYPE_NAME (class)))
{
- int i, n;
- tree basetype_vec = TYPE_BINFO_BASETYPES (class);
search_applicable_methods_list (lc, TYPE_METHODS (class),
name, arglist, &list, &all_list);
- n = TREE_VEC_LENGTH (basetype_vec);
- for (i = 1; i < n; i++)
+ for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
{
- tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
+ tree t = BINFO_TYPE (base_binfo);
tree rlist;
-
+
rlist = find_applicable_accessible_methods_list (lc, t, name,
arglist);
list = chainon (rlist, list);
/* We must search all interfaces of this class */
if (!lc)
- {
- tree basetype_vec = TYPE_BINFO_BASETYPES (class);
- int n = TREE_VEC_LENGTH (basetype_vec), i;
- for (i = 1; i < n; i++)
- {
- tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
- if (t != object_type_node)
- {
- tree rlist
- = find_applicable_accessible_methods_list (lc, t,
- name, arglist);
- list = chainon (rlist, list);
- }
- }
- }
+ {
+ for (i = 1;
+ BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
+ {
+ tree t = BINFO_TYPE (base_binfo);
+ if (t != object_type_node)
+ {
+ tree rlist
+ = find_applicable_accessible_methods_list (lc, t,
+ name, arglist);
+ list = chainon (rlist, list);
+ }
+ }
+ }
/* Search superclass */
if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
/* If we have several and they're all abstract, just pick the
closest one. */
- if (candidates > 0 && (candidates == abstract))
+ if (candidates > 0 && candidates == abstract)
{
+ /* FIXME: merge the throws clauses. There is no convenient way
+ to do this in gcj right now, since ideally we'd like to
+ introduce a new METHOD_DECL here, but that is really not
+ possible. */
new_list = nreverse (new_list);
TREE_CHAIN (new_list) = NULL_TREE;
+ return new_list;
}
/* We have several (we couldn't find a most specific), all but one
static int
argument_types_convertible (tree m1, tree m2_or_arglist)
{
- register tree m1_arg, m2_arg;
+ tree m1_arg, m2_arg;
SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
/* Qualification routines */
+/* Given a name x.y.z, look up x locally. If it's found, save the
+ decl. If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
+ so that we later try and load the appropriate classes. */
static void
qualify_ambiguous_name (tree id)
{
- tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
- 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 {
+ tree name, decl;
- /* 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
- || (EXPR_WFL_QUALIFICATION (qual_wfl)
- && TREE_CODE (EXPR_WFL_QUALIFICATION (qual_wfl)) == TREE_LIST))
- {
- qual = EXPR_WFL_QUALIFICATION (qual_wfl);
- qual_wfl = QUAL_WFL (qual);
- }
- break;
- case NEW_ARRAY_EXPR:
- case NEW_ANONYMOUS_ARRAY_EXPR:
- qual = TREE_CHAIN (qual);
- again = new_array_found = 1;
- continue;
- case CONVERT_EXPR:
- break;
- case NEW_CLASS_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;
- case CLASS_LITERAL:
- qual = TREE_CHAIN (qual);
- qual_wfl = QUAL_WFL (qual);
- break;
- default:
- /* Fix for -Wall. Just break doing nothing */
- break;
- }
+ /* We inspect the first item of the qualification list. As a sanity
+ check, make sure that it is an identfier node. */
+ tree qual = EXPR_WFL_QUALIFICATION (id);
+ tree qual_wfl = QUAL_WFL (qual);
- 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 == INTEGER_CST)
- name = qual_wfl;
-
- else if (code == CONVERT_EXPR &&
- TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
- name = TREE_OPERAND (qual_wfl, 0);
-
- else if (code == CONVERT_EXPR
- && TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == CALL_EXPR
- && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0))
- == EXPR_WITH_FILE_LOCATION))
- name = TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0);
-
- else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
- TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
- name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
+ if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
+ return;
- else if (code == TREE_LIST)
- name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
+ name = EXPR_WFL_NODE (qual_wfl);
- else if (code == STRING_CST || code == CONDITIONAL_EXPR
- || code == PLUS_EXPR)
- {
- qual = TREE_CHAIN (qual);
- qual_wfl = QUAL_WFL (qual);
- again = 1;
- }
- else
- {
- name = EXPR_WFL_NODE (qual_wfl);
- if (!name)
- {
- qual = EXPR_WFL_QUALIFICATION (qual_wfl);
- again = 1;
- }
- }
-
- /* If we have a THIS (from a primary), we set the context accordingly */
- if (name == this_identifier_node)
- {
- /* This isn't really elegant. One more added irregularity
- before I start using COMPONENT_REF (hopefully very soon.) */
- if (TREE_CODE (TREE_PURPOSE (qual)) == ARRAY_REF
- && TREE_CODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
- EXPR_WITH_FILE_LOCATION
- && EXPR_WFL_NODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
- this_identifier_node)
- {
- qual = TREE_OPERAND (TREE_PURPOSE (qual), 0);
- qual = EXPR_WFL_QUALIFICATION (qual);
- }
- qual = TREE_CHAIN (qual);
- qual_wfl = QUAL_WFL (qual);
- if (TREE_CODE (qual_wfl) == CALL_EXPR)
- again = 1;
- else if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION)
- name = EXPR_WFL_NODE (qual_wfl);
- else if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
- name = TREE_OPERAND (qual_wfl, 0);
- 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 we don't have an identifier, or we have a 'this' or 'super',
+ then field access processing is all we need : there is nothing
+ for us to do. */
+ if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
+ name == this_identifier_node ||
+ name == super_identifier_node)
+ return;
/* If name appears within the scope of a local 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
- && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
- && (decl = IDENTIFIER_LOCAL_VALUE (name)))
- {
- RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+ or parameter declaration, or is a field within an enclosing
+ class, then it is an expression name. Save the decl and let
+ resolve_field_access do it's work. */
+ if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
+ (decl = lookup_field_wrapper (current_class, name)))
+ {
QUAL_RESOLUTION (qual) = decl;
+ return;
}
- /* 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))
- || name == length_identifier_node)
- {
- RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
- QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
- }
-
- /* We reclassify NAME as yielding to a type name resolution 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.
- - NAME is actually a STRING_CST.
- This can't happen if the expression was qualified by `this.' */
- else if (! this_found &&
- (TREE_CODE (name) == STRING_CST ||
- TREE_CODE (name) == INTEGER_CST ||
- (decl = resolve_and_layout (name, NULL_TREE))))
+ /* If name is a known class name (either declared or imported), mark
+ us as a type name. */
+ if ((decl = resolve_and_layout (name, NULL_TREE)))
{
RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
QUAL_RESOLUTION (qual) = decl;
}
- /* Method call, array references and cast 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
- || TREE_CODE (QUAL_WFL (qual)) == MODIFY_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 */
+ /* We couldn't find a declaration for the name. Assume for now that
+ we have a qualified class name that needs to be loaded from an
+ external class file. */
else
RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
- /* Propagate the qualification accross other components of the
+ /* Propagate the qualification across 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))
+ 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 (tree *left, tree *right, tree source)
-{
- char *p, *base;
- int l = IDENTIFIER_LENGTH (source);
-
- base = alloca (l + 1);
- memcpy (base, IDENTIFIER_POINTER (source), l + 1);
-
- /* Breakdown NAME into REMAINDER . IDENTIFIER. */
- p = base + 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 (base);
-
- return 0;
-}
-
-/* Return TRUE if two classes are from the same package. */
-
-static int
-in_same_package (tree name1, tree name2)
-{
- tree tmp;
- tree pkg1;
- tree pkg2;
-
- if (TREE_CODE (name1) == TYPE_DECL)
- name1 = DECL_NAME (name1);
- if (TREE_CODE (name2) == TYPE_DECL)
- name2 = DECL_NAME (name2);
-
- if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
- /* One in empty package. */
- return 0;
-
- if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
- /* Both in empty package. */
- return 1;
-
- breakdown_qualified (&pkg1, &tmp, name1);
- breakdown_qualified (&pkg2, &tmp, name2);
-
- return (pkg1 == pkg2);
}
/* Patch tree nodes in a function body. When a BLOCK is found, push
long blocks. */
ptr = &BLOCK_EXPR_BODY (node);
while (TREE_CODE (*ptr) == COMPOUND_EXPR
- && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
+ && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
{
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)
+ if (IS_EMPTY_STMT (cur))
{
/* Optimization; makes it easier to detect empty bodies.
Most useful for <clinit> with all-constant initializer. */
&& TREE_CODE (wfl_op2) != DEFAULT_EXPR)
unreachable_stmt_error (*ptr);
}
+ if (TREE_TYPE (*ptr) == NULL_TREE)
+ TREE_TYPE (*ptr) = void_type_node;
ptr = next;
}
*ptr = java_complete_tree (*ptr);
case TRY_FINALLY_EXPR:
COMPLETE_CHECK_OP_0 (node);
COMPLETE_CHECK_OP_1 (node);
- if (TREE_OPERAND (node, 0) == empty_stmt_node)
+ if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
+ /* Reduce try/finally nodes with an empty try block. */
return TREE_OPERAND (node, 1);
- if (TREE_OPERAND (node, 1) == empty_stmt_node)
+ if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
+ /* Likewise for an empty finally block. */
return TREE_OPERAND (node, 0);
CAN_COMPLETE_NORMALLY (node)
= (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
TREE_TYPE (node) = void_type_node;
POP_LABELED_BLOCK ();
- if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
+ if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
{
LABELED_BLOCK_BODY (node) = NULL_TREE;
CAN_COMPLETE_NORMALLY (node) = 1;
TREE_OPERAND (cn, 1));
}
/* Accept final locals too. */
- else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
+ else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
+ && DECL_INITIAL (cn))
cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
if (!TREE_CONSTANT (cn) && !flag_emit_xref)
wfl_op2 = TREE_OPERAND (node, 1);
TREE_OPERAND (node, 0) = nn =
java_complete_tree (TREE_OPERAND (node, 0));
- if (wfl_op2 == empty_stmt_node)
+ if (IS_EMPTY_STMT (wfl_op2))
CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
else
{
nn = wfl_op2;
if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
nn = EXPR_WFL_NODE (nn);
- if (TREE_CODE (nn) != EXIT_EXPR)
+ /* NN can be NULL_TREE exactly when UPDATE is, in
+ finish_for_loop. */
+ if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
{
SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
if (SUPPRESS_UNREACHABLE_ERROR (nn))
else
{
tree body;
- int save_lineno = lineno;
- lineno = EXPR_WFL_LINENO (node);
+ int save_lineno = input_line;
+ input_line = EXPR_WFL_LINENO (node);
body = java_complete_tree (EXPR_WFL_NODE (node));
- lineno = save_lineno;
+ input_line = 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 || TREE_CONSTANT (body))
+ if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
{
/* Makes it easier to constant fold, detect empty bodies. */
return body;
int in_this = CALL_THIS_CONSTRUCTOR_P (node);
int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
super_identifier_node);
+ tree arguments;
+ int location = EXPR_WFL_LINECOL (node);
node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
from_super, 0, &decl);
if (node == error_mark_node)
return error_mark_node;
- check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
+ if (TREE_CODE (node) == CALL_EXPR
+ && TREE_OPERAND (node, 1) != NULL_TREE)
+ arguments = TREE_VALUE (TREE_OPERAND (node, 1));
+ else
+ arguments = NULL_TREE;
+ check_thrown_exceptions (location, decl, arguments);
/* If we call this(...), register signature and positions */
if (in_this)
DECL_CONSTRUCTOR_CALLS (current_function_decl) =
/* When we have a primitype type, or a string and we're not
emitting a class file, we actually don't want to generate
anything for the assignment. */
- if (value != NULL_TREE &&
- (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
+ if (value != NULL_TREE &&
+ (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
(TREE_TYPE (value) == string_ptr_type_node &&
! flag_emit_class_files)))
{
else
DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
DECL_FIELD_FINAL_IUD (nn) = 1;
- return empty_stmt_node;
+ return build_java_empty_stmt ();
}
}
if (! flag_emit_class_files)
TREE_OPERAND (node, 1) = nn;
}
- return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
+ return patch_binop (node, wfl_op1, wfl_op2);
case INSTANCEOF_EXPR:
wfl_op1 = TREE_OPERAND (node, 0);
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
+ /* If we have a string literal that we haven't transformed yet or a
+ crafted string buffer, as a result of the use of the String
`+' operator. Build `parm.toString()' and expand it. */
if ((temp = patch_string (parm)))
parm = temp;
static tree
build_expr_block (tree body, tree decls)
-
{
tree node = make_node (BLOCK);
BLOCK_EXPR_DECLS (node) = decls;
{
tree b = exit_block ();
java_method_add_stmt (current_function_decl, b);
- SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
+ SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
}
}
{
tree wfl, node_to_insert = node;
- /* We want to process THIS . xxx symbolicaly, to keep it consistent
+ /* We want to process THIS . xxx symbolically, 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 (node) == THIS_EXPR)
return wfl;
}
-/* Build a super() constructor invocation. Returns empty_stmt_node if
+/* Build a super() constructor invocation. Returns an empty statement if
we're currently dealing with the class java.lang.Object. */
static tree
build_super_invocation (tree mdecl)
{
if (DECL_CONTEXT (mdecl) == object_type_node)
- return empty_stmt_node;
+ return build_java_empty_stmt ();
else
{
tree super_wfl = build_wfl_node (super_identifier_node);
+ /* This is called after parsing is done, so the parser context
+ won't be accurate. Set location info from current_class decl. */
+ tree class_wfl = lookup_cl (TYPE_NAME (current_class));
+ EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
tree a = NULL_TREE, t;
/* If we're dealing with an anonymous class, pass the arguments
of the crafted constructor along. */
static char *
string_convert_int_cst (tree node)
{
- static char buffer[80];
+ /* Long.MIN_VALUE is -9223372036854775808, 20 characters. */
+ static char buffer[21];
unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
- char *p = buffer + sizeof (buffer) - 1;
+ char *p = buffer + sizeof (buffer);
int neg = 0;
unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
<< (HOST_BITS_PER_WIDE_INT - 1));
- *p-- = '\0';
+ *--p = '\0';
/* If negative, note the fact and negate the value. */
if ((hi & hibit))
}
/* Divide by 10 until there are no bits left. */
- while (hi || lo)
+ do
{
unsigned HOST_WIDE_INT acc = 0;
unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
}
}
- /* FIXME: ASCII assumption. */
- *p-- = '0' + acc;
+ /* '0' == 060 in Java, but might not be here (think EBCDIC). */
+ *--p = '\060' + acc;
hi = outhi;
lo = outlo;
}
+ while (hi || lo);
if (neg)
- *p-- = '-';
+ *--p = '\055'; /* '-' == 055 in Java, but might not be here. */
- return p + 1;
+ return p;
}
/* Print an INTEGER_CST node in a static buffer, and return the
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));
- }
+ sprintf (buffer, "-" 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));
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);
+ if (!new_rhs)
+ new_rhs = try_reference_assignconv (lhs_type, rhs);
/* 15.25.2 If we have a compound assignment, convert RHS into the
type of the LHS */
)
{
TREE_CONSTANT (lvalue) = 1;
+ TREE_INVARIANT (lvalue) = 1;
DECL_INITIAL (lvalue) = new_rhs;
}
case INDIRECT_REF:
case COMPONENT_REF:
/* Transform a = foo.bar
- into a = { int tmp; tmp = foo.bar; tmp; ).
+ into a = ({int tmp; tmp = foo.bar;}).
We need to ensure that if a read from memory fails
because of a NullPointerException, a destination variable
will remain unchanged. An explicit temporary does what
{
tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
TREE_TYPE (new_rhs));
- tree block = build (BLOCK, TREE_TYPE (new_rhs), NULL);
+ tree block = make_node (BLOCK);
tree assignment
= build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
+ DECL_CONTEXT (tmp) = current_function_decl;
+ TREE_TYPE (block) = TREE_TYPE (new_rhs);
BLOCK_VARS (block) = tmp;
- BLOCK_EXPR_BODY (block)
- = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
+ BLOCK_EXPR_BODY (block) = assignment;
TREE_SIDE_EFFECTS (block) = 1;
new_rhs = block;
}
/* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
conversion (5.1.1) or widening primitive conversion (5.1.2). Return
0 is the conversion test fails. This implements parts the method
- invocation convertion (5.3). */
+ invocation conversion (5.3). */
static int
valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
/* Otherwise, SOURCE must implement DEST */
return interface_of_p (dest, source);
}
- /* DEST is an array, cast permited if SOURCE is of Object type */
+ /* DEST is an array, cast permitted if SOURCE is of Object type */
return (cast && source == object_type_node ? 1 : 0);
}
if (TYPE_INTERFACE_P (source))
{
parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
TREE_CONSTANT (node) = 0;
+ TREE_INVARIANT (node) = 0;
}
/* Change the division operator if necessary */
if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
TREE_SET_CODE (node, TRUNC_DIV_EXPR);
- /* Before divisions as is disapear, try to simplify and bail if
+ /* Before divisions as is disappear, try to simplify and bail if
applicable, otherwise we won't perform even simple
simplifications like (1-1)/3. We can't do that with floating
point number, folds can't handle them at this stage. */
}
/* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
- new STRING_CST on success, NULL_TREE on failure */
+ new STRING_CST on success, NULL_TREE on failure. */
static tree
merge_string_cste (tree op1, tree op2, int after)
{
- /* Handle two string constants right away */
+ /* 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 */
+ /* Reasonable integer constant can be treated right away. */
if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
{
static const char *const boolean_true = "true";
static const char *const boolean_false = "false";
static const char *const null_pointer = "null";
- char ch[3];
+ char ch[4];
const 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)
+ else if (op2 == null_pointer_node
+ || (integer_zerop (op2)
+ && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
+ /* FIXME: null is not a compile-time constant, so it is only safe to
+ merge if the overall expression is non-constant. However, this
+ code always merges without checking the overall expression. */
string = null_pointer;
else if (TREE_TYPE (op2) == char_type_node)
{
/* Convert the character into UTF-8. */
- unsigned char c = (unsigned char) TREE_INT_CST_LOW (op2);
+ unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
unsigned char *p = (unsigned char *) ch;
- if (0x01 <= c
- && c <= 0x7f)
- *p++ = c;
+ if (0x01 <= c && c <= 0x7f)
+ *p++ = (unsigned char) c;
+ else if (c < 0x7ff)
+ {
+ *p++ = (unsigned char) (c >> 6 | 0xc0);
+ *p++ = (unsigned char) ((c & 0x3f) | 0x80);
+ }
else
{
- *p++ = c >> 6 | 0xc0;
- *p++ = (c & 0x3f) | 0x80;
+ *p++ = (unsigned char) (c >> 12 | 0xe0);
+ *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
+ *p++ = (unsigned char) ((c & 0x3f) | 0x80);
}
*p = '\0';
-
+
string = ch;
}
else
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;
+ TREE_INVARIANT (node) = 1;
+
+ /* ??? Guessing that the class file code can't handle casts. */
+ if (! flag_emit_class_files)
+ node = convert (string_ptr_type_node, node);
+ else
+ TREE_TYPE (node) = string_ptr_type_node;
+
return node;
}
build_incomplete_class_ref (int location, tree class_name)
{
tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
+ tree class_decl = GET_CPC ();
+ tree this_class = TREE_TYPE (class_decl);
+
+ /* Generate the synthetic static method `class$'. (Previously we
+ deferred this, causing different method tables to be emitted
+ for native code and bytecode.) */
+ if (!TYPE_DOT_CLASS (this_class)
+ && !JPRIMITIVE_TYPE_P (class_name)
+ && !(TREE_CODE (class_name) == VOID_TYPE))
+ {
+ tree cpc_list = GET_CPC_LIST();
+ tree cpc = cpc_list;
+ tree target_class;
+
+ /* For inner classes, add a 'class$' method to their outermost
+ context, creating it if necessary. */
+
+ while (GET_NEXT_ENCLOSING_CPC(cpc))
+ cpc = GET_NEXT_ENCLOSING_CPC(cpc);
+ class_decl = TREE_VALUE (cpc);
+
+ target_class = TREE_TYPE (class_decl);
+
+ if (CLASS_INTERFACE (TYPE_NAME (target_class)))
+ {
+ /* For interfaces, adding a static 'class$' method directly
+ is illegal. So create an inner class to contain the new
+ method. Empirically this matches the behavior of javac. */
+ tree t, inner;
+ /* We want the generated inner class inside the outermost class. */
+ GET_CPC_LIST() = cpc;
+ t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
+ inner = create_anonymous_class (t);
+ target_class = TREE_TYPE (inner);
+ end_class_declaration (1);
+ GET_CPC_LIST() = cpc_list;
+ }
+
+ if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
+ build_dot_class_method (target_class);
+
+ if (this_class != target_class)
+ TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
+ }
+
EXPR_WFL_LINECOL (node) = location;
return node;
}
if (!(ref_type = resolve_type_during_patch (type)))
return error_mark_node;
- /* Generate the synthetic static method `class$'. (Previously we
- deferred this, causing different method tables to be emitted
- for native code and bytecode.) */
- if (!TYPE_DOT_CLASS (current_class))
- build_dot_class_method (current_class);
-
/* If we're not emitting class files and we know ref_type is a
compiled class, build a direct reference. */
if ((! flag_emit_class_files && is_compiled_class (ref_type))
/* If we're emitting class files and we have to deal with non
primitive types, we invoke the synthetic static method `class$'. */
- ref_type = build_dot_class_method_invocation (ref_type);
+ ref_type = build_dot_class_method_invocation (current_class, ref_type);
return java_complete_tree (ref_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);
+ /* A narrowing conversion from a floating-point number to an
+ integral type requires special handling (5.1.3). */
+ if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
+ if (cast_type != long_type_node)
+ op = convert (integer_type_node, op);
- /* Try widening/narowwing convertion. Potentially, things need
+ /* Try widening/narrowing conversion. Potentially, things need
to be worked out in gcc so we implement the extreme cases
- correctly. fold_convert() needs to be fixed. */
+ correctly. fold_convert() needs to be fixed. */
return convert (cast_type, op);
}
static tree
build_array_ref (int location, tree array, tree index)
{
- tree node = build (ARRAY_REF, NULL_TREE, array, index);
+ tree node = build (ARRAY_REF, NULL_TREE, array, index, NULL_TREE, NULL_TREE);
EXPR_WFL_LINECOL (node) = location;
return node;
}
static tree
build_new_array_init (int location, tree values)
{
- tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
+ tree constructor = build_constructor (NULL_TREE, values);
tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
EXPR_WFL_LINECOL (to_return) = location;
return to_return;
TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
TREE_TYPE (node) = promote_type (type);
TREE_CONSTANT (init) = all_constant;
+ TREE_INVARIANT (init) = all_constant;
TREE_CONSTANT (node) = all_constant;
+ TREE_INVARIANT (node) = all_constant;
return node;
}
{
tree node;
if (!else_body)
- else_body = empty_stmt_node;
+ else_body = build_java_empty_stmt ();
node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
EXPR_WFL_LINECOL (node) = location;
node = build_debugable_stmt (location, node);
return error_mark_node;
}
- if (TREE_CODE (expression) == INTEGER_CST)
- {
- if (integer_zerop (expression))
- node = TREE_OPERAND (node, 2);
- else
- node = TREE_OPERAND (node, 1);
- if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
- {
- node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
- CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
- }
- return node;
- }
TREE_TYPE (node) = void_type_node;
TREE_SIDE_EFFECTS (node) = 1;
CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
/* 14.6 Labeled Statements */
-/* Action taken when a lableled statement is parsed. a new
+/* Action taken when a labeled 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. */
second = (reversed ? condition : body);
return
build (COMPOUND_EXPR, NULL_TREE,
- build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
+ build (COMPOUND_EXPR, NULL_TREE, first, second),
+ build_java_empty_stmt ());
}
/* Install CONDITION (if any) and loop BODY (using REVERSED to tell
this because the (current interpretation of the) JLS requires
that the update expression be considered reachable even if the
for loop's body doesn't complete normally. */
- if (update != NULL_TREE && update != empty_stmt_node)
+ if (update != NULL_TREE && !IS_EMPTY_STMT (update))
{
tree up2 = update;
if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
up2 = EXPR_WFL_NODE (up2);
- /* Try to detect constraint violations. These would be
- programming errors somewhere. */
- if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
- || TREE_CODE (up2) == LOOP_EXPR)
- abort ();
- SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
+ /* It is possible for the update expression to be an
+ EXPR_WFL_NODE wrapping nothing. */
+ if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
+ {
+ /* Try to detect constraint violations. These would be
+ programming errors somewhere. */
+ if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
+ || TREE_CODE (up2) == LOOP_EXPR)
+ abort ();
+ SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
+ }
}
LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
return loop;
(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
+ label name, so that the error can be reported accurately in
patch_bc_statement. */
label_block_expr = EXPR_WFL_NODE (name);
}
tree node;
tree klass = GET_CPC ();
+ if (! enable_assertions (klass))
+ {
+ condition = build (TRUTH_ANDIF_EXPR, NULL_TREE,
+ boolean_false_node, condition);
+ if (value == NULL_TREE)
+ value = build_java_empty_stmt ();
+ return build_if_else_statement (location, condition,
+ value, NULL_TREE);
+ }
+
if (! CLASS_USES_ASSERTIONS (klass))
{
tree field, classdollar, id, call;
MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
FIELD_SYNTHETIC (field) = 1;
- if (!TYPE_DOT_CLASS (class_type))
- build_dot_class_method (class_type);
- classdollar = build_dot_class_method_invocation (class_type);
+ classdollar = build_incomplete_class_ref (location, class_type);
/* Call CLASS.desiredAssertionStatus(). */
id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
catches TYPE and executes CATCH_STMTS. */
static tree
-encapsulate_with_try_catch (int location, tree type, tree try_stmts,
+encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
tree catch_stmts)
{
tree try_block, catch_clause_param, catch_block, catch;
try_block = build_expr_block (try_stmts, NULL_TREE);
/* Build a catch block: we need a catch clause parameter */
- catch_clause_param = build_decl (VAR_DECL,
- wpv_id, build_pointer_type (type));
+ if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
+ {
+ tree catch_type = obtain_incomplete_type (type_or_name);
+ jdep *dep;
+ catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
+ register_incomplete_type (JDEP_VARIABLE, type_or_name,
+ catch_clause_param, catch_type);
+ dep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
+ }
+ else
+ catch_clause_param = build_decl (VAR_DECL, wpv_id,
+ build_pointer_type (type_or_name));
+
/* And a block */
catch_block = build_expr_block (NULL_TREE, catch_clause_param);
/* Add the catch statements */
add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
- /* Now we can build a CATCH_EXPR */
- catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
+ /* Now we can build a JAVA_CATCH_EXPR */
+ catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
return build_try_statement (location, try_block, catch_block);
}
int unreachable;
/* At this point, the structure of the catch clause is
- CATCH_EXPR (catch node)
+ JAVA_CATCH_EXPR (catch node)
BLOCK (with the decl of the parameter)
COMPOUND_EXPR
MODIFY_EXPR (assignment of the catch parameter)
}
/* Check that exception said to be thrown by method DECL can be
- effectively caught from where DECL is invoked. */
-
+ effectively caught from where DECL is invoked. THIS_EXPR is the
+ expression that computes `this' for the method call. */
static void
-check_thrown_exceptions (int location, tree decl)
+check_thrown_exceptions (int location, tree decl, tree this_expr)
{
tree throws;
- /* For all the unchecked exceptions thrown by DECL */
+ int is_array_call = 0;
+
+ /* Skip check within generated methods, such as access$<n>. */
+ if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
+ return;
+
+ if (this_expr != NULL_TREE
+ && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
+ && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
+ is_array_call = 1;
+
+ /* 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"))
+ /* Suppress errors about cloning arrays. */
+ if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
continue;
-#endif
+
EXPR_WFL_LINECOL (wfl_operator) = location;
if (DECL_FINIT_P (current_function_decl))
parse_error_context
if (val == NULL_TREE || ! TREE_CONSTANT (val))
return NULL_TREE;
TREE_OPERAND (node, 0) = val;
- return patch_unaryop (node, op0);
+ val = patch_unaryop (node, op0);
+ if (! TREE_CONSTANT (val))
+ return NULL_TREE;
+ return val;
+
break;
case COND_EXPR:
return true;
}
-/* This function is called for each classes that is known definitely
- assigned when a given static method was called. This function
+/* This function is called for each class that is known definitely
+ initialized when a given static method was called. This function
augments a compound expression (INFO) storing all assignment to
initialized static class flags if a flag already existed, otherwise
a new one is created. */
LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
DECL_CONTEXT (decl) = current_function_decl;
DECL_INITIAL (decl) = boolean_true_node;
+ /* Don't emit any symbolic debugging info for this decl. */
+ DECL_IGNORED_P (decl) = 1;
/* The trick is to find the right context for it. */
block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
OSDN Git Service
