projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix breakpoint condition that use member variables.
[deliverable/binutils-gdb.git] / gdb / jv-lang.c
diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c
index dd323b2a4952baad70b0b6bc121a16c9d3922785..b72b90c27c2966337d3e25f423f3dc59c9ea0e78 100644 (file)
--- a/gdb/jv-lang.c
+++ b/gdb/jv-lang.c
@@ -1,11 +1,13 @@
 /* Java language support routines for GDB, the GNU debugger.
 /* Java language support routines for GDB, the GNU debugger.
-   Copyright 1997, 1998, 1999 Free Software Foundation, Inc.
+
+   Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004, 2005, 2007, 2008
+   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
 
    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,
    (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
    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 <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "symtab.h"
 
 #include "defs.h"
 #include "symtab.h"
@@ -33,7 +33,11 @@
 #include "c-lang.h"
 #include "jv-lang.h"
 #include "gdbcore.h"
 #include "c-lang.h"
 #include "jv-lang.h"
 #include "gdbcore.h"
+#include "block.h"
+#include "demangle.h"
+#include "dictionary.h"
 #include <ctype.h>
 #include <ctype.h>
+#include "gdb_assert.h"
 
 struct type *java_int_type;
 struct type *java_byte_type;
 
 struct type *java_int_type;
 struct type *java_byte_type;
@@ -47,18 +51,19 @@ struct type *java_void_type;
 
 /* Local functions */
 
 
 /* Local functions */
 
-extern void _initialize_java_language PARAMS ((void));
+extern void _initialize_java_language (void);
+
+static int java_demangled_signature_length (char *);
+static void java_demangled_signature_copy (char *, char *);
 
 
-static int java_demangled_signature_length PARAMS ((char *));
-static void java_demangled_signature_copy PARAMS ((char *, char *));
+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 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 void java_emit_char (int c, struct ui_file * stream, int quoter);
 
 
-static void java_emit_char PARAMS ((int c, GDB_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
 
 /* This objfile contains symtabs that have been dynamically created
    to record dynamically loaded Java classes and dynamically
@@ -66,10 +71,16 @@ static void java_emit_char PARAMS ((int c, GDB_FILE * stream, int quoter));
 
 static struct objfile *dynamics_objfile = NULL;
 
 
 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 *
 
 static struct objfile *
-get_dynamics_objfile ()
+get_dynamics_objfile (void)
 {
   if (dynamics_objfile == NULL)
     {
 {
   if (dynamics_objfile == NULL)
     {
@@ -83,12 +94,10 @@ get_dynamics_objfile ()
 
 static struct symtab *class_symtab = NULL;
 
 
 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 *
 
 static struct symtab *
-get_java_class_symtab ()
+get_java_class_symtab (void)
 {
   if (class_symtab == NULL)
     {
 {
   if (class_symtab == NULL)
     {
@@ -98,85 +107,69 @@ get_java_class_symtab ()
       class_symtab = allocate_symtab ("<java-classes>", objfile);
       class_symtab->language = language_java;
       bv = (struct blockvector *)
       class_symtab = allocate_symtab ("<java-classes>", 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. */
       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;
 
       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;
       BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
-      class_symtab->free_ptr = (char *) bl;
+      class_symtab->free_func = free_class_block;
     }
   return class_symtab;
 }
 
 static void
     }
   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 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 *
 
 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 *)
 {
   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;
   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_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;
 }
   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 *
 #endif
 
 struct type *
-java_lookup_class (name)
-     char *name;
+java_lookup_class (char *name)
 {
   struct symbol *sym;
 {
   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);
                       (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 = 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;
   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 *
    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;
 {
   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);
   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';
   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;
 }
 
   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 */
 {
   /* 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 (),
     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");
 
   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
 
 /* 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 *
   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;
 {
   struct type *type;
   char *name;
-  value_ptr temp;
+  struct value *temp;
   struct objfile *objfile;
   struct objfile *objfile;
-  value_ptr utf8_name;
+  struct value *utf8_name;
   char *nptr;
   CORE_ADDR addr;
   struct block *bl;
   char *nptr;
   CORE_ADDR addr;
   struct block *bl;
-  int i;
+  struct dict_iterator iter;
   int is_array = 0;
 
   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);
     }
   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);
 
 #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);
     }
       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))
     {
   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));
       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");
   /* 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 == '/')
   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))
       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");
       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);
     }
 
       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 *
 /* 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;
   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;
 
   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");
   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)
     {
       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),
   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_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++)
   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. */
        }
       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) =
        }
       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"));
       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 *)
   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));
   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. */
        }
       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");
        }
 
       /* 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, "<init>") == 0)
        mname = unqualified_name;
 
       if (strcmp (mname, "<init>") == 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)
            {                   /* 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. */
              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 *)
 
   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;
   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 *
 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;
 {
   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)
                           (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
       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)
 {
   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
   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)
 {
   CHECK_TYPEDEF (type);
   if (TYPE_CODE (type) == TYPE_CODE_PTR)
@@ -635,8 +623,7 @@ is_object_type (type)
 }
 
 struct type *
 }
 
 struct type *
-java_primitive_type (signature)
-     int signature;
+java_primitive_type (int signature)
 {
   switch (signature)
     {
 {
   switch (signature)
     {
@@ -659,16 +646,14 @@ java_primitive_type (signature)
     case 'V':
       return java_void_type;
     }
     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 *
 }
 
 /* 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])
     {
 {
   switch (name[0])
     {
@@ -713,8 +698,7 @@ java_primitive_type_from_name (name, namelen)
    signature string SIGNATURE. */
 
 static int
    signature string SIGNATURE. */
 
 static int
-java_demangled_signature_length (signature)
-     char *signature;
+java_demangled_signature_length (char *signature)
 {
   int array = 0;
   for (; *signature == '['; 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
 /* 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;
 {
   int array = 0;
   char *ptr;
@@ -776,8 +758,7 @@ java_demangled_signature_copy (result, signature)
    as a freshly allocated copy. */
 
 char *
    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);
 {
   int length = java_demangled_signature_length (signature);
   char *result = xmalloc (length + 1);
@@ -786,27 +767,11 @@ java_demangle_type_signature (signature)
   return result;
 }
 
   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 *
 /* 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;
 
 {
   struct type *range_type;
 
@@ -822,12 +787,10 @@ java_array_type (type, dims)
 
 /* Create a Java string in the inferior from a (Utf8) literal. */
 
 
 /* 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
 }
 
 /* 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
    characters and strings is language specific. */
 
 static void
-java_emit_char (c, stream, quoter)
-     int c;
-     GDB_FILE *stream;
-     int quoter;
+java_emit_char (int c, struct ui_file *stream, int quoter)
 {
   switch (c)
     {
 {
   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;
 {
   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)
     {
   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);
        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;
 
        {
          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. */
 
          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);
       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;
          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");
          /* 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));
          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)
          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);
                   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)
        {
        }
       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)
            return value_subscript (arg1, arg2);
        }
       if (name)
-       error ("cannot subscript something of type `%s'", name);
+       error (_("cannot subscript something of type `%s'"), name);
       else
       else
-       error ("cannot subscript requested type");
+       error (_("cannot subscript requested type"));
 
     case OP_STRING:
       (*pos)++;
 
     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);
 
        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. */
       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:
        arg1 = value_addr (arg1);
       return arg1;
     default:
@@ -985,37 +943,63 @@ nosideret:
   return value_from_longest (builtin_type_long, (LONGEST) 1);
 }
 
   return value_from_longest (builtin_type_long, (LONGEST) 1);
 }
 
-static struct type *
-java_create_fundamental_type (objfile, typeid)
-     struct objfile *objfile;
-     int 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)
 {
 {
-  switch (typeid)
+  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)
     {
     {
-    case FT_VOID:
-      return java_void_type;
-    case FT_BOOLEAN:
-      return java_boolean_type;
-    case FT_CHAR:
-      return java_char_type;
-    case FT_FLOAT:
-      return java_float_type;
-    case FT_DBL_PREC_FLOAT:
-      return java_double_type;
-    case FT_BYTE:
-    case FT_SIGNED_CHAR:
-      return java_byte_type;
-    case FT_SHORT:
-    case FT_SIGNED_SHORT:
-      return java_short_type;
-    case FT_INTEGER:
-    case FT_SIGNED_INTEGER:
-      return java_int_type;
-    case FT_LONG:
-    case FT_SIGNED_LONG:
-      return java_long_type;
+      ret = xmalloc (end - demangled_name + 1);
+      memcpy (ret, demangled_name, end - demangled_name);
+      ret[end - demangled_name] = '\0';
     }
     }
-  return c_create_fundamental_type (objfile, typeid);
+
+  xfree (demangled_name);
+  return ret;
 }
 
 /* Table mapping opcodes into strings for printing operators
 }
 
 /* Table mapping opcodes into strings for printing operators
@@ -1058,36 +1042,52 @@ const struct op_print java_op_print_tab[] =
   {NULL, 0, 0, 0}
 };
 
   {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,
 const struct language_defn java_language_defn =
 {
   "java",                      /* Language name */
   language_java,
-  c_builtin_types,
   range_check_off,
   type_check_off,
   range_check_off,
   type_check_off,
+  case_sensitive_on,
+  array_row_major,
+  &exp_descriptor_java,
   java_parse,
   java_error,
   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 */
   c_printchar,                 /* Print a character constant */
   c_printstr,                  /* Function to print string constant */
   java_emit_char,              /* Function to print a single character */
-  java_create_fundamental_type,        /* Create fundamental type in this language */
   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 */
   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 */
+  "this",                      /* name_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 */
   java_op_print_tab,           /* expression operators for printing */
   0,                           /* not c-style arrays */
   0,                           /* String lower bound */
-  &builtin_type_char,          /* Type of string elements */
+  default_word_break_characters,
+  default_make_symbol_completion_list,
+  c_language_arch_info,
+  default_print_array_index,
+  default_pass_by_reference,
   LANG_MAGIC
 };
 
 void
   LANG_MAGIC
 };
 
 void
-_initialize_java_language ()
+_initialize_java_language (void)
 {
 
   java_int_type = init_type (TYPE_CODE_INT, 4, 0, "int", NULL);
 {
 
   java_int_type = init_type (TYPE_CODE_INT, 4, 0, "int", NULL);
@@ -1102,25 +1102,3 @@ _initialize_java_language ()
 
   add_language (&java_language_defn);
 }
 
   add_language (&java_language_defn);
 }
-
-/* Cleanup code that should be run on every "run".
-   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));
-void
-java_rerun_cleanup ()
-{
-  if (class_symtab != NULL)
-    {
-      free_symtab (class_symtab);      /* ??? */
-      class_symtab = NULL;
-    }
-  if (dynamics_objfile != NULL)
-    {
-      free_objfile (dynamics_objfile);
-      dynamics_objfile = NULL;
-    }
-
-  java_object_type = NULL;
-}
GDB Binutils - Deliverables
This page took 0.035139 seconds and 4 git commands to generate.