2010-07-27 Paolo Carlini <paolo.carlini@oracle.com>
[official-gcc/alias-decl.git] / gcc / ada / adadecode.c
blob43f14f1279266e4853ab48f3c489150504f1213c
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * A D A D E C O D E *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 2001-2009, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. *
17 * *
18 * As a special exception under Section 7 of GPL version 3, you are granted *
19 * additional permissions described in the GCC Runtime Library Exception, *
20 * version 3.1, as published by the Free Software Foundation. *
21 * *
22 * You should have received a copy of the GNU General Public License and *
23 * a copy of the GCC Runtime Library Exception along with this program; *
24 * see the files COPYING3 and COPYING.RUNTIME respectively. If not, see *
25 * <http://www.gnu.org/licenses/>. *
26 * *
27 * GNAT was originally developed by the GNAT team at New York University. *
28 * Extensive contributions were provided by Ada Core Technologies Inc. *
29 * *
30 ****************************************************************************/
33 #if defined(IN_RTS)
34 #include "tconfig.h"
35 #include "tsystem.h"
36 #elif defined(IN_GCC)
37 #include "config.h"
38 #include "system.h"
39 #endif
41 #include <string.h>
42 #include <stdio.h>
43 #include <ctype.h>
45 #include "adaint.h"
47 #ifndef ISDIGIT
48 #define ISDIGIT(c) isdigit(c)
49 #endif
51 #ifndef PARMS
52 #define PARMS(ARGS) ARGS
53 #endif
55 #include "adadecode.h"
57 static void add_verbose (const char *, char *);
58 static int has_prefix (const char *, const char *);
59 static int has_suffix (const char *, const char *);
61 /* This is a safe version of strcpy that can be used with overlapped
62 pointers. Does nothing if s2 <= s1. */
63 static void ostrcpy (char *s1, char *s2);
65 /* Set to nonzero if we have written any verbose info. */
66 static int verbose_info;
68 /* Add TEXT to end of ADA_NAME, putting a leading " (" or ", ", depending
69 on VERBOSE_INFO. */
71 static void add_verbose (const char *text, char *ada_name)
73 strcat (ada_name, verbose_info ? ", " : " (");
74 strcat (ada_name, text);
76 verbose_info = 1;
79 /* Returns 1 if NAME starts with PREFIX. */
81 static int
82 has_prefix (const char *name, const char *prefix)
84 return strncmp (name, prefix, strlen (prefix)) == 0;
87 /* Returns 1 if NAME ends with SUFFIX. */
89 static int
90 has_suffix (const char *name, const char *suffix)
92 int nlen = strlen (name);
93 int slen = strlen (suffix);
95 return nlen > slen && strncmp (name + nlen - slen, suffix, slen) == 0;
98 /* Safe overlapped pointers version of strcpy. */
100 static void
101 ostrcpy (char *s1, char *s2)
103 if (s2 > s1)
105 while (*s2) *s1++ = *s2++;
106 *s1 = '\0';
110 /* This function will return the Ada name from the encoded form.
111 The Ada coding is done in exp_dbug.ads and this is the inverse function.
112 see exp_dbug.ads for full encoding rules, a short description is added
113 below. Right now only objects and routines are handled. Ada types are
114 stripped of their encodings.
116 CODED_NAME is the encoded entity name.
118 ADA_NAME is a pointer to a buffer, it will receive the Ada name. A safe
119 size for this buffer is: strlen (coded_name) * 2 + 60. (60 is for the
120 verbose information).
122 VERBOSE is nonzero if more information about the entity is to be
123 added at the end of the Ada name and surrounded by ( and ).
125 Coded name Ada name verbose info
126 ---------------------------------------------------------------------
127 _ada_xyz xyz library level
128 x__y__z x.y.z
129 x__yTKB x.y task body
130 x__yB x.y task body
131 x__yX x.y body nested
132 x__yXb x.y body nested
133 xTK__y x.y in task
134 x__y$2 x.y overloaded
135 x__y__3 x.y overloaded
136 x__Oabs "abs"
137 x__Oand "and"
138 x__Omod "mod"
139 x__Onot "not"
140 x__Oor "or"
141 x__Orem "rem"
142 x__Oxor "xor"
143 x__Oeq "="
144 x__One "/="
145 x__Olt "<"
146 x__Ole "<="
147 x__Ogt ">"
148 x__Oge ">="
149 x__Oadd "+"
150 x__Osubtract "-"
151 x__Oconcat "&"
152 x__Omultiply "*"
153 x__Odivide "/"
154 x__Oexpon "**" */
156 void
157 __gnat_decode (const char *coded_name, char *ada_name, int verbose)
159 int lib_subprog = 0;
160 int overloaded = 0;
161 int task_body = 0;
162 int in_task = 0;
163 int body_nested = 0;
165 /* Check for library level subprogram. */
166 if (has_prefix (coded_name, "_ada_"))
168 strcpy (ada_name, coded_name + 5);
169 lib_subprog = 1;
171 else
172 strcpy (ada_name, coded_name);
174 /* Check for the first triple underscore in the name. This indicates
175 that the name represents a type with encodings; in this case, we
176 need to strip the encodings. */
178 char *encodings;
180 if ((encodings = (char *) strstr (ada_name, "___")) != NULL)
182 *encodings = '\0';
186 /* Check for task body. */
187 if (has_suffix (ada_name, "TKB"))
189 ada_name[strlen (ada_name) - 3] = '\0';
190 task_body = 1;
193 if (has_suffix (ada_name, "B"))
195 ada_name[strlen (ada_name) - 1] = '\0';
196 task_body = 1;
199 /* Check for body-nested entity: X[bn] */
200 if (has_suffix (ada_name, "X"))
202 ada_name[strlen (ada_name) - 1] = '\0';
203 body_nested = 1;
206 if (has_suffix (ada_name, "Xb"))
208 ada_name[strlen (ada_name) - 2] = '\0';
209 body_nested = 1;
212 if (has_suffix (ada_name, "Xn"))
214 ada_name[strlen (ada_name) - 2] = '\0';
215 body_nested = 1;
218 /* Change instance of TK__ (object declared inside a task) to __. */
220 char *tktoken;
222 while ((tktoken = (char *) strstr (ada_name, "TK__")) != NULL)
224 ostrcpy (tktoken, tktoken + 2);
225 in_task = 1;
229 /* Check for overloading: name terminated by $nn or __nn. */
231 int len = strlen (ada_name);
232 int n_digits = 0;
234 if (len > 1)
235 while (ISDIGIT ((int) ada_name[(int) len - 1 - n_digits]))
236 n_digits++;
238 /* Check if we have $ or __ before digits. */
239 if (ada_name[len - 1 - n_digits] == '$')
241 ada_name[len - 1 - n_digits] = '\0';
242 overloaded = 1;
244 else if (ada_name[len - 1 - n_digits] == '_'
245 && ada_name[len - 1 - n_digits - 1] == '_')
247 ada_name[len - 1 - n_digits - 1] = '\0';
248 overloaded = 1;
252 /* Check for nested subprogram ending in .nnnn and strip suffix. */
254 int last = strlen (ada_name) - 1;
256 while (ISDIGIT (ada_name[last]) && last > 0)
258 last--;
261 if (ada_name[last] == '.')
263 ada_name[last] = (char) 0;
267 /* Change all "__" to ".". */
269 int len = strlen (ada_name);
270 int k = 0;
272 while (k < len)
274 if (ada_name[k] == '_' && ada_name[k+1] == '_')
276 ada_name[k] = '.';
277 ostrcpy (ada_name + k + 1, ada_name + k + 2);
278 len = len - 1;
280 k++;
284 /* Checks for operator name. */
286 const char *trans_table[][2]
287 = {{"Oabs", "\"abs\""}, {"Oand", "\"and\""}, {"Omod", "\"mod\""},
288 {"Onot", "\"not\""}, {"Oor", "\"or\""}, {"Orem", "\"rem\""},
289 {"Oxor", "\"xor\""}, {"Oeq", "\"=\""}, {"One", "\"/=\""},
290 {"Olt", "\"<\""}, {"Ole", "\"<=\""}, {"Ogt", "\">\""},
291 {"Oge", "\">=\""}, {"Oadd", "\"+\""}, {"Osubtract", "\"-\""},
292 {"Oconcat", "\"&\""}, {"Omultiply", "\"*\""}, {"Odivide", "\"/\""},
293 {"Oexpon", "\"**\""}, {NULL, NULL} };
294 int k = 0;
296 while (1)
298 char *optoken;
300 if ((optoken = (char *) strstr (ada_name, trans_table[k][0])) != NULL)
302 int codedlen = strlen (trans_table[k][0]);
303 int oplen = strlen (trans_table[k][1]);
305 if (codedlen > oplen)
306 /* We shrink the space. */
307 ostrcpy (optoken, optoken + codedlen - oplen);
308 else if (oplen > codedlen)
310 /* We need more space. */
311 int len = strlen (ada_name);
312 int space = oplen - codedlen;
313 int num_to_move = &ada_name[len] - optoken;
314 int t;
316 for (t = 0; t < num_to_move; t++)
317 ada_name[len + space - t - 1] = ada_name[len - t - 1];
320 /* Write symbol in the space. */
321 strncpy (optoken, trans_table[k][1], oplen);
323 else
324 k++;
326 /* Check for table's ending. */
327 if (trans_table[k][0] == NULL)
328 break;
332 /* If verbose mode is on, we add some information to the Ada name. */
333 if (verbose)
335 if (overloaded)
336 add_verbose ("overloaded", ada_name);
338 if (lib_subprog)
339 add_verbose ("library level", ada_name);
341 if (body_nested)
342 add_verbose ("body nested", ada_name);
344 if (in_task)
345 add_verbose ("in task", ada_name);
347 if (task_body)
348 add_verbose ("task body", ada_name);
350 if (verbose_info == 1)
351 strcat (ada_name, ")");
355 #ifdef IN_GCC
356 char *
357 ada_demangle (const char *coded_name)
359 char ada_name[2048];
361 __gnat_decode (coded_name, ada_name, 0);
362 return xstrdup (ada_name);
364 #endif
366 void
367 get_encoding (const char *coded_name, char *encoding)
369 char * dest_index = encoding;
370 const char *p;
371 int found = 0;
372 int count = 0;
374 /* The heuristics is the following: we assume that the first triple
375 underscore in an encoded name indicates the beginning of the
376 first encoding, and that subsequent triple underscores indicate
377 the next encodings. We assume that the encodings are always at the
378 end of encoded names. */
380 for (p = coded_name; *p != '\0'; p++)
382 if (*p != '_')
383 count = 0;
384 else
385 if (++count == 3)
387 count = 0;
389 if (found)
391 dest_index = dest_index - 2;
392 *dest_index++ = ':';
395 p++;
396 found = 1;
399 if (found)
400 *dest_index++ = *p;
403 *dest_index = '\0';