Host/target/native split for sun4.

[deliverable/binutils-gdb.git] / gdb / symtab.c

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 3c5eea356912ca70a24c1b5a4e67227a682de1bb..fdda171bb8d519c7ab57ca0e36c20af6f7cc493c 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1,5 +1,6 @@
 /* Symbol table lookup for the GNU debugger, GDB.
 /* Symbol table lookup for the GNU debugger, GDB.

-   Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
+   Free Software Foundation, Inc.

 
 This file is part of GDB.
 
 
 This file is part of GDB.
 


@@ -17,17 +18,21 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 

-#include <stdio.h>

 #include "defs.h"
 #include "symtab.h"
 #include "defs.h"
 #include "symtab.h"

+#include "gdbtypes.h"

 #include "gdbcore.h"
 #include "frame.h"
 #include "target.h"
 #include "value.h"
 #include "symfile.h"
 #include "gdbcore.h"
 #include "frame.h"
 #include "target.h"
 #include "value.h"
 #include "symfile.h"

+#include "objfiles.h"

 #include "gdbcmd.h"
 #include "gdbcmd.h"

+#include "call-cmds.h"

 #include "regex.h"
 #include "regex.h"

+#include "expression.h"

 #include "language.h"
 #include "language.h"

+#include "demangle.h"

 
 #include <obstack.h>
 #include <assert.h>
 
 #include <obstack.h>
 #include <assert.h>


@@ -36,21 +41,64 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include <fcntl.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <string.h>
 #include <sys/stat.h>

+#include <ctype.h>

 
 

-extern char *getenv ();
+/* Prototypes for local functions */

 
 

-extern char *cplus_demangle ();
-extern char *cplus_mangle_opname ();
-extern struct value *value_of_this ();
-extern void break_command ();
-extern void select_source_symtab ();
+static char *
+expensive_mangler PARAMS ((const char *));
+
+extern int
+find_methods PARAMS ((struct type *, char *, char **, struct symbol **));
+
+static void
+completion_list_add_symbol PARAMS ((char *, char *, int));
+
+static struct symtabs_and_lines
+decode_line_2 PARAMS ((struct symbol *[], int, int));
+
+static void
+rbreak_command PARAMS ((char *, int));
+
+static void
+types_info PARAMS ((char *, int));
+
+static void
+functions_info PARAMS ((char *, int));
+
+static void
+variables_info PARAMS ((char *, int));
+
+static void
+sources_info PARAMS ((char *, int));
+
+static void
+list_symbols PARAMS ((char *, int, int));
+
+static void
+output_source_filename PARAMS ((char *, int *));

 
 

-/* Functions this file defines */
-static int find_line_common ();
-struct partial_symtab *lookup_partial_symtab ();
-static struct partial_symbol *lookup_partial_symbol ();
-static struct partial_symbol *lookup_demangled_partial_symbol ();
-static struct symbol *lookup_demangled_block_symbol ();
+static char *
+operator_chars PARAMS ((char *, char **));
+
+static int
+find_line_common PARAMS ((struct linetable *, int, int *));
+
+static struct partial_symbol *
+lookup_partial_symbol PARAMS ((struct partial_symtab *, const char *,
+                              int, enum namespace));
+
+static struct partial_symbol *
+lookup_demangled_partial_symbol PARAMS ((const struct partial_symtab *,
+                                        const char *));
+
+static struct symbol *
+lookup_demangled_block_symbol PARAMS ((const struct block *, const char *));
+
+static struct symtab *
+lookup_symtab_1 PARAMS ((char *));
+
+/* */

 
 /* The single non-language-specific builtin type */
 struct type *builtin_type_error;
 
 /* The single non-language-specific builtin type */
 struct type *builtin_type_error;


@@ -58,10 +106,23 @@ struct type *builtin_type_error;
 /* Block in which the most recently searched-for symbol was found.
    Might be better to make this a parameter to lookup_symbol and 
    value_of_this. */
 /* Block in which the most recently searched-for symbol was found.
    Might be better to make this a parameter to lookup_symbol and 
    value_of_this. */

-struct block *block_found;
+
+const struct block *block_found;

 
 char no_symtab_msg[] = "No symbol table is loaded.  Use the \"file\" command.";
 
 
 char no_symtab_msg[] = "No symbol table is loaded.  Use the \"file\" command.";
 

+/* While the C++ support is still in flux, issue a possibly helpful hint on
+   using the new command completion feature on single quoted demangled C++
+   symbols.  Remove when loose ends are cleaned up.   FIXME -fnf */
+
+void
+cplusplus_hint (name)
+     char *name;
+{
+  printf ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name, name);
+  printf ("(Note leading single quote.)\n");
+}
+

 /* Check for a symtab of a specific name; first in symtabs, then in
    psymtabs.  *If* there is no '/' in the name, a match after a '/'
    in the symtab filename will also work.  */
 /* Check for a symtab of a specific name; first in symtabs, then in
    psymtabs.  *If* there is no '/' in the name, a match after a '/'
    in the symtab filename will also work.  */


@@ -72,46 +133,76 @@ lookup_symtab_1 (name)
 {
   register struct symtab *s;
   register struct partial_symtab *ps;
 {
   register struct symtab *s;
   register struct partial_symtab *ps;

-  register char *slash = strchr (name, '/');
-  register int len = strlen (name);
+  register char *slash;
+  register struct objfile *objfile;

 
 

-  for (s = symtab_list; s; s = s->next)
-    if (!strcmp (name, s->filename))
+ got_symtab:
+
+  /* First, search for an exact match */
+
+  ALL_SYMTABS (objfile, s)
+    if (strcmp (name, s->filename) == 0)

       return s;
 
       return s;
 

-  for (ps = partial_symtab_list; ps; ps = ps->next)
-    if (!strcmp (name, ps->filename))
+  slash = strchr (name, '/');
+
+  /* Now, search for a matching tail (only if name doesn't have any dirs) */
+
+  if (!slash)
+    ALL_SYMTABS (objfile, s)

       {
       {

-       if (ps->readin)
-         error ("Internal: readin pst for `%s' found when no symtab found.", name);
-       return PSYMTAB_TO_SYMTAB (ps);
+       char *p = s -> filename;
+       char *tail = strrchr (p, '/');
+
+       if (tail)
+         p = tail + 1;
+
+       if (strcmp (p, name) == 0)
+         return s;

       }
 
       }
 

+  /* Same search rules as above apply here, but now we look thru the
+     psymtabs.  */
+
+  ALL_PSYMTABS (objfile, ps)
+    if (strcmp (name, ps -> filename) == 0)
+      goto got_psymtab;
+

   if (!slash)
   if (!slash)

-    {
-      for (s = symtab_list; s; s = s->next)
-       {
-         int l = strlen (s->filename);
+    ALL_PSYMTABS (objfile, ps)
+      {
+       char *p = ps -> filename;
+       char *tail = strrchr (p, '/');

 
 

-         if (s->filename[l - len -1] == '/'
-             && !strcmp (s->filename + l - len, name))
-           return s;
-       }
+       if (tail)
+         p = tail + 1;

 
 

-      for (ps = partial_symtab_list; ps; ps = ps->next)
-       {
-         int l = strlen (ps->filename);
+       if (strcmp (p, name) == 0)
+         goto got_psymtab;
+      }

 
 

-         if (ps->filename[l - len - 1] == '/'
-             && !strcmp (ps->filename + l - len, name))
-           {
-             if (ps->readin)
-               error ("Internal: readin pst for `%s' found when no symtab found.", name);
-             return PSYMTAB_TO_SYMTAB (ps);
-           }
-       }
-    }
-  return 0;
+  return (NULL);
+
+ got_psymtab:
+
+  if (ps -> readin)
+    error ("Internal: readin %s pst for `%s' found when no symtab found.",
+          ps -> filename, name);
+
+  s = PSYMTAB_TO_SYMTAB (ps);
+
+  if (s)
+    return s;
+
+  /* At this point, we have located the psymtab for this file, but
+     the conversion to a symtab has failed.  This usually happens
+     when we are looking up an include file.  In this case,
+     PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
+     been created.  So, we need to run through the symtabs again in
+     order to find the file.
+     XXX - This is a crock, and should be fixed inside of the the
+     symbol parsing routines. */
+  goto got_symtab;

 }
 
 /* Lookup the symbol table of a source file named NAME.  Try a couple
 }
 
 /* Lookup the symbol table of a source file named NAME.  Try a couple


@@ -147,81 +238,19 @@ struct partial_symtab *
 lookup_partial_symtab (name)
 char *name;
 {
 lookup_partial_symtab (name)
 char *name;
 {

-  register struct partial_symtab *s;
-  
-  for (s = partial_symtab_list; s; s = s->next)
-    if (!strcmp (name, s->filename))
-      return s;
+  register struct partial_symtab *pst;
+  register struct objfile *objfile;

   
   

-  return 0;
-}
-\f
-/* Return a typename for a struct/union/enum type
-   without the tag qualifier.  If the type has a NULL name,
-   NULL is returned.  */
-char *
-type_name_no_tag (type)
-     register struct type *type;
-{
-  register char *name = TYPE_NAME (type);
-
-  if (name == 0)
-    return 0;
-
-  switch (TYPE_CODE (type))
-    {
-    case TYPE_CODE_STRUCT:
-      if(!strncmp(name,"struct ",7))
-       return name + 7;
-      else return name;
-    case TYPE_CODE_UNION:
-      if(!strncmp(name,"union ",6))
-      return name + 6;
-      else return name;
-    case TYPE_CODE_ENUM:
-      if(!strncmp(name,"enum ",5))
-      return name + 5;
-      else return name;
-    default:
-      return name;
-    }
-}
-
-/* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
-
-   If this is a stubbed struct (i.e. declared as struct foo *), see if
-   we can find a full definition in some other file. If so, copy this
-   definition, so we can use it in future.  If not, set a flag so we 
-   don't waste too much time in future.  (FIXME, this doesn't seem
-   to be happening...)
-
-   This used to be coded as a macro, but I don't think it is called 
-   often enough to merit such treatment.
-*/
-
-struct complaint stub_noname_complaint =
-  {"stub type has NULL name", 0, 0};
-
-void 
-check_stub_type(type)
-     struct type *type;
-{
-  if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
+  ALL_PSYMTABS (objfile, pst)

     {
     {

-      char* name= type_name_no_tag (type);
-      struct symbol *sym;
-      if (name == 0)
+      if (strcmp (name, pst -> filename) == 0)

        {
        {

-         complain (&stub_noname_complaint, 0);
-         return;
+         return (pst);

        }
        }

-      sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, 
-                          (struct symtab **)NULL);
-      if (sym)
-       bcopy (SYMBOL_TYPE(sym), type, sizeof (struct type));

     }
     }

+  return (NULL);

 }
 }

-
+\f

 /* Demangle a GDB method stub type.  */
 char *
 gdb_mangle_name (type, i, j)
 /* Demangle a GDB method stub type.  */
 char *
 gdb_mangle_name (type, i, j)


@@ -233,19 +262,29 @@ gdb_mangle_name (type, i, j)
   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
   struct fn_field *method = &f[j];
   char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
   struct fn_field *method = &f[j];
   char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);

-
+  char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
+  char *newname = type_name_no_tag (type);
+  int is_constructor = strcmp(field_name, newname) == 0;
+  int is_destructor = is_constructor && physname[0] == '_'
+      && physname[1] == CPLUS_MARKER && physname[2] == '_';

   /* Need a new type prefix.  */
   /* Need a new type prefix.  */

-  char *strchr ();

   char *const_prefix = method->is_const ? "C" : "";
   char *volatile_prefix = method->is_volatile ? "V" : "";
   char *const_prefix = method->is_const ? "C" : "";
   char *volatile_prefix = method->is_volatile ? "V" : "";

-  char *newname = type_name_no_tag (type);

   char buf[20];
   char buf[20];

+#ifndef GCC_MANGLE_BUG

   int len = strlen (newname);
 
   int len = strlen (newname);
 

+  if (is_destructor)
+    {
+      mangled_name = (char*) xmalloc(strlen(physname)+1);
+      strcpy(mangled_name, physname);
+      return mangled_name;
+    }
+

   sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
   sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);

-  mangled_name_len = (strlen (field_name)
+  mangled_name_len = ((is_constructor ? 0 : strlen (field_name))

                          + strlen (buf) + len
                          + strlen (buf) + len

-                         + strlen (TYPE_FN_FIELD_PHYSNAME (f, j))
+                         + strlen (physname)

                          + 1);
 
   /* Only needed for GNU-mangled names.  ANSI-mangled names
                          + 1);
 
   /* Only needed for GNU-mangled names.  ANSI-mangled names


@@ -265,506 +304,80 @@ gdb_mangle_name (type, i, j)
   else
     {
       mangled_name = (char *)xmalloc (mangled_name_len);
   else
     {
       mangled_name = (char *)xmalloc (mangled_name_len);

-      strcpy (mangled_name, TYPE_FN_FIELDLIST_NAME (type, i));
+      if (is_constructor)
+       mangled_name[0] = '\0';
+      else
+       strcpy (mangled_name, field_name);

     }
   strcat (mangled_name, buf);
   strcat (mangled_name, newname);
     }
   strcat (mangled_name, buf);
   strcat (mangled_name, newname);

-  strcat (mangled_name, TYPE_FN_FIELD_PHYSNAME (f, j));
-
-  return mangled_name;
-}
-
-/* Lookup a primitive type named NAME. 
-   Return zero if NAME is not a primitive type.*/
-
-struct type *
-lookup_primitive_typename (name)
-     char *name;
-{
-   struct type ** const *p;
-
-   for (p = current_language->la_builtin_type_vector; *p; p++)
-      if(!strcmp((**p)->name, name))
-        return **p;
-   return 0; 
-}
-
-/* Lookup a typedef or primitive type named NAME,
-   visible in lexical block BLOCK.
-   If NOERR is nonzero, return zero if NAME is not suitably defined.  */
+#else
+  char *opname;

 
 

-struct type *
-lookup_typename (name, block, noerr)
-     char *name;
-     struct block *block;
-     int noerr;
-{
-  register struct symbol *sym =
-    lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
-  if (sym == 0 || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
-    {
-      struct type *tmp;
-      tmp = lookup_primitive_typename (name);
-      if(tmp)
-        return tmp;
-      else if (!tmp && noerr)
-       return 0;
-      else
-        error ("No type named %s.", name);
+  if (is_constructor)
+    {
+      buf[0] = '\0';

     }
     }

-  return SYMBOL_TYPE (sym);
-}
-
-struct type *
-lookup_unsigned_typename (name)
-     char *name;
-{
-  char *uns = alloca (strlen(name) + 10);
-
-  strcpy (uns, "unsigned ");
-  strcpy (uns+9, name);
-  return lookup_typename (uns, (struct block *)0, 0);
-}
-
-/* Lookup a structure type named "struct NAME",
-   visible in lexical block BLOCK.  */
-
-struct type *
-lookup_struct (name, block)
-     char *name;
-     struct block *block;
-{
-  register struct symbol *sym 
-    = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL);
-
-  if (sym == 0)
-    error ("No struct type named %s.", name);
-  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
-    error ("This context has class, union or enum %s, not a struct.", name);
-  return SYMBOL_TYPE (sym);
-}
-
-/* Lookup a union type named "union NAME",
-   visible in lexical block BLOCK.  */
-
-struct type *
-lookup_union (name, block)
-     char *name;
-     struct block *block;
-{
-  register struct symbol *sym 
-    = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL);
-
-  if (sym == 0)
-    error ("No union type named %s.", name);
-  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
-    error ("This context has class, struct or enum %s, not a union.", name);
-  return SYMBOL_TYPE (sym);
-}
-
-/* Lookup an enum type named "enum NAME",
-   visible in lexical block BLOCK.  */
-
-struct type *
-lookup_enum (name, block)
-     char *name;
-     struct block *block;
-{
-  register struct symbol *sym 
-    = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL);
-  if (sym == 0)
-    error ("No enum type named %s.", name);
-  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
-    error ("This context has class, struct or union %s, not an enum.", name);
-  return SYMBOL_TYPE (sym);
-}
-
-/* Lookup a template type named "template NAME<TYPE>",
-   visible in lexical block BLOCK.  */
-
-struct type *
-lookup_template_type (name, type, block)
-     char *name;
-     struct type *type;
-     struct block *block;
-{
-  struct symbol *sym ;
-  char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4);
-  strcpy(nam, name);
-  strcat(nam, "<");
-  strcat(nam, type->name);
-  strcat(nam, " >");   /* FIXME, extra space still introduced in gcc? */
-
-  sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
-
-  if (sym == 0)
-    error ("No template type named %s.", name);
-  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
-    error ("This context has class, union or enum %s, not a struct.", name);
-  return SYMBOL_TYPE (sym);
-}
-
-/* Given a type TYPE, lookup the type of the component of type named
-   NAME.  
-   If NOERR is nonzero, return zero if NAME is not suitably defined.  */
-
-struct type *
-lookup_struct_elt_type (type, name, noerr)
-     struct type *type;
-     char *name;
-     int noerr;
-{
-  int i;
-
-  if (   TYPE_CODE (type) != TYPE_CODE_STRUCT
-      && TYPE_CODE (type) != TYPE_CODE_UNION)
+  else

     {
     {

-      target_terminal_ours ();
-      fflush (stdout);
-      fprintf (stderr, "Type ");
-      type_print (type, "", stderr, -1);
-      error (" is not a structure or union type.");
+      sprintf (buf, "__%s%s", const_prefix, volatile_prefix);

     }
 
     }
 

-  check_stub_type (type);
+  mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
+                     + strlen (buf) + strlen (physname) + 1);

 
 

-  for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
+  /* Only needed for GNU-mangled names.  ANSI-mangled names
+     work with the normal mechanisms.  */
+  if (OPNAME_PREFIX_P (field_name))

     {
     {

-      char *t_field_name = TYPE_FIELD_NAME (type, i);
+      opname = cplus_mangle_opname (field_name + 3, 0);
+      if (opname == NULL)
+       {
+         error ("No mangling for \"%s\"", field_name);
+       }
+      mangled_name_len += strlen (opname);
+      mangled_name = (char *) xmalloc (mangled_name_len);

 
 

-      if (t_field_name && !strcmp (t_field_name, name))
-       return TYPE_FIELD_TYPE (type, i);
-    }
-  /* OK, it's not in this class.  Recursively check the baseclasses.  */
-  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
-    {
-      struct type *t = lookup_struct_elt_type (TYPE_BASECLASS (type, i),
-                                              name, 0);
-      if (t != NULL)
-       return t;
+      strncpy (mangled_name, field_name, 3);
+      strcpy (mangled_name + 3, opname);

     }
     }

-
-  if (noerr)
-    return NULL;
-  
-  target_terminal_ours ();
-  fflush (stdout);
-  fprintf (stderr, "Type ");
-  type_print (type, "", stderr, -1);
-  fprintf (stderr, " has no component named ");
-  fputs_filtered (name, stderr);
-  error (".");
-  return (struct type *)-1;    /* For lint */
-}
-
-/* Given a type TYPE, return a type of pointers to that type.
-   May need to construct such a type if this is the first use.  */
-
-struct type *
-lookup_pointer_type (type)
-     struct type *type;
-{
-  register struct type *ptype = TYPE_POINTER_TYPE (type);
-  if (ptype) return ptype;
-
-  /* This is the first time anyone wanted a pointer to a TYPE.  */
-  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
-    ptype  = (struct type *) xmalloc (sizeof (struct type));

   else
   else

-    ptype  = (struct type *) obstack_alloc (symbol_obstack,
-                                           sizeof (struct type));
-
-  bzero (ptype, sizeof (struct type));
-  TYPE_TARGET_TYPE (ptype) = type;
-  TYPE_POINTER_TYPE (type) = ptype;
-  /* New type is permanent if type pointed to is permanent.  */
-  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
-    TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
-  /* We assume the machine has only one representation for pointers!  */
-  /* FIXME:  This confuses host<->target data representations, and is a
-     poor assumption besides. */
-  TYPE_LENGTH (ptype) = sizeof (char *);
-  TYPE_CODE (ptype) = TYPE_CODE_PTR;
-  return ptype;
-}
-
-struct type *
-lookup_reference_type (type)
-     struct type *type;
-{
-  register struct type *rtype = TYPE_REFERENCE_TYPE (type);
-  if (rtype) return rtype;
-
-  /* This is the first time anyone wanted a pointer to a TYPE.  */
-  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
-    rtype  = (struct type *) xmalloc (sizeof (struct type));
-  else
-    rtype  = (struct type *) obstack_alloc (symbol_obstack,
-                                           sizeof (struct type));
-
-  bzero (rtype, sizeof (struct type));
-  TYPE_TARGET_TYPE (rtype) = type;
-  TYPE_REFERENCE_TYPE (type) = rtype;
-  /* New type is permanent if type pointed to is permanent.  */
-  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
-    TYPE_FLAGS (rtype) |= TYPE_FLAG_PERM;
-  /* We assume the machine has only one representation for pointers!  */
-  TYPE_LENGTH (rtype) = sizeof (char *);
-  TYPE_CODE (rtype) = TYPE_CODE_REF;
-  return rtype;
-}
-
-
-/* Implement direct support for MEMBER_TYPE in GNU C++.
-   May need to construct such a type if this is the first use.
-   The TYPE is the type of the member.  The DOMAIN is the type
-   of the aggregate that the member belongs to.  */
-
-struct type *
-lookup_member_type (type, domain)
-     struct type *type, *domain;
-{
-  register struct type *mtype;
-
-  mtype  = (struct type *) obstack_alloc (symbol_obstack,
-                                         sizeof (struct type));
-  smash_to_member_type (mtype, domain, type);
-  return mtype;
-}
-
-/* Allocate a stub method whose return type is TYPE.  
-   This apparently happens for speed of symbol reading, since parsing
-   out the arguments to the method is cpu-intensive, the way we are doing
-   it.  So, we will fill in arguments later.
-   This always returns a fresh type.   */
-
-struct type *
-allocate_stub_method (type)
-     struct type *type;
-{
-  struct type *mtype = (struct type *) obstack_alloc (symbol_obstack,
-                                                     sizeof (struct type));
-  bzero (mtype, sizeof (struct type));
-  TYPE_TARGET_TYPE (mtype) = type;
-  /*  _DOMAIN_TYPE (mtype) = unknown yet */
-  /*  _ARG_TYPES (mtype) = unknown yet */
-  TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
-  TYPE_CODE (mtype) = TYPE_CODE_METHOD;
-  TYPE_LENGTH (mtype) = 1;
-  return mtype;
-}
-
-/* Ugly hack to convert method stubs into method types.
-
-   He ain't kiddin'.  This demangles the name of the method into a string
-   including argument types, parses out each argument type, generates
-   a string casting a zero to that type, evaluates the string, and stuffs
-   the resulting type into an argtype vector!!!  Then it knows the type
-   of the whole function (including argument types for overloading),
-   which info used to be in the stab's but was removed to hack back
-   the space required for them.  */
-void
-check_stub_method (type, i, j)
-     struct type *type;
-     int i, j;
-{
-  extern char *gdb_mangle_name (), *strchr ();
-  struct fn_field *f;
-  char *mangled_name = gdb_mangle_name (type, i, j);
-  char *demangled_name = cplus_demangle (mangled_name, 0);
-  char *argtypetext, *p;
-  int depth = 0, argcount = 1;
-  struct type **argtypes;
-  struct type *mtype;
-
-  /* Now, read in the parameters that define this type.  */
-  argtypetext = strchr (demangled_name, '(') + 1;
-  p = argtypetext;
-  while (*p)
-    {
-      if (*p == '(')
-       depth += 1;
-      else if (*p == ')')
-       depth -= 1;
-      else if (*p == ',' && depth == 0)
-       argcount += 1;
-
-      p += 1;
-    }
-  /* We need one more slot for the void [...] or NULL [end of arglist] */
-  argtypes = (struct type **) obstack_alloc (symbol_obstack,
-                               (argcount+1) * sizeof (struct type *));
-  p = argtypetext;
-  argtypes[0] = lookup_pointer_type (type);
-  argcount = 1;
-
-  if (*p != ')')                       /* () means no args, skip while */
-    {
-      depth = 0;
-      while (*p)
+    {
+      mangled_name = (char *) xmalloc (mangled_name_len);
+      if (is_constructor)

        {
        {

-         if (depth <= 0 && (*p == ',' || *p == ')'))
-           {
-             argtypes[argcount] =
-                 parse_and_eval_type (argtypetext, p - argtypetext);
-             argcount += 1;
-             argtypetext = p + 1;
-           }
-
-         if (*p == '(')
-           depth += 1;
-         else if (*p == ')')
-           depth -= 1;
-
-         p += 1;
+         mangled_name[0] = '\0';
+       }
+      else
+       {
+         strcpy (mangled_name, field_name);

        }
     }
        }
     }

+  strcat (mangled_name, buf);

 
 

-  if (p[-2] != '.')                    /* ... */
-    argtypes[argcount] = builtin_type_void;    /* Ellist terminator */
-  else
-    argtypes[argcount] = NULL;         /* List terminator */
-
-  free (demangled_name);
-
-  f = TYPE_FN_FIELDLIST1 (type, i);
-  TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
-
-  /* Now update the old "stub" type into a real type.  */
-  mtype = TYPE_FN_FIELD_TYPE (f, j);
-  TYPE_DOMAIN_TYPE (mtype) = type;
-  TYPE_ARG_TYPES (mtype) = argtypes;
-  TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
-}
-
-/* Given a type TYPE, return a type of functions that return that type.
-   May need to construct such a type if this is the first use.  */
-
-struct type *
-lookup_function_type (type)
-     struct type *type;
-{
-  register struct type *ptype = TYPE_FUNCTION_TYPE (type);
-  if (ptype) return ptype;
-
-  /* This is the first time anyone wanted a function returning a TYPE.  */
-  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
-    ptype  = (struct type *) xmalloc (sizeof (struct type));
-  else
-    ptype  = (struct type *) obstack_alloc (symbol_obstack,
-                                           sizeof (struct type));
-
-  bzero (ptype, sizeof (struct type));
-  TYPE_TARGET_TYPE (ptype) = type;
-  TYPE_FUNCTION_TYPE (type) = ptype;
-  /* New type is permanent if type returned is permanent.  */
-  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
-    TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
-  TYPE_LENGTH (ptype) = 1;
-  TYPE_CODE (ptype) = TYPE_CODE_FUNC;
-  TYPE_NFIELDS (ptype) = 0;
-  return ptype;
-}
-\f
-/* Create an array type.  Elements will be of type TYPE, and there will
-   be NUM of them.
-
-   Eventually this should be extended to take two more arguments which
-   specify the bounds of the array and the type of the index.
-   It should also be changed to be a "lookup" function, with the
-   appropriate data structures added to the type field.
-   Then read array type should call here.  */
-
-struct type *
-create_array_type (element_type, number)
-     struct type *element_type;
-     int number;
-{
-  struct type *result_type = (struct type *)
-    obstack_alloc (symbol_obstack, sizeof (struct type));
-  struct type *range_type;
-
-  bzero (result_type, sizeof (struct type));
-
-  TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
-  TYPE_TARGET_TYPE (result_type) = element_type;
-  TYPE_LENGTH (result_type) = number * TYPE_LENGTH (element_type);
-  TYPE_NFIELDS (result_type) = 1;
-  TYPE_FIELDS (result_type) =
-    (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field));
-
-  {
-    /* Create range type.  */
-    range_type = (struct type *) obstack_alloc (symbol_obstack,
-                                               sizeof (struct type));
-    TYPE_CODE (range_type) = TYPE_CODE_RANGE;
-    TYPE_TARGET_TYPE (range_type) = builtin_type_int;  /* FIXME */
-
-    /* This should never be needed.  */
-    TYPE_LENGTH (range_type) = sizeof (int);
-
-    TYPE_NFIELDS (range_type) = 2;
-    TYPE_FIELDS (range_type) =
-      (struct field *) obstack_alloc (symbol_obstack,
-                                     2 * sizeof (struct field));
-    TYPE_FIELD_BITPOS (range_type, 0) = 0; /* FIXME */
-    TYPE_FIELD_BITPOS (range_type, 1) = number-1; /* FIXME */
-    TYPE_FIELD_TYPE (range_type, 0) = builtin_type_int; /* FIXME */
-    TYPE_FIELD_TYPE (range_type, 1) = builtin_type_int; /* FIXME */
-  }
-  TYPE_FIELD_TYPE(result_type,0)=range_type;
-  TYPE_VPTR_FIELDNO (result_type) = -1;
-
-  return result_type;
-}
-
-\f
-/* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. 
-   A MEMBER is a wierd thing -- it amounts to a typed offset into
-   a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
-   include the offset (that's the value of the MEMBER itself), but does
-   include the structure type into which it points (for some reason).  */
-
-void
-smash_to_member_type (type, domain, to_type)
-     struct type *type, *domain, *to_type;
-{
-  bzero (type, sizeof (struct type));
-  TYPE_TARGET_TYPE (type) = to_type;
-  TYPE_DOMAIN_TYPE (type) = domain;
-  TYPE_LENGTH (type) = 1;      /* In practice, this is never needed.  */
-  TYPE_CODE (type) = TYPE_CODE_MEMBER;
+#endif
+  strcat (mangled_name, physname);
+  return (mangled_name);

 }
 
 }
 

-/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
-   METHOD just means `function that gets an extra "this" argument'.  */
-
-void
-smash_to_method_type (type, domain, to_type, args)
-     struct type *type, *domain, *to_type, **args;
-{
-  bzero (type, sizeof (struct type));
-  TYPE_TARGET_TYPE (type) = to_type;
-  TYPE_DOMAIN_TYPE (type) = domain;
-  TYPE_ARG_TYPES (type) = args;
-  TYPE_LENGTH (type) = 1;      /* In practice, this is never needed.  */
-  TYPE_CODE (type) = TYPE_CODE_METHOD;
-}

 \f
 \f

-/* Find which partial symtab on the partial_symtab_list contains
-   PC.  Return 0 if none.  */
+/* Find which partial symtab on contains PC.  Return 0 if none.  */

 
 struct partial_symtab *
 find_pc_psymtab (pc)
      register CORE_ADDR pc;
 {
 
 struct partial_symtab *
 find_pc_psymtab (pc)
      register CORE_ADDR pc;
 {

-  register struct partial_symtab *ps;
-
-  for (ps = partial_symtab_list; ps; ps = ps->next)
-    if (pc >= ps->textlow && pc < ps->texthigh)
-      return ps;
+  register struct partial_symtab *pst;
+  register struct objfile *objfile;

 
 

-  return 0;
+  ALL_PSYMTABS (objfile, pst)
+    {
+      if (pc >= pst -> textlow && pc < pst -> texthigh)
+       {
+         return (pst);
+       }
+    }
+  return (NULL);

 }
 
 /* Find which partial symbol within a psymtab contains PC.  Return 0
 }
 
 /* Find which partial symbol within a psymtab contains PC.  Return 0


@@ -784,8 +397,8 @@ find_pc_psymbol (psymtab, pc)
 
   best_pc = psymtab->textlow - 1;
 
 
   best_pc = psymtab->textlow - 1;
 

-  for (p = static_psymbols.list + psymtab->statics_offset;
-       (p - (static_psymbols.list + psymtab->statics_offset)
+  for (p = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
+       (p - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)

        < psymtab->n_static_syms);
        p++)
     if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
        < psymtab->n_static_syms);
        p++)
     if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE


@@ -815,9 +428,9 @@ find_pc_psymbol (psymtab, pc)
 
 struct symbol *
 lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
 
 struct symbol *
 lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)

-     char *name;
-     register struct block *block;
-     enum namespace namespace;
+     const char *name;
+     register const struct block *block;
+     const enum namespace namespace;

      int *is_a_field_of_this;
      struct symtab **symtab;
 {
      int *is_a_field_of_this;
      struct symtab **symtab;
 {


@@ -825,6 +438,23 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
   register struct symtab *s;
   register struct partial_symtab *ps;
   struct blockvector *bv;
   register struct symtab *s;
   register struct partial_symtab *ps;
   struct blockvector *bv;

+  register struct objfile *objfile;
+  register struct block *b;
+  register struct minimal_symbol *msymbol;
+  char *temp;
+  extern char *gdb_completer_word_break_characters;
+
+  /* If NAME contains any characters from gdb_completer_word_break_characters
+     then it is probably from a quoted name string.  So check to see if it
+     has a C++ mangled equivalent, and if so, use the mangled equivalent. */
+
+  if (strpbrk (name, gdb_completer_word_break_characters) != NULL)
+    {
+      if ((temp = expensive_mangler (name)) != NULL)
+       {
+         name = temp;
+       }
+    }

 
   /* Search specified block and its superiors.  */
 
 
   /* Search specified block and its superiors.  */
 


@@ -838,19 +468,19 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
            {
              /* Search the list of symtabs for one which contains the
                 address of the start of this block.  */
            {
              /* Search the list of symtabs for one which contains the
                 address of the start of this block.  */

-             struct block *b;
-             for (s = symtab_list; s; s = s->next)
+             ALL_SYMTABS (objfile, s)

                {
                  bv = BLOCKVECTOR (s);
                  b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
                  if (BLOCK_START (b) <= BLOCK_START (block)
                      && BLOCK_END (b) > BLOCK_START (block))
                {
                  bv = BLOCKVECTOR (s);
                  b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
                  if (BLOCK_START (b) <= BLOCK_START (block)
                      && BLOCK_END (b) > BLOCK_START (block))

-                   break;
+                   goto found;

                }
                }

+found:

              *symtab = s;
            }
 
              *symtab = s;
            }
 

-         return sym;
+         return (sym);

        }
       block = BLOCK_SUPERBLOCK (block);
     }
        }
       block = BLOCK_SUPERBLOCK (block);
     }


@@ -866,7 +496,7 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
     {
       struct block *b;
       /* Find the right symtab.  */
     {
       struct block *b;
       /* Find the right symtab.  */

-      for (s = symtab_list; s; s = s->next)
+      ALL_SYMTABS (objfile, s)

        {
          bv = BLOCKVECTOR (s);
          b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
        {
          bv = BLOCKVECTOR (s);
          b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);


@@ -904,8 +534,8 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
 
   /* Now search all global blocks.  Do the symtab's first, then
      check the psymtab's */
 
   /* Now search all global blocks.  Do the symtab's first, then
      check the psymtab's */

-
-  for (s = symtab_list; s; s = s->next)
+  
+  ALL_SYMTABS (objfile, s)

     {
       bv = BLOCKVECTOR (s);
       block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
     {
       bv = BLOCKVECTOR (s);
       block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);


@@ -920,49 +550,55 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
     }
 
   /* Check for the possibility of the symbol being a global function
     }
 
   /* Check for the possibility of the symbol being a global function

-     that is stored on the misc function vector.  Eventually, all
+     that is stored in one of the minimal symbol tables.  Eventually, all

      global symbols might be resolved in this way.  */
   
   if (namespace == VAR_NAMESPACE)
     {
      global symbols might be resolved in this way.  */
   
   if (namespace == VAR_NAMESPACE)
     {

-      int ind = lookup_misc_func (name);
+      msymbol = lookup_minimal_symbol (name, (struct objfile *) NULL);

 
 

-      /* Look for a mangled C++ name for NAME. */
-      if (ind == -1)
+      if (msymbol == NULL)

        {
        {

-         int name_len = strlen (name);
+         /* Test each minimal symbol to see if the minimal symbol's name
+            is a C++ mangled name that matches a user visible name.  */
+
+         char *demangled;

 
 

-         for (ind = misc_function_count; --ind >= 0; )
-             /* Assume orginal name is prefix of mangled name. */
-             if (!strncmp (misc_function_vector[ind].name, name, name_len))
+         ALL_MSYMBOLS (objfile, msymbol)
+           {
+             demangled = demangle_and_match (msymbol -> name, name,
+                                             DMGL_PARAMS | DMGL_ANSI);
+             if (demangled != NULL)

                {
                {

-                 char *demangled =
-                     cplus_demangle(misc_function_vector[ind].name, -1);
-                 if (demangled != NULL)
-                   {
-                     int cond = strcmp (demangled, name);
-                     free (demangled);
-                     if (!cond)
-                         break;
-                   }
-               }
-         /* Loop terminates on no match with ind == -1. */
+                 free (demangled);
+                 goto found_msym;
+               }
+           }
+         msymbol = NULL;               /* Not found */

         }
 
         }
 

-      if (ind != -1)
+found_msym:
+      if (msymbol != NULL)

        {
        {

-         s = find_pc_symtab (misc_function_vector[ind].address);
-         /* If S is zero, there are no debug symbols for this file.
+         s = find_pc_symtab (msymbol -> address);
+         /* If S is NULL, there are no debug symbols for this file.

             Skip this stuff and check for matching static symbols below. */
             Skip this stuff and check for matching static symbols below. */

-         if (s)
+         if (s != NULL)

            {
              bv = BLOCKVECTOR (s);
              block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
            {
              bv = BLOCKVECTOR (s);
              block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);

-             sym = lookup_block_symbol (block, misc_function_vector[ind].name,
-                                        namespace);
-             /* sym == 0 if symbol was found in the misc_function_vector
+             sym = lookup_block_symbol (block, msymbol -> name, namespace);
+              /* We kept static functions in minimal symbol table as well as
+                in static scope. We want to find them in the symbol table. */
+               if (!sym) {
+                 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+                 sym = lookup_block_symbol (block, msymbol -> name,
+                                            namespace);
+               }
+
+             /* sym == 0 if symbol was found in the minimal symbol table

                 but not in the symtab.
                 but not in the symtab.

-                Return 0 to use the misc_function definition of "foo_".
+                Return 0 to use the msymbol definition of "foo_".

 
                 This happens for Fortran  "foo_" symbols,
                 which are "foo" in the symtab.
 
                 This happens for Fortran  "foo_" symbols,
                 which are "foo" in the symtab.


@@ -980,25 +616,27 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
        }
     }
       
        }
     }
       

-  for (ps = partial_symtab_list; ps; ps = ps->next)
-    if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace))
-      {
-       s = PSYMTAB_TO_SYMTAB(ps);
-       bv = BLOCKVECTOR (s);
-       block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-       sym = lookup_block_symbol (block, name, namespace);
-       if (!sym)
-         error ("Internal: global symbol `%s' found in psymtab but not in symtab", name);
-       if (symtab != NULL)
-         *symtab = s;
-       return sym;
-      }
+  ALL_PSYMTABS (objfile, ps)
+    {
+      if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace))
+       {
+         s = PSYMTAB_TO_SYMTAB(ps);
+         bv = BLOCKVECTOR (s);
+         block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+         sym = lookup_block_symbol (block, name, namespace);
+         if (!sym)
+           error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
+         if (symtab != NULL)
+           *symtab = s;
+         return sym;
+       }
+    }

 
   /* Now search all per-file blocks.
      Not strictly correct, but more useful than an error.
      Do the symtabs first, then check the psymtabs */
 
 
   /* Now search all per-file blocks.
      Not strictly correct, but more useful than an error.
      Do the symtabs first, then check the psymtabs */
 

-  for (s = symtab_list; s; s = s->next)
+  ALL_SYMTABS (objfile, s)

     {
       bv = BLOCKVECTOR (s);
       block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
     {
       bv = BLOCKVECTOR (s);
       block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);


@@ -1012,26 +650,28 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
        }
     }
 
        }
     }
 

-  for (ps = partial_symtab_list; ps; ps = ps->next)
-    if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace))
-      {
-       s = PSYMTAB_TO_SYMTAB(ps);
-       bv = BLOCKVECTOR (s);
-       block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-       sym = lookup_block_symbol (block, name, namespace);
-       if (!sym)
-         error ("Internal: static symbol `%s' found in psymtab but not in symtab", name);
-       if (symtab != NULL)
-         *symtab = s;
-       return sym;
-      }
+  ALL_PSYMTABS (objfile, ps)
+    {
+      if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace))
+       {
+         s = PSYMTAB_TO_SYMTAB(ps);
+         bv = BLOCKVECTOR (s);
+         block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+         sym = lookup_block_symbol (block, name, namespace);
+         if (!sym)
+           error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
+         if (symtab != NULL)
+           *symtab = s;
+         return sym;
+       }
+    }

 
   /* Now search all per-file blocks for static mangled symbols.
      Do the symtabs first, then check the psymtabs.  */
 
 
   /* Now search all per-file blocks for static mangled symbols.
      Do the symtabs first, then check the psymtabs.  */
 

-  if (namespace ==  VAR_NAMESPACE)
+  if (namespace == VAR_NAMESPACE)

     {
     {

-      for (s = symtab_list; s; s = s->next)
+      ALL_SYMTABS (objfile, s)

        {
          bv = BLOCKVECTOR (s);
          block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
        {
          bv = BLOCKVECTOR (s);
          block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);


@@ -1045,19 +685,21 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
            }
        }
 
            }
        }
 

-      for (ps = partial_symtab_list; ps; ps = ps->next)
-       if (!ps->readin && lookup_demangled_partial_symbol (ps, name))
-         {
-           s = PSYMTAB_TO_SYMTAB(ps);
-           bv = BLOCKVECTOR (s);
-           block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-           sym = lookup_demangled_block_symbol (block, name);
-           if (!sym)
-             error ("Internal: mangled static symbol `%s' found in psymtab but not in symtab", name);
-           if (symtab != NULL)
-             *symtab = s;
-           return sym;
-         }
+      ALL_PSYMTABS (objfile, ps)
+       {
+         if (!ps->readin && lookup_demangled_partial_symbol (ps, name))
+           {
+             s = PSYMTAB_TO_SYMTAB(ps);
+             bv = BLOCKVECTOR (s);
+             block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+             sym = lookup_demangled_block_symbol (block, name);
+             if (!sym)
+               error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
+             if (symtab != NULL)
+               *symtab = s;
+             return sym;
+           }
+       }

     }
 
   if (symtab != NULL)
     }
 
   if (symtab != NULL)


@@ -1069,69 +711,65 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
 
 static struct symbol *
 lookup_demangled_block_symbol (block, name)
 
 static struct symbol *
 lookup_demangled_block_symbol (block, name)

-     register struct block *block;
-     char *name;
+     register const struct block *block;
+     const char *name;

 {
 {

-  register int bot, top, inc;
+  register int bot, top;

   register struct symbol *sym;
   register struct symbol *sym;

+  char *demangled;

 
   bot = 0;
   top = BLOCK_NSYMS (block);
 
   bot = 0;
   top = BLOCK_NSYMS (block);

-  inc = name[0];

 
   while (bot < top)
     {
       sym = BLOCK_SYM (block, bot);
 
   while (bot < top)
     {
       sym = BLOCK_SYM (block, bot);

-      if (SYMBOL_NAME (sym)[0] == inc
-         && SYMBOL_NAMESPACE (sym) == VAR_NAMESPACE)
+      if (SYMBOL_NAMESPACE (sym) == VAR_NAMESPACE)

        {
        {

-         char *demangled = cplus_demangle(SYMBOL_NAME (sym), -1);
+         demangled = demangle_and_match (SYMBOL_NAME (sym), name,
+                                         DMGL_PARAMS | DMGL_ANSI);

          if (demangled != NULL)
            {
          if (demangled != NULL)
            {

-             int cond = strcmp (demangled, name);

              free (demangled);
              free (demangled);

-             if (!cond)
-               return sym;
+             return (sym);

            }
        }
       bot++;
     }
 
            }
        }
       bot++;
     }
 

-  return 0;
+  return (NULL);

 }
 
 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
 
 static struct partial_symbol *
 lookup_demangled_partial_symbol (pst, name)
 }
 
 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
 
 static struct partial_symbol *
 lookup_demangled_partial_symbol (pst, name)

-     struct partial_symtab *pst;
-     char *name;
+     const struct partial_symtab *pst;
+     const char *name;

 {
   struct partial_symbol *start, *psym;
   int length = pst->n_static_syms;
 {
   struct partial_symbol *start, *psym;
   int length = pst->n_static_syms;

-  register int inc = name[0];
+  char *demangled;

 
   if (!length)
     return (struct partial_symbol *) 0;
   
 
   if (!length)
     return (struct partial_symbol *) 0;
   

-  start = static_psymbols.list + pst->statics_offset;
+  start = pst->objfile->static_psymbols.list + pst->statics_offset;

   for (psym = start; psym < start + length; psym++)
     {
   for (psym = start; psym < start + length; psym++)
     {

-      if (SYMBOL_NAME (psym)[0] == inc
-         && SYMBOL_NAMESPACE (psym) == VAR_NAMESPACE)
+      if (SYMBOL_NAMESPACE (psym) == VAR_NAMESPACE)

        {
        {

-         char *demangled = cplus_demangle(SYMBOL_NAME (psym), -1);
+         demangled = demangle_and_match (SYMBOL_NAME (psym), name,
+                                         DMGL_PARAMS | DMGL_ANSI);

          if (demangled != NULL)
            {
          if (demangled != NULL)
            {

-             int cond = strcmp (demangled, name);

              free (demangled);
              free (demangled);

-             if (!cond)
-               return psym;
+             return (psym);

            }
        }
     }
 
            }
        }
     }
 

-  return (struct partial_symbol *) 0;
+  return (NULL);

 }
 
 /* Look, in partial_symtab PST, for symbol NAME.  Check the global
 }
 
 /* Look, in partial_symtab PST, for symbol NAME.  Check the global


@@ -1140,7 +778,7 @@ lookup_demangled_partial_symbol (pst, name)
 static struct partial_symbol *
 lookup_partial_symbol (pst, name, global, namespace)
      struct partial_symtab *pst;
 static struct partial_symbol *
 lookup_partial_symbol (pst, name, global, namespace)
      struct partial_symtab *pst;

-     char *name;
+     const char *name;

      int global;
      enum namespace namespace;
 {
      int global;
      enum namespace namespace;
 {


@@ -1151,8 +789,8 @@ lookup_partial_symbol (pst, name, global, namespace)
     return (struct partial_symbol *) 0;
   
   start = (global ?
     return (struct partial_symbol *) 0;
   
   start = (global ?

-          global_psymbols.list + pst->globals_offset :
-          static_psymbols.list + pst->statics_offset  );
+          pst->objfile->global_psymbols.list + pst->globals_offset :
+          pst->objfile->static_psymbols.list + pst->statics_offset  );

 
   if (global)                  /* This means we can use a binary */
                                /* search.  */
 
   if (global)                  /* This means we can use a binary */
                                /* search.  */


@@ -1203,19 +841,25 @@ struct partial_symtab *
 find_main_psymtab ()
 {
   register struct partial_symtab *pst;
 find_main_psymtab ()
 {
   register struct partial_symtab *pst;

-  for (pst = partial_symtab_list; pst; pst = pst->next)
-    if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE))
-       return pst;
-  return NULL;
+  register struct objfile *objfile;
+
+  ALL_PSYMTABS (objfile, pst)
+    {
+      if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE))
+       {
+         return (pst);
+       }
+    }
+  return (NULL);

 }
 
 /* Look for a symbol in block BLOCK.  */
 
 struct symbol *
 lookup_block_symbol (block, name, namespace)
 }
 
 /* Look for a symbol in block BLOCK.  */
 
 struct symbol *
 lookup_block_symbol (block, name, namespace)

-     register struct block *block;
-     char *name;
-     enum namespace namespace;
+     register const struct block *block;
+     const char *name;
+     const enum namespace namespace;

 {
   register int bot, top, inc;
   register struct symbol *sym, *parameter_sym;
 {
   register int bot, top, inc;
   register struct symbol *sym, *parameter_sym;


@@ -1325,32 +969,36 @@ find_pc_symtab (pc)
 {
   register struct block *b;
   struct blockvector *bv;
 {
   register struct block *b;
   struct blockvector *bv;

-  register struct symtab *s;
+  register struct symtab *s = 0;

   register struct partial_symtab *ps;
   register struct partial_symtab *ps;

+  register struct objfile *objfile;

 
   /* Search all symtabs for one whose file contains our pc */
 
 
   /* Search all symtabs for one whose file contains our pc */
 

-  for (s = symtab_list; s; s = s->next)
+  ALL_SYMTABS (objfile, s)

     {
       bv = BLOCKVECTOR (s);
       b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
       if (BLOCK_START (b) <= pc
          && BLOCK_END (b) > pc)
     {
       bv = BLOCKVECTOR (s);
       b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
       if (BLOCK_START (b) <= pc
          && BLOCK_END (b) > pc)

-       break;
+       goto found;

     }
 
   if (!s)
     {
       ps = find_pc_psymtab (pc);
       if (ps && ps->readin)
     }
 
   if (!s)
     {
       ps = find_pc_psymtab (pc);
       if (ps && ps->readin)

-       printf_filtered (
-         "(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc);
-
+       {
+         printf_filtered ("(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc);
+       }

       if (ps)
       if (ps)

-       s = PSYMTAB_TO_SYMTAB (ps);
+       {
+         s = PSYMTAB_TO_SYMTAB (ps);
+       }

     }
 
     }
 

-  return s;
+found:
+  return (s);

 }
 
 /* Find the source file and line number for a given PC value.
 }
 
 /* Find the source file and line number for a given PC value.


@@ -1459,10 +1107,10 @@ find_pc_line (pc, notcurrent)
          best_pc = prev_pc;
          best_line = prev_line;
          best_symtab = s;
          best_pc = prev_pc;
          best_line = prev_line;
          best_symtab = s;

-         if (i < len)
+         /* If another line is in the linetable, and its PC is closer
+            than the best_end we currently have, take it as best_end.  */
+         if (i < len && (best_end == 0 || best_end > item->pc))

            best_end = item->pc;
            best_end = item->pc;

-         else
-           best_end = 0;

        }
       /* Is this file's first line closer than the first lines of other files?
         If so, record this file, and its first line, as best alternate.  */
        }
       /* Is this file's first line closer than the first lines of other files?
         If so, record this file, and its first line, as best alternate.  */


@@ -1486,9 +1134,12 @@ find_pc_line (pc, notcurrent)
       val.symtab = best_symtab;
       val.line = best_line;
       val.pc = best_pc;
       val.symtab = best_symtab;
       val.line = best_line;
       val.pc = best_pc;

-      val.end = (best_end ? best_end
-                  : (alt_pc ? alt_pc
-                     : BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))));
+      if (best_end && (alt_pc == 0 || best_end < alt_pc))
+       val.end = best_end;
+      else if (alt_pc)
+       val.end = alt_pc;
+      else
+       val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));

     }
   return val;
 }
     }
   return val;
 }


@@ -1634,14 +1285,24 @@ operator_chars (p, end)
 
   /* Don't get faked out by `operator' being part of a longer
      identifier.  */
 
   /* Don't get faked out by `operator' being part of a longer
      identifier.  */

-  if ((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z')
-      || *p == '_' || *p == '$' || *p == '\0')
+  if (isalpha(*p) || *p == '_' || *p == '$' || *p == '\0')

     return *end;
 
   /* Allow some whitespace between `operator' and the operator symbol.  */
   while (*p == ' ' || *p == '\t')
     p++;
 
     return *end;
 
   /* Allow some whitespace between `operator' and the operator symbol.  */
   while (*p == ' ' || *p == '\t')
     p++;
 

+  /* Recognize 'operator TYPENAME'. */
+
+  if (isalpha(*p) || *p == '_' || *p == '$')
+    {
+      register char *q = p+1;
+      while (isalnum(*q) || *q == '_' || *q == '$')
+       q++;
+      *end = q;
+      return p;
+    }
+

   switch (*p)
     {
     case '!':
   switch (*p)
     {
     case '!':


@@ -1703,7 +1364,7 @@ operator_chars (p, end)
  */
 
 int
  */
 
 int

-find_methods(t, name, physnames, sym_arr)
+find_methods (t, name, physnames, sym_arr)

      struct type *t;
      char *name;
      char **physnames;
      struct type *t;
      char *name;
      char **physnames;


@@ -1755,7 +1416,7 @@ find_methods(t, name, physnames, sym_arr)
                 --field_counter)
              {
                char *phys_name;
                 --field_counter)
              {
                char *phys_name;

-               if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f, field_counter)) & TYPE_FLAG_STUB)
+               if (TYPE_FN_FIELD_STUB (f, field_counter))

                  check_stub_method (t, method_counter, field_counter);
                phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
                physnames[i1] = (char*) alloca (strlen (phys_name) + 1);
                  check_stub_method (t, method_counter, field_counter);
                phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
                physnames[i1] = (char*) alloca (strlen (phys_name) + 1);


@@ -1766,6 +1427,12 @@ find_methods(t, name, physnames, sym_arr)
                                             (int *) NULL,
                                             (struct symtab **) NULL);
                if (sym_arr[i1]) i1++;
                                             (int *) NULL,
                                             (struct symtab **) NULL);
                if (sym_arr[i1]) i1++;

+               else
+                 {
+                   fputs_filtered("(Cannot find method ", stdout);
+                   fputs_demangled(phys_name, stdout, DMGL_PARAMS);
+                   fputs_filtered(" - possibly inlined.)\n", stdout);
+                 }

              }
        }
     }
              }
        }
     }


@@ -1795,7 +1462,7 @@ find_methods(t, name, physnames, sym_arr)
    FILE:FUNCTION -- likewise, but prefer functions in that file.
    *EXPR -- line in which address EXPR appears.
 
    FILE:FUNCTION -- likewise, but prefer functions in that file.
    *EXPR -- line in which address EXPR appears.
 

-   FUNCTION may be an undebuggable function found in misc_function_vector.
+   FUNCTION may be an undebuggable function found in minimal symbol table.

 
    If the argument FUNFIRSTLINE is nonzero, we want the first line
    of real code inside a function when a function is specified.
 
    If the argument FUNFIRSTLINE is nonzero, we want the first line
    of real code inside a function when a function is specified.


@@ -1816,7 +1483,6 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
      struct symtab *default_symtab;
      int default_line;
 {
      struct symtab *default_symtab;
      int default_line;
 {

-  struct symtabs_and_lines decode_line_2 ();

   struct symtabs_and_lines values;
   struct symtab_and_line val;
   register char *p, *p1;
   struct symtabs_and_lines values;
   struct symtab_and_line val;
   register char *p, *p1;


@@ -1828,13 +1494,16 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
   struct symtab *sym_symtab;
 
   register CORE_ADDR pc;
   struct symtab *sym_symtab;
 
   register CORE_ADDR pc;

-  register int i;
+  register struct minimal_symbol *msymbol;

   char *copy;
   struct symbol *sym_class;
   int i1;
   char *copy;
   struct symbol *sym_class;
   int i1;

+  int is_quoted;

   struct symbol **sym_arr;
   struct type *t;
   char **physnames;
   struct symbol **sym_arr;
   struct type *t;
   char **physnames;

+  char *saved_arg = *argptr;
+  extern char *gdb_completer_quote_characters;

   
   /* Defaults have defaults.  */
 
   
   /* Defaults have defaults.  */
 


@@ -1848,7 +1517,10 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
 
   if (**argptr == '*')
     {
 
   if (**argptr == '*')
     {

-      (*argptr)++;
+      if (**argptr == '*')
+       {
+         (*argptr)++;
+       }

       pc = parse_and_eval_address_1 (argptr);
       values.sals = (struct symtab_and_line *)
        xmalloc (sizeof (struct symtab_and_line));
       pc = parse_and_eval_address_1 (argptr);
       values.sals = (struct symtab_and_line *)
        xmalloc (sizeof (struct symtab_and_line));


@@ -1860,7 +1532,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
 
   /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
 
 
   /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
 

-  s = 0;
+  s = NULL;
+  is_quoted = (strchr (gdb_completer_quote_characters, **argptr) != NULL);

 
   for (p = *argptr; *p; p++)
     {
 
   for (p = *argptr; *p; p++)
     {


@@ -1869,7 +1542,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
     }
   while (p[0] == ' ' || p[0] == '\t') p++;
 
     }
   while (p[0] == ' ' || p[0] == '\t') p++;
 

-  if (p[0] == ':')
+  if ((p[0] == ':') && !is_quoted)

     {
 
       /*  C++  */
     {
 
       /*  C++  */


@@ -1879,7 +1552,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
          p1 = p;
          while (p != *argptr && p[-1] == ' ') --p;
          copy = (char *) alloca (p - *argptr + 1);
          p1 = p;
          while (p != *argptr && p[-1] == ' ') --p;
          copy = (char *) alloca (p - *argptr + 1);

-         bcopy (*argptr, copy, p - *argptr);
+         memcpy (copy, *argptr, p - *argptr);

          copy[p - *argptr] = 0;
 
          /* Discard the class name from the arg.  */
          copy[p - *argptr] = 0;
 
          /* Discard the class name from the arg.  */


@@ -1900,19 +1573,27 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
              while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p !=':') p++;
              q = operator_chars (*argptr, &q1);
 
              while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p !=':') p++;
              q = operator_chars (*argptr, &q1);
 

-             copy = (char *) alloca (p - *argptr + 1 + (q1 - q));

              if (q1 - q)
                {
              if (q1 - q)
                {

-                 copy[0] = 'o';
-                 copy[1] = 'p';
-                 copy[2] = CPLUS_MARKER;
-                 bcopy (q, copy + 3, q1 - q);
-                 copy[3 + (q1 - q)] = '\0';
+                 char *opname;
+                 char *tmp = alloca (q1 - q + 1);
+                 memcpy (tmp, q, q1 - q);
+                 tmp[q1 - q] = '\0';
+                 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
+                 if (opname == NULL)
+                   {
+                     warning ("no mangling for \"%s\"", tmp);
+                     cplusplus_hint (saved_arg);
+                     return_to_top_level ();
+                   }
+                 copy = (char*) alloca (3 + strlen(opname));
+                 sprintf (copy, "__%s", opname);

                  p = q1;
                }
              else
                {
                  p = q1;
                }
              else
                {

-                 bcopy (*argptr, copy, p - *argptr);
+                 copy = (char *) alloca (p - *argptr + 1 + (q1 - q));
+                 memcpy (copy, *argptr, p - *argptr);

                  copy[p - *argptr] = '\0';
                }
 
                  copy[p - *argptr] = '\0';
                }
 


@@ -1982,16 +1663,23 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
                  else
                    tmp = copy;
                  if (tmp[0] == '~')
                  else
                    tmp = copy;
                  if (tmp[0] == '~')

-                   error ("The class `%s' does not have destructor defined",
-                          sym_class->name);
+                   warning ("the class `%s' does not have destructor defined",
+                            sym_class->name);

                  else
                  else

-                   error ("The class %s does not have any method named %s",
-                          sym_class->name, tmp);
+                   warning ("the class %s does not have any method named %s",
+                            sym_class->name, tmp);
+                 cplusplus_hint (saved_arg);
+                 return_to_top_level ();

                }
            }
          else
                }
            }
          else

-           /* The quotes are important if copy is empty.  */
-           error("No class, struct, or union named \"%s\"", copy );
+           {
+             /* The quotes are important if copy is empty.  */
+             warning ("can't find class, struct, or union named \"%s\"",
+                      copy);
+             cplusplus_hint (saved_arg);
+             return_to_top_level ();
+           }

        }
       /*  end of C++  */
 
        }
       /*  end of C++  */
 


@@ -2000,14 +1688,14 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
       p1 = p;
       while (p != *argptr && p[-1] == ' ') --p;
       copy = (char *) alloca (p - *argptr + 1);
       p1 = p;
       while (p != *argptr && p[-1] == ' ') --p;
       copy = (char *) alloca (p - *argptr + 1);

-      bcopy (*argptr, copy, p - *argptr);
+      memcpy (copy, *argptr, p - *argptr);

       copy[p - *argptr] = 0;
 
       /* Find that file's data.  */
       s = lookup_symtab (copy);
       if (s == 0)
        {
       copy[p - *argptr] = 0;
 
       /* Find that file's data.  */
       s = lookup_symtab (copy);
       if (s == 0)
        {

-         if (symtab_list == 0 && partial_symtab_list == 0)
+         if (!have_full_symbols () && !have_partial_symbols ())

            error (no_symtab_msg);
          error ("No source file named %s.", copy);
        }
            error (no_symtab_msg);
          error ("No source file named %s.", copy);
        }


@@ -2084,11 +1772,22 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
 
   /* Arg token is not digits => try it as a variable name
      Find the next token (everything up to end or next whitespace).  */
 
   /* Arg token is not digits => try it as a variable name
      Find the next token (everything up to end or next whitespace).  */

-  p = *argptr;
-  while (*p && *p != ' ' && *p != '\t' && *p != ',') p++;
+
+  p = skip_quoted (*argptr);

   copy = (char *) alloca (p - *argptr + 1);
   copy = (char *) alloca (p - *argptr + 1);

-  bcopy (*argptr, copy, p - *argptr);
-  copy[p - *argptr] = 0;
+  memcpy (copy, *argptr, p - *argptr);
+  copy[p - *argptr] = '\0';
+  if ((copy[0] == copy [p - *argptr - 1])
+      && strchr (gdb_completer_quote_characters, copy[0]) != NULL)
+    {
+      char *temp;
+      copy [p - *argptr - 1] = '\0';
+      copy++;
+      if ((temp = expensive_mangler (copy)) != NULL)
+       {
+         copy = temp;
+       }
+    }

   while (*p == ' ' || *p == '\t') p++;
   *argptr = p;
 
   while (*p == ' ' || *p == '\t') p++;
   *argptr = p;
 


@@ -2113,7 +1812,16 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
          /* Convex: no need to suppress code on first line, if any */
          val.pc = pc;
 #else
          /* Convex: no need to suppress code on first line, if any */
          val.pc = pc;
 #else

-         val.pc = (val.end && val.pc != pc) ? val.end : pc;
+         /* If SKIP_PROLOGUE left us in mid-line, and the next line is still
+            part of the same function:
+               advance to next line, 
+               recalculate its line number (might not be N+1).  */
+         if (val.pc != pc && val.end &&
+             lookup_minimal_symbol_by_pc (pc) == lookup_minimal_symbol_by_pc (val.end)) {
+           pc = val.end;       /* First pc of next line */
+           val = find_pc_line (pc, 0);
+         }
+         val.pc = pc;

 #endif
          values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
          values.sals[0] = val;
 #endif
          values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
          values.sals[0] = val;


@@ -2134,7 +1842,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
          values.sals = (struct symtab_and_line *)
            xmalloc (sizeof (struct symtab_and_line));
          values.nelts = 1;
          values.sals = (struct symtab_and_line *)
            xmalloc (sizeof (struct symtab_and_line));
          values.nelts = 1;

-         bzero (&values.sals[0], sizeof (values.sals[0]));
+         memset (&values.sals[0], 0, sizeof (values.sals[0]));

          values.sals[0].symtab = sym_symtab;
          values.sals[0].line = SYMBOL_LINE (sym);
          return values;
          values.sals[0].symtab = sym_symtab;
          values.sals[0].line = SYMBOL_LINE (sym);
          return values;


@@ -2145,11 +1853,12 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
        error ("Line number not known for symbol \"%s\"", copy);
     }
 
        error ("Line number not known for symbol \"%s\"", copy);
     }
 

-  if ((i = lookup_misc_func (copy)) >= 0)
+  msymbol = lookup_minimal_symbol (copy, (struct objfile *) NULL);
+  if (msymbol != NULL)

     {
       val.symtab = 0;
       val.line = 0;
     {
       val.symtab = 0;
       val.line = 0;

-      val.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
+      val.pc = msymbol -> address + FUNCTION_START_OFFSET;

       if (funfirstline)
        SKIP_PROLOGUE (val.pc);
       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
       if (funfirstline)
        SKIP_PROLOGUE (val.pc);
       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));


@@ -2158,10 +1867,11 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line)
       return values;
     }
 
       return values;
     }
 

-  if (symtab_list == 0 && partial_symtab_list == 0 && misc_function_count == 0)
+  if (!have_full_symbols () &&
+      !have_partial_symbols () && !have_minimal_symbols ())

     error (no_symtab_msg);
 
     error (no_symtab_msg);
 

-  error ("Function %s not defined.", copy);
+  error ("Function \"%s\" not defined.", copy);

   return values;       /* for lint */
 }
 
   return values;       /* for lint */
 }
 


@@ -2183,7 +1893,7 @@ decode_line_spec (string, funfirstline)
 /* Given a list of NELTS symbols in sym_arr (with corresponding
    mangled names in physnames), return a list of lines to operate on
    (ask user if necessary).  */
 /* Given a list of NELTS symbols in sym_arr (with corresponding
    mangled names in physnames), return a list of lines to operate on
    (ask user if necessary).  */

-struct symtabs_and_lines
+static struct symtabs_and_lines

 decode_line_2 (sym_arr, nelts, funfirstline)
      struct symbol *sym_arr[];
      int nelts;
 decode_line_2 (sym_arr, nelts, funfirstline)
      struct symbol *sym_arr[];
      int nelts;


@@ -2191,9 +1901,10 @@ decode_line_2 (sym_arr, nelts, funfirstline)
 {
   struct symtabs_and_lines values, return_values;
   register CORE_ADDR pc;
 {
   struct symtabs_and_lines values, return_values;
   register CORE_ADDR pc;

-  char *args, *arg1, *command_line_input ();
+  char *args, *arg1;

   int i;
   char *prompt;
   int i;
   char *prompt;

+  char *demangled;

 
   values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
   return_values.sals = (struct symtab_and_line *) xmalloc (nelts * sizeof(struct symtab_and_line));
 
   values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
   return_values.sals = (struct symtab_and_line *) xmalloc (nelts * sizeof(struct symtab_and_line));


@@ -2212,8 +1923,15 @@ decode_line_2 (sym_arr, nelts, funfirstline)
          values.sals[i] = find_pc_line (pc, 0);
          values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
                               values.sals[i].end                      :  pc;
          values.sals[i] = find_pc_line (pc, 0);
          values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
                               values.sals[i].end                      :  pc;

-         printf("[%d] file:%s; line number:%d\n",
-                (i+2), values.sals[i].symtab->filename, values.sals[i].line);
+         demangled = cplus_demangle (SYMBOL_NAME (sym_arr[i]),
+                                     DMGL_PARAMS | DMGL_ANSI);
+         printf("[%d] %s at %s:%d\n", (i+2),
+                demangled ? demangled : SYMBOL_NAME (sym_arr[i]), 
+                values.sals[i].symtab->filename, values.sals[i].line);
+         if (demangled != NULL)
+           {
+             free (demangled);
+           }

        }
       else printf ("?HERE\n");
       i++;
        }
       else printf ("?HERE\n");
       i++;


@@ -2226,7 +1944,7 @@ decode_line_2 (sym_arr, nelts, funfirstline)
   printf("%s ",prompt);
   fflush(stdout);
 
   printf("%s ",prompt);
   fflush(stdout);
 

-  args = command_line_input (0, 0);
+  args = command_line_input ((char *) NULL, 0);

   
   if (args == 0)
     error_no_arg ("one or more choice numbers");
   
   if (args == 0)
     error_no_arg ("one or more choice numbers");


@@ -2247,7 +1965,8 @@ decode_line_2 (sym_arr, nelts, funfirstline)
        error ("cancelled");
       else if (num == 1)
        {
        error ("cancelled");
       else if (num == 1)
        {

-         bcopy (values.sals, return_values.sals, (nelts * sizeof(struct symtab_and_line)));
+         memcpy (return_values.sals, values.sals,
+                 (nelts * sizeof(struct symtab_and_line)));

          return_values.nelts = nelts;
          return return_values;
        }
          return_values.nelts = nelts;
          return return_values;
        }


@@ -2277,19 +1996,6 @@ decode_line_2 (sym_arr, nelts, funfirstline)
   return return_values;
 }
 
   return return_values;
 }
 

-/* Return the index of misc function named NAME.  */
-
-int
-lookup_misc_func (name)
-     register char *name;
-{
-  register int i;
-
-  for (i = 0; i < misc_function_count; i++)
-    if (!strcmp (misc_function_vector[i].name, name))
-      return i;
-  return -1;           /* not found */
-}

 \f
 /* Slave routine for sources_info.  Force line breaks at ,'s.
    NAME is the name to print and *FIRST is nonzero if this is the first
 \f
 /* Slave routine for sources_info.  Force line breaks at ,'s.
    NAME is the name to print and *FIRST is nonzero if this is the first


@@ -2299,7 +2005,6 @@ output_source_filename (name, first)
      char *name;
      int *first;
 {
      char *name;
      int *first;
 {

-  static int column;

   /* Table of files printed so far.  Since a single source file can
      result in several partial symbol tables, we need to avoid printing
      it more than once.  Note: if some of the psymtabs are read in and
   /* Table of files printed so far.  Since a single source file can
      result in several partial symbol tables, we need to avoid printing
      it more than once.  Note: if some of the psymtabs are read in and


@@ -2334,66 +2039,78 @@ output_source_filename (name, first)
   if (tab_cur_size == tab_alloc_size)
     {
       tab_alloc_size *= 2;
   if (tab_cur_size == tab_alloc_size)
     {
       tab_alloc_size *= 2;

-      tab = (char **) xrealloc (tab, tab_alloc_size * sizeof (*tab));
+      tab = (char **) xrealloc ((char *) tab, tab_alloc_size * sizeof (*tab));

     }
   tab[tab_cur_size++] = name;
 
   if (*first)
     {
     }
   tab[tab_cur_size++] = name;
 
   if (*first)
     {

-      column = 0;

       *first = 0;
     }
   else
     {
       *first = 0;
     }
   else
     {

-      printf_filtered (",");
-      column++;
+      printf_filtered (", ");

     }
 
     }
 

-  if (column != 0 && column + strlen (name) >= 70)
-    {
-      printf_filtered ("\n");
-      column = 0;
-    }
-  else if (column != 0)
-    {
-      printf_filtered (" ");
-      column++;
-    }
+  wrap_here ("");

   fputs_filtered (name, stdout);
   fputs_filtered (name, stdout);

-  column += strlen (name);

 }  
 
 static void
 }  
 
 static void

-sources_info ()
+sources_info (ignore, from_tty)
+     char *ignore;
+     int from_tty;

 {
   register struct symtab *s;
   register struct partial_symtab *ps;
 {
   register struct symtab *s;
   register struct partial_symtab *ps;

+  register struct objfile *objfile;

   int first;
   
   int first;
   

-  if (symtab_list == 0 && partial_symtab_list == 0)
+  if (!have_full_symbols () && !have_partial_symbols ())

     {
     {

-      printf (no_symtab_msg);
-      return;
+      error (no_symtab_msg);

     }
   
   printf_filtered ("Source files for which symbols have been read in:\n\n");
 
   first = 1;
     }
   
   printf_filtered ("Source files for which symbols have been read in:\n\n");
 
   first = 1;

-  for (s = symtab_list; s; s = s->next)
-    output_source_filename (s->filename, &first);
+  ALL_SYMTABS (objfile, s)
+    {
+      output_source_filename (s -> filename, &first);
+    }

   printf_filtered ("\n\n");
   
   printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
 
   first = 1;
   printf_filtered ("\n\n");
   
   printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
 
   first = 1;

-  for (ps = partial_symtab_list; ps; ps = ps->next)
-    if (!ps->readin)
-      output_source_filename (ps->filename, &first);
+  ALL_PSYMTABS (objfile, ps)
+    {
+      if (!ps->readin)
+       {
+         output_source_filename (ps -> filename, &first);
+       }
+    }

   printf_filtered ("\n");
 }
 
   printf_filtered ("\n");
 }
 

+static int
+name_match (name)
+     char *name;
+{
+  char *demangled = cplus_demangle (name, DMGL_ANSI);
+  if (demangled != NULL)
+    {
+      int cond = re_exec (demangled);
+      free (demangled);
+      return (cond);
+    }
+  return (re_exec (name));
+}
+#define NAME_MATCH(NAME) name_match(NAME)
+

 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.

-   If CLASS is zero, list all symbols except functions and type names.
+   If CLASS is zero, list all symbols except functions, type names, and
+                    constants (enums).

    If CLASS is 1, list only functions.
    If CLASS is 2, list only type names.
    If CLASS is 3, list only method names.
    If CLASS is 1, list only functions.
    If CLASS is 2, list only type names.
    If CLASS is 3, list only method names.


@@ -2415,46 +2132,81 @@ list_symbols (regexp, class, bpt)
   register int i, j;
   register struct symbol *sym;
   struct partial_symbol *psym;
   register int i, j;
   register struct symbol *sym;
   struct partial_symbol *psym;

+  struct objfile *objfile;
+  struct minimal_symbol *msymbol;

   char *val;
   static char *classnames[]
     = {"variable", "function", "type", "method"};
   int found_in_file = 0;
   int found_misc = 0;
   char *val;
   static char *classnames[]
     = {"variable", "function", "type", "method"};
   int found_in_file = 0;
   int found_misc = 0;

-  static enum misc_function_type types[]
-    = {mf_data, mf_text, mf_abs, mf_unknown};
-  static enum misc_function_type types2[]
-    = {mf_bss,  mf_text, mf_abs, mf_unknown};
-  enum misc_function_type ourtype = types[class];
-  enum misc_function_type ourtype2 = types2[class];
+  static enum minimal_symbol_type types[]
+    = {mst_data, mst_text, mst_abs, mst_unknown};
+  static enum minimal_symbol_type types2[]
+    = {mst_bss,  mst_text, mst_abs, mst_unknown};
+  enum minimal_symbol_type ourtype = types[class];
+  enum minimal_symbol_type ourtype2 = types2[class];

 
   if (regexp)
 
   if (regexp)

-    if (0 != (val = re_comp (regexp)))
-      error ("Invalid regexp (%s): %s", val, regexp);
+    {
+      /* Make sure spacing is right for C++ operators.
+        This is just a courtesy to make the matching less sensitive
+        to how many spaces the user leaves between 'operator'
+        and <TYPENAME> or <OPERATOR>. */
+      char *opend;
+      char *opname = operator_chars (regexp, &opend);
+      if (*opname)
+       {
+          int fix = -1; /* -1 means ok; otherwise number of spaces needed. */
+         if (isalpha(*opname) || *opname == '_' || *opname == '$')
+           {
+             /* There should 1 space between 'operator' and 'TYPENAME'. */
+             if (opname[-1] != ' ' || opname[-2] == ' ')
+               fix = 1;
+           }
+         else
+           {
+             /* There should 0 spaces between 'operator' and 'OPERATOR'. */
+             if (opname[-1] == ' ')
+               fix = 0;
+           }
+         /* If wrong number of spaces, fix it. */
+         if (fix >= 0)
+           {
+             char *tmp = (char*) alloca(opend-opname+10);
+             sprintf(tmp, "operator%.*s%s", fix, " ", opname);
+             regexp = tmp;
+           }
+        }
+      
+      if (0 != (val = re_comp (regexp)))
+       error ("Invalid regexp (%s): %s", val, regexp);
+    }

 
 

-  /* Search through the partial_symtab_list *first* for all symbols
+  /* Search through the partial symtabs *first* for all symbols

      matching the regexp.  That way we don't have to reproduce all of
      the machinery below. */
      matching the regexp.  That way we don't have to reproduce all of
      the machinery below. */

-  for (ps = partial_symtab_list; ps; ps = ps->next)
+
+  ALL_PSYMTABS (objfile, ps)

     {
       struct partial_symbol *bound, *gbound, *sbound;
       int keep_going = 1;
     {
       struct partial_symbol *bound, *gbound, *sbound;
       int keep_going = 1;

-
+      

       if (ps->readin) continue;
       
       if (ps->readin) continue;
       

-      gbound = global_psymbols.list + ps->globals_offset + ps->n_global_syms;
-      sbound = static_psymbols.list + ps->statics_offset + ps->n_static_syms;
+      gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
+      sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;

       bound = gbound;
       bound = gbound;

-
+      

       /* Go through all of the symbols stored in a partial
         symtab in one loop. */
       /* Go through all of the symbols stored in a partial
         symtab in one loop. */

-      psym = global_psymbols.list + ps->globals_offset;
+      psym = objfile->global_psymbols.list + ps->globals_offset;

       while (keep_going)
        {
          if (psym >= bound)
            {
              if (bound == gbound && ps->n_static_syms != 0)
                {
       while (keep_going)
        {
          if (psym >= bound)
            {
              if (bound == gbound && ps->n_static_syms != 0)
                {

-                 psym = static_psymbols.list + ps->statics_offset;
+                 psym = objfile->static_psymbols.list + ps->statics_offset;

                  bound = sbound;
                }
              else
                  bound = sbound;
                }
              else


@@ -2467,14 +2219,14 @@ list_symbols (regexp, class, bpt)
 
              /* If it would match (logic taken from loop below)
                 load the file and go on to the next one */
 
              /* If it would match (logic taken from loop below)
                 load the file and go on to the next one */

-             if ((regexp == 0 || re_exec (SYMBOL_NAME (psym)))
+             if ((regexp == 0 || NAME_MATCH (SYMBOL_NAME (psym)))

                  && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF
                  && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF

-                                 && SYMBOL_CLASS (psym) != LOC_BLOCK)
+                      && SYMBOL_CLASS (psym) != LOC_BLOCK)

                      || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK)
                      || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF)
                      || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK)))
                {
                      || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK)
                      || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF)
                      || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK)))
                {

-                 (void) PSYMTAB_TO_SYMTAB(ps);
+                 PSYMTAB_TO_SYMTAB(ps);

                  keep_going = 0;
                }
            }
                  keep_going = 0;
                }
            }


@@ -2482,23 +2234,28 @@ list_symbols (regexp, class, bpt)
        }
     }
 
        }
     }
 

-  /* Here, we search through the misc function vector for functions that
+  /* Here, we search through the minimal symbol tables for functions that

      match, and call find_pc_symtab on them to force their symbols to
      be read.  The symbol will then be found during the scan of symtabs
      below.  If find_pc_symtab fails, set found_misc so that we will
      rescan to print any matching symbols without debug info.  */
 
      match, and call find_pc_symtab on them to force their symbols to
      be read.  The symbol will then be found during the scan of symtabs
      below.  If find_pc_symtab fails, set found_misc so that we will
      rescan to print any matching symbols without debug info.  */
 

-  if (class == 1) {
-    for (i = 0; i < misc_function_count; i++) {
-      if (misc_function_vector[i].type != ourtype
-       && misc_function_vector[i].type != ourtype2)
-       continue;
-      if (regexp == 0 || re_exec (misc_function_vector[i].name)) {
-         if (0 == find_pc_symtab (misc_function_vector[i].address))
-           found_misc = 1;
-      }
+  if (class == 1)
+    {
+      ALL_MSYMBOLS (objfile, msymbol)
+       {
+         if (msymbol -> type == ourtype || msymbol -> type == ourtype2)
+           {
+             if (regexp == 0 || NAME_MATCH (msymbol -> name))
+               {
+                 if (0 == find_pc_symtab (msymbol -> address))
+                   {
+                     found_misc = 1;
+                   }
+               }
+           }
+       }

     }
     }

-  }

 
   /* Printout here so as to get after the "Reading in symbols"
      messages which will be generated above.  */
 
   /* Printout here so as to get after the "Reading in symbols"
      messages which will be generated above.  */


@@ -2509,7 +2266,7 @@ list_symbols (regexp, class, bpt)
          classnames[class],
          regexp);
 
          classnames[class],
          regexp);
 

-  for (s = symtab_list; s; s = s->next)
+  ALL_SYMTABS (objfile, s)

     {
       found_in_file = 0;
       bv = BLOCKVECTOR (s);
     {
       found_in_file = 0;
       bv = BLOCKVECTOR (s);


@@ -2529,9 +2286,10 @@ list_symbols (regexp, class, bpt)
              {
                QUIT;
                sym = BLOCK_SYM (b, j);
              {
                QUIT;
                sym = BLOCK_SYM (b, j);

-               if ((regexp == 0 || re_exec (SYMBOL_NAME (sym)))
+               if ((regexp == 0 || NAME_MATCH (SYMBOL_NAME (sym)))

                    && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
                    && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF

-                                   && SYMBOL_CLASS (sym) != LOC_BLOCK)
+                        && SYMBOL_CLASS (sym) != LOC_BLOCK
+                        && SYMBOL_CLASS (sym) != LOC_CONST)

                        || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
                        || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
                        || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))
                        || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
                        || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
                        || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))


@@ -2549,29 +2307,30 @@ list_symbols (regexp, class, bpt)
                        fputs_filtered (":\n", stdout);
                      }
                    found_in_file = 1;
                        fputs_filtered (":\n", stdout);
                      }
                    found_in_file = 1;

-
+                   

                    if (class != 2 && i == STATIC_BLOCK)
                      printf_filtered ("static ");
                    if (class != 2 && i == STATIC_BLOCK)
                      printf_filtered ("static ");

-
+                   

                    /* Typedef that is not a C++ class */
                    if (class == 2
                        && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
                    /* Typedef that is not a C++ class */
                    if (class == 2
                        && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)

-                      typedef_print (SYMBOL_TYPE(sym), sym, stdout);
+                     typedef_print (SYMBOL_TYPE(sym), sym, stdout);

                    /* variable, func, or typedef-that-is-c++-class */
                    else if (class < 2 || 
                             (class == 2 && 
                    /* variable, func, or typedef-that-is-c++-class */
                    else if (class < 2 || 
                             (class == 2 && 

-                               SYMBOL_NAMESPACE(sym) == STRUCT_NAMESPACE))
+                             SYMBOL_NAMESPACE(sym) == STRUCT_NAMESPACE))

                      {
                      {

-                        type_print (SYMBOL_TYPE (sym),
-                                    (SYMBOL_CLASS (sym) == LOC_TYPEDEF
-                                     ? "" : SYMBOL_NAME (sym)),
-                                    stdout, 0);
-                        
-                        printf_filtered (";\n");
+                       type_print (SYMBOL_TYPE (sym),
+                                   (SYMBOL_CLASS (sym) == LOC_TYPEDEF
+                                    ? "" : SYMBOL_NAME (sym)),
+                                   stdout, 0);
+                       
+                       printf_filtered (";\n");

                      }
                    else
                      {
 # if 0
                      }
                    else
                      {
 # if 0

+/* FIXME, why is this zapped out? */

                        char buf[1024];
                        type_print_base (TYPE_FN_FIELD_TYPE(t, i), stdout, 0, 0); 
                        type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i), stdout, 0); 
                        char buf[1024];
                        type_print_base (TYPE_FN_FIELD_TYPE(t, i), stdout, 0, 0); 
                        type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i), stdout, 0); 


@@ -2585,54 +2344,63 @@ list_symbols (regexp, class, bpt)
       prev_bv = bv;
     }
 
       prev_bv = bv;
     }
 

-

   /* If there are no eyes, avoid all contact.  I mean, if there are
   /* If there are no eyes, avoid all contact.  I mean, if there are

-     no debug symbols, then print directly from the misc_function_vector.  */
-
-  if (found_misc || class != 1) {
-    found_in_file = 0;
-    for (i = 0; i < misc_function_count; i++) {
-      if (misc_function_vector[i].type != ourtype
-       && misc_function_vector[i].type != ourtype2)
-       continue;
-      if (regexp == 0 || re_exec (misc_function_vector[i].name)) {
-       /* Functions:  Look up by address. */
-       if (class == 1)
-         if (0 != find_pc_symtab (misc_function_vector[i].address))
-           continue;
-       /* Variables/Absolutes:  Look up by name */
-       if (0 != lookup_symbol (misc_function_vector[i].name, 
-               (struct block *)0, VAR_NAMESPACE, 0, (struct symtab **)0))
-         continue;
-       if (!found_in_file) {
-         printf_filtered ("\nNon-debugging symbols:\n");
-         found_in_file = 1;
+     no debug symbols, then print directly from the msymbol_vector.  */
+
+  if (found_misc || class != 1)
+    {
+      found_in_file = 0;
+      ALL_MSYMBOLS (objfile, msymbol)
+       {
+         if (msymbol -> type == ourtype || msymbol -> type == ourtype2)
+           {
+             if (regexp == 0 || NAME_MATCH (msymbol -> name))
+               {
+                 /* Functions:  Look up by address. */
+                 if (class != 1 ||
+                     (0 == find_pc_symtab (msymbol -> address)))
+                   {
+                     /* Variables/Absolutes:  Look up by name */
+                     if (lookup_symbol (msymbol -> name, 
+                                        (struct block *) 0, VAR_NAMESPACE, 0,
+                                        (struct symtab **) 0) == NULL)
+                       {
+                         if (!found_in_file)
+                           {
+                             printf_filtered ("\nNon-debugging symbols:\n");
+                             found_in_file = 1;
+                           }
+                         printf_filtered ("    %08x  %s\n",
+                                          msymbol -> address,
+                                          msymbol -> name);
+                       }
+                   }
+               }
+           }

        }
        }

-       printf_filtered ("      %08x  %s\n",
-             misc_function_vector[i].address,
-             misc_function_vector[i].name);
-      }

     }
     }

-  }

 }
 
 static void
 }
 
 static void

-variables_info (regexp)
+variables_info (regexp, from_tty)

      char *regexp;
      char *regexp;

+     int from_tty;

 {
   list_symbols (regexp, 0, 0);
 }
 
 static void
 {
   list_symbols (regexp, 0, 0);
 }
 
 static void

-functions_info (regexp)
+functions_info (regexp, from_tty)

      char *regexp;
      char *regexp;

+     int from_tty;

 {
   list_symbols (regexp, 1, 0);
 }
 
 static void
 {
   list_symbols (regexp, 1, 0);
 }
 
 static void

-types_info (regexp)
+types_info (regexp, from_tty)

      char *regexp;
      char *regexp;

+     int from_tty;

 {
   list_symbols (regexp, 2, 0);
 }
 {
   list_symbols (regexp, 2, 0);
 }


@@ -2649,41 +2417,13 @@ methods_info (regexp)
 
 /* Breakpoint all functions matching regular expression. */
 static void
 
 /* Breakpoint all functions matching regular expression. */
 static void

-rbreak_command (regexp)
+rbreak_command (regexp, from_tty)

      char *regexp;
      char *regexp;

+     int from_tty;

 {
   list_symbols (regexp, 1, 1);
 }
 \f
 {
   list_symbols (regexp, 1, 1);
 }
 \f

-/* Helper function to initialize the standard scalar types.  */
-
-struct type *
-init_type (code, length, uns, name)
-     enum type_code code;
-     int length, uns;
-     char *name;
-{
-  register struct type *type;
-
-  type = (struct type *) xmalloc (sizeof (struct type));
-  bzero (type, sizeof *type);
-  TYPE_CODE (type) = code;
-  TYPE_LENGTH (type) = length;
-  TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0;
-  TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
-  TYPE_NFIELDS (type) = 0;
-  TYPE_NAME (type) = name;
-
-  /* C++ fancies.  */
-  if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
-    {
-      TYPE_CPLUS_SPECIFIC (type)
-       = (struct cplus_struct_type *) xmalloc (sizeof (struct cplus_struct_type));
-      TYPE_NFN_FIELDS (type) = 0;
-      TYPE_N_BASECLASSES (type) = 0;
-    }
-  return type;
-}

 
 /* Return Nonzero if block a is lexically nested within block b,
    or if a and b have the same pc range.
 
 /* Return Nonzero if block a is lexically nested within block b,
    or if a and b have the same pc range.


@@ -2701,93 +2441,276 @@ contained_in (a, b)
 \f
 /* Helper routine for make_symbol_completion_list.  */
 
 \f
 /* Helper routine for make_symbol_completion_list.  */
 

-int return_val_size, return_val_index;
-char **return_val;
+static int return_val_size;
+static int return_val_index;
+static char **return_val;

 
 

-void
-completion_list_add_symbol (symname)
+/*  Test to see if the symbol specified by SYMNAME (or it's demangled
+    equivalent) matches TEXT in the first TEXT_LEN characters.  If so,
+    add it to the current completion list. */
+
+static void
+completion_list_add_symbol (symname, text, text_len)

      char *symname;
      char *symname;

+     char *text;
+     int text_len;

 {
 {

-  if (return_val_index + 3 > return_val_size)
-    return_val =
-      (char **)xrealloc (return_val,
-                        (return_val_size *= 2) * sizeof (char *));
-  
-  return_val[return_val_index] =
-    (char *)xmalloc (1 + strlen (symname));
-  
-  strcpy (return_val[return_val_index], symname);
+  char *demangled;
+  int newsize;
+  int i;
+
+  /* clip symbols that cannot match */
+
+  if (!cplus_match (symname, text, text_len)) {
+    return;
+  }
+
+  /* matches mangled, may match unmangled.  now clip any symbol names
+     that we've already considered.  (This is a time optimization)  */
+
+  for (i = 0; i < return_val_index; ++i) {
+    if (strcmp (symname, return_val[i]) == 0) {
+      return;
+    }
+  }

   
   

-  return_val[++return_val_index] = (char *)NULL;
+  /* See if SYMNAME is a C++ mangled name, and if so, use the
+     demangled name instead, including any parameters.  */
+
+  if ((demangled = cplus_demangle (symname, DMGL_PARAMS | DMGL_ANSI)) != NULL)
+    {
+      if (strncmp (demangled, text, text_len) != 0) {
+       return;
+      }        /* demangled, but didn't match so clip it */
+
+      symname = demangled;
+    } else {
+      symname = savestring (symname, strlen (symname));
+    }
+
+  /* If we have a match for a completion, then add SYMNAME to the current
+     list of matches. Note that the name is in freshly malloc'd space;
+     either from cplus_demangle or from savestring above.  */
+
+  if (return_val_index + 3 > return_val_size)
+    {
+      newsize = (return_val_size *= 2) * sizeof (char *);
+      return_val = (char **) xrealloc ((char *) return_val, newsize);
+    }
+  return_val[return_val_index++] = symname;
+  return_val[return_val_index] = NULL;
+
+  return;

 }
 
 /* Return a NULL terminated array of all symbols (regardless of class) which
    begin by matching TEXT.  If the answer is no symbols, then the return value
    is an array which contains only a NULL pointer.
 
 }
 
 /* Return a NULL terminated array of all symbols (regardless of class) which
    begin by matching TEXT.  If the answer is no symbols, then the return value
    is an array which contains only a NULL pointer.
 

-   Problem: All of the symbols have to be copied because readline
-   frees them.  I'm not going to worry about this; hopefully there
-   won't be that many.  */
+   Problem: All of the symbols have to be copied because readline frees them.
+   I'm not going to worry about this; hopefully there won't be that many.  */

 
 char **
 make_symbol_completion_list (text)
   char *text;
 {
 
 char **
 make_symbol_completion_list (text)
   char *text;
 {

+  register struct symbol *sym;

   register struct symtab *s;
   register struct partial_symtab *ps;
   register struct symtab *s;
   register struct partial_symtab *ps;

+  register struct minimal_symbol *msymbol;
+  register struct objfile *objfile;

   register struct block *b, *surrounding_static_block = 0;
   register struct block *b, *surrounding_static_block = 0;

-  extern struct block *get_selected_block ();

   register int i, j;
   register int i, j;

+  int text_len;

   struct partial_symbol *psym;
 
   struct partial_symbol *psym;
 

-  int text_len = strlen (text);
+  text_len = strlen (text);

   return_val_size = 100;
   return_val_index = 0;
   return_val_size = 100;
   return_val_index = 0;

-  return_val =
-    (char **)xmalloc ((1 + return_val_size) *sizeof (char *));
-  return_val[0] = (char *)NULL;
+  return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
+  return_val[0] = NULL;

 
   /* Look through the partial symtabs for all symbols which begin
      by matching TEXT.  Add each one that you find to the list.  */
 
 
   /* Look through the partial symtabs for all symbols which begin
      by matching TEXT.  Add each one that you find to the list.  */
 

-  for (ps = partial_symtab_list; ps; ps = ps->next)
+  ALL_PSYMTABS (objfile, ps)

     {
       /* If the psymtab's been read in we'll get it when we search
         through the blockvector.  */
       if (ps->readin) continue;
     {
       /* If the psymtab's been read in we'll get it when we search
         through the blockvector.  */
       if (ps->readin) continue;

-
-      for (psym = global_psymbols.list + ps->globals_offset;
-          psym < (global_psymbols.list + ps->globals_offset
+      
+      for (psym = objfile->global_psymbols.list + ps->globals_offset;
+          psym < (objfile->global_psymbols.list + ps->globals_offset

                   + ps->n_global_syms);
           psym++)
        {
                   + ps->n_global_syms);
           psym++)
        {

-         QUIT;                 /* If interrupted, then quit. */
-         if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0))
-           completion_list_add_symbol (SYMBOL_NAME (psym));
+         /* If interrupted, then quit. */
+         QUIT;
+         completion_list_add_symbol (SYMBOL_NAME (psym), text, text_len);

        }
       
        }
       

-      for (psym = static_psymbols.list + ps->statics_offset;
-          psym < (static_psymbols.list + ps->statics_offset
+      for (psym = objfile->static_psymbols.list + ps->statics_offset;
+          psym < (objfile->static_psymbols.list + ps->statics_offset

                   + ps->n_static_syms);
           psym++)
        {
          QUIT;
                   + ps->n_static_syms);
           psym++)
        {
          QUIT;

-         if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0))
-           completion_list_add_symbol (SYMBOL_NAME (psym));
+         completion_list_add_symbol (SYMBOL_NAME (psym), text, text_len);

        }
     }
 
        }
     }
 

-  /* At this point scan through the misc function vector and add each
+  /* At this point scan through the misc symbol vectors and add each

      symbol you find to the list.  Eventually we want to ignore
      anything that isn't a text symbol (everything else will be
      handled by the psymtab code above).  */
 
      symbol you find to the list.  Eventually we want to ignore
      anything that isn't a text symbol (everything else will be
      handled by the psymtab code above).  */
 

-  for (i = 0; i < misc_function_count; i++)
-    if (!strncmp (text, misc_function_vector[i].name, text_len))
-      completion_list_add_symbol (misc_function_vector[i].name);
+  ALL_MSYMBOLS (objfile, msymbol)
+    {
+      QUIT;
+      completion_list_add_symbol (msymbol -> name, text, text_len);
+    }

 
   /* Search upwards from currently selected frame (so that we can
      complete on local vars.  */
 
   /* Search upwards from currently selected frame (so that we can
      complete on local vars.  */

+
+  for (b = get_selected_block (); b != NULL; b = BLOCK_SUPERBLOCK (b))
+    {
+      if (!BLOCK_SUPERBLOCK (b))
+       {
+         surrounding_static_block = b;         /* For elmin of dups */
+       }
+      
+      /* Also catch fields of types defined in this places which match our
+        text string.  Only complete on types visible from current context. */
+
+      for (i = 0; i < BLOCK_NSYMS (b); i++)
+       {
+         sym = BLOCK_SYM (b, i);
+         completion_list_add_symbol (SYMBOL_NAME (sym), text, text_len);
+         if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+           {
+             struct type *t = SYMBOL_TYPE (sym);
+             enum type_code c = TYPE_CODE (t);
+
+             if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
+               {
+                 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
+                   {
+                     if (TYPE_FIELD_NAME (t, j))
+                       {
+                         completion_list_add_symbol (TYPE_FIELD_NAME (t, j),
+                                                     text, text_len);
+                       }
+                   }
+               }
+           }
+       }
+    }
+
+  /* Go through the symtabs and check the externs and statics for
+     symbols which match.  */
+
+  ALL_SYMTABS (objfile, s)
+    {
+      QUIT;
+      b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
+      for (i = 0; i < BLOCK_NSYMS (b); i++)
+       {
+         sym = BLOCK_SYM (b, i);
+         completion_list_add_symbol (SYMBOL_NAME (sym), text, text_len);
+       }
+    }
+
+  ALL_SYMTABS (objfile, s)
+    {
+      QUIT;
+      b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
+      /* Don't do this block twice.  */
+      if (b == surrounding_static_block) continue;
+      for (i = 0; i < BLOCK_NSYMS (b); i++)
+       {
+         sym = BLOCK_SYM (b, i);
+         completion_list_add_symbol (SYMBOL_NAME (sym), text, text_len);
+       }
+    }
+
+  return (return_val);
+}
+
+\f
+/* Find a mangled symbol that corresponds to LOOKFOR using brute force.
+   Basically we go munging through available symbols, demangling each one,
+   looking for a match on the demangled result. */
+
+static char *
+expensive_mangler (lookfor)
+     const char *lookfor;
+{
+  register struct symbol *sym;
+  register struct symtab *s;
+  register struct partial_symtab *ps;
+  register struct minimal_symbol *msymbol;
+  register struct objfile *objfile;
+  register struct block *b, *surrounding_static_block = 0;
+  register int i, j;
+  struct partial_symbol *psym;
+  char *demangled;
+
+  /* Look through the partial symtabs for a symbol that matches */
+
+  ALL_PSYMTABS (objfile, ps)
+    {
+      /* If the psymtab's been read in we'll get it when we search
+        through the blockvector.  */
+      if (ps->readin) continue;
+      
+      for (psym = objfile->global_psymbols.list + ps->globals_offset;
+          psym < (objfile->global_psymbols.list + ps->globals_offset
+                  + ps->n_global_syms);
+          psym++)
+       {
+         QUIT;                 /* If interrupted, then quit. */
+         demangled = demangle_and_match (SYMBOL_NAME (psym), lookfor,
+                                         DMGL_PARAMS | DMGL_ANSI);
+         if (demangled != NULL)
+           {
+             free (demangled);
+             return (SYMBOL_NAME (psym));
+           }
+       }
+      
+      for (psym = objfile->static_psymbols.list + ps->statics_offset;
+          psym < (objfile->static_psymbols.list + ps->statics_offset
+                  + ps->n_static_syms);
+          psym++)
+       {
+         QUIT;
+         demangled = demangle_and_match (SYMBOL_NAME (psym), lookfor,
+                                         DMGL_PARAMS | DMGL_ANSI);
+         if (demangled != NULL)
+           {
+             free (demangled);
+             return (SYMBOL_NAME (psym));
+           }
+       }
+    }
+
+  /* Scan through the misc symbol vectors looking for a match. */
+
+  ALL_MSYMBOLS (objfile, msymbol)
+    {
+      QUIT;
+      demangled = demangle_and_match (msymbol -> name, lookfor,
+                                     DMGL_PARAMS | DMGL_ANSI);
+      if (demangled != NULL)
+       {
+         free (demangled);
+         return (msymbol -> name);
+       }
+    }
+
+  /* Search upwards from currently selected frame looking for a match */
+

   for (b = get_selected_block (); b; b = BLOCK_SUPERBLOCK (b))
     {
       if (!BLOCK_SUPERBLOCK (b))
   for (b = get_selected_block (); b; b = BLOCK_SUPERBLOCK (b))
     {
       if (!BLOCK_SUPERBLOCK (b))


@@ -2798,21 +2721,37 @@ make_symbol_completion_list (text)
         from current context.  */
       for (i = 0; i < BLOCK_NSYMS (b); i++)
        {
         from current context.  */
       for (i = 0; i < BLOCK_NSYMS (b); i++)
        {

-         register struct symbol *sym = BLOCK_SYM (b, i);
-         
-         if (!strncmp (SYMBOL_NAME (sym), text, text_len))
-           completion_list_add_symbol (SYMBOL_NAME (sym));
-
+         sym = BLOCK_SYM (b, i);
+         demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
+                                         DMGL_PARAMS | DMGL_ANSI);
+         if (demangled != NULL)
+           {
+             free (demangled);
+             return (SYMBOL_NAME (sym));
+           }

          if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
            {
              struct type *t = SYMBOL_TYPE (sym);
              enum type_code c = TYPE_CODE (t);
 
              if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
          if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
            {
              struct type *t = SYMBOL_TYPE (sym);
              enum type_code c = TYPE_CODE (t);
 
              if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)

-               for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
-                 if (TYPE_FIELD_NAME (t, j) &&
-                     !strncmp (TYPE_FIELD_NAME (t, j), text, text_len))
-                   completion_list_add_symbol (TYPE_FIELD_NAME (t, j));
+               {
+                 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
+                   {
+                     if (TYPE_FIELD_NAME (t, j))
+                       {
+                         demangled =
+                           demangle_and_match (TYPE_FIELD_NAME (t, j),
+                                               lookfor,
+                                               DMGL_PARAMS | DMGL_ANSI);
+                         if (demangled != NULL)
+                           {
+                             free (demangled);
+                             return (TYPE_FIELD_NAME (t, j));
+                           }
+                       }
+                   }
+               }

            }
        }
     }
            }
        }
     }


@@ -2820,29 +2759,45 @@ make_symbol_completion_list (text)
   /* Go through the symtabs and check the externs and statics for
      symbols which match.  */
 
   /* Go through the symtabs and check the externs and statics for
      symbols which match.  */
 

-  for (s = symtab_list; s; s = s->next)
+  ALL_SYMTABS (objfile, s)

     {
     {

+      QUIT;

       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);

-      

       for (i = 0; i < BLOCK_NSYMS (b); i++)
       for (i = 0; i < BLOCK_NSYMS (b); i++)

-       if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len))
-         completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i)));
+       {
+         sym = BLOCK_SYM (b, i);
+         demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
+                                         DMGL_PARAMS | DMGL_ANSI);
+         if (demangled != NULL)
+           {
+             free (demangled);
+             return (SYMBOL_NAME (sym));
+           }
+       }

     }
 
     }
 

-  for (s = symtab_list; s; s = s->next)
+  ALL_SYMTABS (objfile, s)

     {
     {

+      QUIT;

       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);

-

       /* Don't do this block twice.  */
       if (b == surrounding_static_block) continue;
       /* Don't do this block twice.  */
       if (b == surrounding_static_block) continue;

-      

       for (i = 0; i < BLOCK_NSYMS (b); i++)
       for (i = 0; i < BLOCK_NSYMS (b); i++)

-       if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len))
-         completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i)));
+       {
+         sym = BLOCK_SYM (b, i);
+         demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
+                                         DMGL_PARAMS | DMGL_ANSI);
+         if (demangled != NULL)
+           {
+             free (demangled);
+             return (SYMBOL_NAME (sym));
+           }
+       }

     }
 
     }
 

-  return (return_val);
+  return (NULL);

 }
 }

+

 \f
 #if 0
 /* Add the type of the symbol sym to the type of the current
 \f
 #if 0
 /* Add the type of the symbol sym to the type of the current


@@ -2858,7 +2813,7 @@ make_symbol_completion_list (text)
    to in_function_type if it was called correctly).
 
    Note that since we are modifying a type, the result of 
    to in_function_type if it was called correctly).
 
    Note that since we are modifying a type, the result of 

-   lookup_function_type() should be bcopy()ed before calling
+   lookup_function_type() should be memcpy()ed before calling

    this.  When not in strict typing mode, the expression
    evaluator can choose to ignore this.
 
    this.  When not in strict typing mode, the expression
    evaluator can choose to ignore this.
 


@@ -2875,12 +2830,12 @@ add_param_to_type (type,sym)
    int num = ++(TYPE_NFIELDS(*type));
 
    if(TYPE_NFIELDS(*type)-1)
    int num = ++(TYPE_NFIELDS(*type));
 
    if(TYPE_NFIELDS(*type)-1)

-      TYPE_FIELDS(*type) = 
-        (struct field *)xrealloc((char *)(TYPE_FIELDS(*type)),
-                                 num*sizeof(struct field));
+      TYPE_FIELDS(*type) = (struct field *)
+         (*current_objfile->xrealloc) ((char *)(TYPE_FIELDS(*type)),
+                                       num*sizeof(struct field));

    else
    else

-      TYPE_FIELDS(*type) =
-        (struct field *)xmalloc(num*sizeof(struct field));
+      TYPE_FIELDS(*type) = (struct field *)
+         (*current_objfile->xmalloc) (num*sizeof(struct field));

    
    TYPE_FIELD_BITPOS(*type,num-1) = num-1;
    TYPE_FIELD_BITSIZE(*type,num-1) = 0;
    
    TYPE_FIELD_BITPOS(*type,num-1) = num-1;
    TYPE_FIELD_BITSIZE(*type,num-1) = 0;


@@ -2906,13 +2861,13 @@ _initialize_symtab ()
      I also think "ptype" or "whatis" is more likely to be useful (but if
      there is much disagreement "info types" can be fixed).  */
   add_info ("types", types_info,
      I also think "ptype" or "whatis" is more likely to be useful (but if
      there is much disagreement "info types" can be fixed).  */
   add_info ("types", types_info,

-           "All types names, or those matching REGEXP.");
+           "All type names, or those matching REGEXP.");

 
 #if 0
   add_info ("methods", methods_info,
            "All method names, or those matching REGEXP::REGEXP.\n\
 
 #if 0
   add_info ("methods", methods_info,
            "All method names, or those matching REGEXP::REGEXP.\n\

-If the class qualifier is ommited, it is assumed to be the current scope.\n\
-If the first REGEXP is ommited, then all methods matching the second REGEXP\n\
+If the class qualifier is omitted, it is assumed to be the current scope.\n\
+If the first REGEXP is omitted, then all methods matching the second REGEXP\n\

 are listed.");
 #endif
   add_info ("sources", sources_info,
 are listed.");
 #endif
   add_info ("sources", sources_info,


@@ -2922,5 +2877,6 @@ are listed.");
            "Set a breakpoint for all functions matching REGEXP.");
 
   /* Initialize the one built-in type that isn't language dependent... */
            "Set a breakpoint for all functions matching REGEXP.");
 
   /* Initialize the one built-in type that isn't language dependent... */

-  builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>");
+  builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
+                                 "<unknown type>", (struct objfile *) NULL);

 }
 }