X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=gdb%2Fjv-lang.c;h=3460184a3682442d27b422bc44b3780c57c003f2;hb=a9762ec78a53fbe9209fe1654db42df0cd328d50;hp=367add2427f89aba2236bd2255e160af25e6162d;hpb=72ec28b8afa357cdde70c612b4e0e9f37a34f8e4;p=thirdparty%2Fbinutils-gdb.git
diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c
index 367add2427f..3460184a368 100644
--- a/gdb/jv-lang.c
+++ b/gdb/jv-lang.c
@@ -1,11 +1,13 @@
/* Java language support routines for GDB, the GNU debugger.
- Copyright 1997, 1998, 1999-2000 Free Software Foundation, Inc.
+
+ Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004, 2005, 2007
+ Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -14,9 +16,7 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see . */
#include "defs.h"
#include "symtab.h"
@@ -33,7 +33,11 @@
#include "c-lang.h"
#include "jv-lang.h"
#include "gdbcore.h"
+#include "block.h"
+#include "demangle.h"
+#include "dictionary.h"
#include
+#include "gdb_assert.h"
struct type *java_int_type;
struct type *java_byte_type;
@@ -47,29 +51,36 @@ struct type *java_void_type;
/* Local functions */
-extern void _initialize_java_language PARAMS ((void));
+extern void _initialize_java_language (void);
-static int java_demangled_signature_length PARAMS ((char *));
-static void java_demangled_signature_copy PARAMS ((char *, char *));
+static int java_demangled_signature_length (char *);
+static void java_demangled_signature_copy (char *, char *);
-static struct symtab *get_java_class_symtab PARAMS ((void));
-static char *get_java_utf8_name PARAMS ((struct obstack * obstack, value_ptr name));
-static int java_class_is_primitive PARAMS ((value_ptr clas));
-static struct type *java_lookup_type PARAMS ((char *signature));
-static value_ptr java_value_string PARAMS ((char *ptr, int len));
+static struct symtab *get_java_class_symtab (void);
+static char *get_java_utf8_name (struct obstack *obstack, struct value *name);
+static int java_class_is_primitive (struct value *clas);
+static struct value *java_value_string (char *ptr, int len);
static void java_emit_char (int c, struct ui_file * stream, int quoter);
+static char *java_class_name_from_physname (const char *physname);
+
/* This objfile contains symtabs that have been dynamically created
to record dynamically loaded Java classes and dynamically
compiled java methods. */
static struct objfile *dynamics_objfile = NULL;
-static struct type *java_link_class_type PARAMS ((struct type *, value_ptr));
+static struct type *java_link_class_type (struct type *, struct value *);
+
+/* FIXME: carlton/2003-02-04: This is the main or only caller of
+ allocate_objfile with first argument NULL; as a result, this code
+ breaks every so often. Somebody should write a test case that
+ exercises GDB in various ways (e.g. something involving loading a
+ dynamic library) after this code has been called. */
static struct objfile *
-get_dynamics_objfile ()
+get_dynamics_objfile (void)
{
if (dynamics_objfile == NULL)
{
@@ -83,12 +94,10 @@ get_dynamics_objfile ()
static struct symtab *class_symtab = NULL;
-/* Maximum number of class in class_symtab before relocation is needed. */
-
-static int class_symtab_space;
+static void free_class_block (struct symtab *symtab);
static struct symtab *
-get_java_class_symtab ()
+get_java_class_symtab (void)
{
if (class_symtab == NULL)
{
@@ -98,85 +107,69 @@ get_java_class_symtab ()
class_symtab = allocate_symtab ("", objfile);
class_symtab->language = language_java;
bv = (struct blockvector *)
- obstack_alloc (&objfile->symbol_obstack, sizeof (struct blockvector));
+ obstack_alloc (&objfile->objfile_obstack,
+ sizeof (struct blockvector) + sizeof (struct block *));
BLOCKVECTOR_NBLOCKS (bv) = 1;
BLOCKVECTOR (class_symtab) = bv;
/* Allocate dummy STATIC_BLOCK. */
- bl = (struct block *)
- obstack_alloc (&objfile->symbol_obstack, sizeof (struct block));
- BLOCK_NSYMS (bl) = 0;
- BLOCK_START (bl) = 0;
- BLOCK_END (bl) = 0;
- BLOCK_FUNCTION (bl) = NULL;
- BLOCK_SUPERBLOCK (bl) = NULL;
- BLOCK_GCC_COMPILED (bl) = 0;
+ bl = allocate_block (&objfile->objfile_obstack);
+ BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
+ NULL);
BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
- /* Allocate GLOBAL_BLOCK. This has to be relocatable. */
- class_symtab_space = 128;
- bl = (struct block *)
- mmalloc (objfile->md,
- sizeof (struct block)
- + ((class_symtab_space - 1) * sizeof (struct symbol *)));
- *bl = *BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+ /* Allocate GLOBAL_BLOCK. */
+ bl = allocate_block (&objfile->objfile_obstack);
+ BLOCK_DICT (bl) = dict_create_hashed_expandable ();
BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
- class_symtab->free_ptr = (char *) bl;
+ class_symtab->free_func = free_class_block;
}
return class_symtab;
}
static void
-add_class_symtab_symbol (sym)
- struct symbol *sym;
+add_class_symtab_symbol (struct symbol *sym)
{
struct symtab *symtab = get_java_class_symtab ();
struct blockvector *bv = BLOCKVECTOR (symtab);
- struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- if (BLOCK_NSYMS (bl) >= class_symtab_space)
- {
- /* Need to re-allocate. */
- class_symtab_space *= 2;
- bl = (struct block *)
- mrealloc (symtab->objfile->md, bl,
- sizeof (struct block)
- + ((class_symtab_space - 1) * sizeof (struct symbol *)));
- class_symtab->free_ptr = (char *) bl;
- BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
- }
-
- BLOCK_SYM (bl, BLOCK_NSYMS (bl)) = sym;
- BLOCK_NSYMS (bl) = BLOCK_NSYMS (bl) + 1;
+ dict_add_symbol (BLOCK_DICT (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)), sym);
}
-static struct symbol *add_class_symbol PARAMS ((struct type * type, CORE_ADDR addr));
+static struct symbol *add_class_symbol (struct type *type, CORE_ADDR addr);
static struct symbol *
-add_class_symbol (type, addr)
- struct type *type;
- CORE_ADDR addr;
+add_class_symbol (struct type *type, CORE_ADDR addr)
{
struct symbol *sym;
sym = (struct symbol *)
- obstack_alloc (&dynamics_objfile->symbol_obstack, sizeof (struct symbol));
+ obstack_alloc (&dynamics_objfile->objfile_obstack, sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
SYMBOL_LANGUAGE (sym) = language_java;
- SYMBOL_NAME (sym) = TYPE_TAG_NAME (type);
+ DEPRECATED_SYMBOL_NAME (sym) = TYPE_TAG_NAME (type);
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
/* SYMBOL_VALUE (sym) = valu; */
SYMBOL_TYPE (sym) = type;
- SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
SYMBOL_VALUE_ADDRESS (sym) = addr;
return sym;
}
+
+/* Free the dynamic symbols block. */
+static void
+free_class_block (struct symtab *symtab)
+{
+ struct blockvector *bv = BLOCKVECTOR (symtab);
+ struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+
+ dict_free (BLOCK_DICT (bl));
+}
#endif
struct type *
-java_lookup_class (name)
- char *name;
+java_lookup_class (char *name)
{
struct symbol *sym;
- sym = lookup_symbol (name, expression_context_block, STRUCT_NAMESPACE,
+ sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN,
(int *) 0, (struct symtab **) NULL);
if (sym != NULL)
return SYMBOL_TYPE (sym);
@@ -196,7 +189,7 @@ java_lookup_class (name)
type = alloc_type (objfile);
TYPE_CODE (type) = TYPE_CODE_STRUCT;
INIT_CPLUS_SPECIFIC (type);
- TYPE_TAG_NAME (type) = obsavestring (name, strlen (name), &objfile->type_obstack);
+ TYPE_TAG_NAME (type) = obsavestring (name, strlen (name), &objfile->objfile_obstack);
TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
TYPE ? = addr;
return type;
@@ -210,36 +203,33 @@ java_lookup_class (name)
a name given by NAME (which has type Utf8Const*). */
char *
-get_java_utf8_name (obstack, name)
- struct obstack *obstack;
- value_ptr name;
+get_java_utf8_name (struct obstack *obstack, struct value *name)
{
char *chrs;
- value_ptr temp = name;
+ struct value *temp = name;
int name_length;
CORE_ADDR data_addr;
temp = value_struct_elt (&temp, NULL, "length", NULL, "structure");
name_length = (int) value_as_long (temp);
- data_addr = VALUE_ADDRESS (temp) + VALUE_OFFSET (temp)
- + TYPE_LENGTH (VALUE_TYPE (temp));
+ data_addr = VALUE_ADDRESS (temp) + value_offset (temp)
+ + TYPE_LENGTH (value_type (temp));
chrs = obstack_alloc (obstack, name_length + 1);
chrs[name_length] = '\0';
- read_memory_section (data_addr, chrs, name_length, NULL);
+ read_memory (data_addr, (gdb_byte *) chrs, name_length);
return chrs;
}
-value_ptr
-java_class_from_object (obj_val)
- value_ptr obj_val;
+struct value *
+java_class_from_object (struct value *obj_val)
{
/* This is all rather inefficient, since the offsets of vtable and
class are fixed. FIXME */
- value_ptr vtable_val;
+ struct value *vtable_val;
- if (TYPE_CODE (VALUE_TYPE (obj_val)) == TYPE_CODE_PTR
- && TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (obj_val))) == 0)
+ if (TYPE_CODE (value_type (obj_val)) == TYPE_CODE_PTR
+ && TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (obj_val))) == 0)
obj_val = value_at (get_java_object_type (),
- value_as_pointer (obj_val), NULL);
+ value_as_address (obj_val));
vtable_val = value_struct_elt (&obj_val, NULL, "vtable", NULL, "structure");
return value_struct_elt (&vtable_val, NULL, "class", NULL, "structure");
@@ -247,46 +237,43 @@ java_class_from_object (obj_val)
/* Check if CLASS_IS_PRIMITIVE(value of clas): */
static int
-java_class_is_primitive (clas)
- value_ptr clas;
+java_class_is_primitive (struct value *clas)
{
- value_ptr vtable = value_struct_elt (&clas, NULL, "vtable", NULL, "struct");
- CORE_ADDR i = value_as_pointer (vtable);
+ struct value *vtable = value_struct_elt (&clas, NULL, "vtable", NULL, "struct");
+ CORE_ADDR i = value_as_address (vtable);
return (int) (i & 0x7fffffff) == (int) 0x7fffffff;
}
/* Read a GCJ Class object, and generated a gdb (TYPE_CODE_STRUCT) type. */
struct type *
-type_from_class (clas)
- value_ptr clas;
+type_from_class (struct value *clas)
{
struct type *type;
char *name;
- value_ptr temp;
+ struct value *temp;
struct objfile *objfile;
- value_ptr utf8_name;
+ struct value *utf8_name;
char *nptr;
CORE_ADDR addr;
struct block *bl;
- int i;
+ struct dict_iterator iter;
int is_array = 0;
- type = check_typedef (VALUE_TYPE (clas));
+ type = check_typedef (value_type (clas));
if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
if (value_logical_not (clas))
return NULL;
clas = value_ind (clas);
}
- addr = VALUE_ADDRESS (clas) + VALUE_OFFSET (clas);
+ addr = VALUE_ADDRESS (clas) + value_offset (clas);
#if 0
get_java_class_symtab ();
bl = BLOCKVECTOR_BLOCK (BLOCKVECTOR (class_symtab), GLOBAL_BLOCK);
- for (i = BLOCK_NSYMS (bl); --i >= 0;)
+ ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- struct symbol *sym = BLOCK_SYM (bl, i);
if (SYMBOL_VALUE_ADDRESS (sym) == addr)
return SYMBOL_TYPE (sym);
}
@@ -295,7 +282,7 @@ type_from_class (clas)
objfile = get_dynamics_objfile ();
if (java_class_is_primitive (clas))
{
- value_ptr sig;
+ struct value *sig;
temp = clas;
sig = value_struct_elt (&temp, NULL, "method_count", NULL, "structure");
return java_primitive_type (value_as_long (sig));
@@ -305,7 +292,7 @@ type_from_class (clas)
/* if clasloader non-null, prepend loader address. FIXME */
temp = clas;
utf8_name = value_struct_elt (&temp, NULL, "name", NULL, "structure");
- name = get_java_utf8_name (&objfile->type_obstack, utf8_name);
+ name = get_java_utf8_name (&objfile->objfile_obstack, utf8_name);
for (nptr = name; *nptr != 0; nptr++)
{
if (*nptr == '/')
@@ -325,14 +312,14 @@ type_from_class (clas)
char *signature = name;
int namelen = java_demangled_signature_length (signature);
if (namelen > strlen (name))
- name = obstack_alloc (&objfile->type_obstack, namelen + 1);
+ name = obstack_alloc (&objfile->objfile_obstack, namelen + 1);
java_demangled_signature_copy (name, signature);
name[namelen] = '\0';
is_array = 1;
temp = clas;
/* Set array element type. */
temp = value_struct_elt (&temp, NULL, "methods", NULL, "structure");
- VALUE_TYPE (temp) = lookup_pointer_type (VALUE_TYPE (clas));
+ deprecated_set_value_type (temp, lookup_pointer_type (value_type (clas)));
TYPE_TARGET_TYPE (type) = type_from_class (temp);
}
@@ -346,29 +333,31 @@ type_from_class (clas)
/* Fill in class TYPE with data from the CLAS value. */
struct type *
-java_link_class_type (type, clas)
- struct type *type;
- value_ptr clas;
+java_link_class_type (struct type *type, struct value *clas)
{
- value_ptr temp;
+ struct value *temp;
char *unqualified_name;
char *name = TYPE_TAG_NAME (type);
int ninterfaces, nfields, nmethods;
int type_is_object = 0;
struct fn_field *fn_fields;
struct fn_fieldlist *fn_fieldlists;
- value_ptr fields, field, method, methods;
+ struct value *fields;
+ struct value *methods;
+ struct value *method = NULL;
+ struct value *field = NULL;
int i, j;
struct objfile *objfile = get_dynamics_objfile ();
struct type *tsuper;
+ gdb_assert (name != NULL);
unqualified_name = strrchr (name, '.');
if (unqualified_name == NULL)
unqualified_name = name;
temp = clas;
temp = value_struct_elt (&temp, NULL, "superclass", NULL, "structure");
- if (name != NULL && strcmp (name, "java.lang.Object") == 0)
+ if (strcmp (name, "java.lang.Object") == 0)
{
tsuper = get_java_object_type ();
if (tsuper && TYPE_CODE (tsuper) == TYPE_CODE_PTR)
@@ -434,9 +423,9 @@ java_link_class_type (type, clas)
fields = NULL;
nfields--; /* First set up dummy "class" field. */
SET_FIELD_PHYSADDR (TYPE_FIELD (type, nfields),
- VALUE_ADDRESS (clas) + VALUE_OFFSET (clas));
+ VALUE_ADDRESS (clas) + value_offset (clas));
TYPE_FIELD_NAME (type, nfields) = "class";
- TYPE_FIELD_TYPE (type, nfields) = VALUE_TYPE (clas);
+ TYPE_FIELD_TYPE (type, nfields) = value_type (clas);
SET_TYPE_FIELD_PRIVATE (type, nfields);
for (i = TYPE_N_BASECLASSES (type); i < nfields; i++)
@@ -451,13 +440,13 @@ java_link_class_type (type, clas)
}
else
{ /* Re-use field value for next field. */
- VALUE_ADDRESS (field) += TYPE_LENGTH (VALUE_TYPE (field));
- VALUE_LAZY (field) = 1;
+ VALUE_ADDRESS (field) += TYPE_LENGTH (value_type (field));
+ set_value_lazy (field, 1);
}
temp = field;
temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");
TYPE_FIELD_NAME (type, i) =
- get_java_utf8_name (&objfile->type_obstack, temp);
+ get_java_utf8_name (&objfile->objfile_obstack, temp);
temp = field;
accflags = value_as_long (value_struct_elt (&temp, NULL, "accflags",
NULL, "structure"));
@@ -503,7 +492,7 @@ java_link_class_type (type, clas)
TYPE_NFN_FIELDS_TOTAL (type) = nmethods;
j = nmethods * sizeof (struct fn_field);
fn_fields = (struct fn_field *)
- obstack_alloc (&dynamics_objfile->symbol_obstack, j);
+ obstack_alloc (&dynamics_objfile->objfile_obstack, j);
memset (fn_fields, 0, j);
fn_fieldlists = (struct fn_fieldlist *)
alloca (nmethods * sizeof (struct fn_fieldlist));
@@ -521,14 +510,14 @@ java_link_class_type (type, clas)
}
else
{ /* Re-use method value for next method. */
- VALUE_ADDRESS (method) += TYPE_LENGTH (VALUE_TYPE (method));
- VALUE_LAZY (method) = 1;
+ VALUE_ADDRESS (method) += TYPE_LENGTH (value_type (method));
+ set_value_lazy (method, 1);
}
/* Get method name. */
temp = method;
temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");
- mname = get_java_utf8_name (&objfile->type_obstack, temp);
+ mname = get_java_utf8_name (&objfile->objfile_obstack, temp);
if (strcmp (mname, "") == 0)
mname = unqualified_name;
@@ -553,7 +542,7 @@ java_link_class_type (type, clas)
{ /* Found an existing method with the same name. */
int l;
if (mname != unqualified_name)
- obstack_free (&objfile->type_obstack, mname);
+ obstack_free (&objfile->objfile_obstack, mname);
mname = fn_fieldlists[j].name;
fn_fieldlists[j].length++;
k = i - k; /* Index of new slot. */
@@ -574,7 +563,7 @@ java_link_class_type (type, clas)
j = TYPE_NFN_FIELDS (type) * sizeof (struct fn_fieldlist);
TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
- obstack_alloc (&dynamics_objfile->symbol_obstack, j);
+ obstack_alloc (&dynamics_objfile->objfile_obstack, j);
memcpy (TYPE_FN_FIELDLISTS (type), fn_fieldlists, j);
return type;
@@ -583,33 +572,32 @@ java_link_class_type (type, clas)
static struct type *java_object_type;
struct type *
-get_java_object_type ()
+get_java_object_type (void)
{
if (java_object_type == NULL)
{
struct symbol *sym;
- sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_NAMESPACE,
+ sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN,
(int *) 0, (struct symtab **) NULL);
if (sym == NULL)
- error ("cannot find java.lang.Object");
+ error (_("cannot find java.lang.Object"));
java_object_type = SYMBOL_TYPE (sym);
}
return java_object_type;
}
int
-get_java_object_header_size ()
+get_java_object_header_size (void)
{
struct type *objtype = get_java_object_type ();
if (objtype == NULL)
- return (2 * TARGET_PTR_BIT / TARGET_CHAR_BIT);
+ return (2 * gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);
else
return TYPE_LENGTH (objtype);
}
int
-is_object_type (type)
- struct type *type;
+is_object_type (struct type *type)
{
CHECK_TYPEDEF (type);
if (TYPE_CODE (type) == TYPE_CODE_PTR)
@@ -635,8 +623,7 @@ is_object_type (type)
}
struct type *
-java_primitive_type (signature)
- int signature;
+java_primitive_type (int signature)
{
switch (signature)
{
@@ -659,16 +646,14 @@ java_primitive_type (signature)
case 'V':
return java_void_type;
}
- error ("unknown signature '%c' for primitive type", (char) signature);
+ error (_("unknown signature '%c' for primitive type"), (char) signature);
}
/* If name[0 .. namelen-1] is the name of a primitive Java type,
return that type. Otherwise, return NULL. */
struct type *
-java_primitive_type_from_name (name, namelen)
- char *name;
- int namelen;
+java_primitive_type_from_name (char *name, int namelen)
{
switch (name[0])
{
@@ -713,8 +698,7 @@ java_primitive_type_from_name (name, namelen)
signature string SIGNATURE. */
static int
-java_demangled_signature_length (signature)
- char *signature;
+java_demangled_signature_length (char *signature)
{
int array = 0;
for (; *signature == '['; signature++)
@@ -732,9 +716,7 @@ java_demangled_signature_length (signature)
/* Demangle the Java type signature SIGNATURE, leaving the result in RESULT. */
static void
-java_demangled_signature_copy (result, signature)
- char *result;
- char *signature;
+java_demangled_signature_copy (char *result, char *signature)
{
int array = 0;
char *ptr;
@@ -776,8 +758,7 @@ java_demangled_signature_copy (result, signature)
as a freshly allocated copy. */
char *
-java_demangle_type_signature (signature)
- char *signature;
+java_demangle_type_signature (char *signature)
{
int length = java_demangled_signature_length (signature);
char *result = xmalloc (length + 1);
@@ -786,27 +767,11 @@ java_demangle_type_signature (signature)
return result;
}
-struct type *
-java_lookup_type (signature)
- char *signature;
-{
- switch (signature[0])
- {
- case 'L':
- case '[':
- error ("java_lookup_type not fully implemented");
- default:
- return java_primitive_type (signature[0]);
- }
-}
-
/* Return the type of TYPE followed by DIMS pairs of [ ].
If DIMS == 0, TYPE is returned. */
struct type *
-java_array_type (type, dims)
- struct type *type;
- int dims;
+java_array_type (struct type *type, int dims)
{
struct type *range_type;
@@ -822,12 +787,10 @@ java_array_type (type, dims)
/* Create a Java string in the inferior from a (Utf8) literal. */
-static value_ptr
-java_value_string (ptr, len)
- char *ptr;
- int len;
+static struct value *
+java_value_string (char *ptr, int len)
{
- error ("not implemented - java_value_string"); /* FIXME */
+ error (_("not implemented - java_value_string")); /* FIXME */
}
/* Print the character C on STREAM as part of the contents of a literal
@@ -835,10 +798,7 @@ java_value_string (ptr, len)
characters and strings is language specific. */
static void
-java_emit_char (c, stream, quoter)
- int c;
- struct ui_file *stream;
- int quoter;
+java_emit_char (int c, struct ui_file *stream, int quoter)
{
switch (c)
{
@@ -870,18 +830,16 @@ java_emit_char (c, stream, quoter)
}
}
-static value_ptr
-evaluate_subexp_java (expect_type, exp, pos, noside)
- struct type *expect_type;
- register struct expression *exp;
- register int *pos;
- enum noside noside;
+static struct value *
+evaluate_subexp_java (struct type *expect_type, struct expression *exp,
+ int *pos, enum noside noside)
{
int pc = *pos;
int i;
char *name;
enum exp_opcode op = exp->elts[*pos].opcode;
- value_ptr arg1, arg2;
+ struct value *arg1;
+ struct value *arg2;
struct type *type;
switch (op)
{
@@ -890,7 +848,7 @@ evaluate_subexp_java (expect_type, exp, pos, noside)
goto standard;
(*pos)++;
arg1 = evaluate_subexp_java (NULL_TYPE, exp, pos, EVAL_NORMAL);
- if (is_object_type (VALUE_TYPE (arg1)))
+ if (is_object_type (value_type (arg1)))
{
struct type *type;
@@ -911,8 +869,8 @@ evaluate_subexp_java (expect_type, exp, pos, noside)
array or pointer type (like a plain int variable for example),
then report this as an error. */
- COERCE_REF (arg1);
- type = check_typedef (VALUE_TYPE (arg1));
+ arg1 = coerce_ref (arg1);
+ type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_PTR)
type = check_typedef (TYPE_TARGET_TYPE (type));
name = TYPE_NAME (type);
@@ -925,30 +883,30 @@ evaluate_subexp_java (expect_type, exp, pos, noside)
CORE_ADDR address;
long length, index;
struct type *el_type;
- char buf4[4];
+ gdb_byte buf4[4];
- value_ptr clas = java_class_from_object (arg1);
- value_ptr temp = clas;
+ struct value *clas = java_class_from_object (arg1);
+ struct value *temp = clas;
/* Get CLASS_ELEMENT_TYPE of the array type. */
temp = value_struct_elt (&temp, NULL, "methods",
NULL, "structure");
- VALUE_TYPE (temp) = VALUE_TYPE (clas);
+ deprecated_set_value_type (temp, value_type (clas));
el_type = type_from_class (temp);
if (TYPE_CODE (el_type) == TYPE_CODE_STRUCT)
el_type = lookup_pointer_type (el_type);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (el_type, VALUE_LVAL (arg1));
- address = value_as_pointer (arg1);
+ address = value_as_address (arg1);
address += JAVA_OBJECT_SIZE;
read_memory (address, buf4, 4);
length = (long) extract_signed_integer (buf4, 4);
index = (long) value_as_long (arg2);
if (index >= length || index < 0)
- error ("array index (%ld) out of bounds (length: %ld)",
+ error (_("array index (%ld) out of bounds (length: %ld)"),
index, length);
address = (address + 4) + index * TYPE_LENGTH (el_type);
- return value_at (el_type, address, NULL);
+ return value_at (el_type, address);
}
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
@@ -958,9 +916,9 @@ evaluate_subexp_java (expect_type, exp, pos, noside)
return value_subscript (arg1, arg2);
}
if (name)
- error ("cannot subscript something of type `%s'", name);
+ error (_("cannot subscript something of type `%s'"), name);
else
- error ("cannot subscript requested type");
+ error (_("cannot subscript requested type"));
case OP_STRING:
(*pos)++;
@@ -970,10 +928,10 @@ evaluate_subexp_java (expect_type, exp, pos, noside)
goto nosideret;
return java_value_string (&exp->elts[pc + 2].string, i);
- case STRUCTOP_STRUCT:
+ case STRUCTOP_PTR:
arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
/* Convert object field (such as TYPE.class) to reference. */
- if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT)
+ if (TYPE_CODE (value_type (arg1)) == TYPE_CODE_STRUCT)
arg1 = value_addr (arg1);
return arg1;
default:
@@ -986,9 +944,7 @@ nosideret:
}
static struct type *
-java_create_fundamental_type (objfile, typeid)
- struct objfile *objfile;
- int typeid;
+java_create_fundamental_type (struct objfile *objfile, int typeid)
{
switch (typeid)
{
@@ -1018,6 +974,65 @@ java_create_fundamental_type (objfile, typeid)
return c_create_fundamental_type (objfile, typeid);
}
+static char *java_demangle (const char *mangled, int options)
+{
+ return cplus_demangle (mangled, options | DMGL_JAVA);
+}
+
+/* Find the member function name of the demangled name NAME. NAME
+ must be a method name including arguments, in order to correctly
+ locate the last component.
+
+ This function return a pointer to the first dot before the
+ member function name, or NULL if the name was not of the
+ expected form. */
+
+static const char *
+java_find_last_component (const char *name)
+{
+ const char *p;
+
+ /* Find argument list. */
+ p = strchr (name, '(');
+
+ if (p == NULL)
+ return NULL;
+
+ /* Back up and find first dot prior to argument list. */
+ while (p > name && *p != '.')
+ p--;
+
+ if (p == name)
+ return NULL;
+
+ return p;
+}
+
+/* Return the name of the class containing method PHYSNAME. */
+
+static char *
+java_class_name_from_physname (const char *physname)
+{
+ char *ret = NULL;
+ const char *end;
+ int depth = 0;
+ char *demangled_name = java_demangle (physname, DMGL_PARAMS | DMGL_ANSI);
+
+ if (demangled_name == NULL)
+ return NULL;
+
+ end = java_find_last_component (demangled_name);
+ if (end != NULL)
+ {
+ ret = xmalloc (end - demangled_name + 1);
+ memcpy (ret, demangled_name, end - demangled_name);
+ ret[end - demangled_name] = '\0';
+ }
+
+ xfree (demangled_name);
+ return ret;
+}
+
/* Table mapping opcodes into strings for printing operators
and precedences of the operators. */
@@ -1058,16 +1073,28 @@ const struct op_print java_op_print_tab[] =
{NULL, 0, 0, 0}
};
+const struct exp_descriptor exp_descriptor_java =
+{
+ print_subexp_standard,
+ operator_length_standard,
+ op_name_standard,
+ dump_subexp_body_standard,
+ evaluate_subexp_java
+};
+
const struct language_defn java_language_defn =
{
"java", /* Language name */
language_java,
- c_builtin_types,
+ NULL,
range_check_off,
type_check_off,
+ case_sensitive_on,
+ array_row_major,
+ &exp_descriptor_java,
java_parse,
java_error,
- evaluate_subexp_java,
+ null_post_parser,
c_printchar, /* Print a character constant */
c_printstr, /* Function to print string constant */
java_emit_char, /* Function to print a single character */
@@ -1075,19 +1102,24 @@ const struct language_defn java_language_defn =
java_print_type, /* Print a type using appropriate syntax */
java_val_print, /* Print a value using appropriate syntax */
java_value_print, /* Print a top-level value */
- {"", "", "", ""}, /* Binary format info */
- {"0%lo", "0", "o", ""}, /* Octal format info */
- {"%ld", "", "d", ""}, /* Decimal format info */
- {"0x%lx", "0x", "x", ""}, /* Hex format info */
+ NULL, /* Language specific skip_trampoline */
+ value_of_this, /* value_of_this */
+ basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
+ basic_lookup_transparent_type,/* lookup_transparent_type */
+ java_demangle, /* Language specific symbol demangler */
+ java_class_name_from_physname,/* Language specific class name */
java_op_print_tab, /* expression operators for printing */
0, /* not c-style arrays */
0, /* String lower bound */
- &builtin_type_char, /* Type of string elements */
+ NULL,
+ default_word_break_characters,
+ c_language_arch_info,
+ default_print_array_index,
LANG_MAGIC
};
void
-_initialize_java_language ()
+_initialize_java_language (void)
{
java_int_type = init_type (TYPE_CODE_INT, 4, 0, "int", NULL);
@@ -1107,9 +1139,9 @@ _initialize_java_language ()
We should use make_run_cleanup to have this be called.
But will that mess up values in value histry? FIXME */
-extern void java_rerun_cleanup PARAMS ((void));
+extern void java_rerun_cleanup (void);
void
-java_rerun_cleanup ()
+java_rerun_cleanup (void)
{
if (class_symtab != NULL)
{