#include <dirent.h>
#include "tree.h"
#include "rtl.h"
+#include "real.h"
#include "obstack.h"
#include "toplev.h"
#include "flags.h"
#include "function.h"
#include "except.h"
#include "ggc.h"
+#include "debug.h"
#ifndef DIR_SEPARATOR
#define DIR_SEPARATOR '/'
static int check_pkg_class_access PARAMS ((tree, tree, bool));
static void register_package PARAMS ((tree));
static tree resolve_package PARAMS ((tree, tree *, tree *));
-static tree lookup_package_type PARAMS ((const char *, int));
static tree resolve_class PARAMS ((tree, tree, tree, tree));
static void declare_local_variables PARAMS ((int, tree, tree));
static void dump_java_tree PARAMS ((enum tree_dump_index, tree));
/* JDK 1.1 work. FIXME */
static tree maybe_make_nested_class_name PARAMS ((tree));
-static void make_nested_class_name PARAMS ((tree));
+static int make_nested_class_name PARAMS ((tree));
static void set_nested_class_simple_name_value PARAMS ((tree, int));
static void link_nested_class_to_enclosing PARAMS ((void));
-static tree resolve_inner_class PARAMS ((struct hash_table *, tree, tree *,
- tree *, tree));
+static tree resolve_inner_class PARAMS ((htab_t, tree, tree *, tree *, tree));
static tree find_as_inner_class PARAMS ((tree, tree, tree));
static tree find_as_inner_class_do PARAMS ((tree, tree));
static int check_inner_class_redefinition PARAMS ((tree, tree));
static void mark_parser_ctxt PARAMS ((void *));
static tree maybe_build_class_init_for_field PARAMS ((tree, tree));
-static bool attach_init_test_initialization_flags PARAMS ((struct hash_entry *,
- PTR));
-static bool emit_test_initialization PARAMS ((struct hash_entry *, PTR));
+static int attach_init_test_initialization_flags PARAMS ((PTR *, PTR));
+static int emit_test_initialization PARAMS ((PTR *, PTR));
+
+static char *string_convert_int_cst PARAMS ((tree));
/* Number of error found so far. */
int java_error_count;
#define BINOP_COMPOUND_CANDIDATES 11
/* The "$L" identifier we use to create labels. */
-static tree label_id = NULL_TREE;
+static GTY(()) tree label_id;
/* The "StringBuffer" identifier used for the String `+' operator. */
-static tree wfl_string_buffer = NULL_TREE;
+static GTY(()) tree wfl_string_buffer;
/* The "append" identifier used for String `+' operator. */
-static tree wfl_append = NULL_TREE;
+static GTY(()) tree wfl_append;
/* The "toString" identifier used for String `+' operator. */
-static tree wfl_to_string = NULL_TREE;
+static GTY(()) tree wfl_to_string;
/* The "java.lang" import qualified name. */
-static tree java_lang_id = NULL_TREE;
+static GTY(()) tree java_lang_id;
/* The generated `inst$' identifier used for generated enclosing
instance/field access functions. */
-static tree inst_id = NULL_TREE;
+static GTY(()) tree inst_id;
/* The "java.lang.Cloneable" qualified name. */
-static tree java_lang_cloneable = NULL_TREE;
+static GTY(()) tree java_lang_cloneable;
/* The "java.io.Serializable" qualified name. */
-static tree java_io_serializable = NULL_TREE;
+static GTY(()) tree java_io_serializable;
/* Context and flag for static blocks */
-static tree current_static_block = NULL_TREE;
+static GTY(()) tree current_static_block;
/* The generated `write_parm_value$' identifier. */
-static tree wpv_id;
+static GTY(()) tree wpv_id;
/* The list of all packages we've seen so far */
-static tree package_list = NULL_TREE;
+static GTY(()) tree package_list;
/* Hold THIS for the scope of the current method decl. */
-static tree current_this;
+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. */
-static tree currently_caught_type_list;
+static GTY(()) tree currently_caught_type_list;
/* This holds a linked list of all the case labels for the current
switch statement. It is only used when checking to see if there
are duplicate labels. FIXME: probably this should just be attached
to the switch itself; then it could be referenced via
`ctxp->current_loop'. */
-static tree case_label_list;
+static GTY(()) tree case_label_list;
-static tree src_parse_roots[1];
+/* Anonymous class counter. Will be reset to 1 every time a non
+ anonymous class gets created. */
+static int anonymous_class_counter = 1;
+
+static GTY(()) tree src_parse_roots[1];
/* All classes seen from source code */
#define gclass_list src_parse_roots[0]
{
/* Register static variables with the garbage
collector. */
- ggc_add_tree_root (&label_id, 1);
- ggc_add_tree_root (&wfl_string_buffer, 1);
- ggc_add_tree_root (&wfl_append, 1);
- ggc_add_tree_root (&wfl_to_string, 1);
- ggc_add_tree_root (&java_lang_id, 1);
- ggc_add_tree_root (&inst_id, 1);
- ggc_add_tree_root (&java_lang_cloneable, 1);
- ggc_add_tree_root (&java_io_serializable, 1);
- ggc_add_tree_root (¤t_static_block, 1);
- ggc_add_tree_root (&wpv_id, 1);
- ggc_add_tree_root (&package_list, 1);
- ggc_add_tree_root (¤t_this, 1);
- ggc_add_tree_root (¤tly_caught_type_list, 1);
- ggc_add_tree_root (&case_label_list, 1);
ggc_add_root (&ctxp, 1,
sizeof (struct parser_ctxt *),
mark_parser_ctxt);
return 0;
}
-static void
+/* Construct a nested class name. If the final component starts with
+ a digit, return true. Otherwise return false. */
+static int
make_nested_class_name (cpc_list)
tree cpc_list;
{
tree name;
if (!cpc_list)
- return;
- else
- make_nested_class_name (TREE_CHAIN (cpc_list));
+ return 0;
+
+ make_nested_class_name (TREE_CHAIN (cpc_list));
/* Pick the qualified name when dealing with the first upmost
enclosing class */
- name = (TREE_CHAIN (cpc_list) ?
- TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
+ name = (TREE_CHAIN (cpc_list)
+ ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
obstack_grow (&temporary_obstack,
IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
obstack_1grow (&temporary_obstack, '$');
+
+ return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
}
/* Can't redefine a class already defined in an earlier scope. */
static tree
resolve_inner_class (circularity_hash, cl, enclosing, super, class_type)
- struct hash_table *circularity_hash;
+ htab_t circularity_hash;
tree cl, *enclosing, *super, class_type;
{
tree local_enclosing = *enclosing;
{
tree intermediate, decl;
- hash_lookup (circularity_hash,
- (const hash_table_key) local_enclosing, TRUE, NULL);
+ *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
+ local_enclosing;
if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
return decl;
/* We may not have checked for circular inheritance yet, so do so
here to prevent an infinite loop. */
- if (hash_lookup (circularity_hash,
- (const hash_table_key) local_super, FALSE, NULL))
+ if (htab_find (circularity_hash, local_super) != NULL)
{
if (!cl)
cl = lookup_cl (local_enclosing);
if (CPC_INNER_P ())
{
- make_nested_class_name (GET_CPC_LIST ());
+ /* If we're in a function, we must append a number to create the
+ nested class name. However, we don't do this if the class we
+ are constructing is anonymous, because in that case we'll
+ already have a number as the class name. */
+ if (! make_nested_class_name (GET_CPC_LIST ())
+ && current_function_decl != NULL_TREE
+ && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
+ {
+ char buf[10];
+ sprintf (buf, "%d", anonymous_class_counter);
+ ++anonymous_class_counter;
+ obstack_grow (&temporary_obstack, buf, strlen (buf));
+ obstack_1grow (&temporary_obstack, '$');
+ }
obstack_grow0 (&temporary_obstack,
IDENTIFIER_POINTER (name),
IDENTIFIER_LENGTH (name));
return decl;
}
-/* Anonymous class counter. Will be reset to 1 every time a non
- anonymous class gets created. */
-static int anonymous_class_counter = 1;
-
/* Patch anonymous class CLASS, by either extending or implementing
DEP. */
/* Verify a circular call to METH. Return 1 if an error is found, 0
otherwise. */
+static GTY(()) tree vcc_list;
static int
verify_constructor_circularity (meth, current)
tree meth, current;
{
- static tree list = NULL_TREE;
- static int initialized_p;
tree c;
- /* If we haven't already registered LIST with the garbage collector,
- do so now. */
- if (!initialized_p)
- {
- ggc_add_tree_root (&list, 1);
- initialized_p = 1;
- }
-
for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
{
if (TREE_VALUE (c) == meth)
{
char *t;
- if (list)
+ if (vcc_list)
{
tree liste;
- list = nreverse (list);
- for (liste = list; liste; liste = TREE_CHAIN (liste))
+ vcc_list = nreverse (vcc_list);
+ for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
{
parse_error_context
(TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
"%s: recursive invocation of constructor `%s'",
constructor_circularity_msg (current, meth), t);
free (t);
- list = NULL_TREE;
+ vcc_list = NULL_TREE;
return 1;
}
}
for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
{
- list = tree_cons (c, current, list);
+ vcc_list = tree_cons (c, current, vcc_list);
if (verify_constructor_circularity (meth, TREE_VALUE (c)))
return 1;
- list = TREE_CHAIN (list);
+ vcc_list = TREE_CHAIN (vcc_list);
}
return 0;
}
tree new_class_decl = NULL_TREE, super = NULL_TREE;
tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
tree decl_result;
- struct hash_table _ht, *circularity_hash = &_ht;
+ htab_t circularity_hash;
/* This hash table is used to register the classes we're going
through when searching the current class as an inner class, in
order to detect circular references. Remember to free it before
returning the section 0- of this function. */
- hash_table_init (circularity_hash, hash_newfunc,
- java_hash_hash_tree_node, java_hash_compare_tree_node);
+ circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
+ NULL);
/* 0- Search in the current class as an inner class.
Maybe some code here should be added to load the class or
enclosing = NULL_TREE;
}
- hash_table_free (circularity_hash);
+ htab_delete (circularity_hash);
if (new_class_decl)
return new_class_decl;
applicable and use the matching DECL instead. */
if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
{
- tree name = TYPE_NAME (class_type);
char *separator;
+ tree name = TYPE_NAME (class_type);
+ char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
+
+ strcpy (namebuffer, IDENTIFIER_POINTER (name));
+
do {
/* Reach the last '.', and if applicable, replace it by a `$' and
see if this exists as a type. */
- if ((separator = strrchr (IDENTIFIER_POINTER (name), '.')))
+ if ((separator = strrchr (namebuffer, '.')))
{
- int c = *separator;
*separator = '$';
- name = get_identifier (IDENTIFIER_POINTER (name));
- *separator = c;
+ name = get_identifier (namebuffer);
decl_result = IDENTIFIER_CLASS_VALUE (name);
}
} while (!decl_result && separator);
/* Return the line that matches DECL line number, and try its best to
position the column number. Used during error reports. */
+static GTY(()) tree cl_v;
static tree
lookup_cl (decl)
tree decl;
{
- static tree cl = NULL_TREE;
char *line, *found;
if (!decl)
return NULL_TREE;
- if (cl == NULL_TREE)
+ if (cl_v == NULL_TREE)
{
- cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
- ggc_add_tree_root (&cl, 1);
+ cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
}
- EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
- EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
+ EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
+ EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE_FIRST (decl), -1);
- line = java_get_line_col (EXPR_WFL_FILENAME (cl),
- EXPR_WFL_LINENO (cl), EXPR_WFL_COLNO (cl));
+ line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
+ EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
found = strstr ((const char *)line,
(const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
if (found)
- EXPR_WFL_SET_LINECOL (cl, EXPR_WFL_LINENO (cl), found - line);
+ EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
- return cl;
+ return cl_v;
}
/* Look for a simple name in the single-type import list */
register_package (name)
tree name;
{
- static struct hash_table _pht, *pht = NULL;
+ static htab_t pht;
+ PTR *e;
- if (!pht)
- {
- hash_table_init (&_pht, hash_newfunc,
- java_hash_hash_tree_node, java_hash_compare_tree_node);
- pht = &_pht;
- }
-
- if (!hash_lookup (pht, (const hash_table_key) name, FALSE, NULL))
+ if (pht == NULL)
+ pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
+
+ e = htab_find_slot (pht, name, INSERT);
+ if (*e == NULL)
{
package_list = chainon (package_list, build_tree_list (name, NULL));
- hash_lookup (pht, (const hash_table_key) name, TRUE, NULL);
+ *e = name;
}
}
}
}
+static GTY(()) tree stop_reordering;
void
java_reorder_fields ()
{
- static tree stop_reordering = NULL_TREE;
- static int initialized_p;
tree current;
- /* Register STOP_REORDERING with the garbage collector. */
- if (!initialized_p)
- {
- ggc_add_tree_root (&stop_reordering, 1);
- initialized_p = 1;
- }
-
for (current = gclass_list; current; current = TREE_CHAIN (current))
{
current_class = TREE_TYPE (TREE_VALUE (current));
/* Before we check initialization, attached all class initialization
variable to the block_body */
- hash_traverse (&DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
+ htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
attach_init_test_initialization_flags, block_body);
if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
MDECL. This used with caution helps removing extra
initialization of self. */
if (METHOD_STATIC (mdecl))
- hash_lookup (&DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
- (hash_table_key) DECL_CONTEXT (mdecl),
- TRUE, NULL);
+ {
+ *(htab_find_slot
+ (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
+ DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
+ }
}
}
ctxp->explicit_constructor_p = 0;
/* For each class definitely initialized in
CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
assignment to the class initialization flag. */
- hash_traverse (&DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
+ htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
emit_test_initialization,
assignment_compound_list);
This function can be invoked with TYPE to NULL, available and then
has to count the parser context. */
+static GTY(()) tree saved_thisn;
+static GTY(()) tree saved_type;
+
static tree
build_current_thisn (type)
tree type;
{
static int saved_i = -1;
- static tree saved_thisn = NULL_TREE;
- static tree saved_type = NULL_TREE;
static int saved_type_i = 0;
- static int initialized_p;
tree decl;
char buffer [24];
int i = 0;
- /* Register SAVED_THISN and SAVED_TYPE with the garbage collector. */
- if (!initialized_p)
- {
- ggc_add_tree_root (&saved_thisn, 1);
- ggc_add_tree_root (&saved_type, 1);
- initialized_p = 1;
- }
-
if (type)
{
if (type == saved_type)
throw new NoClassDefFoundError(e.getMessage());}
} */
+static GTY(()) tree get_message_wfl;
+static GTY(()) tree type_parm_wfl;
+
static tree
build_dot_class_method (class)
tree class;
tree args, tmp, saved_current_function_decl, mdecl;
tree stmt, throw_stmt;
- static tree get_message_wfl, type_parm_wfl;
-
if (!get_message_wfl)
{
get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
type_parm_wfl = build_wfl_node (get_identifier ("type$"));
- ggc_add_tree_root (&get_message_wfl, 1);
- ggc_add_tree_root (&type_parm_wfl, 1);
}
/* Build the arguments */
/* Generate code for all context remembered for code generation. */
+static GTY(()) tree reversed_class_list;
void
java_expand_classes ()
{
for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
{
tree current;
+ reversed_class_list = NULL;
+
ctxp = cur_ctxp;
- for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+
+ /* We write out the classes in reverse order. This ensures that
+ inner classes are written before their containing classes,
+ which is important for parallel builds. Otherwise, the
+ class file for the outer class may be found, but the class
+ file for the inner class may not be present. In that
+ situation, the compiler cannot fall back to the original
+ source, having already read the outer class, so we must
+ prevent that situation. */
+ for (current = ctxp->class_list;
+ current;
+ current = TREE_CHAIN (current))
+ reversed_class_list
+ = tree_cons (NULL_TREE, current, reversed_class_list);
+
+ for (current = reversed_class_list;
+ current;
+ current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (current);
+ current_class = TREE_TYPE (TREE_VALUE (current));
outgoing_cpool = TYPE_CPOOL (current_class);
if (flag_emit_class_files)
write_classfile (current_class);
*where_found = patch_method_invocation (qual_wfl, decl, type,
from_super,
&is_static, &ret_decl);
+ from_super = 0;
if (*where_found == error_mark_node)
{
RESTORE_THIS_AND_CURRENT_CLASS;
/* Returns 1 if class was declared in the current package, 0 otherwise */
+static GTY(()) tree cicp_cache;
static int
class_in_current_package (class)
tree class;
{
- static tree cache = NULL_TREE;
int qualified_flag;
tree left;
- if (cache == class)
+ if (cicp_cache == class)
return 1;
qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
if (ctxp->package == left)
{
- static int initialized_p;
- /* Register CACHE with the garbage collector. */
- if (!initialized_p)
- {
- ggc_add_tree_root (&cache, 1);
- initialized_p = 1;
- }
-
- cache = class;
+ cicp_cache = class;
return 1;
}
return 0;
/* This handles the situation where a constructor invocation needs
to have an enclosing context passed as a second parameter (the
- constructor is one of an inner class. We extract it from the
- current function. */
+ constructor is one of an inner class). */
if ((is_super_init ||
(TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
&& PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
{
- tree enclosing_decl = DECL_CONTEXT (TYPE_NAME (current_class));
- tree extra_arg;
-
- if (ANONYMOUS_CLASS_P (current_class) || !DECL_CONTEXT (enclosing_decl))
- {
- extra_arg = DECL_FUNCTION_BODY (current_function_decl);
- extra_arg = TREE_CHAIN (BLOCK_EXPR_DECLS (extra_arg));
- }
- else
- {
- tree dest = TREE_TYPE (DECL_CONTEXT (enclosing_decl));
- extra_arg =
- build_access_to_thisn (TREE_TYPE (enclosing_decl), dest, 0);
- extra_arg = java_complete_tree (extra_arg);
- }
+ tree dest = TYPE_NAME (DECL_CONTEXT (list));
+ tree extra_arg =
+ build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
+ extra_arg = java_complete_tree (extra_arg);
args = tree_cons (NULL_TREE, extra_arg, args);
}
int lc;
tree class, name, arglist;
{
- static struct hash_table t, *searched_classes = NULL;
+ static htab_t searched_classes;
static int search_not_done = 0;
tree list = NULL_TREE, all_list = NULL_TREE;
already. */
if (searched_classes)
{
- if (hash_lookup (searched_classes,
- (const hash_table_key) class, FALSE, NULL))
- return NULL;
+ if (htab_find (searched_classes, class) != NULL)
+ return NULL;
}
else
{
- hash_table_init (&t, hash_newfunc, java_hash_hash_tree_node,
- java_hash_compare_tree_node);
- searched_classes = &t;
+ searched_classes = htab_create (10, htab_hash_pointer,
+ htab_eq_pointer, NULL);
}
search_not_done++;
- hash_lookup (searched_classes,
- (const hash_table_key) class, TRUE, NULL);
+ *htab_find_slot (searched_classes, class, INSERT) = class;
if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
{
{
if (!lc
&& TYPE_METHODS (object_type_node)
- && !hash_lookup (searched_classes,
- (const hash_table_key) object_type_node,
- FALSE, NULL))
+ && htab_find (searched_classes, object_type_node) == NULL)
{
search_applicable_methods_list (lc,
TYPE_METHODS (object_type_node),
name, arglist, &list, &all_list);
}
- hash_table_free (searched_classes);
+ htab_delete (searched_classes);
searched_classes = NULL;
}
corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
to change less often than M1. */
+static GTY(()) tree m2_arg_value;
+static GTY(()) tree m2_arg_cache;
+
static int
argument_types_convertible (m1, m2_or_arglist)
tree m1, m2_or_arglist;
{
- static tree m2_arg_value = NULL_TREE;
- static tree m2_arg_cache = NULL_TREE;
- static int initialized_p;
-
register tree m1_arg, m2_arg;
- /* Register M2_ARG_VALUE and M2_ARG_CACHE with the garbage
- collector. */
- if (!initialized_p)
- {
- ggc_add_tree_root (&m2_arg_value, 1);
- ggc_add_tree_root (&m2_arg_cache, 1);
- initialized_p = 1;
- }
-
SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
if (m2_arg_value == m2_or_arglist)
{
case CALL_EXPR:
qual_wfl = TREE_OPERAND (qual_wfl, 0);
- if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
+ 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);
if (TREE_CODE (nn) != EXIT_EXPR)
{
SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
- parse_error_context (wfl_operator, "Unreachable statement");
+ if (SUPPRESS_UNREACHABLE_ERROR (nn))
+ {
+ /* Perhaps this warning should have an
+ associated flag. The code being compiled is
+ pedantically correct, but useless. */
+ parse_warning_context (wfl_operator,
+ "Unreachable statement");
+ }
+ else
+ parse_error_context (wfl_operator,
+ "Unreachable statement");
}
}
TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
return assignment;
}
-/* Print an INTEGER_CST node in a static buffer, and return the buffer. */
+/* Print an INTEGER_CST node as decimal in a static buffer, and return
+ the buffer. This is used only for string conversion. */
+static char *
+string_convert_int_cst (node)
+ tree node;
+{
+ static char buffer[80];
+
+ 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;
+ int neg = 0;
+
+ unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
+ << (HOST_BITS_PER_WIDE_INT - 1));
+
+ *p-- = '\0';
+
+ /* If negative, note the fact and negate the value. */
+ if ((hi & hibit))
+ {
+ lo = ~lo;
+ hi = ~hi;
+ if (++lo == 0)
+ ++hi;
+ neg = 1;
+ }
+ /* Divide by 10 until there are no bits left. */
+ while (hi || lo)
+ {
+ unsigned HOST_WIDE_INT acc = 0;
+ unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
+ unsigned int i;
+
+ /* Use long division to compute the result and the remainder. */
+ for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
+ {
+ /* Shift a bit into accumulator. */
+ acc <<= 1;
+ if ((hi & hibit))
+ acc |= 1;
+
+ /* Shift the value. */
+ hi <<= 1;
+ if ((lo & hibit))
+ hi |= 1;
+ lo <<= 1;
+
+ /* Shift the correct bit into the result. */
+ outhi <<= 1;
+ if ((outlo & hibit))
+ outhi |= 1;
+ outlo <<= 1;
+ if (acc >= 10)
+ {
+ acc -= 10;
+ outlo |= 1;
+ }
+ }
+
+ /* FIXME: ASCII assumption. */
+ *p-- = '0' + acc;
+
+ hi = outhi;
+ lo = outlo;
+ }
+
+ if (neg)
+ *p-- = '-';
+
+ return p + 1;
+}
+
+/* Print an INTEGER_CST node in a static buffer, and return the
+ buffer. This is used only for error handling. */
char *
print_int_node (node)
tree node;
if (code == URSHIFT_EXPR && ! flag_emit_class_files)
{
tree to_return;
- tree utype = unsigned_type (prom_type);
+ tree utype = java_unsigned_type (prom_type);
op1 = convert (utype, op1);
TREE_SET_CODE (node, RSHIFT_EXPR);
TREE_OPERAND (node, 0) = op1;
TREE_TYPE (node) = boolean_type_node;
+ /* OP1_TYPE might be NULL when OP1 is a string constant. */
+ if ((cn = patch_string (op1)))
+ {
+ op1 = cn;
+ op1_type = TREE_TYPE (op1);
+ }
+ if (op1_type == NULL_TREE)
+ abort ();
+
if (!(op2_type = resolve_type_during_patch (op2)))
return error_mark_node;
string = ch;
}
else
- string = print_int_node (op2);
-
+ string = string_convert_int_cst (op2);
+
return do_merge_string_cste (op1, string, strlen (string), after);
}
return NULL_TREE;
op2 = patch_string_cst (op2);
/* If either one of the constant is null and the other non null
- operand is a String object, return it. */
- if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
+ operand is a String constant, return it. */
+ if ((TREE_CODE (op1) == STRING_CST) && !op2)
return op1;
/* If OP1 isn't already a StringBuffer, create and
/* Put the condition and the loop body in place */
tree loop = finish_loop_body (location, condition, body, 0);
/* LOOP is the current loop which has been now popped of the loop
- stack. Install the update block */
+ stack. Mark the update block as reachable and install it. We do
+ 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)
+ {
+ 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;
+ }
LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
return loop;
}
void
init_src_parse ()
{
- /* Register roots with the garbage collector. */
- ggc_add_tree_root (src_parse_roots, ARRAY_SIZE (src_parse_roots));
-
/* Sanity check; we've been bit by this before. */
if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
abort ();
/* Attach to PTR (a block) the declaration found in ENTRY. */
-static bool
+static int
attach_init_test_initialization_flags (entry, ptr)
- struct hash_entry *entry;
+ PTR *entry;
PTR ptr;
{
tree block = (tree)ptr;
- struct init_test_hash_entry *ite = (struct init_test_hash_entry *) entry;
+ struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
- TREE_CHAIN (ite->init_test_decl) = BLOCK_EXPR_DECLS (block);
- BLOCK_EXPR_DECLS (block) = ite->init_test_decl;
+ TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
+ BLOCK_EXPR_DECLS (block) = ite->value;
return true;
}
initialized static class flags if a flag already existed, otherwise
a new one is created. */
-static bool
-emit_test_initialization (entry, info)
- struct hash_entry *entry;
+static int
+emit_test_initialization (entry_p, info)
+ PTR *entry_p;
PTR info;
{
tree l = (tree) info;
tree decl, init;
-
- struct init_test_hash_entry *ite = (struct init_test_hash_entry *)
- hash_lookup (&DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl),
- entry->key,
- current_function_decl != TREE_PURPOSE (l), NULL);
+ tree key = (tree) *entry_p;
+ tree *ite;
+ htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
/* If we haven't found a flag and we're dealing with self registered
with current_function_decl, then don't do anything. Self is
always added as definitely initialized but this information is
valid only if used outside the current function. */
- if (! ite)
+ if (current_function_decl == TREE_PURPOSE (l)
+ && java_treetreehash_find (cf_ht, key) == NULL)
return true;
+
+ ite = java_treetreehash_new (cf_ht, key);
/* If we don't have a variable, create one and install it. */
- if (! ite->init_test_decl)
+ if (*ite == NULL)
{
tree block;
block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
BLOCK_EXPR_DECLS (block) = decl;
- ite->init_test_decl = decl;
+ *ite = decl;
}
else
- decl = ite->init_test_decl;
+ decl = *ite;
/* Now simply augment the compound that holds all the assignments
pertaining to this method invocation. */
return true;
}
+
+#include "gt-java-parse.h"
+#include "gtype-java.h"
OSDN Git Service
