#include "libiberty.h"
+static char *ada_demangle PARAMS ((const char *, int));
+
#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
/* A value at least one greater than the maximum number of characters
"GNU (g++) new-ABI-style demangling"
}
,
+ {
+ JAVA_DEMANGLING_STYLE_STRING,
+ java_demangling,
+ "Java style demangling"
+ }
+ ,
+ {
+ GNAT_DEMANGLING_STYLE_STRING,
+ gnat_demangling,
+ "GNAT style demangling"
+ }
+ ,
{
NULL, unknown_demangling, NULL
}
recursively_demangle PARAMS ((struct work_stuff *, const char **, string *,
int));
+static void
+grow_vect PARAMS ((void **, size_t *, size_t, int));
+
/* Translate count to integer, consuming tokens in the process.
Conversion terminates on the first non-digit character.
char *ret;
struct work_stuff work[1];
memset ((char *) work, 0, sizeof (work));
- work -> options = options;
- if ((work -> options & DMGL_STYLE_MASK) == 0)
- work -> options |= (int) current_demangling_style & DMGL_STYLE_MASK;
+ work->options = options;
+ if ((work->options & DMGL_STYLE_MASK) == 0)
+ work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
/* The new-ABI demangling is implemented elsewhere. */
if (GNU_NEW_ABI_DEMANGLING)
return cplus_demangle_new_abi (mangled);
+ if (GNAT_DEMANGLING)
+ return ada_demangle(mangled,options);
+
ret = internal_cplus_demangle (work, mangled);
squangle_mop_up (work);
return (ret);
}
+/* Assuming *OLD_VECT points to an array of *SIZE objects of size
+ ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
+ updating *OLD_VECT and *SIZE as necessary. */
+
+static void
+grow_vect (old_vect, size, min_size, element_size)
+ void **old_vect;
+ size_t *size;
+ size_t min_size;
+ int element_size;
+{
+ if (*size < min_size)
+ {
+ *size *= 2;
+ if (*size < min_size)
+ *size = min_size;
+ *old_vect = xrealloc (*old_vect, *size * element_size);
+ }
+}
+
+/* Demangle ada names:
+ 1. Discard final __{DIGIT}+ or ${DIGIT}+
+ 2. Convert other instances of embedded "__" to `.'.
+ 3. Discard leading _ada_.
+ 4. Remove everything after first ___ if it is followed by 'X'.
+ 5. Put symbols that should be suppressed in <...> brackets.
+ The resulting string is valid until the next call of ada_demangle. */
+
+static char *
+ada_demangle (mangled, option)
+ const char *mangled;
+ int option ATTRIBUTE_UNUSED;
+{
+ int i, j;
+ int len0;
+ const char* p;
+ char *demangled = NULL;
+ int at_start_name;
+ int changed;
+ char *demangling_buffer = NULL;
+ size_t demangling_buffer_size = 0;
+
+ changed = 0;
+
+ if (strncmp (mangled, "_ada_", 5) == 0)
+ {
+ mangled += 5;
+ changed = 1;
+ }
+
+ if (mangled[0] == '_' || mangled[0] == '<')
+ goto Suppress;
+
+ p = strstr (mangled, "___");
+ if (p == NULL)
+ len0 = strlen (mangled);
+ else
+ {
+ if (p[3] == 'X')
+ {
+ len0 = p - mangled;
+ changed = 1;
+ }
+ else
+ goto Suppress;
+ }
+
+ /* Make demangled big enough for possible expansion by operator name. */
+ grow_vect ((void **) &(demangling_buffer),
+ &demangling_buffer_size, 2 * len0 + 1,
+ sizeof (char));
+ demangled = demangling_buffer;
+
+ if (isdigit ((unsigned char) mangled[len0 - 1])) {
+ for (i = len0 - 2; i >= 0 && isdigit ((unsigned char) mangled[i]); i -= 1)
+ ;
+ if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
+ {
+ len0 = i - 1;
+ changed = 1;
+ }
+ else if (mangled[i] == '$')
+ {
+ len0 = i;
+ changed = 1;
+ }
+ }
+
+ for (i = 0, j = 0; i < len0 && ! isalpha ((unsigned char)mangled[i]);
+ i += 1, j += 1)
+ demangled[j] = mangled[i];
+
+ at_start_name = 1;
+ while (i < len0)
+ {
+ at_start_name = 0;
+
+ if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
+ {
+ demangled[j] = '.';
+ changed = at_start_name = 1;
+ i += 2; j += 1;
+ }
+ else
+ {
+ demangled[j] = mangled[i];
+ i += 1; j += 1;
+ }
+ }
+ demangled[j] = '\000';
+
+ for (i = 0; demangled[i] != '\0'; i += 1)
+ if (isupper ((unsigned char)demangled[i]) || demangled[i] == ' ')
+ goto Suppress;
+
+ if (! changed)
+ return NULL;
+ else
+ return demangled;
+
+ Suppress:
+ grow_vect ((void **) &(demangling_buffer),
+ &demangling_buffer_size, strlen (mangled) + 3,
+ sizeof (char));
+ demangled = demangling_buffer;
+ if (mangled[0] == '<')
+ strcpy (demangled, mangled);
+ else
+ sprintf (demangled, "<%s>", mangled);
+
+ return demangled;
+}
+
/* This function performs most of what cplus_demangle use to do, but
to be able to demangle a name with a B, K or n code, we need to
have a longer term memory of what types have been seen. The original
string decl;
int success = 0;
char *demangled = NULL;
- int s1,s2,s3,s4;
+ int s1, s2, s3, s4;
s1 = work->constructor;
s2 = work->destructor;
s3 = work->static_type;
work->destructor = s2;
work->static_type = s3;
work->type_quals = s4;
- return (demangled);
+ return demangled;
}
else
{
string_appendn (declp, "", 1);
- demangled = declp -> b;
+ demangled = declp->b;
}
return (demangled);
}
case gnu_demangling:
case lucid_demangling:
case arm_demangling:
+ case java_demangling:
case edg_demangling:
+ case gnat_demangling:
valid_symbols = standard_symbol_characters ();
break;
case hp_demangling: