URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc1/] [gcc/] [ada/] [adadecode.c] - Rev 338
Compare with Previous | Blame | View Log
/**************************************************************************** * * * GNAT COMPILER COMPONENTS * * * * A D A D E C O D E * * * * C Implementation File * * * * Copyright (C) 2001-2009, 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" #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; /* Check for library level subprogram. */ 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 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'; }