include/:

	* demangle.h: New cplus_demangle_print_callback,
	cplus_demangle_v3_callback, and java_demangle_v3_callback function
	prototypes, and demangle_callbackref type definition.
libiberty/:
	* cp-demangle.h (cplus_demangle_operators): External definition
	suppressed if not building for libstdc++.
	* cp-demangle.c (__gcclibcxx_demangle_callback): Augmented interface
	to demangling, provides a malloc-less version of __cxa_demangle.
	(cplus_demangle_print_callback): Public callback version of
	cplus_demangle_print.
	(struct d_growable_string): New growable string structure.
	(d_growable_string_init): New function, provides support for
	growable strings separate from print info.
	(d_growable_string_resize): Likewise.
	(d_growable_string_append_buffer): Likewise.
	(d_growable_string_callback_adapter):): Likewise.
	(d_print_init): New print info initialization function.
	(d_print_error): Macro replace by inline function.
	(d_print_saw_error): Likewise.
	(d_append_char): Likewise.
	(d_append_buffer): Likewise.
	(d_append_string): New inline function, replaces the
	d_append_string_constant macro.
	(d_flush_buffer): New function, flushes buffer to callback.
	(d_demangle_callback, is_ctor_or_dtor): Malloc-based fallback
	for unsupported dynamic arrays replaced by alloca().
	(d_demangle): Return string length estimating removed.
	(d_dump): Moved error case handling from call site into function.
	(d_print_resize): Function removed.
	(d_print_append_char): Likewise.
	(d_print_append_buffer): Likewise.
	(d_print_error): Likewise.
	(d_print_comp): Added special case handling for Java arrays.
	(java_demangle_v3): Removed string post-processing for Java arrays,
	now replaced by special case handling in d_print_comp.
	(cplus_demangle_v3_callback): Augmented interface to demangling,
	provides a malloc-less version of cplus_demangle_v3.
	(java_demangle_v3_callback): Augmented interface to demangling,
	provides a malloc-less version of java_demangle_v3.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@121305 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/include/ChangeLog b/include/ChangeLog
index 572f45a..0e8b150 100644 (file)
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,3 +1,9 @@
+2007-01-29  Simon Baldwin <simonb@google.com>
+
+       * demangle.h: New cplus_demangle_print_callback,
+       cplus_demangle_v3_callback, and java_demangle_v3_callback function
+       prototypes, and demangle_callbackref type definition.
+

 2006-12-06  Nick Clifton  <nickc@redhat.com>
 
        * ansidecl.h (ATTRIBUTE_PACKED): Define.
 2006-12-06  Nick Clifton  <nickc@redhat.com>
 
        * ansidecl.h (ATTRIBUTE_PACKED): Define.

diff --git a/include/demangle.h b/include/demangle.h
index af29467..360538c 100644 (file)
--- a/include/demangle.h
+++ b/include/demangle.h
@@ -1,6 +1,6 @@
 /* Defs for interface to demanglers.
    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002,
 /* Defs for interface to demanglers.
    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002,

-   2003, 2004 Free Software Foundation, Inc.
+   2003, 2004, 2005, 2007 Free Software Foundation, Inc.

    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by


@@ -131,13 +131,25 @@ cplus_demangle_set_style (enum demangling_styles style);
 extern enum demangling_styles 
 cplus_demangle_name_to_style (const char *name);
 
 extern enum demangling_styles 
 cplus_demangle_name_to_style (const char *name);
 

-/* V3 ABI demangling entry points, defined in cp-demangle.c.  */
-extern char*
-cplus_demangle_v3 (const char* mangled, int options);
+/* Callback typedef for allocation-less demangler interfaces. */
+typedef void (*demangle_callbackref) (const char *, size_t, void *);
+
+/* V3 ABI demangling entry points, defined in cp-demangle.c.  Callback
+   variants return non-zero on success, zero on error.  char* variants
+   return a string allocated by malloc on success, NULL on error.  */
+extern int
+cplus_demangle_v3_callback (const char *mangled, int options,
+                            demangle_callbackref callback, void *opaque);

 
 extern char*
 
 extern char*

-java_demangle_v3 (const char* mangled);
+cplus_demangle_v3 (const char *mangled, int options);

 
 

+extern int
+java_demangle_v3_callback (const char *mangled,
+                           demangle_callbackref callback, void *opaque);
+
+extern char*
+java_demangle_v3 (const char *mangled);

 
 enum gnu_v3_ctor_kinds {
   gnu_v3_complete_object_ctor = 1,
 
 enum gnu_v3_ctor_kinds {
   gnu_v3_complete_object_ctor = 1,


@@ -529,6 +541,25 @@ cplus_demangle_print (int options,
                       int estimated_length,
                       size_t *p_allocated_size);
 
                       int estimated_length,
                       size_t *p_allocated_size);
 

+/* This function takes a struct demangle_component tree and passes back
+   a demangled string in one or more calls to a callback function.
+   The first argument is DMGL_* options.  The second is the tree to
+   demangle.  The third is a pointer to a callback function; on each call
+   this receives an element of the demangled string, its length, and an
+   opaque value.  The fourth is the opaque value passed to the callback.
+   The callback is called once or more to return the full demangled
+   string.  The demangled element string is always nul-terminated, though
+   its length is also provided for convenience.  In contrast to
+   cplus_demangle_print(), this function does not allocate heap memory
+   to grow output strings (except perhaps where alloca() is implemented
+   by malloc()), and so is normally safe for use where the heap has been
+   corrupted.  On success, this function returns 1; on failure, 0.  */
+
+extern int
+cplus_demangle_print_callback (int options,
+                               const struct demangle_component *tree,
+                               demangle_callbackref callback, void *opaque);
+

 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog
index 608d430..09c8c75 100644 (file)
--- a/libiberty/ChangeLog
+++ b/libiberty/ChangeLog
@@ -1,3 +1,41 @@
+2007-01-29  Simon Baldwin <simonb@google.com>
+
+       * cp-demangle.h (cplus_demangle_operators): External definition
+       suppressed if not building for libstdc++.
+       * cp-demangle.c (__gcclibcxx_demangle_callback): Augmented interface
+       to demangling, provides a malloc-less version of __cxa_demangle.
+       (cplus_demangle_print_callback): Public callback version of
+       cplus_demangle_print.
+       (struct d_growable_string): New growable string structure.
+       (d_growable_string_init): New function, provides support for
+       growable strings separate from print info.
+       (d_growable_string_resize): Likewise.
+       (d_growable_string_append_buffer): Likewise.
+       (d_growable_string_callback_adapter):): Likewise.
+       (d_print_init): New print info initialization function.
+       (d_print_error): Macro replace by inline function.
+       (d_print_saw_error): Likewise.
+       (d_append_char): Likewise.
+       (d_append_buffer): Likewise.
+       (d_append_string): New inline function, replaces the
+       d_append_string_constant macro.
+       (d_flush_buffer): New function, flushes buffer to callback.
+       (d_demangle_callback, is_ctor_or_dtor): Malloc-based fallback
+       for unsupported dynamic arrays replaced by alloca().
+       (d_demangle): Return string length estimating removed.
+       (d_dump): Moved error case handling from call site into function.
+       (d_print_resize): Function removed.
+       (d_print_append_char): Likewise.
+       (d_print_append_buffer): Likewise.
+       (d_print_error): Likewise.
+       (d_print_comp): Added special case handling for Java arrays.
+       (java_demangle_v3): Removed string post-processing for Java arrays,
+       now replaced by special case handling in d_print_comp.
+       (cplus_demangle_v3_callback): Augmented interface to demangling,
+       provides a malloc-less version of cplus_demangle_v3.
+       (java_demangle_v3_callback): Augmented interface to demangling,
+       provides a malloc-less version of java_demangle_v3.
+

 2007-01-12  Ben Elliston  <bje@au.ibm.com>
 
        * pex-unix.c (writeerr): Cast write result to void.
 2007-01-12  Ben Elliston  <bje@au.ibm.com>
 
        * pex-unix.c (writeerr): Cast write result to void.

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index ac1dfe5..1e775d9 100644 (file)
--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@@ -1,5 +1,5 @@
 /* Demangler for g++ V3 ABI.
 /* Demangler for g++ V3 ABI.

-   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.

    Written by Ian Lance Taylor <ian@wasabisystems.com>.
 
    This file is part of the libiberty library, which is part of GCC.
    Written by Ian Lance Taylor <ian@wasabisystems.com>.
 
    This file is part of the libiberty library, which is part of GCC.


@@ -42,6 +42,10 @@
    This file will normally define the following functions, q.v.:
       char *cplus_demangle_v3(const char *mangled, int options)
       char *java_demangle_v3(const char *mangled)
    This file will normally define the following functions, q.v.:
       char *cplus_demangle_v3(const char *mangled, int options)
       char *java_demangle_v3(const char *mangled)

+      int cplus_demangle_v3_callback(const char *mangled, int options,
+                                     demangle_callbackref callback)
+      int java_demangle_v3_callback(const char *mangled,
+                                    demangle_callbackref callback)

       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
 
       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
 


@@ -50,12 +54,14 @@
    defined in demangle.h:
       enum demangle_component_type
       struct demangle_component
    defined in demangle.h:
       enum demangle_component_type
       struct demangle_component

+      demangle_callbackref

    and these functions defined in this file:
       cplus_demangle_fill_name
       cplus_demangle_fill_extended_operator
       cplus_demangle_fill_ctor
       cplus_demangle_fill_dtor
       cplus_demangle_print
    and these functions defined in this file:
       cplus_demangle_fill_name
       cplus_demangle_fill_extended_operator
       cplus_demangle_fill_ctor
       cplus_demangle_fill_dtor
       cplus_demangle_print

+      cplus_demangle_print_callback

    and other functions defined in the file cp-demint.c.
 
    This file also defines some other functions and variables which are
    and other functions defined in the file cp-demint.c.
 
    This file also defines some other functions and variables which are


@@ -64,14 +70,20 @@
    Preprocessor macros you can define while compiling this file:
 
    IN_LIBGCC2
    Preprocessor macros you can define while compiling this file:
 
    IN_LIBGCC2

-      If defined, this file defines the following function, q.v.:
+      If defined, this file defines the following functions, q.v.:

          char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
                                int *status)
          char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
                                int *status)

-      instead of cplus_demangle_v3() and java_demangle_v3().
+         int __gcclibcxx_demangle_callback (const char *,
+                                            void (*)
+                                              (const char *, size_t, void *),
+                                            void *)
+      instead of cplus_demangle_v3[_callback]() and
+      java_demangle_v3[_callback]().

 
    IN_GLIBCPP_V3
 
    IN_GLIBCPP_V3

-      If defined, this file defines only __cxa_demangle(), and no other
-      publically visible functions or variables.
+      If defined, this file defines only __cxa_demangle() and
+      __gcclibcxx_demangle_callback(), and no other publically visible
+      functions or variables.

 
    STANDALONE_DEMANGLER
       If defined, this file defines a main() function which demangles
 
    STANDALONE_DEMANGLER
       If defined, this file defines a main() function which demangles


@@ -82,6 +94,10 @@
       stdout about the mangled string.  This is not generally useful.
 */
 
       stdout about the mangled string.  This is not generally useful.
 */
 

+#if defined (_AIX) && !defined (__GNUC__)
+ #pragma alloca
+#endif
+

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif


@@ -95,6 +111,18 @@
 #include <string.h>
 #endif
 
 #include <string.h>
 #endif
 

+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#else
+# ifndef alloca
+#  ifdef __GNUC__
+#   define alloca __builtin_alloca
+#  else
+extern char *alloca ();
+#  endif /* __GNUC__ */
+# endif /* alloca */
+#endif /* HAVE_ALLOCA_H */
+

 #include "ansidecl.h"
 #include "libiberty.h"
 #include "demangle.h"
 #include "ansidecl.h"
 #include "libiberty.h"
 #include "demangle.h"


@@ -135,6 +163,10 @@ static struct demangle_component *d_type (struct d_info *);
 #define cplus_demangle_print d_print
 static char *d_print (int, const struct demangle_component *, int, size_t *);
 
 #define cplus_demangle_print d_print
 static char *d_print (int, const struct demangle_component *, int, size_t *);
 

+#define cplus_demangle_print_callback d_print_callback
+static int d_print_callback (int, const struct demangle_component *,
+                             demangle_callbackref, void *);
+

 #define cplus_demangle_init_info d_init_info
 static void d_init_info (const char *, int, size_t, struct d_info *);
 
 #define cplus_demangle_init_info d_init_info
 static void d_init_info (const char *, int, size_t, struct d_info *);
 


@@ -162,8 +194,8 @@ static void d_init_info (const char *, int, size_t, struct d_info *);
    V3 demangler code.
 
    As of this writing this file has the following undefined references
    V3 demangler code.
 
    As of this writing this file has the following undefined references

-   when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy,
-   strcpy, strcat, strlen.  */
+   when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
+   strcat, strlen.  */

 
 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
 
 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')


@@ -228,58 +260,46 @@ struct d_print_mod
   struct d_print_template *templates;
 };
 
   struct d_print_template *templates;
 };
 

-/* We use this structure to hold information during printing.  */
+/* We use these structures to hold information during printing.  */

 
 

-struct d_print_info
+struct d_growable_string

 {
 {

-  /* The options passed to the demangler.  */
-  int options;

   /* Buffer holding the result.  */
   char *buf;
   /* Current length of data in buffer.  */
   size_t len;
   /* Allocated size of buffer.  */
   size_t alc;
   /* Buffer holding the result.  */
   char *buf;
   /* Current length of data in buffer.  */
   size_t len;
   /* Allocated size of buffer.  */
   size_t alc;

+  /* Set to 1 if we had a memory allocation failure.  */
+  int allocation_failure;
+};
+
+enum { D_PRINT_BUFFER_LENGTH = 256 };
+struct d_print_info
+{
+  /* The options passed to the demangler.  */
+  int options;
+  /* Fixed-length allocated buffer for demangled data, flushed to the
+     callback with a NUL termination once full.  */
+  char buf[D_PRINT_BUFFER_LENGTH];
+  /* Current length of data in buffer.  */
+  size_t len;
+  /* The last character printed, saved individually so that it survives
+     any buffer flush.  */
+  char last_char;
+  /* Callback function to handle demangled buffer flush.  */
+  demangle_callbackref callback;
+  /* Opaque callback argument.  */
+  void *opaque;

   /* The current list of templates, if any.  */
   struct d_print_template *templates;
   /* The current list of modifiers (e.g., pointer, reference, etc.),
      if any.  */
   struct d_print_mod *modifiers;
   /* The current list of templates, if any.  */
   struct d_print_template *templates;
   /* The current list of modifiers (e.g., pointer, reference, etc.),
      if any.  */
   struct d_print_mod *modifiers;

-  /* Set to 1 if we had a memory allocation failure.  */
-  int allocation_failure;
+  /* Set to 1 if we saw a demangling error.  */
+  int demangle_failure;

 };
 
 };
 

-#define d_print_saw_error(dpi) ((dpi)->buf == NULL)
-
-#define d_append_char(dpi, c) \
-  do \
-    { \
-      if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
-        (dpi)->buf[(dpi)->len++] = (c); \
-      else \
-        d_print_append_char ((dpi), (c)); \
-    } \
-  while (0)
-
-#define d_append_buffer(dpi, s, l) \
-  do \
-    { \
-      if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
-        { \
-          memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
-          (dpi)->len += l; \
-        } \
-      else \
-        d_print_append_buffer ((dpi), (s), (l)); \
-    } \
-  while (0)
-
-#define d_append_string_constant(dpi, s) \
-  d_append_buffer (dpi, (s), sizeof (s) - 1)
-
-#define d_last_char(dpi) \
-  ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
-

 #ifdef CP_DEMANGLE_DEBUG
 static void d_dump (struct demangle_component *, int);
 #endif
 #ifdef CP_DEMANGLE_DEBUG
 static void d_dump (struct demangle_component *, int);
 #endif


@@ -389,14 +409,34 @@ d_add_substitution (struct d_info *, struct demangle_component *);
 
 static struct demangle_component *d_substitution (struct d_info *, int);
 
 
 static struct demangle_component *d_substitution (struct d_info *, int);
 

-static void d_print_resize (struct d_print_info *, size_t);
+static void d_growable_string_init (struct d_growable_string *, size_t);

 
 

-static void d_print_append_char (struct d_print_info *, int);
+static inline void
+d_growable_string_resize (struct d_growable_string *, size_t);

 
 

+static inline void
+d_growable_string_append_buffer (struct d_growable_string *,
+                                 const char *, size_t);

 static void
 static void

-d_print_append_buffer (struct d_print_info *, const char *, size_t);
+d_growable_string_callback_adapter (const char *, size_t, void *);
+
+static void
+d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
+
+static inline void d_print_error (struct d_print_info *);
+
+static inline int d_print_saw_error (struct d_print_info *);
+
+static inline void d_print_flush (struct d_print_info *);
+
+static inline void d_append_char (struct d_print_info *, char);

 
 

-static void d_print_error (struct d_print_info *);
+static inline void d_append_buffer (struct d_print_info *,
+                                    const char *, size_t);
+
+static inline void d_append_string (struct d_print_info *, const char *);
+
+static inline char d_last_char (struct d_print_info *);

 
 static void
 d_print_comp (struct d_print_info *, const struct demangle_component *);
 
 static void
 d_print_comp (struct d_print_info *, const struct demangle_component *);


@@ -426,6 +466,8 @@ d_print_expr_op (struct d_print_info *, const struct demangle_component *);
 static void
 d_print_cast (struct d_print_info *, const struct demangle_component *);
 
 static void
 d_print_cast (struct d_print_info *, const struct demangle_component *);
 

+static int d_demangle_callback (const char *, int,
+                                demangle_callbackref, void *);

 static char *d_demangle (const char *, int, size_t *);
 
 #ifdef CP_DEMANGLE_DEBUG
 static char *d_demangle (const char *, int, size_t *);
 
 #ifdef CP_DEMANGLE_DEBUG


@@ -436,7 +478,11 @@ d_dump (struct demangle_component *dc, int indent)
   int i;
 
   if (dc == NULL)
   int i;
 
   if (dc == NULL)

-    return;
+    {
+      if (indent == 0)
+        printf ("failed demangling\n");
+      return;
+    }

 
   for (i = 0; i < indent; ++i)
     putchar (' ');
 
   for (i = 0; i < indent; ++i)
     putchar (' ');


@@ -2567,80 +2613,181 @@ d_substitution (struct d_info *di, int prefix)
     }
 }
 
     }
 }
 

-/* Resize the print buffer.  */
+/* Initialize a growable string.  */

 
 static void
 
 static void

-d_print_resize (struct d_print_info *dpi, size_t add)
+d_growable_string_init (struct d_growable_string *dgs, size_t estimate)

 {
 {

-  size_t need;
+  dgs->buf = NULL;
+  dgs->len = 0;
+  dgs->alc = 0;
+  dgs->allocation_failure = 0;

 
 

-  if (dpi->buf == NULL)
+  if (estimate > 0)
+    d_growable_string_resize (dgs, estimate);
+}
+
+/* Grow a growable string to a given size.  */
+
+static inline void
+d_growable_string_resize (struct d_growable_string *dgs, size_t need)
+{
+  size_t newalc;
+  char *newbuf;
+
+  if (dgs->allocation_failure)

     return;
     return;

-  need = dpi->len + add;
-  while (need > dpi->alc)
-    {
-      size_t newalc;
-      char *newbuf;

 
 

-      newalc = dpi->alc * 2;
-      newbuf = (char *) realloc (dpi->buf, newalc);
-      if (newbuf == NULL)
-       {
-         free (dpi->buf);
-         dpi->buf = NULL;
-         dpi->allocation_failure = 1;
-         return;
-       }
-      dpi->buf = newbuf;
-      dpi->alc = newalc;
+  /* Start allocation at two bytes to avoid any possibility of confusion
+     with the special value of 1 used as a return in *palc to indicate
+     allocation failures.  */
+  newalc = dgs->alc > 0 ? dgs->alc : 2;
+  while (newalc < need)
+    newalc <<= 1;
+
+  newbuf = (char *) realloc (dgs->buf, newalc);
+  if (newbuf == NULL)
+    {
+      free (dgs->buf);
+      dgs->buf = NULL;
+      dgs->len = 0;
+      dgs->alc = 0;
+      dgs->allocation_failure = 1;
+      return;

     }
     }

+  dgs->buf = newbuf;
+  dgs->alc = newalc;

 }
 
 }
 

-/* Append a character to the print buffer.  */
+/* Append a buffer to a growable string.  */

 
 

-static void
-d_print_append_char (struct d_print_info *dpi, int c)
+static inline void
+d_growable_string_append_buffer (struct d_growable_string *dgs,
+                                 const char *s, size_t l)

 {
 {

-  if (dpi->buf != NULL)
-    {
-      if (dpi->len >= dpi->alc)
-       {
-         d_print_resize (dpi, 1);
-         if (dpi->buf == NULL)
-           return;
-       }
+  size_t need;

 
 

-      dpi->buf[dpi->len] = c;
-      ++dpi->len;
-    }
+  need = dgs->len + l + 1;
+  if (need > dgs->alc)
+    d_growable_string_resize (dgs, need);
+
+  if (dgs->allocation_failure)
+    return;
+
+  memcpy (dgs->buf + dgs->len, s, l);
+  dgs->buf[dgs->len + l] = '\0';
+  dgs->len += l;

 }
 
 }
 

-/* Append a buffer to the print buffer.  */
+/* Bridge growable strings to the callback mechanism.  */

 
 static void
 
 static void

-d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
+d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)

 {
 {

-  if (dpi->buf != NULL)
-    {
-      if (dpi->len + l > dpi->alc)
-       {
-         d_print_resize (dpi, l);
-         if (dpi->buf == NULL)
-           return;
-       }
+  struct d_growable_string *dgs = (struct d_growable_string*) opaque;

 
 

-      memcpy (dpi->buf + dpi->len, s, l);
-      dpi->len += l;
-    }
+  d_growable_string_append_buffer (dgs, s, l);

 }
 
 }
 

-/* Indicate that an error occurred during printing.  */
+/* Initialize a print information structure.  */

 
 static void
 
 static void

+d_print_init (struct d_print_info *dpi, int options,
+              demangle_callbackref callback, void *opaque)
+{
+  dpi->options = options;
+  dpi->len = 0;
+  dpi->last_char = '\0';
+  dpi->templates = NULL;
+  dpi->modifiers = NULL;
+
+  dpi->callback = callback;
+  dpi->opaque = opaque;
+
+  dpi->demangle_failure = 0;
+}
+
+/* Indicate that an error occurred during printing, and test for error.  */
+
+static inline void

 d_print_error (struct d_print_info *dpi)
 {
 d_print_error (struct d_print_info *dpi)
 {

-  free (dpi->buf);
-  dpi->buf = NULL;
+  dpi->demangle_failure = 1;
+}
+
+static inline int
+d_print_saw_error (struct d_print_info *dpi)
+{
+  return dpi->demangle_failure != 0;
+}
+
+/* Flush buffered characters to the callback.  */
+
+static inline void
+d_print_flush (struct d_print_info *dpi)
+{
+  dpi->buf[dpi->len] = '\0';
+  dpi->callback (dpi->buf, dpi->len, dpi->opaque);
+  dpi->len = 0;
+}
+
+/* Append characters and buffers for printing.  */
+
+static inline void
+d_append_char (struct d_print_info *dpi, char c)
+{
+  if (dpi->len == sizeof (dpi->buf) - 1)
+    d_print_flush (dpi);
+
+  dpi->buf[dpi->len++] = c;
+  dpi->last_char = c;
+}
+
+static inline void
+d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
+{
+  size_t i;
+
+  for (i = 0; i < l; i++)
+    d_append_char (dpi, s[i]);
+}
+
+static inline void
+d_append_string (struct d_print_info *dpi, const char *s)
+{
+  d_append_buffer (dpi, s, strlen (s));
+}
+
+static inline char
+d_last_char (struct d_print_info *dpi)
+{
+  return dpi->last_char;
+}
+
+/* Turn components into a human readable string.  OPTIONS is the
+   options bits passed to the demangler.  DC is the tree to print.
+   CALLBACK is a function to call to flush demangled string segments
+   as they fill the intermediate buffer, and OPAQUE is a generalized
+   callback argument.  On success, this returns 1.  On failure,
+   it returns 0, indicating a bad parse.  It does not use heap
+   memory to build an output string, so cannot encounter memory
+   allocation failure.  */
+
+CP_STATIC_IF_GLIBCPP_V3
+int
+cplus_demangle_print_callback (int options,
+                               const struct demangle_component *dc,
+                               demangle_callbackref callback, void *opaque)
+{
+  struct d_print_info dpi;
+
+  d_print_init (&dpi, options, callback, opaque);
+
+  d_print_comp (&dpi, dc);
+
+  d_print_flush (&dpi);
+
+  return ! d_print_saw_error (&dpi);

 }
 
 /* Turn components into a human readable string.  OPTIONS is the
 }
 
 /* Turn components into a human readable string.  OPTIONS is the


@@ -2656,34 +2803,21 @@ char *
 cplus_demangle_print (int options, const struct demangle_component *dc,
                       int estimate, size_t *palc)
 {
 cplus_demangle_print (int options, const struct demangle_component *dc,
                       int estimate, size_t *palc)
 {

-  struct d_print_info dpi;
+  struct d_growable_string dgs;

 
 

-  dpi.options = options;
+  d_growable_string_init (&dgs, estimate);

 
 

-  dpi.alc = estimate + 1;
-  dpi.buf = (char *) malloc (dpi.alc);
-  if (dpi.buf == NULL)
+  if (! cplus_demangle_print_callback (options, dc,
+                                       d_growable_string_callback_adapter,
+                                       &dgs))

     {
     {

-      *palc = 1;
+      free (dgs.buf);
+      *palc = 0;

       return NULL;
     }
 
       return NULL;
     }
 

-  dpi.len = 0;
-  dpi.templates = NULL;
-  dpi.modifiers = NULL;
-
-  dpi.allocation_failure = 0;
-
-  d_print_comp (&dpi, dc);
-
-  d_append_char (&dpi, '\0');
-
-  if (dpi.buf != NULL)
-    *palc = dpi.alc;
-  else
-    *palc = dpi.allocation_failure;
-
-  return dpi.buf;
+  *palc = dgs.allocation_failure ? 1 : dgs.alc;
+  return dgs.buf;

 }
 
 /* Subroutine to handle components.  */
 }
 
 /* Subroutine to handle components.  */


@@ -2713,7 +2847,7 @@ d_print_comp (struct d_print_info *dpi,
     case DEMANGLE_COMPONENT_LOCAL_NAME:
       d_print_comp (dpi, d_left (dc));
       if ((dpi->options & DMGL_JAVA) == 0)
     case DEMANGLE_COMPONENT_LOCAL_NAME:
       d_print_comp (dpi, d_left (dc));
       if ((dpi->options & DMGL_JAVA) == 0)

-       d_append_string_constant (dpi, "::");
+       d_append_string (dpi, "::");

       else
        d_append_char (dpi, '.');
       d_print_comp (dpi, d_right (dc));
       else
        d_append_char (dpi, '.');
       d_print_comp (dpi, d_right (dc));


@@ -2822,6 +2956,7 @@ d_print_comp (struct d_print_info *dpi,
     case DEMANGLE_COMPONENT_TEMPLATE:
       {
        struct d_print_mod *hold_dpm;
     case DEMANGLE_COMPONENT_TEMPLATE:
       {
        struct d_print_mod *hold_dpm;

+       struct demangle_component *dcl;

 
        /* Don't push modifiers into a template definition.  Doing so
           could give the wrong definition for a template argument.
 
        /* Don't push modifiers into a template definition.  Doing so
           could give the wrong definition for a template argument.


@@ -2830,16 +2965,32 @@ d_print_comp (struct d_print_info *dpi,
        hold_dpm = dpi->modifiers;
        dpi->modifiers = NULL;
 
        hold_dpm = dpi->modifiers;
        dpi->modifiers = NULL;
 

-       d_print_comp (dpi, d_left (dc));
-       if (d_last_char (dpi) == '<')
-         d_append_char (dpi, ' ');
-       d_append_char (dpi, '<');
-       d_print_comp (dpi, d_right (dc));
-       /* Avoid generating two consecutive '>' characters, to avoid
-          the C++ syntactic ambiguity.  */
-       if (d_last_char (dpi) == '>')
-         d_append_char (dpi, ' ');
-       d_append_char (dpi, '>');
+        dcl = d_left (dc);
+
+        if ((dpi->options & DMGL_JAVA) != 0
+            && dcl->type == DEMANGLE_COMPONENT_NAME
+            && dcl->u.s_name.len == 6
+            && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
+          {
+            /* Special-case Java arrays, so that JArray<TYPE> appears
+               instead as TYPE[].  */
+
+            d_print_comp (dpi, d_right (dc));
+            d_append_string (dpi, "[]");
+          }
+        else
+          {
+           d_print_comp (dpi, dcl);
+           if (d_last_char (dpi) == '<')
+             d_append_char (dpi, ' ');
+           d_append_char (dpi, '<');
+           d_print_comp (dpi, d_right (dc));
+           /* Avoid generating two consecutive '>' characters, to avoid
+              the C++ syntactic ambiguity.  */
+           if (d_last_char (dpi) == '>')
+             d_append_char (dpi, ' ');
+           d_append_char (dpi, '>');
+          }

 
        dpi->modifiers = hold_dpm;
 
 
        dpi->modifiers = hold_dpm;
 


@@ -2902,69 +3053,69 @@ d_print_comp (struct d_print_info *dpi,
       return;
 
     case DEMANGLE_COMPONENT_VTABLE:
       return;
 
     case DEMANGLE_COMPONENT_VTABLE:

-      d_append_string_constant (dpi, "vtable for ");
+      d_append_string (dpi, "vtable for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_VTT:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_VTT:

-      d_append_string_constant (dpi, "VTT for ");
+      d_append_string (dpi, "VTT for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:

-      d_append_string_constant (dpi, "construction vtable for ");
+      d_append_string (dpi, "construction vtable for ");

       d_print_comp (dpi, d_left (dc));
       d_print_comp (dpi, d_left (dc));

-      d_append_string_constant (dpi, "-in-");
+      d_append_string (dpi, "-in-");

       d_print_comp (dpi, d_right (dc));
       return;
 
     case DEMANGLE_COMPONENT_TYPEINFO:
       d_print_comp (dpi, d_right (dc));
       return;
 
     case DEMANGLE_COMPONENT_TYPEINFO:

-      d_append_string_constant (dpi, "typeinfo for ");
+      d_append_string (dpi, "typeinfo for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_TYPEINFO_NAME:

-      d_append_string_constant (dpi, "typeinfo name for ");
+      d_append_string (dpi, "typeinfo name for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_TYPEINFO_FN:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_TYPEINFO_FN:

-      d_append_string_constant (dpi, "typeinfo fn for ");
+      d_append_string (dpi, "typeinfo fn for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_THUNK:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_THUNK:

-      d_append_string_constant (dpi, "non-virtual thunk to ");
+      d_append_string (dpi, "non-virtual thunk to ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:

-      d_append_string_constant (dpi, "virtual thunk to ");
+      d_append_string (dpi, "virtual thunk to ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_COVARIANT_THUNK:

-      d_append_string_constant (dpi, "covariant return thunk to ");
+      d_append_string (dpi, "covariant return thunk to ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_JAVA_CLASS:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_JAVA_CLASS:

-      d_append_string_constant (dpi, "java Class for ");
+      d_append_string (dpi, "java Class for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_GUARD:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_GUARD:

-      d_append_string_constant (dpi, "guard variable for ");
+      d_append_string (dpi, "guard variable for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_REFTEMP:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_REFTEMP:

-      d_append_string_constant (dpi, "reference temporary for ");
+      d_append_string (dpi, "reference temporary for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
       d_print_comp (dpi, d_left (dc));
       return;
 
     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:

-      d_append_string_constant (dpi, "hidden alias for ");
+      d_append_string (dpi, "hidden alias for ");

       d_print_comp (dpi, d_left (dc));
       return;
 
       d_print_comp (dpi, d_left (dc));
       return;
 


@@ -3163,7 +3314,7 @@ d_print_comp (struct d_print_info *dpi,
          {
            d_append_char (dpi, ' ');
            d_print_comp (dpi, d_left (dc));
          {
            d_append_char (dpi, ' ');
            d_print_comp (dpi, d_left (dc));

-           d_append_string_constant (dpi, "::*");
+           d_append_string (dpi, "::*");

          }
 
        dpi->modifiers = dpm.next;
          }
 
        dpi->modifiers = dpm.next;


@@ -3176,7 +3327,7 @@ d_print_comp (struct d_print_info *dpi,
       d_print_comp (dpi, d_left (dc));
       if (d_right (dc) != NULL)
        {
       d_print_comp (dpi, d_left (dc));
       if (d_right (dc) != NULL)
        {

-         d_append_string_constant (dpi, ", ");
+         d_append_string (dpi, ", ");

          d_print_comp (dpi, d_right (dc));
        }
       return;
          d_print_comp (dpi, d_right (dc));
        }
       return;


@@ -3185,7 +3336,7 @@ d_print_comp (struct d_print_info *dpi,
       {
        char c;
 
       {
        char c;
 

-       d_append_string_constant (dpi, "operator");
+       d_append_string (dpi, "operator");

        c = dc->u.s_operator.op->name[0];
        if (IS_LOWER (c))
          d_append_char (dpi, ' ');
        c = dc->u.s_operator.op->name[0];
        if (IS_LOWER (c))
          d_append_char (dpi, ' ');


@@ -3195,12 +3346,12 @@ d_print_comp (struct d_print_info *dpi,
       }
 
     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
       }
 
     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:

-      d_append_string_constant (dpi, "operator ");
+      d_append_string (dpi, "operator ");

       d_print_comp (dpi, dc->u.s_extended_operator.name);
       return;
 
     case DEMANGLE_COMPONENT_CAST:
       d_print_comp (dpi, dc->u.s_extended_operator.name);
       return;
 
     case DEMANGLE_COMPONENT_CAST:

-      d_append_string_constant (dpi, "operator ");
+      d_append_string (dpi, "operator ");

       d_print_cast (dpi, dc);
       return;
 
       d_print_cast (dpi, dc);
       return;
 


@@ -3235,9 +3386,9 @@ d_print_comp (struct d_print_info *dpi,
 
       d_append_char (dpi, '(');
       d_print_comp (dpi, d_left (d_right (dc)));
 
       d_append_char (dpi, '(');
       d_print_comp (dpi, d_left (d_right (dc)));

-      d_append_string_constant (dpi, ") ");
+      d_append_string (dpi, ") ");

       d_print_expr_op (dpi, d_left (dc));
       d_print_expr_op (dpi, d_left (dc));

-      d_append_string_constant (dpi, " (");
+      d_append_string (dpi, " (");

       d_print_comp (dpi, d_right (d_right (dc)));
       d_append_char (dpi, ')');
 
       d_print_comp (dpi, d_right (d_right (dc)));
       d_append_char (dpi, ')');
 


@@ -3262,11 +3413,11 @@ d_print_comp (struct d_print_info *dpi,
        }
       d_append_char (dpi, '(');
       d_print_comp (dpi, d_left (d_right (dc)));
        }
       d_append_char (dpi, '(');
       d_print_comp (dpi, d_left (d_right (dc)));

-      d_append_string_constant (dpi, ") ");
+      d_append_string (dpi, ") ");

       d_print_expr_op (dpi, d_left (dc));
       d_print_expr_op (dpi, d_left (dc));

-      d_append_string_constant (dpi, " (");
+      d_append_string (dpi, " (");

       d_print_comp (dpi, d_left (d_right (d_right (dc))));
       d_print_comp (dpi, d_left (d_right (d_right (dc))));

-      d_append_string_constant (dpi, ") : (");
+      d_append_string (dpi, ") : (");

       d_print_comp (dpi, d_right (d_right (d_right (dc))));
       d_append_char (dpi, ')');
       return;
       d_print_comp (dpi, d_right (d_right (d_right (dc))));
       d_append_char (dpi, ')');
       return;


@@ -3311,13 +3462,13 @@ d_print_comp (struct d_print_info *dpi,
                        d_append_char (dpi, 'l');
                        break;
                      case D_PRINT_UNSIGNED_LONG:
                        d_append_char (dpi, 'l');
                        break;
                      case D_PRINT_UNSIGNED_LONG:

-                       d_append_string_constant (dpi, "ul");
+                       d_append_string (dpi, "ul");

                        break;
                      case D_PRINT_LONG_LONG:
                        break;
                      case D_PRINT_LONG_LONG:

-                       d_append_string_constant (dpi, "ll");
+                       d_append_string (dpi, "ll");

                        break;
                      case D_PRINT_UNSIGNED_LONG_LONG:
                        break;
                      case D_PRINT_UNSIGNED_LONG_LONG:

-                       d_append_string_constant (dpi, "ull");
+                       d_append_string (dpi, "ull");

                        break;
                      }
                    return;
                        break;
                      }
                    return;


@@ -3332,10 +3483,10 @@ d_print_comp (struct d_print_info *dpi,
                    switch (d_right (dc)->u.s_name.s[0])
                      {
                      case '0':
                    switch (d_right (dc)->u.s_name.s[0])
                      {
                      case '0':

-                       d_append_string_constant (dpi, "false");
+                       d_append_string (dpi, "false");

                        return;
                      case '1':
                        return;
                      case '1':

-                       d_append_string_constant (dpi, "true");
+                       d_append_string (dpi, "true");

                        return;
                      default:
                        break;
                        return;
                      default:
                        break;


@@ -3474,7 +3625,7 @@ d_print_mod_list (struct d_print_info *dpi,
       dpi->modifiers = hold_modifiers;
 
       if ((dpi->options & DMGL_JAVA) == 0)
       dpi->modifiers = hold_modifiers;
 
       if ((dpi->options & DMGL_JAVA) == 0)

-       d_append_string_constant (dpi, "::");
+       d_append_string (dpi, "::");

       else
        d_append_char (dpi, '.');
 
       else
        d_append_char (dpi, '.');
 


@@ -3507,15 +3658,15 @@ d_print_mod (struct d_print_info *dpi,
     {
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_RESTRICT_THIS:
     {
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_RESTRICT_THIS:

-      d_append_string_constant (dpi, " restrict");
+      d_append_string (dpi, " restrict");

       return;
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_VOLATILE_THIS:
       return;
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_VOLATILE_THIS:

-      d_append_string_constant (dpi, " volatile");
+      d_append_string (dpi, " volatile");

       return;
     case DEMANGLE_COMPONENT_CONST:
     case DEMANGLE_COMPONENT_CONST_THIS:
       return;
     case DEMANGLE_COMPONENT_CONST:
     case DEMANGLE_COMPONENT_CONST_THIS:

-      d_append_string_constant (dpi, " const");
+      d_append_string (dpi, " const");

       return;
     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
       d_append_char (dpi, ' ');
       return;
     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
       d_append_char (dpi, ' ');


@@ -3530,16 +3681,16 @@ d_print_mod (struct d_print_info *dpi,
       d_append_char (dpi, '&');
       return;
     case DEMANGLE_COMPONENT_COMPLEX:
       d_append_char (dpi, '&');
       return;
     case DEMANGLE_COMPONENT_COMPLEX:

-      d_append_string_constant (dpi, "complex ");
+      d_append_string (dpi, "complex ");

       return;
     case DEMANGLE_COMPONENT_IMAGINARY:
       return;
     case DEMANGLE_COMPONENT_IMAGINARY:

-      d_append_string_constant (dpi, "imaginary ");
+      d_append_string (dpi, "imaginary ");

       return;
     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
       if (d_last_char (dpi) != '(')
        d_append_char (dpi, ' ');
       d_print_comp (dpi, d_left (mod));
       return;
     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
       if (d_last_char (dpi) != '(')
        d_append_char (dpi, ' ');
       d_print_comp (dpi, d_left (mod));

-      d_append_string_constant (dpi, "::*");
+      d_append_string (dpi, "::*");

       return;
     case DEMANGLE_COMPONENT_TYPED_NAME:
       d_print_comp (dpi, d_left (mod));
       return;
     case DEMANGLE_COMPONENT_TYPED_NAME:
       d_print_comp (dpi, d_left (mod));


@@ -3672,7 +3823,7 @@ d_print_array_type (struct d_print_info *dpi,
        }
 
       if (need_paren)
        }
 
       if (need_paren)

-       d_append_string_constant (dpi, " (");
+       d_append_string (dpi, " (");

 
       d_print_mod_list (dpi, mods, 0);
 
 
       d_print_mod_list (dpi, mods, 0);
 


@@ -3778,26 +3929,19 @@ cplus_demangle_init_info (const char *mangled, int options, size_t len,
   di->expansion = 0;
 }
 
   di->expansion = 0;
 }
 

-/* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
-   name, return a buffer allocated with malloc holding the demangled
-   name.  OPTIONS is the usual libiberty demangler options.  On
-   success, this sets *PALC to the allocated size of the returned
-   buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
-   a memory allocation failure.  On failure, this returns NULL.  */
+/* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
+   mangled name, return strings in repeated callback giving the demangled
+   name.  OPTIONS is the usual libiberty demangler options.  On success,
+   this returns 1.  On failure, returns 0.  */

 
 

-static char *
-d_demangle (const char* mangled, int options, size_t *palc)
+static int
+d_demangle_callback (const char *mangled, int options,
+                     demangle_callbackref callback, void *opaque)

 {
 {

-  size_t len;

   int type;
   struct d_info di;
   struct demangle_component *dc;
   int type;
   struct d_info di;
   struct demangle_component *dc;

-  int estimate;
-  char *ret;
-
-  *palc = 0;
-
-  len = strlen (mangled);
+  int status;

 
   if (mangled[0] == '_' && mangled[1] == 'Z')
     type = 0;
 
   if (mangled[0] == '_' && mangled[1] == 'Z')
     type = 0;


@@ -3806,57 +3950,41 @@ d_demangle (const char* mangled, int options, size_t *palc)
           && (mangled[9] == 'D' || mangled[9] == 'I')
           && mangled[10] == '_')
     {
           && (mangled[9] == 'D' || mangled[9] == 'I')
           && mangled[10] == '_')
     {

-      char *r;
+      const char *intro;

 
 

-      r = (char *) malloc (40 + len - 11);
-      if (r == NULL)
-       *palc = 1;
-      else
-       {
-         if (mangled[9] == 'I')
-           strcpy (r, "global constructors keyed to ");
-         else
-           strcpy (r, "global destructors keyed to ");
-         strcat (r, mangled + 11);
-       }
-      return r;
+      intro = (mangled[9] == 'I')
+              ? "global constructors keyed to "
+              : "global destructors keyed to ";
+
+      callback (intro, strlen (intro), opaque);
+      callback (mangled + 11, strlen (mangled + 11), opaque);
+      return 1;

     }
   else
     {
       if ((options & DMGL_TYPES) == 0)
     }
   else
     {
       if ((options & DMGL_TYPES) == 0)

-       return NULL;
+       return 0;

       type = 1;
     }
 
       type = 1;
     }
 

-  cplus_demangle_init_info (mangled, options, len, &di);
+  cplus_demangle_init_info (mangled, options, strlen (mangled), &di);

 
   {
 #ifdef CP_DYNAMIC_ARRAYS
     __extension__ struct demangle_component comps[di.num_comps];
     __extension__ struct demangle_component *subs[di.num_subs];
 
 
   {
 #ifdef CP_DYNAMIC_ARRAYS
     __extension__ struct demangle_component comps[di.num_comps];
     __extension__ struct demangle_component *subs[di.num_subs];
 

-    di.comps = &comps[0];
-    di.subs = &subs[0];
+    di.comps = comps;
+    di.subs = subs;

 #else
 #else

-    di.comps = ((struct demangle_component *)
-               malloc (di.num_comps * sizeof (struct demangle_component)));
-    di.subs = ((struct demangle_component **)
-              malloc (di.num_subs * sizeof (struct demangle_component *)));
-    if (di.comps == NULL || di.subs == NULL)
-      {
-       if (di.comps != NULL)
-         free (di.comps);
-       if (di.subs != NULL)
-         free (di.subs);
-       *palc = 1;
-       return NULL;
-      }
+    di.comps = alloca (di.num_comps * sizeof (*di.comps));
+    di.subs = alloca (di.num_subs * sizeof (*di.subs));

 #endif
 
 #endif
 

-    if (! type)
-      dc = cplus_demangle_mangled_name (&di, 1);
-    else
+    if (type)

       dc = cplus_demangle_type (&di);
       dc = cplus_demangle_type (&di);

+    else
+      dc = cplus_demangle_mangled_name (&di, 1);

 
     /* If DMGL_PARAMS is set, then if we didn't consume the entire
        mangled string, then we didn't successfully demangle it.  If
 
     /* If DMGL_PARAMS is set, then if we didn't consume the entire
        mangled string, then we didn't successfully demangle it.  If


@@ -3866,46 +3994,43 @@ d_demangle (const char* mangled, int options, size_t *palc)
       dc = NULL;
 
 #ifdef CP_DEMANGLE_DEBUG
       dc = NULL;
 
 #ifdef CP_DEMANGLE_DEBUG

-    if (dc == NULL)
-      printf ("failed demangling\n");
-    else
-      d_dump (dc, 0);
+    d_dump (dc, 0);

 #endif
 
 #endif
 

-    /* We try to guess the length of the demangled string, to minimize
-       calls to realloc during demangling.  */
-    estimate = len + di.expansion + 10 * di.did_subs;
-    estimate += estimate / 8;
+    status = (dc != NULL)
+             ? cplus_demangle_print_callback (options, dc, callback, opaque)
+             : 0;
+  }

 
 

-    ret = NULL;
-    if (dc != NULL)
-      ret = cplus_demangle_print (options, dc, estimate, palc);
+  return status;
+}

 
 

-#ifndef CP_DYNAMIC_ARRAYS
-    free (di.comps);
-    free (di.subs);
-#endif
+/* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
+   name, return a buffer allocated with malloc holding the demangled
+   name.  OPTIONS is the usual libiberty demangler options.  On
+   success, this sets *PALC to the allocated size of the returned
+   buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
+   a memory allocation failure, and returns NULL.  */

 
 

-#ifdef CP_DEMANGLE_DEBUG
-    if (ret != NULL)
-      {
-       int rlen;
-
-       rlen = strlen (ret);
-       if (rlen > 2 * estimate)
-         printf ("*** Length %d much greater than estimate %d\n",
-                 rlen, estimate);
-       else if (rlen > estimate)
-         printf ("*** Length %d greater than estimate %d\n",
-                 rlen, estimate);
-       else if (rlen < estimate / 2)
-         printf ("*** Length %d much less than estimate %d\n",
-                 rlen, estimate);
-      }
-#endif
-  }
+static char *
+d_demangle (const char *mangled, int options, size_t *palc)
+{
+  struct d_growable_string dgs;
+  int status;

 
 

-  return ret;
+  d_growable_string_init (&dgs, 0);
+
+  status = d_demangle_callback (mangled, options,
+                                d_growable_string_callback_adapter, &dgs);
+  if (status == 0)
+    {
+      free (dgs.buf);
+      *palc = 0;
+      return NULL;
+    }
+
+  *palc = dgs.allocation_failure ? 1 : 0;
+  return dgs.buf;

 }
 
 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
 }
 
 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)


@@ -3922,7 +4047,7 @@ extern char *__cxa_demangle (const char *, char *, size_t *, int *);
    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
    is placed in a region of memory allocated with malloc.
 
    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
    is placed in a region of memory allocated with malloc.
 

-   If LENGTH is non-NULL, the length of the buffer conaining the
+   If LENGTH is non-NULL, the length of the buffer containing the

    demangled name, is placed in *LENGTH.
 
    The return value is a pointer to the start of the NUL-terminated
    demangled name, is placed in *LENGTH.
 
    The return value is a pointer to the start of the NUL-terminated


@@ -3999,6 +4124,48 @@ __cxa_demangle (const char *mangled_name, char *output_buffer,
   return demangled;
 }
 
   return demangled;
 }
 

+extern int __gcclibcxx_demangle_callback (const char *,
+                                          void (*)
+                                            (const char *, size_t, void *),
+                                          void *);
+
+/* Alternative, allocationless entry point in the C++ runtime library
+   for performing demangling.  MANGLED_NAME is a NUL-terminated character
+   string containing the name to be demangled.
+
+   CALLBACK is a callback function, called with demangled string
+   segments as demangling progresses; it is called at least once,
+   but may be called more than once.  OPAQUE is a generalized pointer
+   used as a callback argument.
+
+   The return code is one of the following values, equivalent to
+   the STATUS values of __cxa_demangle() (excluding -1, since this
+   function performs no memory allocations):
+      0: The demangling operation succeeded.
+     -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
+     -3: One of the arguments is invalid.
+
+   The demangling is performed using the C++ ABI mangling rules, with
+   GNU extensions.  */
+
+int
+__gcclibcxx_demangle_callback (const char *mangled_name,
+                               void (*callback) (const char *, size_t, void *),
+                               void *opaque)
+{
+  int status;
+
+  if (mangled_name == NULL || callback == NULL)
+    return -3;
+
+  status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
+                                callback, opaque);
+  if (status == 0)
+    return -2;
+
+  return 0;
+}
+

 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
 
 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
 
 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI


@@ -4006,61 +4173,41 @@ __cxa_demangle (const char *mangled_name, char *output_buffer,
    demangled name.  Otherwise, return NULL.  */
 
 char *
    demangled name.  Otherwise, return NULL.  */
 
 char *

-cplus_demangle_v3 (const char* mangled, int options)
+cplus_demangle_v3 (const char *mangled, int options)

 {
   size_t alc;
 
   return d_demangle (mangled, options, &alc);
 }
 
 {
   size_t alc;
 
   return d_demangle (mangled, options, &alc);
 }
 

+int
+cplus_demangle_v3_callback (const char *mangled, int options,
+                            demangle_callbackref callback, void *opaque)
+{
+  return d_demangle_callback (mangled, options, callback, opaque);
+}
+

 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling 
    conventions, but the output formatting is a little different.
 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling 
    conventions, but the output formatting is a little different.

-   This instructs the C++ demangler not to emit pointer characters ("*"), and 
-   to use Java's namespace separator symbol ("." instead of "::").  It then 
-   does an additional pass over the demangled output to replace instances 
-   of JArray<TYPE> with TYPE[].  */
+   This instructs the C++ demangler not to emit pointer characters ("*"), to
+   use Java's namespace separator symbol ("." instead of "::"), and to output
+   JArray<TYPE> as TYPE[].  */

 
 char *
 
 char *

-java_demangle_v3 (const char* mangled)
+java_demangle_v3 (const char *mangled)

 {
   size_t alc;
 {
   size_t alc;

-  char *demangled;
-  int nesting;
-  char *from;
-  char *to;
-
-  demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, 
-                         &alc);
-
-  if (demangled == NULL)
-    return NULL;
-
-  nesting = 0;
-  from = demangled;
-  to = from;
-  while (*from != '\0')
-    {
-      if (strncmp (from, "JArray<", 7) == 0)
-       {
-         from += 7;
-         ++nesting;
-       }
-      else if (nesting > 0 && *from == '>')
-       {
-         while (to > demangled && to[-1] == ' ')
-           --to;
-         *to++ = '[';
-         *to++ = ']';
-         --nesting;
-         ++from;
-       }
-      else
-       *to++ = *from++;
-    }

 
 

-  *to = '\0';
+  return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
+}

 
 

-  return demangled;
+int
+java_demangle_v3_callback (const char *mangled,
+                           demangle_callbackref callback, void *opaque)
+{
+  return d_demangle_callback (mangled,
+                              DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
+                              callback, opaque);

 }
 
 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
 }
 
 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */


@@ -4090,21 +4237,11 @@ is_ctor_or_dtor (const char *mangled,
     __extension__ struct demangle_component comps[di.num_comps];
     __extension__ struct demangle_component *subs[di.num_subs];
 
     __extension__ struct demangle_component comps[di.num_comps];
     __extension__ struct demangle_component *subs[di.num_subs];
 

-    di.comps = &comps[0];
-    di.subs = &subs[0];
+    di.comps = comps;
+    di.subs = subs;

 #else
 #else

-    di.comps = ((struct demangle_component *)
-               malloc (di.num_comps * sizeof (struct demangle_component)));
-    di.subs = ((struct demangle_component **)
-              malloc (di.num_subs * sizeof (struct demangle_component *)));
-    if (di.comps == NULL || di.subs == NULL)
-      {
-       if (di.comps != NULL)
-         free (di.comps);
-       if (di.subs != NULL)
-         free (di.subs);
-       return 0;
-      }
+    di.comps = alloca (di.num_comps * sizeof (*di.comps));
+    di.subs = alloca (di.num_subs * sizeof (*di.subs));

 #endif
 
     dc = cplus_demangle_mangled_name (&di, 1);
 #endif
 
     dc = cplus_demangle_mangled_name (&di, 1);


@@ -4143,11 +4280,6 @@ is_ctor_or_dtor (const char *mangled,
            break;
          }
       }
            break;
          }
       }

-
-#ifndef CP_DYNAMIC_ARRAYS
-    free (di.subs);
-    free (di.comps);
-#endif

   }
 
   return ret;
   }
 
   return ret;

diff --git a/libiberty/cp-demangle.h b/libiberty/cp-demangle.h
index 920ca47..8622f29 100644 (file)
--- a/libiberty/cp-demangle.h
+++ b/libiberty/cp-demangle.h
@@ -1,5 +1,5 @@
 /* Internal demangler interface for g++ V3 ABI.
 /* Internal demangler interface for g++ V3 ABI.

-   Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.

    Written by Ian Lance Taylor <ian@wasabisystems.com>.
 
    This file is part of the libiberty library, which is part of GCC.
    Written by Ian Lance Taylor <ian@wasabisystems.com>.
 
    This file is part of the libiberty library, which is part of GCC.


@@ -143,8 +143,9 @@ struct d_info
 #define CP_STATIC_IF_GLIBCPP_V3 extern
 #endif
 
 #define CP_STATIC_IF_GLIBCPP_V3 extern
 #endif
 

-CP_STATIC_IF_GLIBCPP_V3
-const struct demangle_operator_info cplus_demangle_operators[];
+#ifndef IN_GLIBCPP_V3
+extern const struct demangle_operator_info cplus_demangle_operators[];
+#endif

 
 #define D_BUILTIN_TYPE_COUNT (26)
 
 
 #define D_BUILTIN_TYPE_COUNT (26)