OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
gcc/libiberty/cp-demangle.c

4200 lines
122 KiB
C
Raw Blame History

/* Demangler for IA64 / g++ V3 ABI.
Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
Written by Alex Samuel <samuel@codesourcery.com>.
This file is part of the libiberty library, which is part of GCC.
This file is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file. (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combined
executable.)
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* This file implements demangling of C++ names mangled according to
the IA64 / g++ V3 ABI. Use the cp_demangle function to
demangle a mangled name, or compile with the preprocessor macro
STANDALONE_DEMANGLER defined to create a demangling filter
executable (functionally similar to c++filt, but includes this
demangler only). */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <sys/types.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <stdio.h>
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include <ctype.h>
#include "ansidecl.h"
#include "libiberty.h"
#include "dyn-string.h"
#include "demangle.h"
/* If CP_DEMANGLE_DEBUG is defined, a trace of the grammar evaluation,
and other debugging output, will be generated. */
#ifdef CP_DEMANGLE_DEBUG
#define DEMANGLE_TRACE(PRODUCTION, DM) \
fprintf (stderr, " -> %-24s at position %3d\n", \
(PRODUCTION), current_position (DM));
#else
#define DEMANGLE_TRACE(PRODUCTION, DM)
#endif
/* Don't include <ctype.h>, to prevent additional unresolved symbols
from being dragged into the C++ runtime library. */
#define IS_DIGIT(CHAR) ((CHAR) >= '0' && (CHAR) <= '9')
#define IS_ALPHA(CHAR) \
(((CHAR) >= 'a' && (CHAR) <= 'z') \
|| ((CHAR) >= 'A' && (CHAR) <= 'Z'))
/* The prefix prepended by GCC to an identifier represnting the
anonymous namespace. */
#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
/* Character(s) to use for namespace separation in demangled output */
#define NAMESPACE_SEPARATOR (dm->style == DMGL_JAVA ? "." : "::")
/* If flag_verbose is zero, some simplifications will be made to the
output to make it easier to read and supress details that are
generally not of interest to the average C++ programmer.
Otherwise, the demangled representation will attempt to convey as
much information as the mangled form. */
static int flag_verbose;
/* If flag_strict is non-zero, demangle strictly according to the
specification -- don't demangle special g++ manglings. */
static int flag_strict;
/* String_list_t is an extended form of dyn_string_t which provides a
link field and a caret position for additions to the string. A
string_list_t may safely be cast to and used as a dyn_string_t. */
struct string_list_def
{
/* The dyn_string; must be first. */
struct dyn_string string;
/* The position at which additional text is added to this string
(using the result_add* macros). This value is an offset from the
end of the string, not the beginning (and should be
non-positive). */
int caret_position;
/* The next string in the list. */
struct string_list_def *next;
};
typedef struct string_list_def *string_list_t;
/* Data structure representing a potential substitution. */
struct substitution_def
{
/* The demangled text of the substitution. */
dyn_string_t text;
/* Whether this substitution represents a template item. */
int template_p : 1;
};
/* Data structure representing a template argument list. */
struct template_arg_list_def
{
/* The next (lower) template argument list in the stack of currently
active template arguments. */
struct template_arg_list_def *next;
/* The first element in the list of template arguments in
left-to-right order. */
string_list_t first_argument;
/* The last element in the arguments lists. */
string_list_t last_argument;
};
typedef struct template_arg_list_def *template_arg_list_t;
/* Data structure to maintain the state of the current demangling. */
struct demangling_def
{
/* The full mangled name being mangled. */
const char *name;
/* Pointer into name at the current position. */
const char *next;
/* Stack for strings containing demangled result generated so far.
Text is emitted to the topmost (first) string. */
string_list_t result;
/* The number of presently available substitutions. */
int num_substitutions;
/* The allocated size of the substitutions array. */
int substitutions_allocated;
/* An array of available substitutions. The number of elements in
the array is given by num_substitions, and the allocated array
size in substitutions_size.
The most recent substition is at the end, so
- `S_' corresponds to substititutions[num_substitutions - 1]
- `S0_' corresponds to substititutions[num_substitutions - 2]
etc. */
struct substitution_def *substitutions;
/* The stack of template argument lists. */
template_arg_list_t template_arg_lists;
/* The most recently demangled source-name. */
dyn_string_t last_source_name;
/* Language style to use for demangled output. */
int style;
/* Set to non-zero iff this name is a constructor. The actual value
indicates what sort of constructor this is; see demangle.h. */
enum gnu_v3_ctor_kinds is_constructor;
/* Set to non-zero iff this name is a destructor. The actual value
indicates what sort of destructor this is; see demangle.h. */
enum gnu_v3_dtor_kinds is_destructor;
};
typedef struct demangling_def *demangling_t;
/* This type is the standard return code from most functions. Values
other than STATUS_OK contain descriptive messages. */
typedef const char *status_t;
/* Special values that can be used as a status_t. */
#define STATUS_OK NULL
#define STATUS_ERROR "Error."
#define STATUS_UNIMPLEMENTED "Unimplemented."
#define STATUS_INTERNAL_ERROR "Internal error."
/* This status code indicates a failure in malloc or realloc. */
static const char *const status_allocation_failed = "Allocation failed.";
#define STATUS_ALLOCATION_FAILED status_allocation_failed
/* Non-zero if STATUS indicates that no error has occurred. */
#define STATUS_NO_ERROR(STATUS) ((STATUS) == STATUS_OK)
/* Evaluate EXPR, which must produce a status_t. If the status code
indicates an error, return from the current function with that
status code. */
#define RETURN_IF_ERROR(EXPR) \
do \
{ \
status_t s = EXPR; \
if (!STATUS_NO_ERROR (s)) \
return s; \
} \
while (0)
static status_t int_to_dyn_string
PARAMS ((int, dyn_string_t));
static string_list_t string_list_new
PARAMS ((int));
static void string_list_delete
PARAMS ((string_list_t));
static status_t result_add_separated_char
PARAMS ((demangling_t, int));
static status_t result_push
PARAMS ((demangling_t));
static string_list_t result_pop
PARAMS ((demangling_t));
static int substitution_start
PARAMS ((demangling_t));
static status_t substitution_add
PARAMS ((demangling_t, int, int));
static dyn_string_t substitution_get
PARAMS ((demangling_t, int, int *));
#ifdef CP_DEMANGLE_DEBUG
static void substitutions_print
PARAMS ((demangling_t, FILE *));
#endif
static template_arg_list_t template_arg_list_new
PARAMS ((void));
static void template_arg_list_delete
PARAMS ((template_arg_list_t));
static void template_arg_list_add_arg
PARAMS ((template_arg_list_t, string_list_t));
static string_list_t template_arg_list_get_arg
PARAMS ((template_arg_list_t, int));
static void push_template_arg_list
PARAMS ((demangling_t, template_arg_list_t));
static void pop_to_template_arg_list
PARAMS ((demangling_t, template_arg_list_t));
#ifdef CP_DEMANGLE_DEBUG
static void template_arg_list_print
PARAMS ((template_arg_list_t, FILE *));
#endif
static template_arg_list_t current_template_arg_list
PARAMS ((demangling_t));
static demangling_t demangling_new
PARAMS ((const char *, int));
static void demangling_delete
PARAMS ((demangling_t));
/* The last character of DS. Warning: DS is evaluated twice. */
#define dyn_string_last_char(DS) \
(dyn_string_buf (DS)[dyn_string_length (DS) - 1])
/* Append a space character (` ') to DS if it does not already end
with one. Evaluates to 1 on success, or 0 on allocation failure. */
#define dyn_string_append_space(DS) \
((dyn_string_length (DS) > 0 \
&& dyn_string_last_char (DS) != ' ') \
? dyn_string_append_char ((DS), ' ') \
: 1)
/* Returns the index of the current position in the mangled name. */
#define current_position(DM) ((DM)->next - (DM)->name)
/* Returns the character at the current position of the mangled name. */
#define peek_char(DM) (*((DM)->next))
/* Returns the character one past the current position of the mangled
name. */
#define peek_char_next(DM) \
(peek_char (DM) == '\0' ? '\0' : (*((DM)->next + 1)))
/* Returns the character at the current position, and advances the
current position to the next character. */
#define next_char(DM) (*((DM)->next)++)
/* Returns non-zero if the current position is the end of the mangled
name, i.e. one past the last character. */
#define end_of_name_p(DM) (peek_char (DM) == '\0')
/* Advances the current position by one character. */
#define advance_char(DM) (++(DM)->next)
/* Returns the string containing the current demangled result. */
#define result_string(DM) (&(DM)->result->string)
/* Returns the position at which new text is inserted into the
demangled result. */
#define result_caret_pos(DM) \
(result_length (DM) + \
((string_list_t) result_string (DM))->caret_position)
/* Adds a dyn_string_t to the demangled result. */
#define result_add_string(DM, STRING) \
(dyn_string_insert (&(DM)->result->string, \
result_caret_pos (DM), (STRING)) \
? STATUS_OK : STATUS_ALLOCATION_FAILED)
/* Adds NUL-terminated string CSTR to the demangled result. */
#define result_add(DM, CSTR) \
(dyn_string_insert_cstr (&(DM)->result->string, \
result_caret_pos (DM), (CSTR)) \
? STATUS_OK : STATUS_ALLOCATION_FAILED)
/* Adds character CHAR to the demangled result. */
#define result_add_char(DM, CHAR) \
(dyn_string_insert_char (&(DM)->result->string, \
result_caret_pos (DM), (CHAR)) \
? STATUS_OK : STATUS_ALLOCATION_FAILED)
/* Inserts a dyn_string_t to the demangled result at position POS. */
#define result_insert_string(DM, POS, STRING) \
(dyn_string_insert (&(DM)->result->string, (POS), (STRING)) \
? STATUS_OK : STATUS_ALLOCATION_FAILED)
/* Inserts NUL-terminated string CSTR to the demangled result at
position POS. */
#define result_insert(DM, POS, CSTR) \
(dyn_string_insert_cstr (&(DM)->result->string, (POS), (CSTR)) \
? STATUS_OK : STATUS_ALLOCATION_FAILED)
/* Inserts character CHAR to the demangled result at position POS. */
#define result_insert_char(DM, POS, CHAR) \
(dyn_string_insert_char (&(DM)->result->string, (POS), (CHAR)) \
? STATUS_OK : STATUS_ALLOCATION_FAILED)
/* The length of the current demangled result. */
#define result_length(DM) \
dyn_string_length (&(DM)->result->string)
/* Appends a (less-than, greater-than) character to the result in DM
to (open, close) a template argument or parameter list. Appends a
space first if necessary to prevent spurious elision of angle
brackets with the previous character. */
#define result_open_template_list(DM) result_add_separated_char(DM, '<')
#define result_close_template_list(DM) result_add_separated_char(DM, '>')
/* Appends a base 10 representation of VALUE to DS. STATUS_OK on
success. On failure, deletes DS and returns an error code. */
static status_t
int_to_dyn_string (value, ds)
int value;
dyn_string_t ds;
{
int i;
int mask = 1;
/* Handle zero up front. */
if (value == 0)
{
if (!dyn_string_append_char (ds, '0'))
return STATUS_ALLOCATION_FAILED;
return STATUS_OK;
}
/* For negative numbers, emit a minus sign. */
if (value < 0)
{
if (!dyn_string_append_char (ds, '-'))
return STATUS_ALLOCATION_FAILED;
value = -value;
}
/* Find the power of 10 of the first digit. */
i = value;
while (i > 9)
{
mask *= 10;
i /= 10;
}
/* Write the digits. */
while (mask > 0)
{
int digit = value / mask;
if (!dyn_string_append_char (ds, '0' + digit))
return STATUS_ALLOCATION_FAILED;
value -= digit * mask;
mask /= 10;
}
return STATUS_OK;
}
/* Creates a new string list node. The contents of the string are
empty, but the initial buffer allocation is LENGTH. The string
list node should be deleted with string_list_delete. Returns NULL
if allocation fails. */
static string_list_t
string_list_new (length)
int length;
{
string_list_t s = (string_list_t) malloc (sizeof (struct string_list_def));
s->caret_position = 0;
if (s == NULL)
return NULL;
if (!dyn_string_init ((dyn_string_t) s, length))
return NULL;
return s;
}
/* Deletes the entire string list starting at NODE. */
static void
string_list_delete (node)
string_list_t node;
{
while (node != NULL)
{
string_list_t next = node->next;
dyn_string_delete ((dyn_string_t) node);
node = next;
}
}
/* Appends CHARACTER to the demangled result. If the current trailing
character of the result is CHARACTER, a space is inserted first. */
static status_t
result_add_separated_char (dm, character)
demangling_t dm;
int character;
{
char *result = dyn_string_buf (result_string (dm));
int caret_pos = result_caret_pos (dm);
/* Add a space if the last character is already the character we
want to add. */
if (caret_pos > 0 && result[caret_pos - 1] == character)
RETURN_IF_ERROR (result_add_char (dm, ' '));
/* Add the character. */
RETURN_IF_ERROR (result_add_char (dm, character));
return STATUS_OK;
}
/* Allocates and pushes a new string onto the demangled results stack
for DM. Subsequent demangling with DM will emit to the new string.
Returns STATUS_OK on success, STATUS_ALLOCATION_FAILED on
allocation failure. */
static status_t
result_push (dm)
demangling_t dm;
{
string_list_t new_string = string_list_new (0);
if (new_string == NULL)
/* Allocation failed. */
return STATUS_ALLOCATION_FAILED;
/* Link the new string to the front of the list of result strings. */
new_string->next = (string_list_t) dm->result;
dm->result = new_string;
return STATUS_OK;
}
/* Removes and returns the topmost element on the demangled results
stack for DM. The caller assumes ownership for the returned
string. */
static string_list_t
result_pop (dm)
demangling_t dm;
{
string_list_t top = dm->result;
dm->result = top->next;
return top;
}
/* Returns the current value of the caret for the result string. The
value is an offet from the end of the result string. */
static int
result_get_caret (dm)
demangling_t dm;
{
return ((string_list_t) result_string (dm))->caret_position;
}
/* Sets the value of the caret for the result string, counted as an
offet from the end of the result string. */
static void
result_set_caret (dm, position)
demangling_t dm;
int position;
{
((string_list_t) result_string (dm))->caret_position = position;
}
/* Shifts the position of the next addition to the result by
POSITION_OFFSET. A negative value shifts the caret to the left. */
static void
result_shift_caret (dm, position_offset)
demangling_t dm;
int position_offset;
{
((string_list_t) result_string (dm))->caret_position += position_offset;
}
/* Returns non-zero if the character that comes right before the place
where text will be added to the result is a space. In this case,
the caller should supress adding another space. */
static int
result_previous_char_is_space (dm)
demangling_t dm;
{
char *result = dyn_string_buf (result_string (dm));
int pos = result_caret_pos (dm);
return pos > 0 && result[pos - 1] == ' ';
}
/* Returns the start position of a fragment of the demangled result
that will be a substitution candidate. Should be called at the
start of productions that can add substitutions. */
static int
substitution_start (dm)
demangling_t dm;
{
return result_caret_pos (dm);
}
/* Adds the suffix of the current demangled result of DM starting at
START_POSITION as a potential substitution. If TEMPLATE_P is
non-zero, this potential substitution is a template-id. */
static status_t
substitution_add (dm, start_position, template_p)
demangling_t dm;
int start_position;
int template_p;
{
dyn_string_t result = result_string (dm);
dyn_string_t substitution = dyn_string_new (0);
int i;
if (substitution == NULL)
return STATUS_ALLOCATION_FAILED;
/* Extract the substring of the current demangling result that
represents the subsitution candidate. */
if (!dyn_string_substring (substitution,
result, start_position, result_caret_pos (dm)))
{
dyn_string_delete (substitution);
return STATUS_ALLOCATION_FAILED;
}
/* If there's no room for the new entry, grow the array. */
if (dm->substitutions_allocated == dm->num_substitutions)
{
size_t new_array_size;
if (dm->substitutions_allocated > 0)
dm->substitutions_allocated *= 2;
else
dm->substitutions_allocated = 2;
new_array_size =
sizeof (struct substitution_def) * dm->substitutions_allocated;
dm->substitutions = (struct substitution_def *)
realloc (dm->substitutions, new_array_size);
if (dm->substitutions == NULL)
/* Realloc failed. */
{
dyn_string_delete (substitution);
return STATUS_ALLOCATION_FAILED;
}
}
/* Add the substitution to the array. */
i = dm->num_substitutions++;
dm->substitutions[i].text = substitution;
dm->substitutions[i].template_p = template_p;
#ifdef CP_DEMANGLE_DEBUG
substitutions_print (dm, stderr);
#endif
return STATUS_OK;
}
/* Returns the Nth-most-recent substitution. Sets *TEMPLATE_P to
non-zero if the substitution is a template-id, zero otherwise.
N is numbered from zero. DM retains ownership of the returned
string. If N is negative, or equal to or greater than the current
number of substitution candidates, returns NULL. */
static dyn_string_t
substitution_get (dm, n, template_p)
demangling_t dm;
int n;
int *template_p;
{
struct substitution_def *sub;
/* Make sure N is in the valid range. */
if (n < 0 || n >= dm->num_substitutions)
return NULL;
sub = &(dm->substitutions[n]);
*template_p = sub->template_p;
return sub->text;
}
#ifdef CP_DEMANGLE_DEBUG
/* Debugging routine to print the current substitutions to FP. */
static void
substitutions_print (dm, fp)
demangling_t dm;
FILE *fp;
{
int seq_id;
int num = dm->num_substitutions;
fprintf (fp, "SUBSTITUTIONS:\n");
for (seq_id = -1; seq_id < num - 1; ++seq_id)
{
int template_p;
dyn_string_t text = substitution_get (dm, seq_id + 1, &template_p);
if (seq_id == -1)
fprintf (fp, " S_ ");
else
fprintf (fp, " S%d_", seq_id);
fprintf (fp, " %c: %s\n", template_p ? '*' : ' ', dyn_string_buf (text));
}
}
#endif /* CP_DEMANGLE_DEBUG */
/* Creates a new template argument list. Returns NULL if allocation
fails. */
static template_arg_list_t
template_arg_list_new ()
{
template_arg_list_t new_list =
(template_arg_list_t) malloc (sizeof (struct template_arg_list_def));
if (new_list == NULL)
return NULL;
/* Initialize the new list to have no arguments. */
new_list->first_argument = NULL;
new_list->last_argument = NULL;
/* Return the new list. */
return new_list;
}
/* Deletes a template argument list and the template arguments it
contains. */
static void
template_arg_list_delete (list)
template_arg_list_t list;
{
/* If there are any arguments on LIST, delete them. */
if (list->first_argument != NULL)
string_list_delete (list->first_argument);
/* Delete LIST. */
free (list);
}
/* Adds ARG to the template argument list ARG_LIST. */
static void
template_arg_list_add_arg (arg_list, arg)
template_arg_list_t arg_list;
string_list_t arg;
{
if (arg_list->first_argument == NULL)
/* If there were no arguments before, ARG is the first one. */
arg_list->first_argument = arg;
else
/* Make ARG the last argument on the list. */
arg_list->last_argument->next = arg;
/* Make ARG the last on the list. */
arg_list->last_argument = arg;
arg->next = NULL;
}
/* Returns the template arugment at position INDEX in template
argument list ARG_LIST. */
static string_list_t
template_arg_list_get_arg (arg_list, index)
template_arg_list_t arg_list;
int index;
{
string_list_t arg = arg_list->first_argument;
/* Scan down the list of arguments to find the one at position
INDEX. */
while (index--)
{
arg = arg->next;
if (arg == NULL)
/* Ran out of arguments before INDEX hit zero. That's an
error. */
return NULL;
}
/* Return the argument at position INDEX. */
return arg;
}
/* Pushes ARG_LIST onto the top of the template argument list stack. */
static void
push_template_arg_list (dm, arg_list)
demangling_t dm;
template_arg_list_t arg_list;
{
arg_list->next = dm->template_arg_lists;
dm->template_arg_lists = arg_list;
#ifdef CP_DEMANGLE_DEBUG
fprintf (stderr, " ** pushing template arg list\n");
template_arg_list_print (arg_list, stderr);
#endif
}
/* Pops and deletes elements on the template argument list stack until
arg_list is the topmost element. If arg_list is NULL, all elements
are popped and deleted. */
static void
pop_to_template_arg_list (dm, arg_list)
demangling_t dm;
template_arg_list_t arg_list;
{
while (dm->template_arg_lists != arg_list)
{
template_arg_list_t top = dm->template_arg_lists;
/* Disconnect the topmost element from the list. */
dm->template_arg_lists = top->next;
/* Delete the popped element. */
template_arg_list_delete (top);
#ifdef CP_DEMANGLE_DEBUG
fprintf (stderr, " ** removing template arg list\n");
#endif
}
}
#ifdef CP_DEMANGLE_DEBUG
/* Prints the contents of ARG_LIST to FP. */
static void
template_arg_list_print (arg_list, fp)
template_arg_list_t arg_list;
FILE *fp;
{
string_list_t arg;
int index = -1;
fprintf (fp, "TEMPLATE ARGUMENT LIST:\n");
for (arg = arg_list->first_argument; arg != NULL; arg = arg->next)
{
if (index == -1)
fprintf (fp, " T_ : ");
else
fprintf (fp, " T%d_ : ", index);
++index;
fprintf (fp, "%s\n", dyn_string_buf ((dyn_string_t) arg));
}
}
#endif /* CP_DEMANGLE_DEBUG */
/* Returns the topmost element on the stack of template argument
lists. If there is no list of template arguments, returns NULL. */
static template_arg_list_t
current_template_arg_list (dm)
demangling_t dm;
{
return dm->template_arg_lists;
}
/* Allocates a demangling_t object for demangling mangled NAME. A new
result must be pushed before the returned object can be used.
Returns NULL if allocation fails. */
static demangling_t
demangling_new (name, style)
const char *name;
int style;
{
demangling_t dm;
dm = (demangling_t) malloc (sizeof (struct demangling_def));
if (dm == NULL)
return NULL;
dm->name = name;
dm->next = name;
dm->result = NULL;
dm->num_substitutions = 0;
dm->substitutions_allocated = 10;
dm->template_arg_lists = NULL;
dm->last_source_name = dyn_string_new (0);
if (dm->last_source_name == NULL)
return NULL;
dm->substitutions = (struct substitution_def *)
malloc (dm->substitutions_allocated * sizeof (struct substitution_def));
if (dm->substitutions == NULL)
{
dyn_string_delete (dm->last_source_name);
return NULL;
}
dm->style = style;
dm->is_constructor = (enum gnu_v3_ctor_kinds) 0;
dm->is_destructor = (enum gnu_v3_dtor_kinds) 0;
return dm;
}
/* Deallocates a demangling_t object and all memory associated with
it. */
static void
demangling_delete (dm)
demangling_t dm;
{
int i;
template_arg_list_t arg_list = dm->template_arg_lists;
/* Delete the stack of template argument lists. */
while (arg_list != NULL)
{
template_arg_list_t next = arg_list->next;
template_arg_list_delete (arg_list);
arg_list = next;
}
/* Delete the list of substitutions. */
for (i = dm->num_substitutions; --i >= 0; )
dyn_string_delete (dm->substitutions[i].text);
free (dm->substitutions);
/* Delete the demangled result. */
string_list_delete (dm->result);
/* Delete the stored identifier name. */
dyn_string_delete (dm->last_source_name);
/* Delete the context object itself. */
free (dm);
}
/* These functions demangle an alternative of the corresponding
production in the mangling spec. The first argument of each is a
demangling context structure for the current demangling
operation. Most emit demangled text directly to the topmost result
string on the result string stack in the demangling context
structure. */
static status_t demangle_char
PARAMS ((demangling_t, int));
static status_t demangle_mangled_name
PARAMS ((demangling_t));
static status_t demangle_encoding
PARAMS ((demangling_t));
static status_t demangle_name
PARAMS ((demangling_t, int *));
static status_t demangle_nested_name
PARAMS ((demangling_t, int *));
static status_t demangle_prefix
PARAMS ((demangling_t, int *));
static status_t demangle_unqualified_name
PARAMS ((demangling_t, int *));
static status_t demangle_source_name
PARAMS ((demangling_t));
static status_t demangle_number
PARAMS ((demangling_t, int *, int, int));
static status_t demangle_number_literally
PARAMS ((demangling_t, dyn_string_t, int, int));
static status_t demangle_identifier
PARAMS ((demangling_t, int, dyn_string_t));
static status_t demangle_operator_name
PARAMS ((demangling_t, int, int *, int *));
static status_t demangle_nv_offset
PARAMS ((demangling_t));
static status_t demangle_v_offset
PARAMS ((demangling_t));
static status_t demangle_call_offset
PARAMS ((demangling_t));
static status_t demangle_special_name
PARAMS ((demangling_t));
static status_t demangle_ctor_dtor_name
PARAMS ((demangling_t));
static status_t demangle_type_ptr
PARAMS ((demangling_t, int *, int));
static status_t demangle_type
PARAMS ((demangling_t));
static status_t demangle_CV_qualifiers
PARAMS ((demangling_t, dyn_string_t));
static status_t demangle_builtin_type
PARAMS ((demangling_t));
static status_t demangle_function_type
PARAMS ((demangling_t, int *));
static status_t demangle_bare_function_type
PARAMS ((demangling_t, int *));
static status_t demangle_class_enum_type
PARAMS ((demangling_t, int *));
static status_t demangle_array_type
PARAMS ((demangling_t, int *));
static status_t demangle_template_param
PARAMS ((demangling_t));
static status_t demangle_template_args
PARAMS ((demangling_t));
static status_t demangle_literal
PARAMS ((demangling_t));
static status_t demangle_template_arg
PARAMS ((demangling_t));
static status_t demangle_expression
PARAMS ((demangling_t));
static status_t demangle_scope_expression
PARAMS ((demangling_t));
static status_t demangle_expr_primary
PARAMS ((demangling_t));
static status_t demangle_substitution
PARAMS ((demangling_t, int *));
static status_t demangle_local_name
PARAMS ((demangling_t));
static status_t demangle_discriminator
PARAMS ((demangling_t, int));
static status_t cp_demangle
PARAMS ((const char *, dyn_string_t, int));
static status_t cp_demangle_type
PARAMS ((const char*, dyn_string_t));
/* When passed to demangle_bare_function_type, indicates that the
function's return type is not encoded before its parameter types. */
#define BFT_NO_RETURN_TYPE NULL
/* Check that the next character is C. If so, consume it. If not,
return an error. */
static status_t
demangle_char (dm, c)
demangling_t dm;
int c;
{
static char *error_message = NULL;
if (peek_char (dm) == c)
{
advance_char (dm);
return STATUS_OK;
}
else
{
if (error_message == NULL)
error_message = (char *) strdup ("Expected ?");
error_message[9] = c;
return error_message;
}
}
/* Demangles and emits a <mangled-name>.
<mangled-name> ::= _Z <encoding> */
static status_t
demangle_mangled_name (dm)
demangling_t dm;
{
DEMANGLE_TRACE ("mangled-name", dm);
RETURN_IF_ERROR (demangle_char (dm, '_'));
RETURN_IF_ERROR (demangle_char (dm, 'Z'));
RETURN_IF_ERROR (demangle_encoding (dm));
return STATUS_OK;
}
/* Demangles and emits an <encoding>.
<encoding> ::= <function name> <bare-function-type>
::= <data name>
::= <special-name> */
static status_t
demangle_encoding (dm)
demangling_t dm;
{
int encode_return_type;
int start_position;
template_arg_list_t old_arg_list = current_template_arg_list (dm);
char peek = peek_char (dm);
DEMANGLE_TRACE ("encoding", dm);
/* Remember where the name starts. If it turns out to be a template
function, we'll have to insert the return type here. */
start_position = result_caret_pos (dm);
if (peek == 'G' || peek == 'T')
RETURN_IF_ERROR (demangle_special_name (dm));
else
{
/* Now demangle the name. */
RETURN_IF_ERROR (demangle_name (dm, &encode_return_type));
/* If there's anything left, the name was a function name, with
maybe its return type, and its parameter types, following. */
if (!end_of_name_p (dm)
&& peek_char (dm) != 'E')
{
if (encode_return_type)
/* Template functions have their return type encoded. The
return type should be inserted at start_position. */
RETURN_IF_ERROR
(demangle_bare_function_type (dm, &start_position));
else
/* Non-template functions don't have their return type
encoded. */
RETURN_IF_ERROR
(demangle_bare_function_type (dm, BFT_NO_RETURN_TYPE));
}
}
/* Pop off template argument lists that were built during the
mangling of this name, to restore the old template context. */
pop_to_template_arg_list (dm, old_arg_list);
return STATUS_OK;
}
/* Demangles and emits a <name>.
<name> ::= <unscoped-name>
::= <unscoped-template-name> <template-args>
::= <nested-name>
::= <local-name>
<unscoped-name> ::= <unqualified-name>
::= St <unqualified-name> # ::std::
<unscoped-template-name>
::= <unscoped-name>
::= <substitution> */
static status_t
demangle_name (dm, encode_return_type)
demangling_t dm;
int *encode_return_type;
{
int start = substitution_start (dm);
char peek = peek_char (dm);
int is_std_substitution = 0;
/* Generally, the return type is encoded if the function is a
template-id, and suppressed otherwise. There are a few cases,
though, in which the return type is not encoded even for a
templated function. In these cases, this flag is set. */
int suppress_return_type = 0;
DEMANGLE_TRACE ("name", dm);
switch (peek)
{
case 'N':
/* This is a <nested-name>. */
RETURN_IF_ERROR (demangle_nested_name (dm, encode_return_type));
break;
case 'Z':
RETURN_IF_ERROR (demangle_local_name (dm));
*encode_return_type = 0;
break;
case 'S':
/* The `St' substitution allows a name nested in std:: to appear
without being enclosed in a nested name. */
if (peek_char_next (dm) == 't')
{
(void) next_char (dm);
(void) next_char (dm);
RETURN_IF_ERROR (result_add (dm, "std::"));
RETURN_IF_ERROR
(demangle_unqualified_name (dm, &suppress_return_type));
is_std_substitution = 1;
}
else
RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
/* Check if a template argument list immediately follows.
If so, then we just demangled an <unqualified-template-name>. */
if (peek_char (dm) == 'I')
{
/* A template name of the form std::<unqualified-name> is a
substitution candidate. */
if (is_std_substitution)
RETURN_IF_ERROR (substitution_add (dm, start, 0));
/* Demangle the <template-args> here. */
RETURN_IF_ERROR (demangle_template_args (dm));
*encode_return_type = !suppress_return_type;
}
else
*encode_return_type = 0;
break;
default:
/* This is an <unscoped-name> or <unscoped-template-name>. */
RETURN_IF_ERROR (demangle_unqualified_name (dm, &suppress_return_type));
/* If the <unqualified-name> is followed by template args, this
is an <unscoped-template-name>. */
if (peek_char (dm) == 'I')
{
/* Add a substitution for the unqualified template name. */
RETURN_IF_ERROR (substitution_add (dm, start, 0));
RETURN_IF_ERROR (demangle_template_args (dm));
*encode_return_type = !suppress_return_type;
}
else
*encode_return_type = 0;
break;
}
return STATUS_OK;
}
/* Demangles and emits a <nested-name>.
<nested-name> ::= N [<CV-qualifiers>] <prefix> <unqulified-name> E */
static status_t
demangle_nested_name (dm, encode_return_type)
demangling_t dm;
int *encode_return_type;
{
char peek;
DEMANGLE_TRACE ("nested-name", dm);
RETURN_IF_ERROR (demangle_char (dm, 'N'));
peek = peek_char (dm);
if (peek == 'r' || peek == 'V' || peek == 'K')
{
dyn_string_t cv_qualifiers;
status_t status;
/* Snarf up CV qualifiers. */
cv_qualifiers = dyn_string_new (24);
if (cv_qualifiers == NULL)
return STATUS_ALLOCATION_FAILED;
demangle_CV_qualifiers (dm, cv_qualifiers);
/* Emit them, preceded by a space. */
status = result_add_char (dm, ' ');
if (STATUS_NO_ERROR (status))
status = result_add_string (dm, cv_qualifiers);
/* The CV qualifiers that occur in a <nested-name> will be
qualifiers for member functions. These are placed at the end
of the function. Therefore, shift the caret to the left by
the length of the qualifiers, so other text is inserted
before them and they stay at the end. */
result_shift_caret (dm, -dyn_string_length (cv_qualifiers) - 1);
/* Clean up. */
dyn_string_delete (cv_qualifiers);
RETURN_IF_ERROR (status);
}
RETURN_IF_ERROR (demangle_prefix (dm, encode_return_type));
/* No need to demangle the final <unqualified-name>; demangle_prefix
will handle it. */
RETURN_IF_ERROR (demangle_char (dm, 'E'));
return STATUS_OK;
}
/* Demangles and emits a <prefix>.
<prefix> ::= <prefix> <unqualified-name>
::= <template-prefix> <template-args>
::= # empty
::= <substitution>
<template-prefix> ::= <prefix>
::= <substitution> */
static status_t
demangle_prefix (dm, encode_return_type)
demangling_t dm;
int *encode_return_type;
{
int start = substitution_start (dm);
int nested = 0;
/* ENCODE_RETURN_TYPE is updated as we decend the nesting chain.
After <template-args>, it is set to non-zero; after everything
else it is set to zero. */
/* Generally, the return type is encoded if the function is a
template-id, and suppressed otherwise. There are a few cases,
though, in which the return type is not encoded even for a
templated function. In these cases, this flag is set. */
int suppress_return_type = 0;
DEMANGLE_TRACE ("prefix", dm);
while (1)
{
char peek;
if (end_of_name_p (dm))
return "Unexpected end of name in <compound-name>.";
peek = peek_char (dm);
/* We'll initialize suppress_return_type to false, and set it to true
if we end up demangling a constructor name. However, make
sure we're not actually about to demangle template arguments
-- if so, this is the <template-args> following a
<template-prefix>, so we'll want the previous flag value
around. */
if (peek != 'I')
suppress_return_type = 0;
if (IS_DIGIT ((unsigned char) peek)
|| (peek >= 'a' && peek <= 'z')
|| peek == 'C' || peek == 'D'
|| peek == 'S')
{
/* We have another level of scope qualification. */
if (nested)
RETURN_IF_ERROR (result_add (dm, NAMESPACE_SEPARATOR));
else
nested = 1;
if (peek == 'S')
/* The substitution determines whether this is a
template-id. */
RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
else
{
/* It's just a name. */
RETURN_IF_ERROR
(demangle_unqualified_name (dm, &suppress_return_type));
*encode_return_type = 0;
}
}
else if (peek == 'Z')
RETURN_IF_ERROR (demangle_local_name (dm));
else if (peek == 'I')
{
RETURN_IF_ERROR (demangle_template_args (dm));
/* Now we want to indicate to the caller that we've
demangled template arguments, thus the prefix was a
<template-prefix>. That's so that the caller knows to
demangle the function's return type, if this turns out to
be a function name. But, if it's a member template
constructor or a templated conversion operator, report it
as untemplated. Those never get encoded return types. */
*encode_return_type = !suppress_return_type;
}
else if (peek == 'E')
/* All done. */
return STATUS_OK;
else
return "Unexpected character in <compound-name>.";
if (peek != 'S'
&& peek_char (dm) != 'E')
/* Add a new substitution for the prefix thus far. */
RETURN_IF_ERROR (substitution_add (dm, start, *encode_return_type));
}
}
/* Demangles and emits an <unqualified-name>. If this
<unqualified-name> is for a special function type that should never
have its return type encoded (particularly, a constructor or
conversion operator), *SUPPRESS_RETURN_TYPE is set to 1; otherwise,
it is set to zero.
<unqualified-name> ::= <operator-name>
::= <special-name>
::= <source-name> */
static status_t
demangle_unqualified_name (dm, suppress_return_type)
demangling_t dm;
int *suppress_return_type;
{
char peek = peek_char (dm);
DEMANGLE_TRACE ("unqualified-name", dm);
/* By default, don't force suppression of the return type (though
non-template functions still don't get a return type encoded). */
*suppress_return_type = 0;
if (IS_DIGIT ((unsigned char) peek))
RETURN_IF_ERROR (demangle_source_name (dm));
else if (peek >= 'a' && peek <= 'z')
{
int num_args;
/* Conversion operators never have a return type encoded. */
if (peek == 'c' && peek_char_next (dm) == 'v')
*suppress_return_type = 1;
RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args, NULL));
}
else if (peek == 'C' || peek == 'D')
{
/* Constructors never have a return type encoded. */
if (peek == 'C')
*suppress_return_type = 1;
RETURN_IF_ERROR (demangle_ctor_dtor_name (dm));
}
else
return "Unexpected character in <unqualified-name>.";
return STATUS_OK;
}
/* Demangles and emits <source-name>.
<source-name> ::= <length number> <identifier> */
static status_t
demangle_source_name (dm)
demangling_t dm;
{
int length;
DEMANGLE_TRACE ("source-name", dm);
/* Decode the length of the identifier. */
RETURN_IF_ERROR (demangle_number (dm, &length, 10, 0));
if (length == 0)
return "Zero length in <source-name>.";
/* Now the identifier itself. It's placed into last_source_name,
where it can be used to build a constructor or destructor name. */
RETURN_IF_ERROR (demangle_identifier (dm, length,
dm->last_source_name));
/* Emit it. */
RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
return STATUS_OK;
}
/* Demangles a number, either a <number> or a <positive-number> at the
current position, consuming all consecutive digit characters. Sets
*VALUE to the resulting numberand returns STATUS_OK. The number is
interpreted as BASE, which must be either 10 or 36. If IS_SIGNED
is non-zero, negative numbers -- prefixed with `n' -- are accepted.
<number> ::= [n] <positive-number>
<positive-number> ::= <decimal integer> */
static status_t
demangle_number (dm, value, base, is_signed)
demangling_t dm;
int *value;
int base;
int is_signed;
{
dyn_string_t number = dyn_string_new (10);
DEMANGLE_TRACE ("number", dm);
if (number == NULL)
return STATUS_ALLOCATION_FAILED;
demangle_number_literally (dm, number, base, is_signed);
*value = strtol (dyn_string_buf (number), NULL, base);
dyn_string_delete (number);
return STATUS_OK;
}
/* Demangles a number at the current position. The digits (and minus
sign, if present) that make up the number are appended to STR.
Only base-BASE digits are accepted; BASE must be either 10 or 36.
If IS_SIGNED, negative numbers -- prefixed with `n' -- are
accepted. Does not consume a trailing underscore or other
terminating character. */
static status_t
demangle_number_literally (dm, str, base, is_signed)
demangling_t dm;
dyn_string_t str;
int base;
int is_signed;
{
DEMANGLE_TRACE ("number*", dm);
if (base != 10 && base != 36)
return STATUS_INTERNAL_ERROR;
/* An `n' denotes a negative number. */
if (is_signed && peek_char (dm) == 'n')
{
/* Skip past the n. */
advance_char (dm);
/* The normal way to write a negative number is with a minus
sign. */
if (!dyn_string_append_char (str, '-'))
return STATUS_ALLOCATION_FAILED;
}
/* Loop until we hit a non-digit. */
while (1)
{
char peek = peek_char (dm);
if (IS_DIGIT ((unsigned char) peek)
|| (base == 36 && peek >= 'A' && peek <= 'Z'))
{
/* Accumulate digits. */
if (!dyn_string_append_char (str, next_char (dm)))
return STATUS_ALLOCATION_FAILED;
}
else
/* Not a digit? All done. */
break;
}
return STATUS_OK;
}
/* Demangles an identifier at the current position of LENGTH
characters and places it in IDENTIFIER. */
static status_t
demangle_identifier (dm, length, identifier)
demangling_t dm;
int length;
dyn_string_t identifier;
{
DEMANGLE_TRACE ("identifier", dm);
dyn_string_clear (identifier);
if (!dyn_string_resize (identifier, length))
return STATUS_ALLOCATION_FAILED;
while (length-- > 0)
{
int ch;
if (end_of_name_p (dm))
return "Unexpected end of name in <identifier>.";
ch = next_char (dm);
/* Handle extended Unicode characters. We encode them as __U{hex}_,
where {hex} omits leading 0's. For instance, '$' is encoded as
"__U24_". */
if (ch == '_'
&& peek_char (dm) == '_'
&& peek_char_next (dm) == 'U')
{
char buf[10];
int pos = 0;
advance_char (dm); advance_char (dm); length -= 2;
while (length-- > 0)
{
ch = next_char (dm);
if (!isxdigit (ch))
break;
buf[pos++] = ch;
}
if (ch != '_' || length < 0)
return STATUS_ERROR;
if (pos == 0)
{
/* __U_ just means __U. */
if (!dyn_string_append_cstr (identifier, "__U"))
return STATUS_ALLOCATION_FAILED;
continue;
}
else
{
buf[pos] = '\0';
ch = strtol (buf, 0, 16);
}
}
if (!dyn_string_append_char (identifier, ch))
return STATUS_ALLOCATION_FAILED;
}
/* GCC encodes anonymous namespaces using a `_GLOBAL_[_.$]N.'
followed by the source file name and some random characters.
Unless we're in strict mode, decipher these names appropriately. */
if (!flag_strict)
{
char *name = dyn_string_buf (identifier);
int prefix_length = strlen (ANONYMOUS_NAMESPACE_PREFIX);
/* Compare the first, fixed part. */
if (strncmp (name, ANONYMOUS_NAMESPACE_PREFIX, prefix_length) == 0)
{
name += prefix_length;
/* The next character might be a period, an underscore, or
dollar sign, depending on the target architecture's
assembler's capabilities. After that comes an `N'. */
if ((*name == '.' || *name == '_' || *name == '$')
&& *(name + 1) == 'N')
/* This looks like the anonymous namespace identifier.
Replace it with something comprehensible. */
dyn_string_copy_cstr (identifier, "(anonymous namespace)");
}
}
return STATUS_OK;
}
/* Demangles and emits an <operator-name>. If SHORT_NAME is non-zero,
the short form is emitted; otherwise the full source form
(`operator +' etc.) is emitted. *NUM_ARGS is set to the number of
operands that the operator takes. If TYPE_ARG is non-NULL,
*TYPE_ARG is set to 1 if the first argument is a type and 0
otherwise.
<operator-name>
::= nw # new
::= na # new[]
::= dl # delete
::= da # delete[]
::= ps # + (unary)
::= ng # - (unary)
::= ad # & (unary)
::= de # * (unary)
::= co # ~
::= pl # +
::= mi # -
::= ml # *
::= dv # /
::= rm # %
::= an # &
::= or # |
::= eo # ^
::= aS # =
::= pL # +=
::= mI # -=
::= mL # *=
::= dV # /=
::= rM # %=
::= aN # &=
::= oR # |=
::= eO # ^=
::= ls # <<
::= rs # >>
::= lS # <<=
::= rS # >>=
::= eq # ==
::= ne # !=
::= lt # <
::= gt # >
::= le # <=
::= ge # >=
::= nt # !
::= aa # &&
::= oo # ||
::= pp # ++
::= mm # --
::= cm # ,
::= pm # ->*
::= pt # ->
::= cl # ()
::= ix # []
::= qu # ?
::= st # sizeof (a type)
::= sz # sizeof (an expression)
::= cv <type> # cast
::= v [0-9] <source-name> # vendor extended operator */
static status_t
demangle_operator_name (dm, short_name, num_args, type_arg)
demangling_t dm;
int short_name;
int *num_args;
int *type_arg;
{
struct operator_code
{
/* The mangled code for this operator. */
const char *const code;
/* The source name of this operator. */
const char *const name;
/* The number of arguments this operator takes. */
const int num_args;
};
static const struct operator_code operators[] =
{
{ "aN", "&=" , 2 },
{ "aS", "=" , 2 },
{ "aa", "&&" , 2 },
{ "ad", "&" , 1 },
{ "an", "&" , 2 },
{ "cl", "()" , 0 },
{ "cm", "," , 2 },
{ "co", "~" , 1 },
{ "dV", "/=" , 2 },
{ "da", " delete[]", 1 },
{ "de", "*" , 1 },
{ "dl", " delete" , 1 },
{ "dv", "/" , 2 },
{ "eO", "^=" , 2 },
{ "eo", "^" , 2 },
{ "eq", "==" , 2 },
{ "ge", ">=" , 2 },
{ "gt", ">" , 2 },
{ "ix", "[]" , 2 },
{ "lS", "<<=" , 2 },
{ "le", "<=" , 2 },
{ "ls", "<<" , 2 },
{ "lt", "<" , 2 },
{ "mI", "-=" , 2 },
{ "mL", "*=" , 2 },
{ "mi", "-" , 2 },
{ "ml", "*" , 2 },
{ "mm", "--" , 1 },
{ "na", " new[]" , 1 },
{ "ne", "!=" , 2 },
{ "ng", "-" , 1 },
{ "nt", "!" , 1 },
{ "nw", " new" , 1 },
{ "oR", "|=" , 2 },
{ "oo", "||" , 2 },
{ "or", "|" , 2 },
{ "pL", "+=" , 2 },
{ "pl", "+" , 2 },
{ "pm", "->*" , 2 },
{ "pp", "++" , 1 },
{ "ps", "+" , 1 },
{ "pt", "->" , 2 },
{ "qu", "?" , 3 },
{ "rM", "%=" , 2 },
{ "rS", ">>=" , 2 },
{ "rm", "%" , 2 },
{ "rs", ">>" , 2 },
{ "sz", " sizeof" , 1 }
};
const int num_operators =
sizeof (operators) / sizeof (struct operator_code);
int c0 = next_char (dm);
int c1 = next_char (dm);
const struct operator_code* p1 = operators;
const struct operator_code* p2 = operators + num_operators;
DEMANGLE_TRACE ("operator-name", dm);
/* Assume the first argument is not a type. */
if (type_arg)
*type_arg = 0;
/* Is this a vendor-extended operator? */
if (c0 == 'v' && IS_DIGIT (c1))
{
RETURN_IF_ERROR (result_add (dm, "operator "));
RETURN_IF_ERROR (demangle_source_name (dm));
*num_args = 0;
return STATUS_OK;
}
/* Is this a conversion operator? */
if (c0 == 'c' && c1 == 'v')
{
RETURN_IF_ERROR (result_add (dm, "operator "));
/* Demangle the converted-to type. */
RETURN_IF_ERROR (demangle_type (dm));
*num_args = 0;
return STATUS_OK;
}
/* Is it the sizeof variant that takes a type? */
if (c0 == 's' && c1 == 't')
{
RETURN_IF_ERROR (result_add (dm, " sizeof"));
*num_args = 1;
if (type_arg)
*type_arg = 1;
return STATUS_OK;
}
/* Perform a binary search for the operator code. */
while (1)
{
const struct operator_code* p = p1 + (p2 - p1) / 2;
char match0 = p->code[0];
char match1 = p->code[1];
if (c0 == match0 && c1 == match1)
/* Found it. */
{
if (!short_name)
RETURN_IF_ERROR (result_add (dm, "operator"));
RETURN_IF_ERROR (result_add (dm, p->name));
*num_args = p->num_args;
return STATUS_OK;
}
if (p == p1)
/* Couldn't find it. */
return "Unknown code in <operator-name>.";
/* Try again. */
if (c0 < match0 || (c0 == match0 && c1 < match1))
p2 = p;
else
p1 = p;
}
}
/* Demangles and omits an <nv-offset>.
<nv-offset> ::= <offset number> # non-virtual base override */
static status_t
demangle_nv_offset (dm)
demangling_t dm;
{
dyn_string_t number;
status_t status = STATUS_OK;
DEMANGLE_TRACE ("h-offset", dm);
/* Demangle the offset. */
number = dyn_string_new (4);
if (number == NULL)
return STATUS_ALLOCATION_FAILED;
demangle_number_literally (dm, number, 10, 1);
/* Don't display the offset unless in verbose mode. */
if (flag_verbose)
{
status = result_add (dm, " [nv:");
if (STATUS_NO_ERROR (status))
status = result_add_string (dm, number);
if (STATUS_NO_ERROR (status))
status = result_add_char (dm, ']');
}
/* Clean up. */
dyn_string_delete (number);
RETURN_IF_ERROR (status);
return STATUS_OK;
}
/* Demangles and emits a <v-offset>.
<v-offset> ::= <offset number> _ <virtual offset number>
# virtual base override, with vcall offset */
static status_t
demangle_v_offset (dm)
demangling_t dm;
{
dyn_string_t number;
status_t status = STATUS_OK;
DEMANGLE_TRACE ("v-offset", dm);
/* Demangle the offset. */
number = dyn_string_new (4);
if (number == NULL)
return STATUS_ALLOCATION_FAILED;
demangle_number_literally (dm, number, 10, 1);
/* Don't display the offset unless in verbose mode. */
if (flag_verbose)
{
status = result_add (dm, " [v:");
if (STATUS_NO_ERROR (status))
status = result_add_string (dm, number);
if (STATUS_NO_ERROR (status))
result_add_char (dm, ',');
}
dyn_string_delete (number);
RETURN_IF_ERROR (status);
/* Demangle the separator. */
RETURN_IF_ERROR (demangle_char (dm, '_'));
/* Demangle the vcall offset. */
number = dyn_string_new (4);
if (number == NULL)
return STATUS_ALLOCATION_FAILED;
demangle_number_literally (dm, number, 10, 1);
/* Don't display the vcall offset unless in verbose mode. */
if (flag_verbose)
{
status = result_add_string (dm, number);
if (STATUS_NO_ERROR (status))
status = result_add_char (dm, ']');
}
dyn_string_delete (number);
RETURN_IF_ERROR (status);
return STATUS_OK;
}
/* Demangles and emits a <call-offset>.
<call-offset> ::= h <nv-offset> _
::= v <v-offset> _ */
static status_t
demangle_call_offset (dm)
demangling_t dm;
{
DEMANGLE_TRACE ("call-offset", dm);
switch (peek_char (dm))
{
case 'h':
advance_char (dm);
/* Demangle the offset. */
RETURN_IF_ERROR (demangle_nv_offset (dm));
/* Demangle the separator. */
RETURN_IF_ERROR (demangle_char (dm, '_'));
break;
case 'v':
advance_char (dm);
/* Demangle the offset. */
RETURN_IF_ERROR (demangle_v_offset (dm));
/* Demangle the separator. */
RETURN_IF_ERROR (demangle_char (dm, '_'));
break;
default:
return "Unrecognized <call-offset>.";
}
return STATUS_OK;
}
/* Demangles and emits a <special-name>.
<special-name> ::= GV <object name> # Guard variable
::= TV <type> # virtual table
::= TT <type> # VTT
::= TI <type> # typeinfo structure
::= TS <type> # typeinfo name
Other relevant productions include thunks:
<special-name> ::= T <call-offset> <base encoding>
# base is the nominal target function of thunk
<special-name> ::= Tc <call-offset> <call-offset> <base encoding>
# base is the nominal target function of thunk
# first call-offset is 'this' adjustment
# second call-offset is result adjustment
where
<call-offset> ::= h <nv-offset> _
::= v <v-offset> _
Also demangles the special g++ manglings,
<special-name> ::= TC <type> <offset number> _ <base type>
# construction vtable
::= TF <type> # typeinfo function (old ABI only)
::= TJ <type> # java Class structure */
static status_t
demangle_special_name (dm)
demangling_t dm;
{
dyn_string_t number;
int unused;
char peek = peek_char (dm);
DEMANGLE_TRACE ("special-name", dm);
if (peek == 'G')
{
/* Consume the G. */
advance_char (dm);
switch (peek_char (dm))
{
case 'V':
/* A guard variable name. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "guard variable for "));
RETURN_IF_ERROR (demangle_name (dm, &unused));
break;
case 'R':
/* A reference temporary. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "reference temporary for "));
RETURN_IF_ERROR (demangle_name (dm, &unused));
break;
default:
return "Unrecognized <special-name>.";
}
}
else if (peek == 'T')
{
status_t status = STATUS_OK;
/* Other C++ implementation miscellania. Consume the T. */
advance_char (dm);
switch (peek_char (dm))
{
case 'V':
/* Virtual table. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "vtable for "));
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'T':
/* VTT structure. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "VTT for "));
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'I':
/* Typeinfo structure. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "typeinfo for "));
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'F':
/* Typeinfo function. Used only in old ABI with new mangling. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "typeinfo fn for "));
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'S':
/* Character string containing type name, used in typeinfo. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "typeinfo name for "));
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'J':
/* The java Class variable corresponding to a C++ class. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "java Class for "));
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'h':
/* Non-virtual thunk. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "non-virtual thunk"));
RETURN_IF_ERROR (demangle_nv_offset (dm));
/* Demangle the separator. */
RETURN_IF_ERROR (demangle_char (dm, '_'));
/* Demangle and emit the target name and function type. */
RETURN_IF_ERROR (result_add (dm, " to "));
RETURN_IF_ERROR (demangle_encoding (dm));
break;
case 'v':
/* Virtual thunk. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "virtual thunk"));
RETURN_IF_ERROR (demangle_v_offset (dm));
/* Demangle the separator. */
RETURN_IF_ERROR (demangle_char (dm, '_'));
/* Demangle and emit the target function. */
RETURN_IF_ERROR (result_add (dm, " to "));
RETURN_IF_ERROR (demangle_encoding (dm));
break;
case 'c':
/* Covariant return thunk. */
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "covariant return thunk"));
RETURN_IF_ERROR (demangle_call_offset (dm));
RETURN_IF_ERROR (demangle_call_offset (dm));
/* Demangle and emit the target function. */
RETURN_IF_ERROR (result_add (dm, " to "));
RETURN_IF_ERROR (demangle_encoding (dm));
break;
case 'C':
/* TC is a special g++ mangling for a construction vtable. */
if (!flag_strict)
{
dyn_string_t derived_type;
advance_char (dm);
RETURN_IF_ERROR (result_add (dm, "construction vtable for "));
/* Demangle the derived type off to the side. */
RETURN_IF_ERROR (result_push (dm));
RETURN_IF_ERROR (demangle_type (dm));
derived_type = (dyn_string_t) result_pop (dm);
/* Demangle the offset. */
number = dyn_string_new (4);
if (number == NULL)
{
dyn_string_delete (derived_type);
return STATUS_ALLOCATION_FAILED;
}
demangle_number_literally (dm, number, 10, 1);
/* Demangle the underscore separator. */
status = demangle_char (dm, '_');
/* Demangle the base type. */
if (STATUS_NO_ERROR (status))
status = demangle_type (dm);
/* Emit the derived type. */
if (STATUS_NO_ERROR (status))
status = result_add (dm, "-in-");
if (STATUS_NO_ERROR (status))
status = result_add_string (dm, derived_type);
dyn_string_delete (derived_type);
/* Don't display the offset unless in verbose mode. */
if (flag_verbose)
{
status = result_add_char (dm, ' ');
if (STATUS_NO_ERROR (status))
result_add_string (dm, number);
}
dyn_string_delete (number);
RETURN_IF_ERROR (status);
break;
}
/* If flag_strict, fall through. */
default:
return "Unrecognized <special-name>.";
}
}
else
return STATUS_ERROR;
return STATUS_OK;
}
/* Demangles and emits a <ctor-dtor-name>.
<ctor-dtor-name>
::= C1 # complete object (in-charge) ctor
::= C2 # base object (not-in-charge) ctor
::= C3 # complete object (in-charge) allocating ctor
::= D0 # deleting (in-charge) dtor
::= D1 # complete object (in-charge) dtor
::= D2 # base object (not-in-charge) dtor */
static status_t
demangle_ctor_dtor_name (dm)
demangling_t dm;
{
static const char *const ctor_flavors[] =
{
"in-charge",
"not-in-charge",
"allocating"
};
static const char *const dtor_flavors[] =
{
"in-charge deleting",
"in-charge",
"not-in-charge"
};
int flavor;
char peek = peek_char (dm);
DEMANGLE_TRACE ("ctor-dtor-name", dm);
if (peek == 'C')
{
/* A constructor name. Consume the C. */
advance_char (dm);
flavor = next_char (dm);
if (flavor < '1' || flavor > '3')
return "Unrecognized constructor.";
RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
switch (flavor)
{
case '1': dm->is_constructor = gnu_v3_complete_object_ctor;
break;
case '2': dm->is_constructor = gnu_v3_base_object_ctor;
break;
case '3': dm->is_constructor = gnu_v3_complete_object_allocating_ctor;
break;
}
/* Print the flavor of the constructor if in verbose mode. */
if (flag_verbose)
{
RETURN_IF_ERROR (result_add (dm, "["));
RETURN_IF_ERROR (result_add (dm, ctor_flavors[flavor - '1']));
RETURN_IF_ERROR (result_add_char (dm, ']'));
}
}
else if (peek == 'D')
{
/* A destructor name. Consume the D. */
advance_char (dm);
flavor = next_char (dm);
if (flavor < '0' || flavor > '2')
return "Unrecognized destructor.";
RETURN_IF_ERROR (result_add_char (dm, '~'));
RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
switch (flavor)
{
case '0': dm->is_destructor = gnu_v3_deleting_dtor;
break;
case '1': dm->is_destructor = gnu_v3_complete_object_dtor;
break;
case '2': dm->is_destructor = gnu_v3_base_object_dtor;
break;
}
/* Print the flavor of the destructor if in verbose mode. */
if (flag_verbose)
{
RETURN_IF_ERROR (result_add (dm, " ["));
RETURN_IF_ERROR (result_add (dm, dtor_flavors[flavor - '0']));
RETURN_IF_ERROR (result_add_char (dm, ']'));
}
}
else
return STATUS_ERROR;
return STATUS_OK;
}
/* Handle pointer, reference, and pointer-to-member cases for
demangle_type. All consecutive `P's, `R's, and 'M's are joined to
build a pointer/reference type. We snarf all these, plus the
following <type>, all at once since we need to know whether we have
a pointer to data or pointer to function to construct the right
output syntax. C++'s pointer syntax is hairy.
This function adds substitution candidates for every nested
pointer/reference type it processes, including the outermost, final
type, assuming the substitution starts at SUBSTITUTION_START in the
demangling result. For example, if this function demangles
`PP3Foo', it will add a substitution for `Foo', `Foo*', and
`Foo**', in that order.
*INSERT_POS is a quantity used internally, when this function calls
itself recursively, to figure out where to insert pointer
punctuation on the way up. On entry to this function, INSERT_POS
should point to a temporary value, but that value need not be
initialized.
<type> ::= P <type>
::= R <type>
::= <pointer-to-member-type>
<pointer-to-member-type> ::= M </class/ type> </member/ type> */
static status_t
demangle_type_ptr (dm, insert_pos, substitution_start)
demangling_t dm;
int *insert_pos;
int substitution_start;
{
status_t status;
int is_substitution_candidate = 1;
DEMANGLE_TRACE ("type*", dm);
/* Scan forward, collecting pointers and references into symbols,
until we hit something else. Then emit the type. */
switch (peek_char (dm))
{
case 'P':
/* A pointer. Snarf the `P'. */
advance_char (dm);
/* Demangle the underlying type. */
RETURN_IF_ERROR (demangle_type_ptr (dm, insert_pos,
substitution_start));
/* Insert an asterisk where we're told to; it doesn't
necessarily go at the end. If we're doing Java style output,
there is no pointer symbol. */
if (dm->style != DMGL_JAVA)
RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '*'));
/* The next (outermost) pointer or reference character should go
after this one. */
++(*insert_pos);
break;
case 'R':
/* A reference. Snarf the `R'. */
advance_char (dm);
/* Demangle the underlying type. */
RETURN_IF_ERROR (demangle_type_ptr (dm, insert_pos,
substitution_start));
/* Insert an ampersand where we're told to; it doesn't
necessarily go at the end. */
RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '&'));
/* The next (outermost) pointer or reference character should go
after this one. */
++(*insert_pos);
break;
case 'M':
{
/* A pointer-to-member. */
dyn_string_t class_type;
/* Eat the 'M'. */
advance_char (dm);
/* Capture the type of which this is a pointer-to-member. */
RETURN_IF_ERROR (result_push (dm));
RETURN_IF_ERROR (demangle_type (dm));
class_type = (dyn_string_t) result_pop (dm);
if (peek_char (dm) == 'F')
/* A pointer-to-member function. We want output along the
lines of `void (C::*) (int, int)'. Demangle the function
type, which would in this case give `void () (int, int)'
and set *insert_pos to the spot between the first
parentheses. */
status = demangle_type_ptr (dm, insert_pos, substitution_start);
else if (peek_char (dm) == 'A')
/* A pointer-to-member array variable. We want output that
looks like `int (Klass::*) [10]'. Demangle the array type
as `int () [10]', and set *insert_pos to the spot between
the parentheses. */
status = demangle_array_type (dm, insert_pos);
else
{
/* A pointer-to-member variable. Demangle the type of the
pointed-to member. */
status = demangle_type (dm);
/* Make it pretty. */
if (STATUS_NO_ERROR (status)
&& !result_previous_char_is_space (dm))
status = result_add_char (dm, ' ');
/* The pointer-to-member notation (e.g. `C::*') follows the
member's type. */
*insert_pos = result_caret_pos (dm);
}
/* Build the pointer-to-member notation. */
if (STATUS_NO_ERROR (status))
status = result_insert (dm, *insert_pos, "::*");
if (STATUS_NO_ERROR (status))
status = result_insert_string (dm, *insert_pos, class_type);
/* There may be additional levels of (pointer or reference)
indirection in this type. If so, the `*' and `&' should be
added after the pointer-to-member notation (e.g. `C::*&' for
a reference to a pointer-to-member of class C). */
*insert_pos += dyn_string_length (class_type) + 3;
/* Clean up. */
dyn_string_delete (class_type);
RETURN_IF_ERROR (status);
}
break;
case 'F':
/* Ooh, tricky, a pointer-to-function. When we demangle the
function type, the return type should go at the very
beginning. */
*insert_pos = result_caret_pos (dm);
/* The parentheses indicate this is a function pointer or
reference type. */
RETURN_IF_ERROR (result_add (dm, "()"));
/* Now demangle the function type. The return type will be
inserted before the `()', and the argument list will go after
it. */
RETURN_IF_ERROR (demangle_function_type (dm, insert_pos));
/* We should now have something along the lines of
`void () (int, int)'. The pointer or reference characters
have to inside the first set of parentheses. *insert_pos has
already been updated to point past the end of the return
type. Move it one character over so it points inside the
`()'. */
++(*insert_pos);
break;
case 'A':
/* An array pointer or reference. demangle_array_type will figure
out where the asterisks and ampersands go. */
RETURN_IF_ERROR (demangle_array_type (dm, insert_pos));
break;
default:
/* No more pointer or reference tokens; this is therefore a
pointer to data. Finish up by demangling the underlying
type. */
RETURN_IF_ERROR (demangle_type (dm));
/* The pointer or reference characters follow the underlying
type, as in `int*&'. */
*insert_pos = result_caret_pos (dm);
/* Because of the production <type> ::= <substitution>,
demangle_type will already have added the underlying type as
a substitution candidate. Don't do it again. */
is_substitution_candidate = 0;
break;
}
if (is_substitution_candidate)
RETURN_IF_ERROR (substitution_add (dm, substitution_start, 0));
return STATUS_OK;
}
/* Demangles and emits a <type>.
<type> ::= <builtin-type>
::= <function-type>
::= <class-enum-type>
::= <array-type>
::= <pointer-to-member-type>
::= <template-param>
::= <template-template-param> <template-args>
::= <CV-qualifiers> <type>
::= P <type> # pointer-to
::= R <type> # reference-to
::= C <type> # complex pair (C 2000)
::= G <type> # imaginary (C 2000)
::= U <source-name> <type> # vendor extended type qualifier
::= <substitution> */
static status_t
demangle_type (dm)
demangling_t dm;
{
int start = substitution_start (dm);
char peek = peek_char (dm);
char peek_next;
int encode_return_type = 0;
template_arg_list_t old_arg_list = current_template_arg_list (dm);
int insert_pos;
/* A <type> can be a <substitution>; therefore, this <type> is a
substitution candidate unless a special condition holds (see
below). */
int is_substitution_candidate = 1;
DEMANGLE_TRACE ("type", dm);
/* A <class-enum-type> can start with a digit (a <source-name>), an
N (a <nested-name>), or a Z (a <local-name>). */
if (IS_DIGIT ((unsigned char) peek) || peek == 'N' || peek == 'Z')
RETURN_IF_ERROR (demangle_class_enum_type (dm, &encode_return_type));
/* Lower-case letters begin <builtin-type>s, except for `r', which
denotes restrict. */
else if (peek >= 'a' && peek <= 'z' && peek != 'r')
{
RETURN_IF_ERROR (demangle_builtin_type (dm));
/* Built-in types are not substitution candidates. */
is_substitution_candidate = 0;
}
else
switch (peek)
{
case 'r':
case 'V':
case 'K':
/* CV-qualifiers (including restrict). We have to demangle
them off to the side, since C++ syntax puts them in a funny
place for qualified pointer and reference types. */
{
status_t status;
dyn_string_t cv_qualifiers = dyn_string_new (24);
int old_caret_position = result_get_caret (dm);
if (cv_qualifiers == NULL)
return STATUS_ALLOCATION_FAILED;
/* Decode all adjacent CV qualifiers. */
demangle_CV_qualifiers (dm, cv_qualifiers);
/* Emit them, and shift the caret left so that the
underlying type will be emitted before the qualifiers. */
status = result_add_string (dm, cv_qualifiers);
result_shift_caret (dm, -dyn_string_length (cv_qualifiers));
/* Clean up. */
dyn_string_delete (cv_qualifiers);
RETURN_IF_ERROR (status);
/* Also prepend a blank, if needed. */
RETURN_IF_ERROR (result_add_char (dm, ' '));
result_shift_caret (dm, -1);
/* Demangle the underlying type. It will be emitted before
the CV qualifiers, since we moved the caret. */
RETURN_IF_ERROR (demangle_type (dm));
/* Put the caret back where it was previously. */
result_set_caret (dm, old_caret_position);
}
break;
case 'F':
return "Non-pointer or -reference function type.";
case 'A':
RETURN_IF_ERROR (demangle_array_type (dm, NULL));
break;
case 'T':
/* It's either a <template-param> or a
<template-template-param>. In either case, demangle the
`T' token first. */
RETURN_IF_ERROR (demangle_template_param (dm));
/* Check for a template argument list; if one is found, it's a
<template-template-param> ::= <template-param>
::= <substitution> */
if (peek_char (dm) == 'I')
{
/* Add a substitution candidate. The template parameter
`T' token is a substitution candidate by itself,
without the template argument list. */
RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
/* Now demangle the template argument list. */
RETURN_IF_ERROR (demangle_template_args (dm));
/* The entire type, including the template template
parameter and its argument list, will be added as a
substitution candidate below. */
}
break;
case 'S':
/* First check if this is a special substitution. If it is,
this is a <class-enum-type>. Special substitutions have a
letter following the `S'; other substitutions have a digit
or underscore. */
peek_next = peek_char_next (dm);
if (IS_DIGIT (peek_next) || peek_next == '_')
{
RETURN_IF_ERROR (demangle_substitution (dm, &encode_return_type));
/* The substituted name may have been a template name.
Check if template arguments follow, and if so, demangle
them. */
if (peek_char (dm) == 'I')
RETURN_IF_ERROR (demangle_template_args (dm));
else
/* A substitution token is not itself a substitution
candidate. (However, if the substituted template is
instantiated, the resulting type is.) */
is_substitution_candidate = 0;
}
else
{
/* Now some trickiness. We have a special substitution
here. Often, the special substitution provides the
name of a template that's subsequently instantiated,
for instance `SaIcE' => std::allocator<char>. In these
cases we need to add a substitution candidate for the
entire <class-enum-type> and thus don't want to clear
the is_substitution_candidate flag.
However, it's possible that what we have here is a
substitution token representing an entire type, such as
`Ss' => std::string. In this case, we mustn't add a
new substitution candidate for this substitution token.
To detect this case, remember where the start of the
substitution token is. */
const char *next = dm->next;
/* Now demangle the <class-enum-type>. */
RETURN_IF_ERROR
(demangle_class_enum_type (dm, &encode_return_type));
/* If all that was just demangled is the two-character
special substitution token, supress the addition of a
new candidate for it. */
if (dm->next == next + 2)
is_substitution_candidate = 0;
}
break;
case 'P':
case 'R':
case 'M':
RETURN_IF_ERROR (demangle_type_ptr (dm, &insert_pos, start));
/* demangle_type_ptr adds all applicable substitution
candidates. */
is_substitution_candidate = 0;
break;
case 'C':
/* A C99 complex type. */
RETURN_IF_ERROR (result_add (dm, "complex "));
advance_char (dm);
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'G':
/* A C99 imaginary type. */
RETURN_IF_ERROR (result_add (dm, "imaginary "));
advance_char (dm);
RETURN_IF_ERROR (demangle_type (dm));
break;
case 'U':
/* Vendor-extended type qualifier. */
advance_char (dm);
RETURN_IF_ERROR (demangle_source_name (dm));
RETURN_IF_ERROR (result_add_char (dm, ' '));
RETURN_IF_ERROR (demangle_type (dm));
break;
default:
return "Unexpected character in <type>.";
}
if (is_substitution_candidate)
/* Add a new substitution for the type. If this type was a
<template-param>, pass its index since from the point of
substitutions; a <template-param> token is a substitution
candidate distinct from the type that is substituted for it. */
RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
/* Pop off template argument lists added during mangling of this
type. */
pop_to_template_arg_list (dm, old_arg_list);
return STATUS_OK;
}
/* C++ source names of builtin types, indexed by the mangled code
letter's position in the alphabet ('a' -> 0, 'b' -> 1, etc). */
static const char *const builtin_type_names[26] =
{
"signed char", /* a */
"bool", /* b */
"char", /* c */
"double", /* d */
"long double", /* e */
"float", /* f */
"__float128", /* g */
"unsigned char", /* h */
"int", /* i */
"unsigned", /* j */
NULL, /* k */
"long", /* l */
"unsigned long", /* m */
"__int128", /* n */
"unsigned __int128", /* o */
NULL, /* p */
NULL, /* q */
NULL, /* r */
"short", /* s */
"unsigned short", /* t */
NULL, /* u */
"void", /* v */
"wchar_t", /* w */
"long long", /* x */
"unsigned long long", /* y */
"..." /* z */
};
/* Java source names of builtin types. Types that arn't valid in Java
are also included here - we don't fail if someone attempts to demangle a
C++ symbol in Java style. */
static const char *const java_builtin_type_names[26] =
{
"signed char", /* a */
"boolean", /* C++ "bool" */ /* b */
"byte", /* C++ "char" */ /* c */
"double", /* d */
"long double", /* e */
"float", /* f */
"__float128", /* g */
"unsigned char", /* h */
"int", /* i */
"unsigned", /* j */
NULL, /* k */
"long", /* l */
"unsigned long", /* m */
"__int128", /* n */
"unsigned __int128", /* o */
NULL, /* p */
NULL, /* q */
NULL, /* r */
"short", /* s */
"unsigned short", /* t */
NULL, /* u */
"void", /* v */
"char", /* C++ "wchar_t" */ /* w */
"long", /* C++ "long long" */ /* x */
"unsigned long long", /* y */
"..." /* z */
};
/* Demangles and emits a <builtin-type>.
<builtin-type> ::= v # void
::= w # wchar_t
::= b # bool
::= c # char
::= a # signed char
::= h # unsigned char
::= s # short
::= t # unsigned short
::= i # int
::= j # unsigned int
::= l # long
::= m # unsigned long
::= x # long long, __int64
::= y # unsigned long long, __int64
::= n # __int128
::= o # unsigned __int128
::= f # float
::= d # double
::= e # long double, __float80
::= g # __float128
::= z # ellipsis
::= u <source-name> # vendor extended type */
static status_t
demangle_builtin_type (dm)
demangling_t dm;
{
char code = peek_char (dm);
DEMANGLE_TRACE ("builtin-type", dm);
if (code == 'u')
{
advance_char (dm);
RETURN_IF_ERROR (demangle_source_name (dm));
return STATUS_OK;
}
else if (code >= 'a' && code <= 'z')
{
const char *type_name;
/* Java uses different names for some built-in types. */
if (dm->style == DMGL_JAVA)
type_name = java_builtin_type_names[code - 'a'];
else
type_name = builtin_type_names[code - 'a'];
if (type_name == NULL)
return "Unrecognized <builtin-type> code.";
RETURN_IF_ERROR (result_add (dm, type_name));
advance_char (dm);
return STATUS_OK;
}
else
return "Non-alphabetic <builtin-type> code.";
}
/* Demangles all consecutive CV-qualifiers (const, volatile, and
restrict) at the current position. The qualifiers are appended to
QUALIFIERS. Returns STATUS_OK. */
static status_t
demangle_CV_qualifiers (dm, qualifiers)
demangling_t dm;
dyn_string_t qualifiers;
{
DEMANGLE_TRACE ("CV-qualifiers", dm);
while (1)
{
switch (peek_char (dm))
{
case 'r':
if (!dyn_string_append_space (qualifiers))
return STATUS_ALLOCATION_FAILED;
if (!dyn_string_append_cstr (qualifiers, "restrict"))
return STATUS_ALLOCATION_FAILED;
break;
case 'V':
if (!dyn_string_append_space (qualifiers))
return STATUS_ALLOCATION_FAILED;
if (!dyn_string_append_cstr (qualifiers, "volatile"))
return STATUS_ALLOCATION_FAILED;
break;
case 'K':
if (!dyn_string_append_space (qualifiers))
return STATUS_ALLOCATION_FAILED;
if (!dyn_string_append_cstr (qualifiers, "const"))
return STATUS_ALLOCATION_FAILED;
break;
default:
return STATUS_OK;
}
advance_char (dm);
}
}
/* Demangles and emits a <function-type>. *FUNCTION_NAME_POS is the
position in the result string of the start of the function
identifier, at which the function's return type will be inserted;
*FUNCTION_NAME_POS is updated to position past the end of the
function's return type.
<function-type> ::= F [Y] <bare-function-type> E */
static status_t
demangle_function_type (dm, function_name_pos)
demangling_t dm;
int *function_name_pos;
{
DEMANGLE_TRACE ("function-type", dm);
RETURN_IF_ERROR (demangle_char (dm, 'F'));
if (peek_char (dm) == 'Y')
{
/* Indicate this function has C linkage if in verbose mode. */
if (flag_verbose)
RETURN_IF_ERROR (result_add (dm, " [extern \"C\"] "));
advance_char (dm);
}
RETURN_IF_ERROR (demangle_bare_function_type (dm, function_name_pos));
RETURN_IF_ERROR (demangle_char (dm, 'E'));
return STATUS_OK;
}
/* Demangles and emits a <bare-function-type>. RETURN_TYPE_POS is the
position in the result string at which the function return type
should be inserted. If RETURN_TYPE_POS is BFT_NO_RETURN_TYPE, the
function's return type is assumed not to be encoded.
<bare-function-type> ::= <signature type>+ */
static status_t
demangle_bare_function_type (dm, return_type_pos)
demangling_t dm;
int *return_type_pos;
{
/* Sequence is the index of the current function parameter, counting
from zero. The value -1 denotes the return type. */
int sequence =
(return_type_pos == BFT_NO_RETURN_TYPE ? 0 : -1);
DEMANGLE_TRACE ("bare-function-type", dm);
RETURN_IF_ERROR (result_add_char (dm, '('));
while (!end_of_name_p (dm) && peek_char (dm) != 'E')
{
if (sequence == -1)
/* We're decoding the function's return type. */
{
dyn_string_t return_type;
status_t status = STATUS_OK;
/* Decode the return type off to the side. */
RETURN_IF_ERROR (result_push (dm));
RETURN_IF_ERROR (demangle_type (dm));
return_type = (dyn_string_t) result_pop (dm);
/* Add a space to the end of the type. Insert the return
type where we've been asked to. */
if (!dyn_string_append_space (return_type))
status = STATUS_ALLOCATION_FAILED;
if (STATUS_NO_ERROR (status))
{
if (!dyn_string_insert (result_string (dm), *return_type_pos,
return_type))
status = STATUS_ALLOCATION_FAILED;
else
*return_type_pos += dyn_string_length (return_type);
}
dyn_string_delete (return_type);
RETURN_IF_ERROR (status);
}
else
{
/* Skip `void' parameter types. One should only occur as
the only type in a parameter list; in that case, we want
to print `foo ()' instead of `foo (void)'. */
if (peek_char (dm) == 'v')
/* Consume the v. */
advance_char (dm);
else
{
/* Separate parameter types by commas. */
if (sequence > 0)
RETURN_IF_ERROR (result_add (dm, ", "));
/* Demangle the type. */
RETURN_IF_ERROR (demangle_type (dm));
}
}
++sequence;
}
RETURN_IF_ERROR (result_add_char (dm, ')'));
/* We should have demangled at least one parameter type (which would
be void, for a function that takes no parameters), plus the
return type, if we were supposed to demangle that. */
if (sequence == -1)
return "Missing function return type.";
else if (sequence == 0)
return "Missing function parameter.";
return STATUS_OK;
}
/* Demangles and emits a <class-enum-type>. *ENCODE_RETURN_TYPE is set to
non-zero if the type is a template-id, zero otherwise.
<class-enum-type> ::= <name> */
static status_t
demangle_class_enum_type (dm, encode_return_type)
demangling_t dm;
int *encode_return_type;
{
DEMANGLE_TRACE ("class-enum-type", dm);
RETURN_IF_ERROR (demangle_name (dm, encode_return_type));
return STATUS_OK;
}
/* Demangles and emits an <array-type>.
If PTR_INSERT_POS is not NULL, the array type is formatted as a
pointer or reference to an array, except that asterisk and
ampersand punctuation is omitted (since it's not know at this
point). *PTR_INSERT_POS is set to the position in the demangled
name at which this punctuation should be inserted. For example,
`A10_i' is demangled to `int () [10]' and *PTR_INSERT_POS points
between the parentheses.
If PTR_INSERT_POS is NULL, the array type is assumed not to be
pointer- or reference-qualified. Then, for example, `A10_i' is
demangled simply as `int[10]'.
<array-type> ::= A [<dimension number>] _ <element type>
::= A <dimension expression> _ <element type> */
static status_t
demangle_array_type (dm, ptr_insert_pos)
demangling_t dm;
int *ptr_insert_pos;
{
status_t status = STATUS_OK;
dyn_string_t array_size = NULL;
char peek;
DEMANGLE_TRACE ("array-type", dm);
RETURN_IF_ERROR (demangle_char (dm, 'A'));
/* Demangle the array size into array_size. */
peek = peek_char (dm);
if (peek == '_')
/* Array bound is omitted. This is a C99-style VLA. */
;
else if (IS_DIGIT (peek_char (dm)))
{
/* It looks like a constant array bound. */
array_size = dyn_string_new (10);
if (array_size == NULL)
return STATUS_ALLOCATION_FAILED;
status = demangle_number_literally (dm, array_size, 10, 0);
}
else
{
/* Anything is must be an expression for a nont-constant array
bound. This happens if the array type occurs in a template
and the array bound references a template parameter. */
RETURN_IF_ERROR (result_push (dm));
RETURN_IF_ERROR (demangle_expression (dm));
array_size = (dyn_string_t) result_pop (dm);
}
/* array_size may have been allocated by now, so we can't use
RETURN_IF_ERROR until it's been deallocated. */
/* Demangle the base type of the array. */
if (STATUS_NO_ERROR (status))
status = demangle_char (dm, '_');
if (STATUS_NO_ERROR (status))
status = demangle_type (dm);
if (ptr_insert_pos != NULL)
{
/* This array is actually part of an pointer- or
reference-to-array type. Format appropriately, except we
don't know which and how much punctuation to use. */
if (STATUS_NO_ERROR (status))
status = result_add (dm, " () ");
/* Let the caller know where to insert the punctuation. */
*ptr_insert_pos = result_caret_pos (dm) - 2;
}
/* Emit the array dimension syntax. */
if (STATUS_NO_ERROR (status))
status = result_add_char (dm, '[');
if (STATUS_NO_ERROR (status) && array_size != NULL)
status = result_add_string (dm, array_size);
if (STATUS_NO_ERROR (status))
status = result_add_char (dm, ']');
if (array_size != NULL)
dyn_string_delete (array_size);
RETURN_IF_ERROR (status);
return STATUS_OK;
}
/* Demangles and emits a <template-param>.
<template-param> ::= T_ # first template parameter
::= T <parameter-2 number> _ */
static status_t
demangle_template_param (dm)
demangling_t dm;
{
int parm_number;
template_arg_list_t current_arg_list = current_template_arg_list (dm);
string_list_t arg;
DEMANGLE_TRACE ("template-param", dm);
/* Make sure there is a template argmust list in which to look up
this parameter reference. */
if (current_arg_list == NULL)
return "Template parameter outside of template.";
RETURN_IF_ERROR (demangle_char (dm, 'T'));
if (peek_char (dm) == '_')
parm_number = 0;
else
{
RETURN_IF_ERROR (demangle_number (dm, &parm_number, 10, 0));
++parm_number;
}
RETURN_IF_ERROR (demangle_char (dm, '_'));
arg = template_arg_list_get_arg (current_arg_list, parm_number);
if (arg == NULL)
/* parm_number exceeded the number of arguments in the current
template argument list. */
return "Template parameter number out of bounds.";
RETURN_IF_ERROR (result_add_string (dm, (dyn_string_t) arg));
return STATUS_OK;
}
/* Demangles and emits a <template-args>.
<template-args> ::= I <template-arg>+ E */
static status_t
demangle_template_args (dm)
demangling_t dm;
{
int first = 1;
dyn_string_t old_last_source_name;
template_arg_list_t arg_list = template_arg_list_new ();
if (arg_list == NULL)
return STATUS_ALLOCATION_FAILED;
/* Preserve the most recently demangled source name. */
old_last_source_name = dm->last_source_name;
dm->last_source_name = dyn_string_new (0);
DEMANGLE_TRACE ("template-args", dm);
if (dm->last_source_name == NULL)
return STATUS_ALLOCATION_FAILED;
RETURN_IF_ERROR (demangle_char (dm, 'I'));
RETURN_IF_ERROR (result_open_template_list (dm));
do
{
string_list_t arg;
if (first)
first = 0;
else
RETURN_IF_ERROR (result_add (dm, ", "));
/* Capture the template arg. */
RETURN_IF_ERROR (result_push (dm));
RETURN_IF_ERROR (demangle_template_arg (dm));
arg = result_pop (dm);
/* Emit it in the demangled name. */
RETURN_IF_ERROR (result_add_string (dm, (dyn_string_t) arg));
/* Save it for use in expanding <template-param>s. */
template_arg_list_add_arg (arg_list, arg);
}
while (peek_char (dm) != 'E');
/* Append the '>'. */
RETURN_IF_ERROR (result_close_template_list (dm));
/* Consume the 'E'. */
advance_char (dm);
/* Restore the most recent demangled source name. */
dyn_string_delete (dm->last_source_name);
dm->last_source_name = old_last_source_name;
/* Push the list onto the top of the stack of template argument
lists, so that arguments from it are used from now on when
expanding <template-param>s. */
push_template_arg_list (dm, arg_list);
return STATUS_OK;
}
/* This function, which does not correspond to a production in the
mangling spec, handles the `literal' production for both
<template-arg> and <expr-primary>. It does not expect or consume
the initial `L' or final `E'. The demangling is given by:
<literal> ::= <type> </value/ number>
and the emitted output is `(type)number'. */
static status_t
demangle_literal (dm)
demangling_t dm;
{
char peek = peek_char (dm);
dyn_string_t value_string;
status_t status;
DEMANGLE_TRACE ("literal", dm);
if (!flag_verbose && peek >= 'a' && peek <= 'z')
{
/* If not in verbose mode and this is a builtin type, see if we
can produce simpler numerical output. In particular, for
integer types shorter than `long', just write the number
without type information; for bools, write `true' or `false'.
Other refinements could be made here too. */
/* This constant string is used to map from <builtin-type> codes
(26 letters of the alphabet) to codes that determine how the
value will be displayed. The codes are:
b: display as bool
i: display as int
l: display as long
A space means the value will be represented using cast
notation. */
static const char *const code_map = "ibi iii ll ii i ";
char code = code_map[peek - 'a'];
/* FIXME: Implement demangling of floats and doubles. */
if (code == 'u')
return STATUS_UNIMPLEMENTED;
if (code == 'b')
{
/* It's a boolean. */
char value;
/* Consume the b. */
advance_char (dm);
/* Look at the next character. It should be 0 or 1,
corresponding to false or true, respectively. */
value = peek_char (dm);
if (value == '0')
RETURN_IF_ERROR (result_add (dm, "false"));
else if (value == '1')
RETURN_IF_ERROR (result_add (dm, "true"));
else
return "Unrecognized bool constant.";
/* Consume the 0 or 1. */
advance_char (dm);
return STATUS_OK;
}
else if (code == 'i' || code == 'l')
{
/* It's an integer or long. */
/* Consume the type character. */
advance_char (dm);
/* Demangle the number and write it out. */
value_string = dyn_string_new (0);
status = demangle_number_literally (dm, value_string, 10, 1);
if (STATUS_NO_ERROR (status))
status = result_add_string (dm, value_string);
/* For long integers, append an l. */
if (code == 'l' && STATUS_NO_ERROR (status))
status = result_add_char (dm, code);
dyn_string_delete (value_string);
RETURN_IF_ERROR (status);
return STATUS_OK;
}
/* ...else code == ' ', so fall through to represent this
literal's type explicitly using cast syntax. */
}
RETURN_IF_ERROR (result_add_char (dm, '('));
RETURN_IF_ERROR (demangle_type (dm));
RETURN_IF_ERROR (result_add_char (dm, ')'));
value_string = dyn_string_new (0);
if (value_string == NULL)
return STATUS_ALLOCATION_FAILED;
status = demangle_number_literally (dm, value_string, 10, 1);
if (STATUS_NO_ERROR (status))
status = result_add_string (dm, value_string);
dyn_string_delete (value_string);
RETURN_IF_ERROR (status);
return STATUS_OK;
}
/* Demangles and emits a <template-arg>.
<template-arg> ::= <type> # type
::= L <type> <value number> E # literal
::= LZ <encoding> E # external name
::= X <expression> E # expression */
static status_t
demangle_template_arg (dm)
demangling_t dm;
{
DEMANGLE_TRACE ("template-arg", dm);
switch (peek_char (dm))
{
case 'L':
advance_char (dm);
if (peek_char (dm) == 'Z')
{
/* External name. */
advance_char (dm);
/* FIXME: Standard is contradictory here. */
RETURN_IF_ERROR (demangle_encoding (dm));
}
else
RETURN_IF_ERROR (demangle_literal (dm));
RETURN_IF_ERROR (demangle_char (dm, 'E'));
break;
case 'X':
/* Expression. */
advance_char (dm);
RETURN_IF_ERROR (demangle_expression (dm));
RETURN_IF_ERROR (demangle_char (dm, 'E'));
break;
default:
RETURN_IF_ERROR (demangle_type (dm));
break;
}
return STATUS_OK;
}
/* Demangles and emits an <expression>.
<expression> ::= <unary operator-name> <expression>
::= <binary operator-name> <expression> <expression>
::= <expr-primary>
::= <scope-expression> */
static status_t
demangle_expression (dm)
demangling_t dm;
{
char peek = peek_char (dm);
DEMANGLE_TRACE ("expression", dm);
if (peek == 'L' || peek == 'T')
RETURN_IF_ERROR (demangle_expr_primary (dm));
else if (peek == 's' && peek_char_next (dm) == 'r')
RETURN_IF_ERROR (demangle_scope_expression (dm));
else
/* An operator expression. */
{
int num_args;
int type_arg;
status_t status = STATUS_OK;
dyn_string_t operator_name;
/* We have an operator name. Since we want to output binary
operations in infix notation, capture the operator name
first. */
RETURN_IF_ERROR (result_push (dm));
RETURN_IF_ERROR (demangle_operator_name (dm, 1, &num_args,
&type_arg));
operator_name = (dyn_string_t) result_pop (dm);
/* If it's binary, do an operand first. */
if (num_args > 1)
{
status = result_add_char (dm, '(');
if (STATUS_NO_ERROR (status))
status = demangle_expression (dm);
if (STATUS_NO_ERROR (status))
status = result_add_char (dm, ')');
}
/* Emit the operator. */
if (STATUS_NO_ERROR (status))
status = result_add_string (dm, operator_name);
dyn_string_delete (operator_name);
RETURN_IF_ERROR (status);
/* Emit its second (if binary) or only (if unary) operand. */
RETURN_IF_ERROR (result_add_char (dm, '('));
if (type_arg)
RETURN_IF_ERROR (demangle_type (dm));
else
RETURN_IF_ERROR (demangle_expression (dm));
RETURN_IF_ERROR (result_add_char (dm, ')'));
/* The ternary operator takes a third operand. */
if (num_args == 3)
{
RETURN_IF_ERROR (result_add (dm, ":("));
RETURN_IF_ERROR (demangle_expression (dm));
RETURN_IF_ERROR (result_add_char (dm, ')'));
}
}
return STATUS_OK;
}
/* Demangles and emits a <scope-expression>.
<scope-expression> ::= sr <qualifying type> <source-name>
::= sr <qualifying type> <encoding> */
static status_t
demangle_scope_expression (dm)
demangling_t dm;
{
RETURN_IF_ERROR (demangle_char (dm, 's'));
RETURN_IF_ERROR (demangle_char (dm, 'r'));
RETURN_IF_ERROR (demangle_type (dm));
RETURN_IF_ERROR (result_add (dm, "::"));
RETURN_IF_ERROR (demangle_encoding (dm));
return STATUS_OK;
}
/* Demangles and emits an <expr-primary>.
<expr-primary> ::= <template-param>
::= L <type> <value number> E # literal
::= L <mangled-name> E # external name */
static status_t
demangle_expr_primary (dm)
demangling_t dm;
{
char peek = peek_char (dm);
DEMANGLE_TRACE ("expr-primary", dm);
if (peek == 'T')
RETURN_IF_ERROR (demangle_template_param (dm));
else if (peek == 'L')
{
/* Consume the `L'. */
advance_char (dm);
peek = peek_char (dm);
if (peek == '_')
RETURN_IF_ERROR (demangle_mangled_name (dm));
else
RETURN_IF_ERROR (demangle_literal (dm));
RETURN_IF_ERROR (demangle_char (dm, 'E'));
}
else
return STATUS_ERROR;
return STATUS_OK;
}
/* Demangles and emits a <substitution>. Sets *TEMPLATE_P to non-zero
if the substitution is the name of a template, zero otherwise.
<substitution> ::= S <seq-id> _
::= S_
::= St # ::std::
::= Sa # ::std::allocator
::= Sb # ::std::basic_string
::= Ss # ::std::basic_string<char,
::std::char_traits<char>,
::std::allocator<char> >
::= Si # ::std::basic_istream<char,
std::char_traits<char> >
::= So # ::std::basic_ostream<char,
std::char_traits<char> >
::= Sd # ::std::basic_iostream<char,
std::char_traits<char> >
*/
static status_t
demangle_substitution (dm, template_p)
demangling_t dm;
int *template_p;
{
int seq_id;
int peek;
dyn_string_t text;
DEMANGLE_TRACE ("substitution", dm);
RETURN_IF_ERROR (demangle_char (dm, 'S'));
/* Scan the substitution sequence index. A missing number denotes
the first index. */
peek = peek_char (dm);
if (peek == '_')
seq_id = -1;
/* If the following character is 0-9 or a capital letter, interpret
the sequence up to the next underscore as a base-36 substitution
index. */
else if (IS_DIGIT ((unsigned char) peek)
|| (peek >= 'A' && peek <= 'Z'))
RETURN_IF_ERROR (demangle_number (dm, &seq_id, 36, 0));
else
{
const char *new_last_source_name = NULL;
switch (peek)
{
case 't':
RETURN_IF_ERROR (result_add (dm, "std"));
break;
case 'a':
RETURN_IF_ERROR (result_add (dm, "std::allocator"));
new_last_source_name = "allocator";
*template_p = 1;
break;
case 'b':
RETURN_IF_ERROR (result_add (dm, "std::basic_string"));
new_last_source_name = "basic_string";
*template_p = 1;
break;
case 's':
if (!flag_verbose)
{
RETURN_IF_ERROR (result_add (dm, "std::string"));
new_last_source_name = "string";
}
else
{
RETURN_IF_ERROR (result_add (dm, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"));
new_last_source_name = "basic_string";
}
*template_p = 0;
break;
case 'i':
if (!flag_verbose)
{
RETURN_IF_ERROR (result_add (dm, "std::istream"));
new_last_source_name = "istream";
}
else
{
RETURN_IF_ERROR (result_add (dm, "std::basic_istream<char, std::char_traits<char> >"));
new_last_source_name = "basic_istream";
}
*template_p = 0;
break;
case 'o':
if (!flag_verbose)
{
RETURN_IF_ERROR (result_add (dm, "std::ostream"));
new_last_source_name = "ostream";
}
else
{
RETURN_IF_ERROR (result_add (dm, "std::basic_ostream<char, std::char_traits<char> >"));
new_last_source_name = "basic_ostream";
}
*template_p = 0;
break;
case 'd':
if (!flag_verbose)
{
RETURN_IF_ERROR (result_add (dm, "std::iostream"));
new_last_source_name = "iostream";
}
else
{
RETURN_IF_ERROR (result_add (dm, "std::basic_iostream<char, std::char_traits<char> >"));
new_last_source_name = "basic_iostream";
}
*template_p = 0;
break;
default:
return "Unrecognized <substitution>.";
}
/* Consume the character we just processed. */
advance_char (dm);
if (new_last_source_name != NULL)
{
if (!dyn_string_copy_cstr (dm->last_source_name,
new_last_source_name))
return STATUS_ALLOCATION_FAILED;
}
return STATUS_OK;
}
/* Look up the substitution text. Since `S_' is the most recent
substitution, `S0_' is the second-most-recent, etc., shift the
numbering by one. */
text = substitution_get (dm, seq_id + 1, template_p);
if (text == NULL)
return "Substitution number out of range.";
/* Emit the substitution text. */
RETURN_IF_ERROR (result_add_string (dm, text));
RETURN_IF_ERROR (demangle_char (dm, '_'));
return STATUS_OK;
}
/* Demangles and emits a <local-name>.
<local-name> := Z <function encoding> E <entity name> [<discriminator>]
:= Z <function encoding> E s [<discriminator>] */
static status_t
demangle_local_name (dm)
demangling_t dm;
{
DEMANGLE_TRACE ("local-name", dm);
RETURN_IF_ERROR (demangle_char (dm, 'Z'));
RETURN_IF_ERROR (demangle_encoding (dm));
RETURN_IF_ERROR (demangle_char (dm, 'E'));
RETURN_IF_ERROR (result_add (dm, "::"));
if (peek_char (dm) == 's')
{
/* Local character string literal. */
RETURN_IF_ERROR (result_add (dm, "string literal"));
/* Consume the s. */
advance_char (dm);
RETURN_IF_ERROR (demangle_discriminator (dm, 0));
}
else
{
int unused;
/* Local name for some other entity. Demangle its name. */
RETURN_IF_ERROR (demangle_name (dm, &unused));
RETURN_IF_ERROR (demangle_discriminator (dm, 1));
}
return STATUS_OK;
}
/* Optimonally demangles and emits a <discriminator>. If there is no
<discriminator> at the current position in the mangled string, the
descriminator is assumed to be zero. Emit the discriminator number
in parentheses, unless SUPPRESS_FIRST is non-zero and the
discriminator is zero.
<discriminator> ::= _ <number> */
static status_t
demangle_discriminator (dm, suppress_first)
demangling_t dm;
int suppress_first;
{
/* Output for <discriminator>s to the demangled name is completely
suppressed if not in verbose mode. */
if (peek_char (dm) == '_')
{
/* Consume the underscore. */
advance_char (dm);
if (flag_verbose)
RETURN_IF_ERROR (result_add (dm, " [#"));
/* Check if there's a number following the underscore. */
if (IS_DIGIT ((unsigned char) peek_char (dm)))
{
int discriminator;
/* Demangle the number. */
RETURN_IF_ERROR (demangle_number (dm, &discriminator, 10, 0));
if (flag_verbose)
/* Write the discriminator. The mangled number is two
less than the discriminator ordinal, counting from
zero. */
RETURN_IF_ERROR (int_to_dyn_string (discriminator + 1,
(dyn_string_t) dm->result));
}
else
return STATUS_ERROR;
if (flag_verbose)
RETURN_IF_ERROR (result_add_char (dm, ']'));
}
else if (!suppress_first)
{
if (flag_verbose)
RETURN_IF_ERROR (result_add (dm, " [#0]"));
}
return STATUS_OK;
}
/* Demangle NAME into RESULT, which must be an initialized
dyn_string_t. On success, returns STATUS_OK. On failure, returns
an error message, and the contents of RESULT are unchanged. */
static status_t
cp_demangle (name, result, style)
const char *name;
dyn_string_t result;
int style;
{
status_t status;
int length = strlen (name);
if (length > 2 && name[0] == '_' && name[1] == 'Z')
{
demangling_t dm = demangling_new (name, style);
if (dm == NULL)
return STATUS_ALLOCATION_FAILED;
status = result_push (dm);
if (status != STATUS_OK)
{
demangling_delete (dm);
return status;
}
status = demangle_mangled_name (dm);
if (STATUS_NO_ERROR (status))
{
dyn_string_t demangled = (dyn_string_t) result_pop (dm);
if (!dyn_string_copy (result, demangled))
return STATUS_ALLOCATION_FAILED;
dyn_string_delete (demangled);
}
demangling_delete (dm);
}
else
{
/* It's evidently not a mangled C++ name. It could be the name
of something with C linkage, though, so just copy NAME into
RESULT. */
if (!dyn_string_copy_cstr (result, name))
return STATUS_ALLOCATION_FAILED;
status = STATUS_OK;
}
return status;
}
/* Demangle TYPE_NAME into RESULT, which must be an initialized
dyn_string_t. On success, returns STATUS_OK. On failiure, returns
an error message, and the contents of RESULT are unchanged. */
static status_t
cp_demangle_type (type_name, result)
const char* type_name;
dyn_string_t result;
{
status_t status;
demangling_t dm = demangling_new (type_name, DMGL_GNU_V3);
if (dm == NULL)
return STATUS_ALLOCATION_FAILED;
/* Demangle the type name. The demangled name is stored in dm. */
status = result_push (dm);
if (status != STATUS_OK)
{
demangling_delete (dm);
return status;
}
status = demangle_type (dm);
if (STATUS_NO_ERROR (status))
{
/* The demangling succeeded. Pop the result out of dm and copy
it into RESULT. */
dyn_string_t demangled = (dyn_string_t) result_pop (dm);
if (!dyn_string_copy (result, demangled))
return STATUS_ALLOCATION_FAILED;
dyn_string_delete (demangled);
}
/* Clean up. */
demangling_delete (dm);
return status;
}
#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
/* ia64 ABI-mandated entry point in the C++ runtime library for performing
demangling. MANGLED_NAME is a NUL-terminated character string
containing the name to be demangled.
OUTPUT_BUFFER is a region of memory, allocated with malloc, of
*LENGTH bytes, into which the demangled name is stored. If
OUTPUT_BUFFER is not long enough, it is expanded using realloc.
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
demangled name, is placed in *LENGTH.
The return value is a pointer to the start of the NUL-terminated
demangled name, or NULL if the demangling fails. The caller is
responsible for deallocating this memory using free.
*STATUS is set to one of the following values:
0: The demangling operation succeeded.
-1: A memory allocation failiure occurred.
-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
-3: One of the arguments is invalid.
The demagling is performed using the C++ ABI mangling rules, with
GNU extensions. */
char *
__cxa_demangle (mangled_name, output_buffer, length, status)
const char *mangled_name;
char *output_buffer;
size_t *length;
int *status;
{
struct dyn_string demangled_name;
status_t result;
if (status == NULL)
return NULL;
if (mangled_name == NULL) {
*status = -3;
return NULL;
}
/* Did the caller provide a buffer for the demangled name? */
if (output_buffer == NULL) {
/* No; dyn_string will malloc a buffer for us. */
if (!dyn_string_init (&demangled_name, 0))
{
*status = -1;
return NULL;
}
}
else {
/* Yes. Check that the length was provided. */
if (length == NULL) {
*status = -3;
return NULL;
}
/* Install the buffer into a dyn_string. */
demangled_name.allocated = *length;
demangled_name.length = 0;
demangled_name.s = output_buffer;
}
if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
/* MANGLED_NAME apprears to be a function or variable name.
Demangle it accordingly. */
result = cp_demangle (mangled_name, &demangled_name, 0);
else
/* Try to demangled MANGLED_NAME as the name of a type. */
result = cp_demangle_type (mangled_name, &demangled_name);
if (result == STATUS_OK)
/* The demangling succeeded. */
{
/* If LENGTH isn't NULL, store the allocated buffer length
there; the buffer may have been realloced by dyn_string
functions. */
if (length != NULL)
*length = demangled_name.allocated;
/* The operation was a success. */
*status = 0;
return dyn_string_buf (&demangled_name);
}
else if (result == STATUS_ALLOCATION_FAILED)
/* A call to malloc or realloc failed during the demangling
operation. */
{
*status = -1;
return NULL;
}
else
/* The demangling failed for another reason, most probably because
MANGLED_NAME isn't a valid mangled name. */
{
/* If the buffer containing the demangled name wasn't provided
by the caller, free it. */
if (output_buffer == NULL)
free (dyn_string_buf (&demangled_name));
*status = -2;
return NULL;
}
}
#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
/* Variant entry point for integration with the existing cplus-dem
demangler. Attempts to demangle MANGLED. If the demangling
succeeds, returns a buffer, allocated with malloc, containing the
demangled name. The caller must deallocate the buffer using free.
If the demangling failes, returns NULL. */
char *
cplus_demangle_v3 (mangled, options)
const char* mangled;
int options;
{
dyn_string_t demangled;
status_t status;
int type = !!(options & DMGL_TYPES);
if (mangled[0] == '_' && mangled[1] == 'Z')
/* It is not a type. */
type = 0;
else
{
/* It is a type. Stop if we don't want to demangle types. */
if (!type)
return NULL;
}
flag_verbose = !!(options & DMGL_VERBOSE);
/* Create a dyn_string to hold the demangled name. */
demangled = dyn_string_new (0);
/* Attempt the demangling. */
if (!type)
/* Appears to be a function or variable name. */
status = cp_demangle (mangled, demangled, 0);
else
/* Try to demangle it as the name of a type. */
status = cp_demangle_type (mangled, demangled);
if (STATUS_NO_ERROR (status))
/* Demangling succeeded. */
{
/* Grab the demangled result from the dyn_string. It was
allocated with malloc, so we can return it directly. */
char *return_value = dyn_string_release (demangled);
/* Hand back the demangled name. */
return return_value;
}
else if (status == STATUS_ALLOCATION_FAILED)
{
fprintf (stderr, "Memory allocation failed.\n");
abort ();
}
else
/* Demangling failed. */
{
dyn_string_delete (demangled);
return NULL;
}
}
/* 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[]. */
char *
java_demangle_v3 (mangled)
const char* mangled;
{
dyn_string_t demangled;
char *next;
char *end;
int len;
status_t status;
int nesting = 0;
char *cplus_demangled;
char *return_value;
/* Create a dyn_string to hold the demangled name. */
demangled = dyn_string_new (0);
/* Attempt the demangling. */
status = cp_demangle ((char *) mangled, demangled, DMGL_JAVA);
if (STATUS_NO_ERROR (status))
/* Demangling succeeded. */
{
/* Grab the demangled result from the dyn_string. */
cplus_demangled = dyn_string_release (demangled);
}
else if (status == STATUS_ALLOCATION_FAILED)
{
fprintf (stderr, "Memory allocation failed.\n");
abort ();
}
else
/* Demangling failed. */
{
dyn_string_delete (demangled);
return NULL;
}
len = strlen (cplus_demangled);
next = cplus_demangled;
end = next + len;
demangled = NULL;
/* Replace occurances of JArray<TYPE> with TYPE[]. */
while (next < end)
{
char *open_str = strstr (next, "JArray<");
char *close_str = NULL;
if (nesting > 0)
close_str = strchr (next, '>');
if (open_str != NULL && (close_str == NULL || close_str > open_str))
{
++nesting;
if (!demangled)
demangled = dyn_string_new(len);
/* Copy prepending symbols, if any. */
if (open_str > next)
{
open_str[0] = 0;
dyn_string_append_cstr (demangled, next);
}
next = open_str + 7;
}
else if (close_str != NULL)
{
--nesting;
/* Copy prepending type symbol, if any. Squash any spurious
whitespace. */
if (close_str > next && next[0] != ' ')
{
close_str[0] = 0;
dyn_string_append_cstr (demangled, next);
}
dyn_string_append_cstr (demangled, "[]");
next = close_str + 1;
}
else
{
/* There are no more arrays. Copy the rest of the symbol, or
simply return the original symbol if no changes were made. */
if (next == cplus_demangled)
return cplus_demangled;
dyn_string_append_cstr (demangled, next);
next = end;
}
}
free (cplus_demangled);
if (demangled)
return_value = dyn_string_release (demangled);
else
return_value = NULL;
return return_value;
}
#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
#ifndef IN_GLIBCPP_V3
/* Demangle NAME in the G++ V3 ABI demangling style, and return either
zero, indicating that some error occurred, or a demangling_t
holding the results. */
static demangling_t
demangle_v3_with_details (name)
const char *name;
{
demangling_t dm;
status_t status;
if (strncmp (name, "_Z", 2))
return 0;
dm = demangling_new (name, DMGL_GNU_V3);
if (dm == NULL)
{
fprintf (stderr, "Memory allocation failed.\n");
abort ();
}
status = result_push (dm);
if (! STATUS_NO_ERROR (status))
{
demangling_delete (dm);
fprintf (stderr, "%s\n", status);
abort ();
}
status = demangle_mangled_name (dm);
if (STATUS_NO_ERROR (status))
return dm;
demangling_delete (dm);
return 0;
}
/* Return non-zero iff NAME is the mangled form of a constructor name
in the G++ V3 ABI demangling style. Specifically, return:
- '1' if NAME is a complete object constructor,
- '2' if NAME is a base object constructor, or
- '3' if NAME is a complete object allocating constructor. */
enum gnu_v3_ctor_kinds
is_gnu_v3_mangled_ctor (name)
const char *name;
{
demangling_t dm = demangle_v3_with_details (name);
if (dm)
{
enum gnu_v3_ctor_kinds result = dm->is_constructor;
demangling_delete (dm);
return result;
}
else
return (enum gnu_v3_ctor_kinds) 0;
}
/* Return non-zero iff NAME is the mangled form of a destructor name
in the G++ V3 ABI demangling style. Specifically, return:
- '0' if NAME is a deleting destructor,
- '1' if NAME is a complete object destructor, or
- '2' if NAME is a base object destructor. */
enum gnu_v3_dtor_kinds
is_gnu_v3_mangled_dtor (name)
const char *name;
{
demangling_t dm = demangle_v3_with_details (name);
if (dm)
{
enum gnu_v3_dtor_kinds result = dm->is_destructor;
demangling_delete (dm);
return result;
}
else
return (enum gnu_v3_dtor_kinds) 0;
}
#endif /* IN_GLIBCPP_V3 */
#ifdef STANDALONE_DEMANGLER
#include "getopt.h"
static void print_usage
PARAMS ((FILE* fp, int exit_value));
/* Non-zero if CHAR is a character than can occur in a mangled name. */
#define is_mangled_char(CHAR) \
(IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
|| (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
/* The name of this program, as invoked. */
const char* program_name;
/* Prints usage summary to FP and then exits with EXIT_VALUE. */
static void
print_usage (fp, exit_value)
FILE* fp;
int exit_value;
{
fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
fprintf (fp, "Options:\n");
fprintf (fp, " -h,--help Display this message.\n");
fprintf (fp, " -s,--strict Demangle standard names only.\n");
fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
exit (exit_value);
}
/* Option specification for getopt_long. */
static const struct option long_options[] =
{
{ "help", no_argument, NULL, 'h' },
{ "strict", no_argument, NULL, 's' },
{ "verbose", no_argument, NULL, 'v' },
{ NULL, no_argument, NULL, 0 },
};
/* Main entry for a demangling filter executable. It will demangle
its command line arguments, if any. If none are provided, it will
filter stdin to stdout, replacing any recognized mangled C++ names
with their demangled equivalents. */
int
main (argc, argv)
int argc;
char *argv[];
{
status_t status;
int i;
int opt_char;
/* Use the program name of this program, as invoked. */
program_name = argv[0];
/* Parse options. */
do
{
opt_char = getopt_long (argc, argv, "hsv", long_options, NULL);
switch (opt_char)
{
case '?': /* Unrecognized option. */
print_usage (stderr, 1);
break;
case 'h':
print_usage (stdout, 0);
break;
case 's':
flag_strict = 1;
break;
case 'v':
flag_verbose = 1;
break;
}
}
while (opt_char != -1);
if (optind == argc)
/* No command line arguments were provided. Filter stdin. */
{
dyn_string_t mangled = dyn_string_new (3);
dyn_string_t demangled = dyn_string_new (0);
status_t status;
/* Read all of input. */
while (!feof (stdin))
{
char c = getchar ();
/* The first character of a mangled name is an underscore. */
if (feof (stdin))
break;
if (c != '_')
{
/* It's not a mangled name. Print the character and go
on. */
putchar (c);
continue;
}
c = getchar ();
/* The second character of a mangled name is a capital `Z'. */
if (feof (stdin))
break;
if (c != 'Z')
{
/* It's not a mangled name. Print the previous
underscore, the `Z', and go on. */
putchar ('_');
putchar (c);
continue;
}
/* Start keeping track of the candidate mangled name. */
dyn_string_append_char (mangled, '_');
dyn_string_append_char (mangled, 'Z');
/* Pile characters into mangled until we hit one that can't
occur in a mangled name. */
c = getchar ();
while (!feof (stdin) && is_mangled_char (c))
{
dyn_string_append_char (mangled, c);
if (feof (stdin))
break;
c = getchar ();
}
/* Attempt to demangle the name. */
status = cp_demangle (dyn_string_buf (mangled), demangled, 0);
/* If the demangling succeeded, great! Print out the
demangled version. */
if (STATUS_NO_ERROR (status))
fputs (dyn_string_buf (demangled), stdout);
/* Abort on allocation failures. */
else if (status == STATUS_ALLOCATION_FAILED)
{
fprintf (stderr, "Memory allocation failed.\n");
abort ();
}
/* Otherwise, it might not have been a mangled name. Just
print out the original text. */
else
fputs (dyn_string_buf (mangled), stdout);
/* If we haven't hit EOF yet, we've read one character that
can't occur in a mangled name, so print it out. */
if (!feof (stdin))
putchar (c);
/* Clear the candidate mangled name, to start afresh next
time we hit a `_Z'. */
dyn_string_clear (mangled);
}
dyn_string_delete (mangled);
dyn_string_delete (demangled);
}
else
/* Demangle command line arguments. */
{
dyn_string_t result = dyn_string_new (0);
/* Loop over command line arguments. */
for (i = optind; i < argc; ++i)
{
/* Attempt to demangle. */
status = cp_demangle (argv[i], result, 0);
/* If it worked, print the demangled name. */
if (STATUS_NO_ERROR (status))
printf ("%s\n", dyn_string_buf (result));
/* Abort on allocaiton failures. */
else if (status == STATUS_ALLOCATION_FAILED)
{
fprintf (stderr, "Memory allocation failed.\n");
abort ();
}
/* If not, print the error message to stderr instead. */
else
fprintf (stderr, "%s\n", status);
}
dyn_string_delete (result);
}
return 0;
}
#endif /* STANDALONE_DEMANGLER */
Reference in New Issue View Git Blame Copy Permalink