| /**************************************************************************** |
| * * |
| * GNAT COMPILER COMPONENTS * |
| * * |
| * A D A D E C O D E * |
| * * |
| * C Implementation File * |
| * * |
| * Copyright (C) 2001-2015, 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 * |
| * <http://www.gnu.org/licenses/>. * |
| * * |
| * 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 <string.h> |
| #include <stdio.h> |
| #include <ctype.h> |
| |
| #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_RTS |
| 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 |
