/****************************************************************************
* *
* GNAT COMPILER COMPONENTS *
* *
* A D A D E C O D E *
* *
* C Implementation File *
* *
* Copyright (C) 2001-2012, Free Software Foundation, Inc. *
* *
* GNAT is free software; you can redistribute it and/or modify it under *
* terms of the GNU General Public License as published by the Free Soft- *
* ware Foundation; either version 3, or (at your option) any later ver- *
* sion. GNAT is distributed in the hope that it will be useful, but WITH- *
* OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
* or FITNESS FOR A PARTICULAR PURPOSE. *
* *
* As a special exception under Section 7 of GPL version 3, you are granted *
* additional permissions described in the GCC Runtime Library Exception, *
* version 3.1, as published by the Free Software Foundation. *
* *
* You should have received a copy of the GNU General Public License and *
* a copy of the GCC Runtime Library Exception along with this program; *
* see the files COPYING3 and COPYING.RUNTIME respectively. If not, see *
* . *
* *
* GNAT was originally developed by the GNAT team at New York University. *
* Extensive contributions were provided by Ada Core Technologies Inc. *
* *
****************************************************************************/
#if defined(IN_RTS)
#include "tconfig.h"
#include "tsystem.h"
#elif defined(IN_GCC)
#include "config.h"
#include "system.h"
#endif
#include
#include
#include
#include "adaint.h" /* for a macro version of xstrdup. */
#ifndef ISDIGIT
#define ISDIGIT(c) isdigit(c)
#endif
#ifndef PARMS
#define PARMS(ARGS) ARGS
#endif
#include "adadecode.h"
static void add_verbose (const char *, char *);
static int has_prefix (const char *, const char *);
static int has_suffix (const char *, const char *);
/* This is a safe version of strcpy that can be used with overlapped
pointers. Does nothing if s2 <= s1. */
static void ostrcpy (char *s1, char *s2);
/* Set to nonzero if we have written any verbose info. */
static int verbose_info;
/* Add TEXT to end of ADA_NAME, putting a leading " (" or ", ", depending
on VERBOSE_INFO. */
static void add_verbose (const char *text, char *ada_name)
{
strcat (ada_name, verbose_info ? ", " : " (");
strcat (ada_name, text);
verbose_info = 1;
}
/* Returns 1 if NAME starts with PREFIX. */
static int
has_prefix (const char *name, const char *prefix)
{
return strncmp (name, prefix, strlen (prefix)) == 0;
}
/* Returns 1 if NAME ends with SUFFIX. */
static int
has_suffix (const char *name, const char *suffix)
{
int nlen = strlen (name);
int slen = strlen (suffix);
return nlen > slen && strncmp (name + nlen - slen, suffix, slen) == 0;
}
/* Safe overlapped pointers version of strcpy. */
static void
ostrcpy (char *s1, char *s2)
{
if (s2 > s1)
{
while (*s2) *s1++ = *s2++;
*s1 = '\0';
}
}
/* This function will return the Ada name from the encoded form.
The Ada coding is done in exp_dbug.ads and this is the inverse function.
see exp_dbug.ads for full encoding rules, a short description is added
below. Right now only objects and routines are handled. Ada types are
stripped of their encodings.
CODED_NAME is the encoded entity name.
ADA_NAME is a pointer to a buffer, it will receive the Ada name. A safe
size for this buffer is: strlen (coded_name) * 2 + 60. (60 is for the
verbose information).
VERBOSE is nonzero if more information about the entity is to be
added at the end of the Ada name and surrounded by ( and ).
Coded name Ada name verbose info
---------------------------------------------------------------------
_ada_xyz xyz library level
x__y__z x.y.z
x__yTKB x.y task body
x__yB x.y task body
x__yX x.y body nested
x__yXb x.y body nested
xTK__y x.y in task
x__y$2 x.y overloaded
x__y__3 x.y overloaded
x__Oabs "abs"
x__Oand "and"
x__Omod "mod"
x__Onot "not"
x__Oor "or"
x__Orem "rem"
x__Oxor "xor"
x__Oeq "="
x__One "/="
x__Olt "<"
x__Ole "<="
x__Ogt ">"
x__Oge ">="
x__Oadd "+"
x__Osubtract "-"
x__Oconcat "&"
x__Omultiply "*"
x__Odivide "/"
x__Oexpon "**" */
void
__gnat_decode (const char *coded_name, char *ada_name, int verbose)
{
int lib_subprog = 0;
int overloaded = 0;
int task_body = 0;
int in_task = 0;
int body_nested = 0;
/* Deal with empty input early. This allows assuming non-null length
later on, simplifying coding. In principle, it should be our callers
business not to call here for empty inputs. It is easy enough to
allow it, however, and might allow simplifications upstream so is not
a bad thing per se. We need a guard in any case. */
if (*coded_name == '\0')
{
*ada_name = '\0';
return;
}
/* Check for library level subprogram. */
else if (has_prefix (coded_name, "_ada_"))
{
strcpy (ada_name, coded_name + 5);
lib_subprog = 1;
}
else
strcpy (ada_name, coded_name);
/* Check for the first triple underscore in the name. This indicates
that the name represents a type with encodings; in this case, we
need to strip the encodings. */
{
char *encodings;
if ((encodings = (char *) strstr (ada_name, "___")) != NULL)
{
*encodings = '\0';
}
}
/* Check for task body. */
if (has_suffix (ada_name, "TKB"))
{
ada_name[strlen (ada_name) - 3] = '\0';
task_body = 1;
}
if (has_suffix (ada_name, "B"))
{
ada_name[strlen (ada_name) - 1] = '\0';
task_body = 1;
}
/* Check for body-nested entity: X[bn] */
if (has_suffix (ada_name, "X"))
{
ada_name[strlen (ada_name) - 1] = '\0';
body_nested = 1;
}
if (has_suffix (ada_name, "Xb"))
{
ada_name[strlen (ada_name) - 2] = '\0';
body_nested = 1;
}
if (has_suffix (ada_name, "Xn"))
{
ada_name[strlen (ada_name) - 2] = '\0';
body_nested = 1;
}
/* Change instance of TK__ (object declared inside a task) to __. */
{
char *tktoken;
while ((tktoken = (char *) strstr (ada_name, "TK__")) != NULL)
{
ostrcpy (tktoken, tktoken + 2);
in_task = 1;
}
}
/* Check for overloading: name terminated by $nn or __nn. */
{
int len = strlen (ada_name);
int n_digits = 0;
if (len > 1)
while (ISDIGIT ((int) ada_name[(int) len - 1 - n_digits]))
n_digits++;
/* Check if we have $ or __ before digits. */
if (ada_name[len - 1 - n_digits] == '$')
{
ada_name[len - 1 - n_digits] = '\0';
overloaded = 1;
}
else if (ada_name[len - 1 - n_digits] == '_'
&& ada_name[len - 1 - n_digits - 1] == '_')
{
ada_name[len - 1 - n_digits - 1] = '\0';
overloaded = 1;
}
}
/* Check for nested subprogram ending in .nnnn and strip suffix. */
{
int last = strlen (ada_name) - 1;
while (ISDIGIT (ada_name[last]) && last > 0)
{
last--;
}
if (ada_name[last] == '.')
{
ada_name[last] = (char) 0;
}
}
/* Change all "__" to ".". */
{
int len = strlen (ada_name);
int k = 0;
while (k < len)
{
if (ada_name[k] == '_' && ada_name[k+1] == '_')
{
ada_name[k] = '.';
ostrcpy (ada_name + k + 1, ada_name + k + 2);
len = len - 1;
}
k++;
}
}
/* Checks for operator name. */
{
const char *trans_table[][2]
= {{"Oabs", "\"abs\""}, {"Oand", "\"and\""}, {"Omod", "\"mod\""},
{"Onot", "\"not\""}, {"Oor", "\"or\""}, {"Orem", "\"rem\""},
{"Oxor", "\"xor\""}, {"Oeq", "\"=\""}, {"One", "\"/=\""},
{"Olt", "\"<\""}, {"Ole", "\"<=\""}, {"Ogt", "\">\""},
{"Oge", "\">=\""}, {"Oadd", "\"+\""}, {"Osubtract", "\"-\""},
{"Oconcat", "\"&\""}, {"Omultiply", "\"*\""}, {"Odivide", "\"/\""},
{"Oexpon", "\"**\""}, {NULL, NULL} };
int k = 0;
while (1)
{
char *optoken;
if ((optoken = (char *) strstr (ada_name, trans_table[k][0])) != NULL)
{
int codedlen = strlen (trans_table[k][0]);
int oplen = strlen (trans_table[k][1]);
if (codedlen > oplen)
/* We shrink the space. */
ostrcpy (optoken, optoken + codedlen - oplen);
else if (oplen > codedlen)
{
/* We need more space. */
int len = strlen (ada_name);
int space = oplen - codedlen;
int num_to_move = &ada_name[len] - optoken;
int t;
for (t = 0; t < num_to_move; t++)
ada_name[len + space - t - 1] = ada_name[len - t - 1];
}
/* Write symbol in the space. */
strncpy (optoken, trans_table[k][1], oplen);
}
else
k++;
/* Check for table's ending. */
if (trans_table[k][0] == NULL)
break;
}
}
/* If verbose mode is on, we add some information to the Ada name. */
if (verbose)
{
if (overloaded)
add_verbose ("overloaded", ada_name);
if (lib_subprog)
add_verbose ("library level", ada_name);
if (body_nested)
add_verbose ("body nested", ada_name);
if (in_task)
add_verbose ("in task", ada_name);
if (task_body)
add_verbose ("task body", ada_name);
if (verbose_info == 1)
strcat (ada_name, ")");
}
}
#ifdef __cplusplus
extern "C" {
#endif
#ifdef IN_GCC
char *
ada_demangle (const char *coded_name)
{
char ada_name[2048];
__gnat_decode (coded_name, ada_name, 0);
return xstrdup (ada_name);
}
#endif
void
get_encoding (const char *coded_name, char *encoding)
{
char * dest_index = encoding;
const char *p;
int found = 0;
int count = 0;
/* The heuristics is the following: we assume that the first triple
underscore in an encoded name indicates the beginning of the
first encoding, and that subsequent triple underscores indicate
the next encodings. We assume that the encodings are always at the
end of encoded names. */
for (p = coded_name; *p != '\0'; p++)
{
if (*p != '_')
count = 0;
else
if (++count == 3)
{
count = 0;
if (found)
{
dest_index = dest_index - 2;
*dest_index++ = ':';
}
p++;
found = 1;
}
if (found)
*dest_index++ = *p;
}
*dest_index = '\0';
}
#ifdef __cplusplus
}
#endif