OSDN Git Service

2002-02-01 H.J. Lu <hjl@gnu.org>
[pf3gnuchains/gcc-fork.git] / libiberty / cp-demangle.c
1 /* Demangler for IA64 / g++ V3 ABI.
2    Copyright (C) 2000, 2001 Free Software Foundation, Inc.
3    Written by Alex Samuel <samuel@codesourcery.com>. 
4
5    This file is part of GNU CC.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
20 */
21
22 /* This file implements demangling of C++ names mangled according to
23    the IA64 / g++ V3 ABI.  Use the cp_demangle function to
24    demangle a mangled name, or compile with the preprocessor macro
25    STANDALONE_DEMANGLER defined to create a demangling filter
26    executable (functionally similar to c++filt, but includes this
27    demangler only).  */
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include <sys/types.h>
34
35 #ifdef HAVE_STDLIB_H
36 #include <stdlib.h>
37 #endif
38
39 #include <stdio.h>
40
41 #ifdef HAVE_STRING_H
42 #include <string.h>
43 #endif
44
45 #include "ansidecl.h"
46 #include "libiberty.h"
47 #include "dyn-string.h"
48 #include "demangle.h"
49
50 /* If CP_DEMANGLE_DEBUG is defined, a trace of the grammar evaluation,
51    and other debugging output, will be generated. */
52 #ifdef CP_DEMANGLE_DEBUG
53 #define DEMANGLE_TRACE(PRODUCTION, DM)                                  \
54   fprintf (stderr, " -> %-24s at position %3d\n",                       \
55            (PRODUCTION), current_position (DM));
56 #else
57 #define DEMANGLE_TRACE(PRODUCTION, DM)
58 #endif
59
60 /* Don't include <ctype.h>, to prevent additional unresolved symbols
61    from being dragged into the C++ runtime library.  */
62 #define IS_DIGIT(CHAR) ((CHAR) >= '0' && (CHAR) <= '9')
63 #define IS_ALPHA(CHAR)                                                  \
64   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
65    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
66
67 /* The prefix prepended by GCC to an identifier represnting the
68    anonymous namespace.  */
69 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
70
71 /* Character(s) to use for namespace separation in demangled output */
72 #define NAMESPACE_SEPARATOR (dm->style == DMGL_JAVA ? "." : "::")
73
74 /* If flag_verbose is zero, some simplifications will be made to the
75    output to make it easier to read and supress details that are
76    generally not of interest to the average C++ programmer.
77    Otherwise, the demangled representation will attempt to convey as
78    much information as the mangled form.  */
79 static int flag_verbose;
80
81 /* If flag_strict is non-zero, demangle strictly according to the
82    specification -- don't demangle special g++ manglings.  */
83 static int flag_strict;
84
85 /* String_list_t is an extended form of dyn_string_t which provides a
86    link field and a caret position for additions to the string.  A
87    string_list_t may safely be cast to and used as a dyn_string_t.  */
88
89 struct string_list_def
90 {
91   /* The dyn_string; must be first.  */
92   struct dyn_string string;
93
94   /* The position at which additional text is added to this string
95      (using the result_add* macros).  This value is an offset from the
96      end of the string, not the beginning (and should be
97      non-positive).  */
98   int caret_position;
99
100   /* The next string in the list.  */
101   struct string_list_def *next;
102 };
103
104 typedef struct string_list_def *string_list_t;
105
106 /* Data structure representing a potential substitution.  */
107
108 struct substitution_def
109 {
110   /* The demangled text of the substitution.  */
111   dyn_string_t text;
112
113   /* Whether this substitution represents a template item.  */
114   int template_p : 1;
115 };
116
117 /* Data structure representing a template argument list.  */
118
119 struct template_arg_list_def
120 {
121   /* The next (lower) template argument list in the stack of currently
122      active template arguments.  */
123   struct template_arg_list_def *next;
124
125   /* The first element in the list of template arguments in
126      left-to-right order.  */
127   string_list_t first_argument;
128
129   /* The last element in the arguments lists.  */
130   string_list_t last_argument;
131 };
132
133 typedef struct template_arg_list_def *template_arg_list_t;
134
135 /* Data structure to maintain the state of the current demangling.  */
136
137 struct demangling_def
138 {
139   /* The full mangled name being mangled.  */
140   const char *name;
141
142   /* Pointer into name at the current position.  */
143   const char *next;
144
145   /* Stack for strings containing demangled result generated so far.
146      Text is emitted to the topmost (first) string.  */
147   string_list_t result;
148
149   /* The number of presently available substitutions.  */
150   int num_substitutions;
151
152   /* The allocated size of the substitutions array.  */
153   int substitutions_allocated;
154
155   /* An array of available substitutions.  The number of elements in
156      the array is given by num_substitions, and the allocated array
157      size in substitutions_size.  
158
159      The most recent substition is at the end, so
160
161        - `S_'  corresponds to substititutions[num_substitutions - 1] 
162        - `S0_' corresponds to substititutions[num_substitutions - 2]
163
164      etc. */
165   struct substitution_def *substitutions;
166
167   /* The stack of template argument lists.  */
168   template_arg_list_t template_arg_lists;
169
170   /* The most recently demangled source-name.  */
171   dyn_string_t last_source_name;
172   
173   /* Language style to use for demangled output. */
174   int style;
175
176   /* Set to non-zero iff this name is a constructor.  The actual value
177      indicates what sort of constructor this is; see demangle.h.  */
178   enum gnu_v3_ctor_kinds is_constructor;
179
180   /* Set to non-zero iff this name is a destructor.  The actual value
181      indicates what sort of destructor this is; see demangle.h.  */
182   enum gnu_v3_dtor_kinds is_destructor;
183
184 };
185
186 typedef struct demangling_def *demangling_t;
187
188 /* This type is the standard return code from most functions.  Values
189    other than STATUS_OK contain descriptive messages.  */
190 typedef const char *status_t;
191
192 /* Special values that can be used as a status_t.  */
193 #define STATUS_OK                       NULL
194 #define STATUS_ERROR                    "Error."
195 #define STATUS_UNIMPLEMENTED            "Unimplemented."
196 #define STATUS_INTERNAL_ERROR           "Internal error."
197
198 /* This status code indicates a failure in malloc or realloc.  */
199 static const char *const status_allocation_failed = "Allocation failed.";
200 #define STATUS_ALLOCATION_FAILED        status_allocation_failed
201
202 /* Non-zero if STATUS indicates that no error has occurred.  */
203 #define STATUS_NO_ERROR(STATUS)         ((STATUS) == STATUS_OK)
204
205 /* Evaluate EXPR, which must produce a status_t.  If the status code
206    indicates an error, return from the current function with that
207    status code.  */
208 #define RETURN_IF_ERROR(EXPR)                                           \
209   do                                                                    \
210     {                                                                   \
211       status_t s = EXPR;                                                \
212       if (!STATUS_NO_ERROR (s))                                         \
213         return s;                                                       \
214     }                                                                   \
215   while (0)
216
217 static status_t int_to_dyn_string 
218   PARAMS ((int, dyn_string_t));
219 static string_list_t string_list_new
220   PARAMS ((int));
221 static void string_list_delete
222   PARAMS ((string_list_t));
223 static status_t result_add_separated_char
224   PARAMS ((demangling_t, int));
225 static status_t result_push
226   PARAMS ((demangling_t));
227 static string_list_t result_pop
228   PARAMS ((demangling_t));
229 static int substitution_start
230   PARAMS ((demangling_t));
231 static status_t substitution_add
232   PARAMS ((demangling_t, int, int));
233 static dyn_string_t substitution_get
234   PARAMS ((demangling_t, int, int *));
235 #ifdef CP_DEMANGLE_DEBUG
236 static void substitutions_print 
237   PARAMS ((demangling_t, FILE *));
238 #endif
239 static template_arg_list_t template_arg_list_new
240   PARAMS ((void));
241 static void template_arg_list_delete
242   PARAMS ((template_arg_list_t));
243 static void template_arg_list_add_arg 
244   PARAMS ((template_arg_list_t, string_list_t));
245 static string_list_t template_arg_list_get_arg
246   PARAMS ((template_arg_list_t, int));
247 static void push_template_arg_list
248   PARAMS ((demangling_t, template_arg_list_t));
249 static void pop_to_template_arg_list
250   PARAMS ((demangling_t, template_arg_list_t));
251 #ifdef CP_DEMANGLE_DEBUG
252 static void template_arg_list_print
253   PARAMS ((template_arg_list_t, FILE *));
254 #endif
255 static template_arg_list_t current_template_arg_list
256   PARAMS ((demangling_t));
257 static demangling_t demangling_new
258   PARAMS ((const char *, int));
259 static void demangling_delete 
260   PARAMS ((demangling_t));
261
262 /* The last character of DS.  Warning: DS is evaluated twice.  */
263 #define dyn_string_last_char(DS)                                        \
264   (dyn_string_buf (DS)[dyn_string_length (DS) - 1])
265
266 /* Append a space character (` ') to DS if it does not already end
267    with one.  Evaluates to 1 on success, or 0 on allocation failure.  */
268 #define dyn_string_append_space(DS)                                     \
269       ((dyn_string_length (DS) > 0                                      \
270         && dyn_string_last_char (DS) != ' ')                            \
271        ? dyn_string_append_char ((DS), ' ')                             \
272        : 1)
273
274 /* Returns the index of the current position in the mangled name.  */
275 #define current_position(DM)    ((DM)->next - (DM)->name)
276
277 /* Returns the character at the current position of the mangled name.  */
278 #define peek_char(DM)           (*((DM)->next))
279
280 /* Returns the character one past the current position of the mangled
281    name.  */
282 #define peek_char_next(DM)                                              \
283   (peek_char (DM) == '\0' ? '\0' : (*((DM)->next + 1)))
284
285 /* Returns the character at the current position, and advances the
286    current position to the next character.  */
287 #define next_char(DM)           (*((DM)->next)++)
288
289 /* Returns non-zero if the current position is the end of the mangled
290    name, i.e. one past the last character.  */
291 #define end_of_name_p(DM)       (peek_char (DM) == '\0')
292
293 /* Advances the current position by one character.  */
294 #define advance_char(DM)        (++(DM)->next)
295
296 /* Returns the string containing the current demangled result.  */
297 #define result_string(DM)       (&(DM)->result->string)
298
299 /* Returns the position at which new text is inserted into the
300    demangled result.  */
301 #define result_caret_pos(DM)                                            \
302   (result_length (DM) +                                                 \
303    ((string_list_t) result_string (DM))->caret_position)
304
305 /* Adds a dyn_string_t to the demangled result.  */
306 #define result_add_string(DM, STRING)                                   \
307   (dyn_string_insert (&(DM)->result->string,                            \
308                       result_caret_pos (DM), (STRING))                  \
309    ? STATUS_OK : STATUS_ALLOCATION_FAILED)
310
311 /* Adds NUL-terminated string CSTR to the demangled result.    */
312 #define result_add(DM, CSTR)                                            \
313   (dyn_string_insert_cstr (&(DM)->result->string,                       \
314                            result_caret_pos (DM), (CSTR))               \
315    ? STATUS_OK : STATUS_ALLOCATION_FAILED)
316
317 /* Adds character CHAR to the demangled result.  */
318 #define result_add_char(DM, CHAR)                                       \
319   (dyn_string_insert_char (&(DM)->result->string,                       \
320                            result_caret_pos (DM), (CHAR))               \
321    ? STATUS_OK : STATUS_ALLOCATION_FAILED)
322
323 /* Inserts a dyn_string_t to the demangled result at position POS.  */
324 #define result_insert_string(DM, POS, STRING)                           \
325   (dyn_string_insert (&(DM)->result->string, (POS), (STRING))           \
326    ? STATUS_OK : STATUS_ALLOCATION_FAILED)
327
328 /* Inserts NUL-terminated string CSTR to the demangled result at
329    position POS.  */
330 #define result_insert(DM, POS, CSTR)                                    \
331   (dyn_string_insert_cstr (&(DM)->result->string, (POS), (CSTR))        \
332    ? STATUS_OK : STATUS_ALLOCATION_FAILED)
333
334 /* Inserts character CHAR to the demangled result at position POS.  */
335 #define result_insert_char(DM, POS, CHAR)                               \
336   (dyn_string_insert_char (&(DM)->result->string, (POS), (CHAR))        \
337    ? STATUS_OK : STATUS_ALLOCATION_FAILED)
338
339 /* The length of the current demangled result.  */
340 #define result_length(DM)                                               \
341   dyn_string_length (&(DM)->result->string)
342
343 /* Appends a (less-than, greater-than) character to the result in DM
344    to (open, close) a template argument or parameter list.  Appends a
345    space first if necessary to prevent spurious elision of angle
346    brackets with the previous character.  */
347 #define result_open_template_list(DM) result_add_separated_char(DM, '<')
348 #define result_close_template_list(DM) result_add_separated_char(DM, '>')
349
350 /* Appends a base 10 representation of VALUE to DS.  STATUS_OK on
351    success.  On failure, deletes DS and returns an error code.  */
352
353 static status_t
354 int_to_dyn_string (value, ds)
355      int value;
356      dyn_string_t ds;
357 {
358   int i;
359   int mask = 1;
360
361   /* Handle zero up front.  */
362   if (value == 0)
363     {
364       if (!dyn_string_append_char (ds, '0'))
365         return STATUS_ALLOCATION_FAILED;
366       return STATUS_OK;
367     }
368
369   /* For negative numbers, emit a minus sign.  */
370   if (value < 0)
371     {
372       if (!dyn_string_append_char (ds, '-'))
373         return STATUS_ALLOCATION_FAILED;
374       value = -value;
375     }
376   
377   /* Find the power of 10 of the first digit.  */
378   i = value;
379   while (i > 9)
380     {
381       mask *= 10;
382       i /= 10;
383     }
384
385   /* Write the digits.  */
386   while (mask > 0)
387     {
388       int digit = value / mask;
389
390       if (!dyn_string_append_char (ds, '0' + digit))
391         return STATUS_ALLOCATION_FAILED;
392
393       value -= digit * mask;
394       mask /= 10;
395     }
396
397   return STATUS_OK;
398 }
399
400 /* Creates a new string list node.  The contents of the string are
401    empty, but the initial buffer allocation is LENGTH.  The string
402    list node should be deleted with string_list_delete.  Returns NULL
403    if allocation fails.  */
404
405 static string_list_t 
406 string_list_new (length)
407      int length;
408 {
409   string_list_t s = (string_list_t) malloc (sizeof (struct string_list_def));
410   s->caret_position = 0;
411   if (s == NULL)
412     return NULL;
413   if (!dyn_string_init ((dyn_string_t) s, length))
414     return NULL;
415   return s;
416 }  
417
418 /* Deletes the entire string list starting at NODE.  */
419
420 static void
421 string_list_delete (node)
422      string_list_t node;
423 {
424   while (node != NULL)
425     {
426       string_list_t next = node->next;
427       dyn_string_delete ((dyn_string_t) node);
428       node = next;
429     }
430 }
431
432 /* Appends CHARACTER to the demangled result.  If the current trailing
433    character of the result is CHARACTER, a space is inserted first.  */
434
435 static status_t
436 result_add_separated_char (dm, character)
437      demangling_t dm;
438      int character;
439 {
440   char *result = dyn_string_buf (result_string (dm));
441   int caret_pos = result_caret_pos (dm);
442
443   /* Add a space if the last character is already the character we
444      want to add.  */
445   if (caret_pos > 0 && result[caret_pos - 1] == character)
446     RETURN_IF_ERROR (result_add_char (dm, ' '));
447   /* Add the character.  */
448   RETURN_IF_ERROR (result_add_char (dm, character));
449
450   return STATUS_OK;
451 }
452
453 /* Allocates and pushes a new string onto the demangled results stack
454    for DM.  Subsequent demangling with DM will emit to the new string.
455    Returns STATUS_OK on success, STATUS_ALLOCATION_FAILED on
456    allocation failure.  */
457
458 static status_t
459 result_push (dm)
460      demangling_t dm;
461 {
462   string_list_t new_string = string_list_new (0);
463   if (new_string == NULL)
464     /* Allocation failed.  */
465     return STATUS_ALLOCATION_FAILED;
466
467   /* Link the new string to the front of the list of result strings.  */
468   new_string->next = (string_list_t) dm->result;
469   dm->result = new_string;
470   return STATUS_OK;
471 }
472
473 /* Removes and returns the topmost element on the demangled results
474    stack for DM.  The caller assumes ownership for the returned
475    string.  */
476
477 static string_list_t
478 result_pop (dm)
479      demangling_t dm;
480 {
481   string_list_t top = dm->result;
482   dm->result = top->next;
483   return top;
484 }
485
486 /* Returns the current value of the caret for the result string.  The
487    value is an offet from the end of the result string.  */
488
489 static int
490 result_get_caret (dm)
491      demangling_t dm;
492 {
493   return ((string_list_t) result_string (dm))->caret_position;
494 }
495
496 /* Sets the value of the caret for the result string, counted as an
497    offet from the end of the result string.  */
498
499 static void
500 result_set_caret (dm, position)
501      demangling_t dm;
502      int position;
503 {
504   ((string_list_t) result_string (dm))->caret_position = position;
505 }
506
507 /* Shifts the position of the next addition to the result by
508    POSITION_OFFSET.  A negative value shifts the caret to the left.  */
509
510 static void
511 result_shift_caret (dm, position_offset)
512      demangling_t dm;
513      int position_offset;
514 {
515   ((string_list_t) result_string (dm))->caret_position += position_offset;
516 }
517
518 /* Returns non-zero if the character that comes right before the place
519    where text will be added to the result is a space.  In this case,
520    the caller should supress adding another space.  */
521
522 static int
523 result_previous_char_is_space (dm)
524      demangling_t dm;
525 {
526   char *result = dyn_string_buf (result_string (dm));
527   int pos = result_caret_pos (dm);
528   return pos > 0 && result[pos - 1] == ' ';
529 }
530
531 /* Returns the start position of a fragment of the demangled result
532    that will be a substitution candidate.  Should be called at the
533    start of productions that can add substitutions.  */
534
535 static int
536 substitution_start (dm)
537      demangling_t dm;
538 {
539   return result_caret_pos (dm);
540 }
541
542 /* Adds the suffix of the current demangled result of DM starting at
543    START_POSITION as a potential substitution.  If TEMPLATE_P is
544    non-zero, this potential substitution is a template-id.  */
545
546 static status_t
547 substitution_add (dm, start_position, template_p)
548      demangling_t dm;
549      int start_position;
550      int template_p;
551 {
552   dyn_string_t result = result_string (dm);
553   dyn_string_t substitution = dyn_string_new (0);
554   int i;
555
556   if (substitution == NULL)
557     return STATUS_ALLOCATION_FAILED;
558
559   /* Extract the substring of the current demangling result that
560      represents the subsitution candidate.  */
561   if (!dyn_string_substring (substitution, 
562                              result, start_position, result_caret_pos (dm)))
563     {
564       dyn_string_delete (substitution);
565       return STATUS_ALLOCATION_FAILED;
566     }
567
568   /* If there's no room for the new entry, grow the array.  */
569   if (dm->substitutions_allocated == dm->num_substitutions)
570     {
571       size_t new_array_size;
572       if (dm->substitutions_allocated > 0)
573         dm->substitutions_allocated *= 2;
574       else
575         dm->substitutions_allocated = 2;
576       new_array_size = 
577         sizeof (struct substitution_def) * dm->substitutions_allocated;
578
579       dm->substitutions = (struct substitution_def *)
580         realloc (dm->substitutions, new_array_size);
581       if (dm->substitutions == NULL)
582         /* Realloc failed.  */
583         {
584           dyn_string_delete (substitution);
585           return STATUS_ALLOCATION_FAILED;
586         }
587     }
588
589   /* Add the substitution to the array.  */
590   i = dm->num_substitutions++;
591   dm->substitutions[i].text = substitution;
592   dm->substitutions[i].template_p = template_p;
593
594 #ifdef CP_DEMANGLE_DEBUG
595   substitutions_print (dm, stderr);
596 #endif
597
598   return STATUS_OK;
599 }
600
601 /* Returns the Nth-most-recent substitution.  Sets *TEMPLATE_P to
602    non-zero if the substitution is a template-id, zero otherwise.  
603    N is numbered from zero.  DM retains ownership of the returned
604    string.  If N is negative, or equal to or greater than the current
605    number of substitution candidates, returns NULL.  */
606
607 static dyn_string_t
608 substitution_get (dm, n, template_p)
609      demangling_t dm;
610      int n;
611      int *template_p;
612 {
613   struct substitution_def *sub;
614
615   /* Make sure N is in the valid range.  */
616   if (n < 0 || n >= dm->num_substitutions)
617     return NULL;
618
619   sub = &(dm->substitutions[n]);
620   *template_p = sub->template_p;
621   return sub->text;
622 }
623
624 #ifdef CP_DEMANGLE_DEBUG
625 /* Debugging routine to print the current substitutions to FP.  */
626
627 static void
628 substitutions_print (dm, fp)
629      demangling_t dm;
630      FILE *fp;
631 {
632   int seq_id;
633   int num = dm->num_substitutions;
634
635   fprintf (fp, "SUBSTITUTIONS:\n");
636   for (seq_id = -1; seq_id < num - 1; ++seq_id)
637     {
638       int template_p;
639       dyn_string_t text = substitution_get (dm, seq_id + 1, &template_p);
640
641       if (seq_id == -1)
642         fprintf (fp, " S_ ");
643       else
644         fprintf (fp, " S%d_", seq_id);
645       fprintf (fp, " %c: %s\n", template_p ? '*' : ' ', dyn_string_buf (text));
646     }
647 }
648
649 #endif /* CP_DEMANGLE_DEBUG */
650
651 /* Creates a new template argument list.  Returns NULL if allocation
652    fails.  */
653
654 static template_arg_list_t
655 template_arg_list_new ()
656 {
657   template_arg_list_t new_list =
658     (template_arg_list_t) malloc (sizeof (struct template_arg_list_def));
659   if (new_list == NULL)
660     return NULL;
661   /* Initialize the new list to have no arguments.  */
662   new_list->first_argument = NULL;
663   new_list->last_argument = NULL;
664   /* Return the new list.  */
665   return new_list;
666 }
667
668 /* Deletes a template argument list and the template arguments it
669    contains.  */
670
671 static void
672 template_arg_list_delete (list)
673      template_arg_list_t list;
674 {
675   /* If there are any arguments on LIST, delete them.  */
676   if (list->first_argument != NULL)
677     string_list_delete (list->first_argument);
678   /* Delete LIST.  */
679   free (list);
680 }
681
682 /* Adds ARG to the template argument list ARG_LIST.  */
683
684 static void 
685 template_arg_list_add_arg (arg_list, arg)
686      template_arg_list_t arg_list;
687      string_list_t arg;
688 {
689   if (arg_list->first_argument == NULL)
690     /* If there were no arguments before, ARG is the first one.  */
691     arg_list->first_argument = arg;
692   else
693     /* Make ARG the last argument on the list.  */
694     arg_list->last_argument->next = arg;
695   /* Make ARG the last on the list.  */
696   arg_list->last_argument = arg;
697   arg->next = NULL;
698 }
699
700 /* Returns the template arugment at position INDEX in template
701    argument list ARG_LIST.  */
702
703 static string_list_t
704 template_arg_list_get_arg (arg_list, index)
705      template_arg_list_t arg_list;
706      int index;
707 {
708   string_list_t arg = arg_list->first_argument;
709   /* Scan down the list of arguments to find the one at position
710      INDEX.  */
711   while (index--)
712     {
713       arg = arg->next;
714       if (arg == NULL)
715         /* Ran out of arguments before INDEX hit zero.  That's an
716            error.  */
717         return NULL;
718     }
719   /* Return the argument at position INDEX.  */
720   return arg;
721 }
722
723 /* Pushes ARG_LIST onto the top of the template argument list stack.  */
724
725 static void
726 push_template_arg_list (dm, arg_list)
727      demangling_t dm;
728      template_arg_list_t arg_list;
729 {
730   arg_list->next = dm->template_arg_lists;
731   dm->template_arg_lists = arg_list;
732 #ifdef CP_DEMANGLE_DEBUG
733   fprintf (stderr, " ** pushing template arg list\n");
734   template_arg_list_print (arg_list, stderr);
735 #endif 
736 }
737
738 /* Pops and deletes elements on the template argument list stack until
739    arg_list is the topmost element.  If arg_list is NULL, all elements
740    are popped and deleted.  */
741
742 static void
743 pop_to_template_arg_list (dm, arg_list)
744      demangling_t dm;
745      template_arg_list_t arg_list;
746 {
747   while (dm->template_arg_lists != arg_list)
748     {
749       template_arg_list_t top = dm->template_arg_lists;
750       /* Disconnect the topmost element from the list.  */
751       dm->template_arg_lists = top->next;
752       /* Delete the popped element.  */
753       template_arg_list_delete (top);
754 #ifdef CP_DEMANGLE_DEBUG
755       fprintf (stderr, " ** removing template arg list\n");
756 #endif
757     }
758 }
759
760 #ifdef CP_DEMANGLE_DEBUG
761
762 /* Prints the contents of ARG_LIST to FP.  */
763
764 static void
765 template_arg_list_print (arg_list, fp)
766   template_arg_list_t arg_list;
767   FILE *fp;
768 {
769   string_list_t arg;
770   int index = -1;
771
772   fprintf (fp, "TEMPLATE ARGUMENT LIST:\n");
773   for (arg = arg_list->first_argument; arg != NULL; arg = arg->next)
774     {
775       if (index == -1)
776         fprintf (fp, " T_  : ");
777       else
778         fprintf (fp, " T%d_ : ", index);
779       ++index;
780       fprintf (fp, "%s\n", dyn_string_buf ((dyn_string_t) arg));
781     }
782 }
783
784 #endif /* CP_DEMANGLE_DEBUG */
785
786 /* Returns the topmost element on the stack of template argument
787    lists.  If there is no list of template arguments, returns NULL.  */
788
789 static template_arg_list_t
790 current_template_arg_list (dm)
791      demangling_t dm;
792 {
793   return dm->template_arg_lists;
794 }
795
796 /* Allocates a demangling_t object for demangling mangled NAME.  A new
797    result must be pushed before the returned object can be used.
798    Returns NULL if allocation fails.  */
799
800 static demangling_t
801 demangling_new (name, style)
802      const char *name;
803      int style;
804 {
805   demangling_t dm;
806   dm = (demangling_t) malloc (sizeof (struct demangling_def));
807   if (dm == NULL)
808     return NULL;
809
810   dm->name = name;
811   dm->next = name;
812   dm->result = NULL;
813   dm->num_substitutions = 0;
814   dm->substitutions_allocated = 10;
815   dm->template_arg_lists = NULL;
816   dm->last_source_name = dyn_string_new (0);
817   if (dm->last_source_name == NULL)
818     return NULL;
819   dm->substitutions = (struct substitution_def *)
820     malloc (dm->substitutions_allocated * sizeof (struct substitution_def));
821   if (dm->substitutions == NULL)
822     {
823       dyn_string_delete (dm->last_source_name);
824       return NULL;
825     }
826   dm->style = style;
827   dm->is_constructor = 0;
828   dm->is_destructor = 0;
829
830   return dm;
831 }
832
833 /* Deallocates a demangling_t object and all memory associated with
834    it.  */
835
836 static void
837 demangling_delete (dm)
838      demangling_t dm;
839 {
840   int i;
841   template_arg_list_t arg_list = dm->template_arg_lists;
842
843   /* Delete the stack of template argument lists.  */
844   while (arg_list != NULL)
845     {
846       template_arg_list_t next = arg_list->next;
847       template_arg_list_delete (arg_list);
848       arg_list = next;
849     }
850   /* Delete the list of substitutions.  */
851   for (i = dm->num_substitutions; --i >= 0; )
852     dyn_string_delete (dm->substitutions[i].text);
853   free (dm->substitutions);
854   /* Delete the demangled result.  */
855   string_list_delete (dm->result);
856   /* Delete the stored identifier name.  */
857   dyn_string_delete (dm->last_source_name);
858   /* Delete the context object itself.  */
859   free (dm);
860 }
861
862 /* These functions demangle an alternative of the corresponding
863    production in the mangling spec.  The first argument of each is a
864    demangling context structure for the current demangling
865    operation.  Most emit demangled text directly to the topmost result
866    string on the result string stack in the demangling context
867    structure.  */
868
869 static status_t demangle_char
870   PARAMS ((demangling_t, int));
871 static status_t demangle_mangled_name 
872   PARAMS ((demangling_t));
873 static status_t demangle_encoding
874   PARAMS ((demangling_t));
875 static status_t demangle_name
876   PARAMS ((demangling_t, int *));
877 static status_t demangle_nested_name
878   PARAMS ((demangling_t, int *));
879 static status_t demangle_prefix
880   PARAMS ((demangling_t, int *));
881 static status_t demangle_unqualified_name
882   PARAMS ((demangling_t, int *));
883 static status_t demangle_source_name
884   PARAMS ((demangling_t));
885 static status_t demangle_number
886   PARAMS ((demangling_t, int *, int, int));
887 static status_t demangle_number_literally
888   PARAMS ((demangling_t, dyn_string_t, int, int));
889 static status_t demangle_identifier
890   PARAMS ((demangling_t, int, dyn_string_t));
891 static status_t demangle_operator_name
892   PARAMS ((demangling_t, int, int *));
893 static status_t demangle_nv_offset
894   PARAMS ((demangling_t));
895 static status_t demangle_v_offset
896   PARAMS ((demangling_t));
897 static status_t demangle_call_offset
898   PARAMS ((demangling_t));
899 static status_t demangle_special_name
900   PARAMS ((demangling_t));
901 static status_t demangle_ctor_dtor_name
902   PARAMS ((demangling_t));
903 static status_t demangle_type_ptr
904   PARAMS ((demangling_t, int *, int));
905 static status_t demangle_type
906   PARAMS ((demangling_t));
907 static status_t demangle_CV_qualifiers
908   PARAMS ((demangling_t, dyn_string_t));
909 static status_t demangle_builtin_type
910   PARAMS ((demangling_t));
911 static status_t demangle_function_type
912   PARAMS ((demangling_t, int *));
913 static status_t demangle_bare_function_type
914   PARAMS ((demangling_t, int *));
915 static status_t demangle_class_enum_type
916   PARAMS ((demangling_t, int *));
917 static status_t demangle_array_type
918   PARAMS ((demangling_t, int *));
919 static status_t demangle_template_param
920   PARAMS ((demangling_t));
921 static status_t demangle_template_args
922   PARAMS ((demangling_t));
923 static status_t demangle_literal
924   PARAMS ((demangling_t));
925 static status_t demangle_template_arg
926   PARAMS ((demangling_t));
927 static status_t demangle_expression
928   PARAMS ((demangling_t));
929 static status_t demangle_scope_expression
930   PARAMS ((demangling_t));
931 static status_t demangle_expr_primary
932   PARAMS ((demangling_t));
933 static status_t demangle_substitution
934   PARAMS ((demangling_t, int *));
935 static status_t demangle_local_name
936   PARAMS ((demangling_t));
937 static status_t demangle_discriminator 
938   PARAMS ((demangling_t, int));
939 static status_t cp_demangle
940   PARAMS ((const char *, dyn_string_t, int));
941 #ifdef IN_LIBGCC2
942 static status_t cp_demangle_type
943   PARAMS ((const char*, dyn_string_t));
944 #endif
945
946 /* When passed to demangle_bare_function_type, indicates that the
947    function's return type is not encoded before its parameter types.  */
948 #define BFT_NO_RETURN_TYPE    NULL
949
950 /* Check that the next character is C.  If so, consume it.  If not,
951    return an error.  */
952
953 static status_t
954 demangle_char (dm, c)
955      demangling_t dm;
956      int c;
957 {
958   static char *error_message = NULL;
959
960   if (peek_char (dm) == c)
961     {
962       advance_char (dm);
963       return STATUS_OK;
964     }
965   else
966     {
967       if (error_message == NULL)
968         error_message = strdup ("Expected ?");
969       error_message[9] = c;
970       return error_message;
971     }
972 }
973
974 /* Demangles and emits a <mangled-name>.  
975
976     <mangled-name>      ::= _Z <encoding>  */
977
978 static status_t
979 demangle_mangled_name (dm)
980      demangling_t dm;
981 {
982   DEMANGLE_TRACE ("mangled-name", dm);
983   RETURN_IF_ERROR (demangle_char (dm, '_'));
984   RETURN_IF_ERROR (demangle_char (dm, 'Z'));
985   RETURN_IF_ERROR (demangle_encoding (dm));
986   return STATUS_OK;
987 }
988
989 /* Demangles and emits an <encoding>.  
990
991     <encoding>          ::= <function name> <bare-function-type>
992                         ::= <data name>
993                         ::= <special-name>  */
994
995 static status_t
996 demangle_encoding (dm)
997      demangling_t dm;
998 {
999   int encode_return_type;
1000   int start_position;
1001   template_arg_list_t old_arg_list = current_template_arg_list (dm);
1002   char peek = peek_char (dm);
1003
1004   DEMANGLE_TRACE ("encoding", dm);
1005   
1006   /* Remember where the name starts.  If it turns out to be a template
1007      function, we'll have to insert the return type here.  */
1008   start_position = result_caret_pos (dm);
1009
1010   if (peek == 'G' || peek == 'T')
1011     RETURN_IF_ERROR (demangle_special_name (dm));
1012   else
1013     {
1014       /* Now demangle the name.  */
1015       RETURN_IF_ERROR (demangle_name (dm, &encode_return_type));
1016
1017       /* If there's anything left, the name was a function name, with
1018          maybe its return type, and its parameter types, following.  */
1019       if (!end_of_name_p (dm) 
1020           && peek_char (dm) != 'E')
1021         {
1022           if (encode_return_type)
1023             /* Template functions have their return type encoded.  The
1024                return type should be inserted at start_position.  */
1025             RETURN_IF_ERROR 
1026               (demangle_bare_function_type (dm, &start_position));
1027           else
1028             /* Non-template functions don't have their return type
1029                encoded.  */
1030             RETURN_IF_ERROR 
1031               (demangle_bare_function_type (dm, BFT_NO_RETURN_TYPE)); 
1032         }
1033     }
1034
1035   /* Pop off template argument lists that were built during the
1036      mangling of this name, to restore the old template context.  */
1037   pop_to_template_arg_list (dm, old_arg_list);
1038
1039   return STATUS_OK;
1040 }
1041
1042 /* Demangles and emits a <name>.
1043
1044     <name>              ::= <unscoped-name>
1045                         ::= <unscoped-template-name> <template-args>
1046                         ::= <nested-name>
1047                         ::= <local-name>
1048
1049     <unscoped-name>     ::= <unqualified-name>
1050                         ::= St <unqualified-name>   # ::std::
1051
1052     <unscoped-template-name>    
1053                         ::= <unscoped-name>
1054                         ::= <substitution>  */
1055
1056 static status_t
1057 demangle_name (dm, encode_return_type)
1058      demangling_t dm;
1059      int *encode_return_type;
1060 {
1061   int start = substitution_start (dm);
1062   char peek = peek_char (dm);
1063   int is_std_substitution = 0;
1064
1065   /* Generally, the return type is encoded if the function is a
1066      template-id, and suppressed otherwise.  There are a few cases,
1067      though, in which the return type is not encoded even for a
1068      templated function.  In these cases, this flag is set.  */
1069   int suppress_return_type = 0;
1070
1071   DEMANGLE_TRACE ("name", dm);
1072
1073   switch (peek)
1074     {
1075     case 'N':
1076       /* This is a <nested-name>.  */
1077       RETURN_IF_ERROR (demangle_nested_name (dm, encode_return_type));
1078       break;
1079
1080     case 'Z':
1081       RETURN_IF_ERROR (demangle_local_name (dm));
1082       *encode_return_type = 0;
1083       break;
1084
1085     case 'S':
1086       /* The `St' substitution allows a name nested in std:: to appear
1087          without being enclosed in a nested name.  */
1088       if (peek_char_next (dm) == 't') 
1089         {
1090           (void) next_char (dm);
1091           (void) next_char (dm);
1092           RETURN_IF_ERROR (result_add (dm, "std::"));
1093           RETURN_IF_ERROR 
1094             (demangle_unqualified_name (dm, &suppress_return_type));
1095           is_std_substitution = 1;
1096         }
1097       else
1098         RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
1099       /* Check if a template argument list immediately follows.
1100          If so, then we just demangled an <unqualified-template-name>.  */
1101       if (peek_char (dm) == 'I') 
1102         {
1103           /* A template name of the form std::<unqualified-name> is a
1104              substitution candidate.  */
1105           if (is_std_substitution)
1106             RETURN_IF_ERROR (substitution_add (dm, start, 0));
1107           /* Demangle the <template-args> here.  */
1108           RETURN_IF_ERROR (demangle_template_args (dm));
1109           *encode_return_type = !suppress_return_type;
1110         }
1111       else
1112         *encode_return_type = 0;
1113
1114       break;
1115
1116     default:
1117       /* This is an <unscoped-name> or <unscoped-template-name>.  */
1118       RETURN_IF_ERROR (demangle_unqualified_name (dm, &suppress_return_type));
1119
1120       /* If the <unqualified-name> is followed by template args, this
1121          is an <unscoped-template-name>.  */
1122       if (peek_char (dm) == 'I')
1123         {
1124           /* Add a substitution for the unqualified template name.  */
1125           RETURN_IF_ERROR (substitution_add (dm, start, 0));
1126
1127           RETURN_IF_ERROR (demangle_template_args (dm));
1128           *encode_return_type = !suppress_return_type;
1129         }
1130       else
1131         *encode_return_type = 0;
1132
1133       break;
1134     }
1135
1136   return STATUS_OK;
1137 }
1138
1139 /* Demangles and emits a <nested-name>. 
1140
1141     <nested-name>     ::= N [<CV-qualifiers>] <prefix> <unqulified-name> E  */
1142
1143 static status_t
1144 demangle_nested_name (dm, encode_return_type)
1145      demangling_t dm;
1146      int *encode_return_type;
1147 {
1148   char peek;
1149
1150   DEMANGLE_TRACE ("nested-name", dm);
1151
1152   RETURN_IF_ERROR (demangle_char (dm, 'N'));
1153
1154   peek = peek_char (dm);
1155   if (peek == 'r' || peek == 'V' || peek == 'K')
1156     {
1157       dyn_string_t cv_qualifiers;
1158       status_t status;
1159
1160       /* Snarf up CV qualifiers.  */
1161       cv_qualifiers = dyn_string_new (24);
1162       if (cv_qualifiers == NULL)
1163         return STATUS_ALLOCATION_FAILED;
1164       demangle_CV_qualifiers (dm, cv_qualifiers);
1165
1166       /* Emit them, preceded by a space.  */
1167       status = result_add_char (dm, ' ');
1168       if (STATUS_NO_ERROR (status)) 
1169         status = result_add_string (dm, cv_qualifiers);
1170       /* The CV qualifiers that occur in a <nested-name> will be
1171          qualifiers for member functions.  These are placed at the end
1172          of the function.  Therefore, shift the caret to the left by
1173          the length of the qualifiers, so other text is inserted
1174          before them and they stay at the end.  */
1175       result_shift_caret (dm, -dyn_string_length (cv_qualifiers) - 1);
1176       /* Clean up.  */
1177       dyn_string_delete (cv_qualifiers);
1178       RETURN_IF_ERROR (status);
1179     }
1180
1181   RETURN_IF_ERROR (demangle_prefix (dm, encode_return_type));
1182   /* No need to demangle the final <unqualified-name>; demangle_prefix
1183      will handle it.  */
1184   RETURN_IF_ERROR (demangle_char (dm, 'E'));
1185
1186   return STATUS_OK;
1187 }
1188
1189 /* Demangles and emits a <prefix>.
1190
1191     <prefix>            ::= <prefix> <unqualified-name>
1192                         ::= <template-prefix> <template-args>
1193                         ::= # empty
1194                         ::= <substitution>
1195
1196     <template-prefix>   ::= <prefix>
1197                         ::= <substitution>  */
1198
1199 static status_t
1200 demangle_prefix (dm, encode_return_type)
1201      demangling_t dm;
1202      int *encode_return_type;
1203 {
1204   int start = substitution_start (dm);
1205   int nested = 0;
1206
1207   /* ENCODE_RETURN_TYPE is updated as we decend the nesting chain.
1208      After <template-args>, it is set to non-zero; after everything
1209      else it is set to zero.  */
1210
1211   /* Generally, the return type is encoded if the function is a
1212      template-id, and suppressed otherwise.  There are a few cases,
1213      though, in which the return type is not encoded even for a
1214      templated function.  In these cases, this flag is set.  */
1215   int suppress_return_type = 0;
1216
1217   DEMANGLE_TRACE ("prefix", dm);
1218
1219   while (1)
1220     {
1221       char peek;
1222
1223       if (end_of_name_p (dm))
1224         return "Unexpected end of name in <compound-name>.";
1225
1226       peek = peek_char (dm);
1227       
1228       /* We'll initialize suppress_return_type to false, and set it to true
1229          if we end up demangling a constructor name.  However, make
1230          sure we're not actually about to demangle template arguments
1231          -- if so, this is the <template-args> following a
1232          <template-prefix>, so we'll want the previous flag value
1233          around.  */
1234       if (peek != 'I')
1235         suppress_return_type = 0;
1236
1237       if (IS_DIGIT ((unsigned char) peek)
1238           || (peek >= 'a' && peek <= 'z')
1239           || peek == 'C' || peek == 'D'
1240           || peek == 'S')
1241         {
1242           /* We have another level of scope qualification.  */
1243           if (nested)
1244             RETURN_IF_ERROR (result_add (dm, NAMESPACE_SEPARATOR));
1245           else
1246             nested = 1;
1247
1248           if (peek == 'S')
1249             /* The substitution determines whether this is a
1250                template-id.  */
1251             RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
1252           else
1253             {
1254               /* It's just a name.  */
1255               RETURN_IF_ERROR 
1256                 (demangle_unqualified_name (dm, &suppress_return_type));
1257               *encode_return_type = 0;
1258             }
1259         }
1260       else if (peek == 'Z')
1261         RETURN_IF_ERROR (demangle_local_name (dm));
1262       else if (peek == 'I')
1263         {
1264           RETURN_IF_ERROR (demangle_template_args (dm));
1265
1266           /* Now we want to indicate to the caller that we've
1267              demangled template arguments, thus the prefix was a
1268              <template-prefix>.  That's so that the caller knows to
1269              demangle the function's return type, if this turns out to
1270              be a function name.  But, if it's a member template
1271              constructor or a templated conversion operator, report it
1272              as untemplated.  Those never get encoded return types.  */
1273           *encode_return_type = !suppress_return_type;
1274         }
1275       else if (peek == 'E')
1276         /* All done.  */
1277         return STATUS_OK;
1278       else
1279         return "Unexpected character in <compound-name>.";
1280
1281       if (peek != 'S'
1282           && peek_char (dm) != 'E')
1283         /* Add a new substitution for the prefix thus far.  */
1284         RETURN_IF_ERROR (substitution_add (dm, start, *encode_return_type));
1285     }
1286 }
1287
1288 /* Demangles and emits an <unqualified-name>.  If this
1289    <unqualified-name> is for a special function type that should never
1290    have its return type encoded (particularly, a constructor or
1291    conversion operator), *SUPPRESS_RETURN_TYPE is set to 1; otherwise,
1292    it is set to zero.
1293
1294     <unqualified-name>  ::= <operator-name>
1295                         ::= <special-name>  
1296                         ::= <source-name>  */
1297
1298 static status_t
1299 demangle_unqualified_name (dm, suppress_return_type)
1300      demangling_t dm;
1301      int *suppress_return_type;
1302 {
1303   char peek = peek_char (dm);
1304
1305   DEMANGLE_TRACE ("unqualified-name", dm);
1306
1307   /* By default, don't force suppression of the return type (though
1308      non-template functions still don't get a return type encoded).  */ 
1309   *suppress_return_type = 0;
1310
1311   if (IS_DIGIT ((unsigned char) peek))
1312     RETURN_IF_ERROR (demangle_source_name (dm));
1313   else if (peek >= 'a' && peek <= 'z')
1314     {
1315       int num_args;
1316
1317       /* Conversion operators never have a return type encoded.  */
1318       if (peek == 'c' && peek_char_next (dm) == 'v')
1319         *suppress_return_type = 1;
1320
1321       RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args));
1322     }
1323   else if (peek == 'C' || peek == 'D')
1324     {
1325       /* Constructors never have a return type encoded.  */
1326       if (peek == 'C')
1327         *suppress_return_type = 1;
1328
1329       RETURN_IF_ERROR (demangle_ctor_dtor_name (dm));
1330     }
1331   else
1332     return "Unexpected character in <unqualified-name>.";
1333
1334   return STATUS_OK;
1335 }
1336
1337 /* Demangles and emits <source-name>.  
1338
1339     <source-name> ::= <length number> <identifier>  */
1340
1341 static status_t
1342 demangle_source_name (dm)
1343      demangling_t dm;
1344 {
1345   int length;
1346
1347   DEMANGLE_TRACE ("source-name", dm);
1348
1349   /* Decode the length of the identifier.  */
1350   RETURN_IF_ERROR (demangle_number (dm, &length, 10, 0));
1351   if (length == 0)
1352     return "Zero length in <source-name>.";
1353
1354   /* Now the identifier itself.  It's placed into last_source_name,
1355      where it can be used to build a constructor or destructor name.  */
1356   RETURN_IF_ERROR (demangle_identifier (dm, length, 
1357                                         dm->last_source_name));
1358
1359   /* Emit it.  */
1360   RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
1361
1362   return STATUS_OK;
1363 }
1364
1365 /* Demangles a number, either a <number> or a <positive-number> at the
1366    current position, consuming all consecutive digit characters.  Sets
1367    *VALUE to the resulting numberand returns STATUS_OK.  The number is
1368    interpreted as BASE, which must be either 10 or 36.  If IS_SIGNED
1369    is non-zero, negative numbers -- prefixed with `n' -- are accepted.
1370
1371     <number> ::= [n] <positive-number>
1372
1373     <positive-number> ::= <decimal integer>  */
1374
1375 static status_t
1376 demangle_number (dm, value, base, is_signed)
1377      demangling_t dm;
1378      int *value;
1379      int base;
1380      int is_signed;
1381 {
1382   dyn_string_t number = dyn_string_new (10);
1383
1384   DEMANGLE_TRACE ("number", dm);
1385
1386   if (number == NULL)
1387     return STATUS_ALLOCATION_FAILED;
1388
1389   demangle_number_literally (dm, number, base, is_signed);
1390   *value = strtol (dyn_string_buf (number), NULL, base);
1391   dyn_string_delete (number);
1392
1393   return STATUS_OK;
1394 }
1395
1396 /* Demangles a number at the current position.  The digits (and minus
1397    sign, if present) that make up the number are appended to STR.
1398    Only base-BASE digits are accepted; BASE must be either 10 or 36.
1399    If IS_SIGNED, negative numbers -- prefixed with `n' -- are
1400    accepted.  Does not consume a trailing underscore or other
1401    terminating character.  */
1402
1403 static status_t
1404 demangle_number_literally (dm, str, base, is_signed)
1405      demangling_t dm;
1406      dyn_string_t str;
1407      int base;
1408      int is_signed;
1409 {
1410   DEMANGLE_TRACE ("number*", dm);
1411
1412   if (base != 10 && base != 36)
1413     return STATUS_INTERNAL_ERROR;
1414
1415   /* An `n' denotes a negative number.  */
1416   if (is_signed && peek_char (dm) == 'n')
1417     {
1418       /* Skip past the n.  */
1419       advance_char (dm);
1420       /* The normal way to write a negative number is with a minus
1421          sign.  */
1422       if (!dyn_string_append_char (str, '-'))
1423         return STATUS_ALLOCATION_FAILED;
1424     }
1425
1426   /* Loop until we hit a non-digit.  */
1427   while (1)
1428     {
1429       char peek = peek_char (dm);
1430       if (IS_DIGIT ((unsigned char) peek)
1431           || (base == 36 && peek >= 'A' && peek <= 'Z'))
1432         {
1433           /* Accumulate digits.  */
1434           if (!dyn_string_append_char (str, next_char (dm)))
1435             return STATUS_ALLOCATION_FAILED;
1436         }
1437       else
1438         /* Not a digit?  All done.  */
1439         break;
1440     }
1441
1442   return STATUS_OK;
1443 }
1444
1445 /* Demangles an identifier at the current position of LENGTH
1446    characters and places it in IDENTIFIER.  */
1447
1448 static status_t
1449 demangle_identifier (dm, length, identifier)
1450      demangling_t dm;
1451      int length;
1452      dyn_string_t identifier;
1453 {
1454   DEMANGLE_TRACE ("identifier", dm);
1455
1456   dyn_string_clear (identifier);
1457   if (!dyn_string_resize (identifier, length))
1458     return STATUS_ALLOCATION_FAILED;
1459
1460   while (length-- > 0)
1461     {
1462       if (end_of_name_p (dm))
1463         return "Unexpected end of name in <identifier>.";
1464       if (!dyn_string_append_char (identifier, next_char (dm)))
1465         return STATUS_ALLOCATION_FAILED;
1466     }
1467
1468   /* GCC encodes anonymous namespaces using a `_GLOBAL_[_.$]N.'
1469      followed by the source file name and some random characters.
1470      Unless we're in strict mode, decipher these names appropriately.  */
1471   if (!flag_strict)
1472     {
1473       char *name = dyn_string_buf (identifier);
1474       int prefix_length = strlen (ANONYMOUS_NAMESPACE_PREFIX);
1475
1476       /* Compare the first, fixed part.  */
1477       if (strncmp (name, ANONYMOUS_NAMESPACE_PREFIX, prefix_length) == 0)
1478         {
1479           name += prefix_length;
1480           /* The next character might be a period, an underscore, or
1481              dollar sign, depending on the target architecture's
1482              assembler's capabilities.  After that comes an `N'.  */
1483           if ((*name == '.' || *name == '_' || *name == '$')
1484               && *(name + 1) == 'N')
1485             /* This looks like the anonymous namespace identifier.
1486                Replace it with something comprehensible.  */
1487             dyn_string_copy_cstr (identifier, "(anonymous namespace)");
1488         }
1489     }
1490
1491   return STATUS_OK;
1492 }
1493
1494 /* Demangles and emits an <operator-name>.  If SHORT_NAME is non-zero,
1495    the short form is emitted; otherwise the full source form
1496    (`operator +' etc.) is emitted.  *NUM_ARGS is set to the number of
1497    operands that the operator takes.  
1498
1499     <operator-name>
1500                   ::= nw        # new           
1501                   ::= na        # new[]
1502                   ::= dl        # delete        
1503                   ::= da        # delete[]      
1504                   ::= ps        # + (unary)
1505                   ::= ng        # - (unary)     
1506                   ::= ad        # & (unary)     
1507                   ::= de        # * (unary)     
1508                   ::= co        # ~             
1509                   ::= pl        # +             
1510                   ::= mi        # -             
1511                   ::= ml        # *             
1512                   ::= dv        # /             
1513                   ::= rm        # %             
1514                   ::= an        # &             
1515                   ::= or        # |             
1516                   ::= eo        # ^             
1517                   ::= aS        # =             
1518                   ::= pL        # +=            
1519                   ::= mI        # -=            
1520                   ::= mL        # *=            
1521                   ::= dV        # /=            
1522                   ::= rM        # %=            
1523                   ::= aN        # &=            
1524                   ::= oR        # |=            
1525                   ::= eO        # ^=            
1526                   ::= ls        # <<            
1527                   ::= rs        # >>            
1528                   ::= lS        # <<=           
1529                   ::= rS        # >>=           
1530                   ::= eq        # ==            
1531                   ::= ne        # !=            
1532                   ::= lt        # <             
1533                   ::= gt        # >             
1534                   ::= le        # <=            
1535                   ::= ge        # >=            
1536                   ::= nt        # !             
1537                   ::= aa        # &&            
1538                   ::= oo        # ||            
1539                   ::= pp        # ++            
1540                   ::= mm        # --            
1541                   ::= cm        # ,             
1542                   ::= pm        # ->*           
1543                   ::= pt        # ->            
1544                   ::= cl        # ()            
1545                   ::= ix        # []            
1546                   ::= qu        # ?
1547                   ::= sz        # sizeof 
1548                   ::= cv <type> # cast        
1549                   ::= v [0-9] <source-name>  # vendor extended operator  */
1550
1551 static status_t
1552 demangle_operator_name (dm, short_name, num_args)
1553      demangling_t dm;
1554      int short_name;
1555      int *num_args;
1556 {
1557   struct operator_code
1558   {
1559     /* The mangled code for this operator.  */
1560     const char *const code;
1561     /* The source name of this operator.  */
1562     const char *const name;
1563     /* The number of arguments this operator takes.  */
1564     const int num_args;
1565   };
1566
1567   static const struct operator_code operators[] = 
1568   {
1569     { "aN", "&="       , 2 },
1570     { "aS", "="        , 2 },
1571     { "aa", "&&"       , 2 },
1572     { "ad", "&"        , 1 },
1573     { "an", "&"        , 2 },
1574     { "cl", "()"       , 0 },
1575     { "cm", ","        , 2 },
1576     { "co", "~"        , 1 },
1577     { "dV", "/="       , 2 },
1578     { "da", " delete[]", 1 },
1579     { "de", "*"        , 1 },
1580     { "dl", " delete"  , 1 },
1581     { "dv", "/"        , 2 },
1582     { "eO", "^="       , 2 },
1583     { "eo", "^"        , 2 },
1584     { "eq", "=="       , 2 },
1585     { "ge", ">="       , 2 },
1586     { "gt", ">"        , 2 },
1587     { "ix", "[]"       , 2 },
1588     { "lS", "<<="      , 2 },
1589     { "le", "<="       , 2 },
1590     { "ls", "<<"       , 2 },
1591     { "lt", "<"        , 2 },
1592     { "mI", "-="       , 2 },
1593     { "mL", "*="       , 2 },
1594     { "mi", "-"        , 2 },
1595     { "ml", "*"        , 2 },
1596     { "mm", "--"       , 1 },
1597     { "na", " new[]"   , 1 },
1598     { "ne", "!="       , 2 },
1599     { "ng", "-"        , 1 },
1600     { "nt", "!"        , 1 },
1601     { "nw", " new"     , 1 },
1602     { "oR", "|="       , 2 },
1603     { "oo", "||"       , 2 },
1604     { "or", "|"        , 2 },
1605     { "pL", "+="       , 2 },
1606     { "pl", "+"        , 2 },
1607     { "pm", "->*"      , 2 },
1608     { "pp", "++"       , 1 },
1609     { "ps", "+"        , 1 },
1610     { "pt", "->"       , 2 },
1611     { "qu", "?"        , 3 },
1612     { "rM", "%="       , 2 },
1613     { "rS", ">>="      , 2 },
1614     { "rm", "%"        , 2 },
1615     { "rs", ">>"       , 2 },
1616     { "sz", " sizeof"  , 1 }
1617   };
1618
1619   const int num_operators = 
1620     sizeof (operators) / sizeof (struct operator_code);
1621
1622   int c0 = next_char (dm);
1623   int c1 = next_char (dm);
1624   const struct operator_code* p1 = operators;
1625   const struct operator_code* p2 = operators + num_operators;
1626
1627   DEMANGLE_TRACE ("operator-name", dm);
1628
1629   /* Is this a vendor-extended operator?  */
1630   if (c0 == 'v' && IS_DIGIT (c1))
1631     {
1632       RETURN_IF_ERROR (result_add (dm, "operator "));
1633       RETURN_IF_ERROR (demangle_source_name (dm));
1634       *num_args = 0;
1635       return STATUS_OK;
1636     }
1637
1638   /* Is this a conversion operator?  */
1639   if (c0 == 'c' && c1 == 'v')
1640     {
1641       RETURN_IF_ERROR (result_add (dm, "operator "));
1642       /* Demangle the converted-to type.  */
1643       RETURN_IF_ERROR (demangle_type (dm));
1644       *num_args = 0;
1645       return STATUS_OK;
1646     }
1647
1648   /* Perform a binary search for the operator code.  */
1649   while (1)
1650     {
1651       const struct operator_code* p = p1 + (p2 - p1) / 2;
1652       char match0 = p->code[0];
1653       char match1 = p->code[1];
1654
1655       if (c0 == match0 && c1 == match1)
1656         /* Found it.  */
1657         {
1658           if (!short_name)
1659             RETURN_IF_ERROR (result_add (dm, "operator"));
1660           RETURN_IF_ERROR (result_add (dm, p->name));
1661           *num_args = p->num_args;
1662
1663           return STATUS_OK;
1664         }
1665
1666       if (p == p1)
1667         /* Couldn't find it.  */
1668         return "Unknown code in <operator-name>.";
1669
1670       /* Try again.  */
1671       if (c0 < match0 || (c0 == match0 && c1 < match1))
1672         p2 = p;
1673       else
1674         p1 = p;
1675     }
1676 }
1677
1678 /* Demangles and omits an <nv-offset>.
1679
1680     <nv-offset> ::= <offset number>   # non-virtual base override  */
1681
1682 static status_t
1683 demangle_nv_offset (dm)
1684      demangling_t dm;
1685 {
1686   dyn_string_t number;
1687   status_t status = STATUS_OK;
1688
1689   DEMANGLE_TRACE ("h-offset", dm);
1690
1691   /* Demangle the offset.  */
1692   number = dyn_string_new (4);
1693   if (number == NULL)
1694     return STATUS_ALLOCATION_FAILED;
1695   demangle_number_literally (dm, number, 10, 1);
1696
1697   /* Don't display the offset unless in verbose mode.  */
1698   if (flag_verbose)
1699     {
1700       status = result_add (dm, " [nv:");
1701       if (STATUS_NO_ERROR (status))
1702         status = result_add_string (dm, number);
1703       if (STATUS_NO_ERROR (status))
1704         status = result_add_char (dm, ']');
1705     }
1706
1707   /* Clean up.  */
1708   dyn_string_delete (number);
1709   RETURN_IF_ERROR (status);
1710   return STATUS_OK;
1711 }
1712
1713 /* Demangles and emits a <v-offset>. 
1714
1715     <v-offset>  ::= <offset number> _ <virtual offset number>
1716                         # virtual base override, with vcall offset  */
1717
1718 static status_t
1719 demangle_v_offset (dm)
1720      demangling_t dm;
1721 {
1722   dyn_string_t number;
1723   status_t status = STATUS_OK;
1724
1725   DEMANGLE_TRACE ("v-offset", dm);
1726
1727   /* Demangle the offset.  */
1728   number = dyn_string_new (4);
1729   if (number == NULL)
1730     return STATUS_ALLOCATION_FAILED;
1731   demangle_number_literally (dm, number, 10, 1);
1732
1733   /* Don't display the offset unless in verbose mode.  */
1734   if (flag_verbose)
1735     {
1736       status = result_add (dm, " [v:");
1737       if (STATUS_NO_ERROR (status))
1738         status = result_add_string (dm, number);
1739       if (STATUS_NO_ERROR (status))
1740         result_add_char (dm, ',');
1741     }
1742   dyn_string_delete (number);
1743   RETURN_IF_ERROR (status);
1744
1745   /* Demangle the separator.  */
1746   RETURN_IF_ERROR (demangle_char (dm, '_'));
1747
1748   /* Demangle the vcall offset.  */
1749   number = dyn_string_new (4);
1750   if (number == NULL)
1751     return STATUS_ALLOCATION_FAILED;
1752   demangle_number_literally (dm, number, 10, 1);
1753
1754   /* Don't display the vcall offset unless in verbose mode.  */
1755   if (flag_verbose)
1756     {
1757       status = result_add_string (dm, number);
1758       if (STATUS_NO_ERROR (status))
1759         status = result_add_char (dm, ']');
1760     }
1761   dyn_string_delete (number);
1762   RETURN_IF_ERROR (status);
1763
1764   return STATUS_OK;
1765 }
1766
1767 /* Demangles and emits a <call-offset>.
1768
1769     <call-offset> ::= h <nv-offset> _
1770                   ::= v <v-offset> _  */
1771
1772 static status_t
1773 demangle_call_offset (dm)
1774      demangling_t dm;
1775 {
1776   DEMANGLE_TRACE ("call-offset", dm);
1777
1778   switch (peek_char (dm))
1779     {
1780     case 'h':
1781       advance_char (dm);
1782       /* Demangle the offset.  */
1783       RETURN_IF_ERROR (demangle_nv_offset (dm));
1784       /* Demangle the separator.  */
1785       RETURN_IF_ERROR (demangle_char (dm, '_'));
1786       break;
1787
1788     case 'v':
1789       advance_char (dm);
1790       /* Demangle the offset.  */
1791       RETURN_IF_ERROR (demangle_v_offset (dm));
1792       /* Demangle the separator.  */
1793       RETURN_IF_ERROR (demangle_char (dm, '_'));
1794       break;
1795
1796     default:
1797       return "Unrecognized <call-offset>.";
1798     }
1799
1800   return STATUS_OK;
1801 }
1802
1803 /* Demangles and emits a <special-name>.  
1804
1805     <special-name> ::= GV <object name>   # Guard variable
1806                    ::= TV <type>          # virtual table
1807                    ::= TT <type>          # VTT
1808                    ::= TI <type>          # typeinfo structure
1809                    ::= TS <type>          # typeinfo name  
1810
1811    Other relevant productions include thunks:
1812
1813     <special-name> ::= T <call-offset> <base encoding>
1814                          # base is the nominal target function of thunk
1815
1816     <special-name> ::= Tc <call-offset> <call-offset> <base encoding>
1817                          # base is the nominal target function of thunk
1818                          # first call-offset is 'this' adjustment
1819                          # second call-offset is result adjustment
1820
1821    where
1822
1823     <call-offset>  ::= h <nv-offset> _
1824                    ::= v <v-offset> _
1825
1826    Also demangles the special g++ manglings,
1827
1828     <special-name> ::= TC <type> <offset number> _ <base type>
1829                                           # construction vtable
1830                    ::= TF <type>          # typeinfo function (old ABI only)
1831                    ::= TJ <type>          # java Class structure  */
1832
1833 static status_t
1834 demangle_special_name (dm)
1835      demangling_t dm;
1836 {
1837   dyn_string_t number;
1838   int unused;
1839   char peek = peek_char (dm);
1840
1841   DEMANGLE_TRACE ("special-name", dm);
1842
1843   if (peek == 'G')
1844     {
1845       /* Consume the G.  */
1846       advance_char (dm);
1847       switch (peek_char (dm))
1848         {
1849         case 'V':
1850           /* A guard variable name.  */
1851           advance_char (dm);
1852           RETURN_IF_ERROR (result_add (dm, "guard variable for "));
1853           RETURN_IF_ERROR (demangle_name (dm, &unused));
1854           break;
1855
1856         case 'R':
1857           /* A reference temporary.  */
1858           advance_char (dm);
1859           RETURN_IF_ERROR (result_add (dm, "reference temporary for "));
1860           RETURN_IF_ERROR (demangle_name (dm, &unused));
1861           break;
1862           
1863         default:
1864           return "Unrecognized <special-name>.";
1865         }
1866     }
1867   else if (peek == 'T')
1868     {
1869       status_t status = STATUS_OK;
1870
1871       /* Other C++ implementation miscellania.  Consume the T.  */
1872       advance_char (dm);
1873
1874       switch (peek_char (dm))
1875         {
1876         case 'V':
1877           /* Virtual table.  */
1878           advance_char (dm);
1879           RETURN_IF_ERROR (result_add (dm, "vtable for "));
1880           RETURN_IF_ERROR (demangle_type (dm));
1881           break;
1882
1883         case 'T':
1884           /* VTT structure.  */
1885           advance_char (dm);
1886           RETURN_IF_ERROR (result_add (dm, "VTT for "));
1887           RETURN_IF_ERROR (demangle_type (dm));
1888           break;
1889
1890         case 'I':
1891           /* Typeinfo structure.  */
1892           advance_char (dm);
1893           RETURN_IF_ERROR (result_add (dm, "typeinfo for "));
1894           RETURN_IF_ERROR (demangle_type (dm));
1895           break;
1896
1897         case 'F':
1898           /* Typeinfo function.  Used only in old ABI with new mangling.  */
1899           advance_char (dm);
1900           RETURN_IF_ERROR (result_add (dm, "typeinfo fn for "));
1901           RETURN_IF_ERROR (demangle_type (dm));
1902           break;
1903
1904         case 'S':
1905           /* Character string containing type name, used in typeinfo. */
1906           advance_char (dm);
1907           RETURN_IF_ERROR (result_add (dm, "typeinfo name for "));
1908           RETURN_IF_ERROR (demangle_type (dm));
1909           break;
1910
1911         case 'J':
1912           /* The java Class variable corresponding to a C++ class.  */
1913           advance_char (dm);
1914           RETURN_IF_ERROR (result_add (dm, "java Class for "));
1915           RETURN_IF_ERROR (demangle_type (dm));
1916           break;
1917
1918         case 'h':
1919           /* Non-virtual thunk.  */
1920           advance_char (dm);
1921           RETURN_IF_ERROR (result_add (dm, "non-virtual thunk"));
1922           RETURN_IF_ERROR (demangle_nv_offset (dm));
1923           /* Demangle the separator.  */
1924           RETURN_IF_ERROR (demangle_char (dm, '_'));
1925           /* Demangle and emit the target name and function type.  */
1926           RETURN_IF_ERROR (result_add (dm, " to "));
1927           RETURN_IF_ERROR (demangle_encoding (dm));
1928           break;
1929
1930         case 'v':
1931           /* Virtual thunk.  */
1932           advance_char (dm);
1933           RETURN_IF_ERROR (result_add (dm, "virtual thunk"));
1934           RETURN_IF_ERROR (demangle_v_offset (dm));
1935           /* Demangle the separator.  */
1936           RETURN_IF_ERROR (demangle_char (dm, '_'));
1937           /* Demangle and emit the target function.  */
1938           RETURN_IF_ERROR (result_add (dm, " to "));
1939           RETURN_IF_ERROR (demangle_encoding (dm));
1940           break;
1941
1942         case 'c':
1943           /* Covariant return thunk.  */
1944           advance_char (dm);
1945           RETURN_IF_ERROR (result_add (dm, "covariant return thunk"));
1946           RETURN_IF_ERROR (demangle_call_offset (dm));
1947           RETURN_IF_ERROR (demangle_call_offset (dm));
1948           /* Demangle and emit the target function.  */
1949           RETURN_IF_ERROR (result_add (dm, " to "));
1950           RETURN_IF_ERROR (demangle_encoding (dm));
1951           break;
1952
1953         case 'C':
1954           /* TC is a special g++ mangling for a construction vtable. */
1955           if (!flag_strict)
1956             {
1957               dyn_string_t derived_type;
1958
1959               advance_char (dm);
1960               RETURN_IF_ERROR (result_add (dm, "construction vtable for "));
1961
1962               /* Demangle the derived type off to the side.  */
1963               RETURN_IF_ERROR (result_push (dm));
1964               RETURN_IF_ERROR (demangle_type (dm));
1965               derived_type = (dyn_string_t) result_pop (dm);
1966
1967               /* Demangle the offset.  */
1968               number = dyn_string_new (4);
1969               if (number == NULL)
1970                 {
1971                   dyn_string_delete (derived_type);
1972                   return STATUS_ALLOCATION_FAILED;
1973                 }
1974               demangle_number_literally (dm, number, 10, 1);
1975               /* Demangle the underscore separator.  */
1976               status = demangle_char (dm, '_');
1977
1978               /* Demangle the base type.  */
1979               if (STATUS_NO_ERROR (status))
1980                 status = demangle_type (dm);
1981
1982               /* Emit the derived type.  */
1983               if (STATUS_NO_ERROR (status))
1984                 status = result_add (dm, "-in-");
1985               if (STATUS_NO_ERROR (status))
1986                 status = result_add_string (dm, derived_type);
1987               dyn_string_delete (derived_type);
1988
1989               /* Don't display the offset unless in verbose mode.  */
1990               if (flag_verbose)
1991                 {
1992                   status = result_add_char (dm, ' ');
1993                   if (STATUS_NO_ERROR (status))
1994                     result_add_string (dm, number);
1995                 }
1996               dyn_string_delete (number);
1997               RETURN_IF_ERROR (status);
1998               break;
1999             }
2000           /* If flag_strict, fall through.  */
2001
2002         default:
2003           return "Unrecognized <special-name>.";
2004         }
2005     }
2006   else
2007     return STATUS_ERROR;
2008
2009   return STATUS_OK;
2010 }
2011
2012 /* Demangles and emits a <ctor-dtor-name>.  
2013    
2014     <ctor-dtor-name>
2015                    ::= C1  # complete object (in-charge) ctor
2016                    ::= C2  # base object (not-in-charge) ctor
2017                    ::= C3  # complete object (in-charge) allocating ctor
2018                    ::= D0  # deleting (in-charge) dtor
2019                    ::= D1  # complete object (in-charge) dtor
2020                    ::= D2  # base object (not-in-charge) dtor  */
2021
2022 static status_t
2023 demangle_ctor_dtor_name (dm)
2024      demangling_t dm;
2025 {
2026   static const char *const ctor_flavors[] = 
2027   {
2028     "in-charge",
2029     "not-in-charge",
2030     "allocating"
2031   };
2032   static const char *const dtor_flavors[] = 
2033   {
2034     "in-charge deleting",
2035     "in-charge",
2036     "not-in-charge"
2037   };
2038
2039   int flavor;
2040   char peek = peek_char (dm);
2041
2042   DEMANGLE_TRACE ("ctor-dtor-name", dm);
2043   
2044   if (peek == 'C')
2045     {
2046       /* A constructor name.  Consume the C.  */
2047       advance_char (dm);
2048       flavor = next_char (dm);
2049       if (flavor < '1' || flavor > '3')
2050         return "Unrecognized constructor.";
2051       RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
2052       switch (flavor)
2053         {
2054         case '1': dm->is_constructor = gnu_v3_complete_object_ctor;
2055           break;
2056         case '2': dm->is_constructor = gnu_v3_base_object_ctor;
2057           break;
2058         case '3': dm->is_constructor = gnu_v3_complete_object_allocating_ctor;
2059           break;
2060         }
2061       /* Print the flavor of the constructor if in verbose mode.  */
2062       if (flag_verbose)
2063         {
2064           RETURN_IF_ERROR (result_add (dm, "["));
2065           RETURN_IF_ERROR (result_add (dm, ctor_flavors[flavor - '1']));
2066           RETURN_IF_ERROR (result_add_char (dm, ']'));
2067         }
2068     }
2069   else if (peek == 'D')
2070     {
2071       /* A destructor name.  Consume the D.  */
2072       advance_char (dm);
2073       flavor = next_char (dm);
2074       if (flavor < '0' || flavor > '2')
2075         return "Unrecognized destructor.";
2076       RETURN_IF_ERROR (result_add_char (dm, '~'));
2077       RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
2078       switch (flavor)
2079         {
2080         case '0': dm->is_destructor = gnu_v3_deleting_dtor;
2081           break;
2082         case '1': dm->is_destructor = gnu_v3_complete_object_dtor;
2083           break;
2084         case '2': dm->is_destructor = gnu_v3_base_object_dtor;
2085           break;
2086         }
2087       /* Print the flavor of the destructor if in verbose mode.  */
2088       if (flag_verbose)
2089         {
2090           RETURN_IF_ERROR (result_add (dm, " ["));
2091           RETURN_IF_ERROR (result_add (dm, dtor_flavors[flavor - '0']));
2092           RETURN_IF_ERROR (result_add_char (dm, ']'));
2093         }
2094     }
2095   else
2096     return STATUS_ERROR;
2097
2098   return STATUS_OK;
2099 }
2100
2101 /* Handle pointer, reference, and pointer-to-member cases for
2102    demangle_type.  All consecutive `P's, `R's, and 'M's are joined to
2103    build a pointer/reference type.  We snarf all these, plus the
2104    following <type>, all at once since we need to know whether we have
2105    a pointer to data or pointer to function to construct the right
2106    output syntax.  C++'s pointer syntax is hairy.  
2107
2108    This function adds substitution candidates for every nested
2109    pointer/reference type it processes, including the outermost, final
2110    type, assuming the substitution starts at SUBSTITUTION_START in the
2111    demangling result.  For example, if this function demangles
2112    `PP3Foo', it will add a substitution for `Foo', `Foo*', and
2113    `Foo**', in that order.
2114
2115    *INSERT_POS is a quantity used internally, when this function calls
2116    itself recursively, to figure out where to insert pointer
2117    punctuation on the way up.  On entry to this function, INSERT_POS
2118    should point to a temporary value, but that value need not be
2119    initialized.
2120
2121      <type> ::= P <type>
2122             ::= R <type>
2123             ::= <pointer-to-member-type>
2124
2125      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2126
2127 static status_t
2128 demangle_type_ptr (dm, insert_pos, substitution_start)
2129      demangling_t dm;
2130      int *insert_pos;
2131      int substitution_start;
2132 {
2133   status_t status;
2134   int is_substitution_candidate = 1;
2135
2136   DEMANGLE_TRACE ("type*", dm);
2137
2138   /* Scan forward, collecting pointers and references into symbols,
2139      until we hit something else.  Then emit the type.  */
2140   switch (peek_char (dm))
2141     {
2142     case 'P':
2143       /* A pointer.  Snarf the `P'.  */
2144       advance_char (dm);
2145       /* Demangle the underlying type.  */
2146       RETURN_IF_ERROR (demangle_type_ptr (dm, insert_pos, 
2147                                           substitution_start));
2148       /* Insert an asterisk where we're told to; it doesn't
2149          necessarily go at the end.  If we're doing Java style output, 
2150          there is no pointer symbol.  */
2151       if (dm->style != DMGL_JAVA)
2152         RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '*'));
2153       /* The next (outermost) pointer or reference character should go
2154          after this one.  */
2155       ++(*insert_pos);
2156       break;
2157
2158     case 'R':
2159       /* A reference.  Snarf the `R'.  */
2160       advance_char (dm);
2161       /* Demangle the underlying type.  */
2162       RETURN_IF_ERROR (demangle_type_ptr (dm, insert_pos, 
2163                                           substitution_start));
2164       /* Insert an ampersand where we're told to; it doesn't
2165          necessarily go at the end.  */
2166       RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '&'));
2167       /* The next (outermost) pointer or reference character should go
2168          after this one.  */
2169       ++(*insert_pos);
2170       break;
2171
2172     case 'M':
2173     {
2174       /* A pointer-to-member.  */
2175       dyn_string_t class_type;
2176       
2177       /* Eat the 'M'.  */
2178       advance_char (dm);
2179       
2180       /* Capture the type of which this is a pointer-to-member.  */
2181       RETURN_IF_ERROR (result_push (dm));
2182       RETURN_IF_ERROR (demangle_type (dm));
2183       class_type = (dyn_string_t) result_pop (dm);
2184       
2185       if (peek_char (dm) == 'F')
2186         /* A pointer-to-member function.  We want output along the
2187            lines of `void (C::*) (int, int)'.  Demangle the function
2188            type, which would in this case give `void () (int, int)'
2189            and set *insert_pos to the spot between the first
2190            parentheses.  */
2191         status = demangle_type_ptr (dm, insert_pos, substitution_start);
2192       else if (peek_char (dm) == 'A')
2193         /* A pointer-to-member array variable.  We want output that
2194            looks like `int (Klass::*) [10]'.  Demangle the array type
2195            as `int () [10]', and set *insert_pos to the spot between
2196            the parentheses.  */
2197         status = demangle_array_type (dm, insert_pos);
2198       else
2199         {
2200           /* A pointer-to-member variable.  Demangle the type of the
2201              pointed-to member.  */
2202           status = demangle_type (dm);
2203           /* Make it pretty.  */
2204           if (STATUS_NO_ERROR (status)
2205               && !result_previous_char_is_space (dm))
2206             status = result_add_char (dm, ' ');
2207           /* The pointer-to-member notation (e.g. `C::*') follows the
2208              member's type.  */
2209           *insert_pos = result_caret_pos (dm);
2210         }
2211
2212       /* Build the pointer-to-member notation.  */
2213       if (STATUS_NO_ERROR (status))
2214         status = result_insert (dm, *insert_pos, "::*");
2215       if (STATUS_NO_ERROR (status))
2216         status = result_insert_string (dm, *insert_pos, class_type);
2217       /* There may be additional levels of (pointer or reference)
2218          indirection in this type.  If so, the `*' and `&' should be
2219          added after the pointer-to-member notation (e.g. `C::*&' for
2220          a reference to a pointer-to-member of class C).  */
2221       *insert_pos += dyn_string_length (class_type) + 3;
2222
2223       /* Clean up. */
2224       dyn_string_delete (class_type);
2225
2226       RETURN_IF_ERROR (status);
2227     }
2228     break;
2229
2230     case 'F':
2231       /* Ooh, tricky, a pointer-to-function.  When we demangle the
2232          function type, the return type should go at the very
2233          beginning.  */
2234       *insert_pos = result_caret_pos (dm);
2235       /* The parentheses indicate this is a function pointer or
2236          reference type.  */
2237       RETURN_IF_ERROR (result_add (dm, "()"));
2238       /* Now demangle the function type.  The return type will be
2239          inserted before the `()', and the argument list will go after
2240          it.  */
2241       RETURN_IF_ERROR (demangle_function_type (dm, insert_pos));
2242       /* We should now have something along the lines of 
2243          `void () (int, int)'.  The pointer or reference characters
2244          have to inside the first set of parentheses.  *insert_pos has
2245          already been updated to point past the end of the return
2246          type.  Move it one character over so it points inside the
2247          `()'.  */
2248       ++(*insert_pos);
2249       break;
2250
2251     case 'A':
2252       /* An array pointer or reference.  demangle_array_type will figure
2253          out where the asterisks and ampersands go.  */
2254       RETURN_IF_ERROR (demangle_array_type (dm, insert_pos));
2255       break;
2256
2257     default:
2258       /* No more pointer or reference tokens; this is therefore a
2259          pointer to data.  Finish up by demangling the underlying
2260          type.  */
2261       RETURN_IF_ERROR (demangle_type (dm));
2262       /* The pointer or reference characters follow the underlying
2263          type, as in `int*&'.  */
2264       *insert_pos = result_caret_pos (dm);
2265       /* Because of the production <type> ::= <substitution>,
2266          demangle_type will already have added the underlying type as
2267          a substitution candidate.  Don't do it again.  */
2268       is_substitution_candidate = 0;
2269       break;
2270     }
2271   
2272   if (is_substitution_candidate)
2273     RETURN_IF_ERROR (substitution_add (dm, substitution_start, 0));
2274   
2275   return STATUS_OK;
2276 }
2277
2278 /* Demangles and emits a <type>.  
2279
2280     <type> ::= <builtin-type>
2281            ::= <function-type>
2282            ::= <class-enum-type>
2283            ::= <array-type>
2284            ::= <pointer-to-member-type>
2285            ::= <template-param>
2286            ::= <template-template-param> <template-args>
2287            ::= <CV-qualifiers> <type>
2288            ::= P <type>   # pointer-to
2289            ::= R <type>   # reference-to
2290            ::= C <type>   # complex pair (C 2000)
2291            ::= G <type>   # imaginary (C 2000)
2292            ::= U <source-name> <type>     # vendor extended type qualifier
2293            ::= <substitution>  */
2294
2295 static status_t
2296 demangle_type (dm)
2297      demangling_t dm;
2298 {
2299   int start = substitution_start (dm);
2300   char peek = peek_char (dm);
2301   char peek_next;
2302   int encode_return_type = 0;
2303   template_arg_list_t old_arg_list = current_template_arg_list (dm);
2304   int insert_pos;
2305
2306   /* A <type> can be a <substitution>; therefore, this <type> is a
2307      substitution candidate unless a special condition holds (see
2308      below).  */
2309   int is_substitution_candidate = 1;
2310
2311   DEMANGLE_TRACE ("type", dm);
2312
2313   /* A <class-enum-type> can start with a digit (a <source-name>), an
2314      N (a <nested-name>), or a Z (a <local-name>).  */
2315   if (IS_DIGIT ((unsigned char) peek) || peek == 'N' || peek == 'Z')
2316     RETURN_IF_ERROR (demangle_class_enum_type (dm, &encode_return_type));
2317   /* Lower-case letters begin <builtin-type>s, except for `r', which
2318      denotes restrict.  */
2319   else if (peek >= 'a' && peek <= 'z' && peek != 'r')
2320     {
2321       RETURN_IF_ERROR (demangle_builtin_type (dm));
2322       /* Built-in types are not substitution candidates.  */
2323       is_substitution_candidate = 0;
2324     }
2325   else
2326     switch (peek)
2327       {
2328       case 'r':
2329       case 'V':
2330       case 'K':
2331         /* CV-qualifiers (including restrict).  We have to demangle
2332            them off to the side, since C++ syntax puts them in a funny
2333            place for qualified pointer and reference types.  */
2334         {
2335           status_t status;
2336           dyn_string_t cv_qualifiers = dyn_string_new (24);
2337           int old_caret_position = result_get_caret (dm);
2338
2339           if (cv_qualifiers == NULL)
2340             return STATUS_ALLOCATION_FAILED;
2341
2342           /* Decode all adjacent CV qualifiers.  */
2343           demangle_CV_qualifiers (dm, cv_qualifiers);
2344           /* Emit them, and shift the caret left so that the
2345              underlying type will be emitted before the qualifiers.  */
2346           status = result_add_string (dm, cv_qualifiers);
2347           result_shift_caret (dm, -dyn_string_length (cv_qualifiers));
2348           /* Clean up.  */
2349           dyn_string_delete (cv_qualifiers);
2350           RETURN_IF_ERROR (status);
2351           /* Also prepend a blank, if needed.  */
2352           RETURN_IF_ERROR (result_add_char (dm, ' '));
2353           result_shift_caret (dm, -1);
2354
2355           /* Demangle the underlying type.  It will be emitted before
2356              the CV qualifiers, since we moved the caret.  */
2357           RETURN_IF_ERROR (demangle_type (dm));
2358
2359           /* Put the caret back where it was previously.  */
2360           result_set_caret (dm, old_caret_position);
2361         }
2362         break;
2363
2364       case 'F':
2365         return "Non-pointer or -reference function type.";
2366
2367       case 'A':
2368         RETURN_IF_ERROR (demangle_array_type (dm, NULL));
2369         break;
2370
2371       case 'T':
2372         /* It's either a <template-param> or a
2373            <template-template-param>.  In either case, demangle the
2374            `T' token first.  */
2375         RETURN_IF_ERROR (demangle_template_param (dm));
2376
2377         /* Check for a template argument list; if one is found, it's a
2378              <template-template-param> ::= <template-param>
2379                                        ::= <substitution>  */
2380         if (peek_char (dm) == 'I')
2381           {
2382             /* Add a substitution candidate.  The template parameter
2383                `T' token is a substitution candidate by itself,
2384                without the template argument list.  */
2385             RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
2386
2387             /* Now demangle the template argument list.  */
2388             RETURN_IF_ERROR (demangle_template_args (dm));
2389             /* The entire type, including the template template
2390                parameter and its argument list, will be added as a
2391                substitution candidate below.  */
2392           }
2393
2394         break;
2395
2396       case 'S':
2397         /* First check if this is a special substitution.  If it is,
2398            this is a <class-enum-type>.  Special substitutions have a
2399            letter following the `S'; other substitutions have a digit
2400            or underscore.  */
2401         peek_next = peek_char_next (dm);
2402         if (IS_DIGIT (peek_next) || peek_next == '_')
2403           {
2404             RETURN_IF_ERROR (demangle_substitution (dm, &encode_return_type));
2405             
2406             /* The substituted name may have been a template name.
2407                Check if template arguments follow, and if so, demangle
2408                them.  */
2409             if (peek_char (dm) == 'I')
2410               RETURN_IF_ERROR (demangle_template_args (dm));
2411             else
2412               /* A substitution token is not itself a substitution
2413                  candidate.  (However, if the substituted template is
2414                  instantiated, the resulting type is.)  */
2415               is_substitution_candidate = 0;
2416           }
2417         else
2418           {
2419             /* Now some trickiness.  We have a special substitution
2420                here.  Often, the special substitution provides the
2421                name of a template that's subsequently instantiated,
2422                for instance `SaIcE' => std::allocator<char>.  In these
2423                cases we need to add a substitution candidate for the
2424                entire <class-enum-type> and thus don't want to clear
2425                the is_substitution_candidate flag.
2426
2427                However, it's possible that what we have here is a
2428                substitution token representing an entire type, such as
2429                `Ss' => std::string.  In this case, we mustn't add a
2430                new substitution candidate for this substitution token.
2431                To detect this case, remember where the start of the
2432                substitution token is.  */
2433             const char *next = dm->next;
2434             /* Now demangle the <class-enum-type>.  */
2435             RETURN_IF_ERROR 
2436               (demangle_class_enum_type (dm, &encode_return_type));
2437             /* If all that was just demangled is the two-character
2438                special substitution token, supress the addition of a
2439                new candidate for it.  */
2440             if (dm->next == next + 2)
2441               is_substitution_candidate = 0;
2442           }
2443
2444         break;
2445
2446       case 'P':
2447       case 'R':
2448       case 'M':
2449         RETURN_IF_ERROR (demangle_type_ptr (dm, &insert_pos, start));
2450         /* demangle_type_ptr adds all applicable substitution
2451            candidates.  */
2452         is_substitution_candidate = 0;
2453         break;
2454
2455       case 'C':
2456         /* A C99 complex type.  */
2457         RETURN_IF_ERROR (result_add (dm, "complex "));
2458         advance_char (dm);
2459         RETURN_IF_ERROR (demangle_type (dm));
2460         break;
2461
2462       case 'G':
2463         /* A C99 imaginary type.  */
2464         RETURN_IF_ERROR (result_add (dm, "imaginary "));
2465         advance_char (dm);
2466         RETURN_IF_ERROR (demangle_type (dm));
2467         break;
2468
2469       case 'U':
2470         /* Vendor-extended type qualifier.  */
2471         advance_char (dm);
2472         RETURN_IF_ERROR (demangle_source_name (dm));
2473         RETURN_IF_ERROR (result_add_char (dm, ' '));
2474         RETURN_IF_ERROR (demangle_type (dm));
2475         break;
2476
2477       default:
2478         return "Unexpected character in <type>.";
2479       }
2480
2481   if (is_substitution_candidate)
2482     /* Add a new substitution for the type. If this type was a
2483        <template-param>, pass its index since from the point of
2484        substitutions; a <template-param> token is a substitution
2485        candidate distinct from the type that is substituted for it.  */
2486     RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
2487
2488   /* Pop off template argument lists added during mangling of this
2489      type.  */
2490   pop_to_template_arg_list (dm, old_arg_list);
2491
2492   return STATUS_OK;
2493 }
2494
2495 /* C++ source names of builtin types, indexed by the mangled code
2496    letter's position in the alphabet ('a' -> 0, 'b' -> 1, etc).  */
2497 static const char *const builtin_type_names[26] = 
2498 {
2499   "signed char",              /* a */
2500   "bool",                     /* b */
2501   "char",                     /* c */
2502   "double",                   /* d */
2503   "long double",              /* e */
2504   "float",                    /* f */
2505   "__float128",               /* g */
2506   "unsigned char",            /* h */
2507   "int",                      /* i */
2508   "unsigned",                 /* j */
2509   NULL,                       /* k */
2510   "long",                     /* l */
2511   "unsigned long",            /* m */
2512   "__int128",                 /* n */
2513   "unsigned __int128",        /* o */
2514   NULL,                       /* p */
2515   NULL,                       /* q */
2516   NULL,                       /* r */
2517   "short",                    /* s */
2518   "unsigned short",           /* t */
2519   NULL,                       /* u */
2520   "void",                     /* v */
2521   "wchar_t",                  /* w */
2522   "long long",                /* x */
2523   "unsigned long long",       /* y */
2524   "..."                       /* z */
2525 };
2526
2527 /* Java source names of builtin types.  Types that arn't valid in Java
2528    are also included here - we don't fail if someone attempts to demangle a 
2529    C++ symbol in Java style. */
2530 static const char *const java_builtin_type_names[26] = 
2531 {
2532   "signed char",                /* a */
2533   "boolean", /* C++ "bool" */   /* b */
2534   "byte", /* C++ "char" */      /* c */
2535   "double",                     /* d */
2536   "long double",                /* e */
2537   "float",                      /* f */
2538   "__float128",                 /* g */
2539   "unsigned char",              /* h */
2540   "int",                        /* i */
2541   "unsigned",                   /* j */
2542   NULL,                         /* k */
2543   "long",                       /* l */
2544   "unsigned long",              /* m */
2545   "__int128",                   /* n */
2546   "unsigned __int128",          /* o */
2547   NULL,                         /* p */
2548   NULL,                         /* q */
2549   NULL,                         /* r */
2550   "short",                      /* s */
2551   "unsigned short",             /* t */
2552   NULL,                         /* u */
2553   "void",                       /* v */
2554   "char", /* C++ "wchar_t" */   /* w */
2555   "long", /* C++ "long long" */ /* x */
2556   "unsigned long long",         /* y */
2557   "..."                         /* z */
2558 };
2559
2560 /* Demangles and emits a <builtin-type>.  
2561
2562     <builtin-type> ::= v  # void
2563                    ::= w  # wchar_t
2564                    ::= b  # bool
2565                    ::= c  # char
2566                    ::= a  # signed char
2567                    ::= h  # unsigned char
2568                    ::= s  # short
2569                    ::= t  # unsigned short
2570                    ::= i  # int
2571                    ::= j  # unsigned int
2572                    ::= l  # long
2573                    ::= m  # unsigned long
2574                    ::= x  # long long, __int64
2575                    ::= y  # unsigned long long, __int64
2576                    ::= n  # __int128
2577                    ::= o  # unsigned __int128
2578                    ::= f  # float
2579                    ::= d  # double
2580                    ::= e  # long double, __float80
2581                    ::= g  # __float128
2582                    ::= z  # ellipsis
2583                    ::= u <source-name>    # vendor extended type  */
2584
2585 static status_t
2586 demangle_builtin_type (dm)
2587      demangling_t dm;
2588 {
2589
2590   char code = peek_char (dm);
2591
2592   DEMANGLE_TRACE ("builtin-type", dm);
2593
2594   if (code == 'u')
2595     {
2596       advance_char (dm);
2597       RETURN_IF_ERROR (demangle_source_name (dm));
2598       return STATUS_OK;
2599     }
2600   else if (code >= 'a' && code <= 'z')
2601     {
2602       const char *type_name;
2603       /* Java uses different names for some built-in types. */
2604       if (dm->style == DMGL_JAVA)
2605         type_name = java_builtin_type_names[code - 'a'];
2606       else
2607         type_name = builtin_type_names[code - 'a'];
2608       if (type_name == NULL)
2609         return "Unrecognized <builtin-type> code.";
2610
2611       RETURN_IF_ERROR (result_add (dm, type_name));
2612       advance_char (dm);
2613       return STATUS_OK;
2614     }
2615   else
2616     return "Non-alphabetic <builtin-type> code.";
2617 }
2618
2619 /* Demangles all consecutive CV-qualifiers (const, volatile, and
2620    restrict) at the current position.  The qualifiers are appended to
2621    QUALIFIERS.  Returns STATUS_OK.  */
2622
2623 static status_t
2624 demangle_CV_qualifiers (dm, qualifiers)
2625      demangling_t dm;
2626      dyn_string_t qualifiers;
2627 {
2628   DEMANGLE_TRACE ("CV-qualifiers", dm);
2629
2630   while (1)
2631     {
2632       switch (peek_char (dm))
2633         {
2634         case 'r':
2635           if (!dyn_string_append_space (qualifiers))
2636             return STATUS_ALLOCATION_FAILED;
2637           if (!dyn_string_append_cstr (qualifiers, "restrict"))
2638             return STATUS_ALLOCATION_FAILED;
2639           break;
2640
2641         case 'V':
2642           if (!dyn_string_append_space (qualifiers))
2643             return STATUS_ALLOCATION_FAILED;
2644           if (!dyn_string_append_cstr (qualifiers, "volatile"))
2645             return STATUS_ALLOCATION_FAILED;
2646           break;
2647
2648         case 'K':
2649           if (!dyn_string_append_space (qualifiers))
2650             return STATUS_ALLOCATION_FAILED;
2651           if (!dyn_string_append_cstr (qualifiers, "const"))
2652             return STATUS_ALLOCATION_FAILED;
2653           break;
2654
2655         default:
2656           return STATUS_OK;
2657         }
2658
2659       advance_char (dm);
2660     }
2661 }
2662
2663 /* Demangles and emits a <function-type>.  *FUNCTION_NAME_POS is the
2664    position in the result string of the start of the function
2665    identifier, at which the function's return type will be inserted;
2666    *FUNCTION_NAME_POS is updated to position past the end of the
2667    function's return type.
2668
2669     <function-type> ::= F [Y] <bare-function-type> E  */
2670
2671 static status_t
2672 demangle_function_type (dm, function_name_pos)
2673      demangling_t dm;
2674      int *function_name_pos;
2675 {
2676   DEMANGLE_TRACE ("function-type", dm);
2677   RETURN_IF_ERROR (demangle_char (dm, 'F'));  
2678   if (peek_char (dm) == 'Y')
2679     {
2680       /* Indicate this function has C linkage if in verbose mode.  */
2681       if (flag_verbose)
2682         RETURN_IF_ERROR (result_add (dm, " [extern \"C\"] "));
2683       advance_char (dm);
2684     }
2685   RETURN_IF_ERROR (demangle_bare_function_type (dm, function_name_pos));
2686   RETURN_IF_ERROR (demangle_char (dm, 'E'));
2687   return STATUS_OK;
2688 }
2689
2690 /* Demangles and emits a <bare-function-type>.  RETURN_TYPE_POS is the
2691    position in the result string at which the function return type
2692    should be inserted.  If RETURN_TYPE_POS is BFT_NO_RETURN_TYPE, the
2693    function's return type is assumed not to be encoded.  
2694
2695     <bare-function-type> ::= <signature type>+  */
2696
2697 static status_t
2698 demangle_bare_function_type (dm, return_type_pos)
2699      demangling_t dm;
2700      int *return_type_pos;
2701 {
2702   /* Sequence is the index of the current function parameter, counting
2703      from zero.  The value -1 denotes the return type.  */
2704   int sequence = 
2705     (return_type_pos == BFT_NO_RETURN_TYPE ? 0 : -1);
2706
2707   DEMANGLE_TRACE ("bare-function-type", dm);
2708
2709   RETURN_IF_ERROR (result_add_char (dm, '('));
2710   while (!end_of_name_p (dm) && peek_char (dm) != 'E')
2711     {
2712       if (sequence == -1)
2713         /* We're decoding the function's return type.  */
2714         {
2715           dyn_string_t return_type;
2716           status_t status = STATUS_OK;
2717
2718           /* Decode the return type off to the side.  */
2719           RETURN_IF_ERROR (result_push (dm));
2720           RETURN_IF_ERROR (demangle_type (dm));
2721           return_type = (dyn_string_t) result_pop (dm);
2722
2723           /* Add a space to the end of the type.  Insert the return
2724              type where we've been asked to. */
2725           if (!dyn_string_append_space (return_type))
2726             status = STATUS_ALLOCATION_FAILED;
2727           if (STATUS_NO_ERROR (status))
2728             {
2729               if (!dyn_string_insert (result_string (dm), *return_type_pos, 
2730                                       return_type))
2731                 status = STATUS_ALLOCATION_FAILED;
2732               else
2733                 *return_type_pos += dyn_string_length (return_type);
2734             }
2735
2736           dyn_string_delete (return_type);
2737           RETURN_IF_ERROR (status);
2738         }
2739       else 
2740         {
2741           /* Skip `void' parameter types.  One should only occur as
2742              the only type in a parameter list; in that case, we want
2743              to print `foo ()' instead of `foo (void)'.  */
2744           if (peek_char (dm) == 'v')
2745             /* Consume the v.  */
2746             advance_char (dm);
2747           else
2748             {
2749               /* Separate parameter types by commas.  */
2750               if (sequence > 0)
2751                 RETURN_IF_ERROR (result_add (dm, ", "));
2752               /* Demangle the type.  */
2753               RETURN_IF_ERROR (demangle_type (dm));
2754             }
2755         }
2756
2757       ++sequence;
2758     }
2759   RETURN_IF_ERROR (result_add_char (dm, ')'));
2760
2761   /* We should have demangled at least one parameter type (which would
2762      be void, for a function that takes no parameters), plus the
2763      return type, if we were supposed to demangle that.  */
2764   if (sequence == -1)
2765     return "Missing function return type.";
2766   else if (sequence == 0)
2767     return "Missing function parameter.";
2768
2769   return STATUS_OK;
2770 }
2771
2772 /* Demangles and emits a <class-enum-type>.  *ENCODE_RETURN_TYPE is set to
2773    non-zero if the type is a template-id, zero otherwise.  
2774
2775     <class-enum-type> ::= <name>  */
2776
2777 static status_t
2778 demangle_class_enum_type (dm, encode_return_type)
2779      demangling_t dm;
2780      int *encode_return_type;
2781 {
2782   DEMANGLE_TRACE ("class-enum-type", dm);
2783
2784   RETURN_IF_ERROR (demangle_name (dm, encode_return_type));
2785   return STATUS_OK;
2786 }
2787
2788 /* Demangles and emits an <array-type>.  
2789
2790    If PTR_INSERT_POS is not NULL, the array type is formatted as a
2791    pointer or reference to an array, except that asterisk and
2792    ampersand punctuation is omitted (since it's not know at this
2793    point).  *PTR_INSERT_POS is set to the position in the demangled
2794    name at which this punctuation should be inserted.  For example,
2795    `A10_i' is demangled to `int () [10]' and *PTR_INSERT_POS points
2796    between the parentheses.
2797
2798    If PTR_INSERT_POS is NULL, the array type is assumed not to be
2799    pointer- or reference-qualified.  Then, for example, `A10_i' is
2800    demangled simply as `int[10]'.  
2801
2802     <array-type> ::= A [<dimension number>] _ <element type>  
2803                  ::= A <dimension expression> _ <element type>  */
2804
2805 static status_t
2806 demangle_array_type (dm, ptr_insert_pos)
2807      demangling_t dm;
2808      int *ptr_insert_pos;
2809 {
2810   status_t status = STATUS_OK;
2811   dyn_string_t array_size = NULL;
2812   char peek;
2813
2814   DEMANGLE_TRACE ("array-type", dm);
2815
2816   RETURN_IF_ERROR (demangle_char (dm, 'A'));
2817
2818   /* Demangle the array size into array_size.  */
2819   peek = peek_char (dm);
2820   if (peek == '_')
2821     /* Array bound is omitted.  This is a C99-style VLA.  */
2822     ;
2823   else if (IS_DIGIT (peek_char (dm))) 
2824     {
2825       /* It looks like a constant array bound.  */
2826       array_size = dyn_string_new (10);
2827       if (array_size == NULL)
2828         return STATUS_ALLOCATION_FAILED;
2829       status = demangle_number_literally (dm, array_size, 10, 0);
2830     }
2831   else
2832     {
2833       /* Anything is must be an expression for a nont-constant array
2834          bound.  This happens if the array type occurs in a template
2835          and the array bound references a template parameter.  */
2836       RETURN_IF_ERROR (result_push (dm));
2837       RETURN_IF_ERROR (demangle_expression (dm));
2838       array_size = (dyn_string_t) result_pop (dm);
2839     }
2840   /* array_size may have been allocated by now, so we can't use
2841      RETURN_IF_ERROR until it's been deallocated.  */
2842
2843   /* Demangle the base type of the array.  */
2844   if (STATUS_NO_ERROR (status))
2845     status = demangle_char (dm, '_');
2846   if (STATUS_NO_ERROR (status))
2847     status = demangle_type (dm);
2848
2849   if (ptr_insert_pos != NULL)
2850     {
2851       /* This array is actually part of an pointer- or
2852          reference-to-array type.  Format appropriately, except we
2853          don't know which and how much punctuation to use.  */
2854       if (STATUS_NO_ERROR (status))
2855         status = result_add (dm, " () ");
2856       /* Let the caller know where to insert the punctuation.  */
2857       *ptr_insert_pos = result_caret_pos (dm) - 2;
2858     }
2859
2860   /* Emit the array dimension syntax.  */
2861   if (STATUS_NO_ERROR (status))
2862     status = result_add_char (dm, '[');
2863   if (STATUS_NO_ERROR (status) && array_size != NULL)
2864     status = result_add_string (dm, array_size);
2865   if (STATUS_NO_ERROR (status))
2866     status = result_add_char (dm, ']');
2867   if (array_size != NULL)
2868     dyn_string_delete (array_size);
2869   
2870   RETURN_IF_ERROR (status);
2871
2872   return STATUS_OK;
2873 }
2874
2875 /* Demangles and emits a <template-param>.  
2876
2877     <template-param> ::= T_       # first template parameter
2878                      ::= T <parameter-2 number> _  */
2879
2880 static status_t
2881 demangle_template_param (dm)
2882      demangling_t dm;
2883 {
2884   int parm_number;
2885   template_arg_list_t current_arg_list = current_template_arg_list (dm);
2886   string_list_t arg;
2887
2888   DEMANGLE_TRACE ("template-param", dm);
2889
2890   /* Make sure there is a template argmust list in which to look up
2891      this parameter reference.  */
2892   if (current_arg_list == NULL)
2893     return "Template parameter outside of template.";
2894
2895   RETURN_IF_ERROR (demangle_char (dm, 'T'));
2896   if (peek_char (dm) == '_')
2897     parm_number = 0;
2898   else
2899     {
2900       RETURN_IF_ERROR (demangle_number (dm, &parm_number, 10, 0));
2901       ++parm_number;
2902     }
2903   RETURN_IF_ERROR (demangle_char (dm, '_'));
2904
2905   arg = template_arg_list_get_arg (current_arg_list, parm_number);
2906   if (arg == NULL)
2907     /* parm_number exceeded the number of arguments in the current
2908        template argument list.  */
2909     return "Template parameter number out of bounds.";
2910   RETURN_IF_ERROR (result_add_string (dm, (dyn_string_t) arg));
2911
2912   return STATUS_OK;
2913 }
2914
2915 /* Demangles and emits a <template-args>.  
2916
2917     <template-args> ::= I <template-arg>+ E  */
2918
2919 static status_t
2920 demangle_template_args (dm)
2921      demangling_t dm;
2922 {
2923   int first = 1;
2924   dyn_string_t old_last_source_name;
2925   template_arg_list_t arg_list = template_arg_list_new ();
2926
2927   if (arg_list == NULL)
2928     return STATUS_ALLOCATION_FAILED;
2929
2930   /* Preserve the most recently demangled source name.  */
2931   old_last_source_name = dm->last_source_name;
2932   dm->last_source_name = dyn_string_new (0);
2933
2934   DEMANGLE_TRACE ("template-args", dm);
2935
2936   if (dm->last_source_name == NULL)
2937     return STATUS_ALLOCATION_FAILED;
2938
2939   RETURN_IF_ERROR (demangle_char (dm, 'I'));
2940   RETURN_IF_ERROR (result_open_template_list (dm));
2941   do
2942     {
2943       string_list_t arg;
2944
2945       if (first)
2946         first = 0;
2947       else
2948         RETURN_IF_ERROR (result_add (dm, ", "));
2949
2950       /* Capture the template arg.  */
2951       RETURN_IF_ERROR (result_push (dm));
2952       RETURN_IF_ERROR (demangle_template_arg (dm));
2953       arg = result_pop (dm);
2954
2955       /* Emit it in the demangled name.  */
2956       RETURN_IF_ERROR (result_add_string (dm, (dyn_string_t) arg));
2957
2958       /* Save it for use in expanding <template-param>s.  */
2959       template_arg_list_add_arg (arg_list, arg);
2960     }
2961   while (peek_char (dm) != 'E');
2962   /* Append the '>'.  */
2963   RETURN_IF_ERROR (result_close_template_list (dm));
2964
2965   /* Consume the 'E'.  */
2966   advance_char (dm);
2967
2968   /* Restore the most recent demangled source name.  */
2969   dyn_string_delete (dm->last_source_name);
2970   dm->last_source_name = old_last_source_name;
2971
2972   /* Push the list onto the top of the stack of template argument
2973      lists, so that arguments from it are used from now on when
2974      expanding <template-param>s.  */
2975   push_template_arg_list (dm, arg_list);
2976
2977   return STATUS_OK;
2978 }
2979
2980 /* This function, which does not correspond to a production in the
2981    mangling spec, handles the `literal' production for both
2982    <template-arg> and <expr-primary>.  It does not expect or consume
2983    the initial `L' or final `E'.  The demangling is given by:
2984
2985      <literal> ::= <type> </value/ number>
2986
2987    and the emitted output is `(type)number'.  */
2988
2989 static status_t
2990 demangle_literal (dm)
2991      demangling_t dm;
2992 {
2993   char peek = peek_char (dm);
2994   dyn_string_t value_string;
2995   status_t status;
2996
2997   DEMANGLE_TRACE ("literal", dm);
2998
2999   if (!flag_verbose && peek >= 'a' && peek <= 'z')
3000     {
3001       /* If not in verbose mode and this is a builtin type, see if we
3002          can produce simpler numerical output.  In particular, for
3003          integer types shorter than `long', just write the number
3004          without type information; for bools, write `true' or `false'.
3005          Other refinements could be made here too.  */
3006
3007       /* This constant string is used to map from <builtin-type> codes
3008          (26 letters of the alphabet) to codes that determine how the 
3009          value will be displayed.  The codes are:
3010            b: display as bool
3011            i: display as int
3012            l: display as long
3013          A space means the value will be represented using cast
3014          notation. */
3015       static const char *const code_map = "ibi    iii ll     ii  i  ";
3016
3017       char code = code_map[peek - 'a'];
3018       /* FIXME: Implement demangling of floats and doubles.  */
3019       if (code == 'u')
3020         return STATUS_UNIMPLEMENTED;
3021       if (code == 'b')
3022         {
3023           /* It's a boolean.  */
3024           char value;
3025
3026           /* Consume the b.  */
3027           advance_char (dm);
3028           /* Look at the next character.  It should be 0 or 1,
3029              corresponding to false or true, respectively.  */
3030           value = peek_char (dm);
3031           if (value == '0')
3032             RETURN_IF_ERROR (result_add (dm, "false"));
3033           else if (value == '1')
3034             RETURN_IF_ERROR (result_add (dm, "true"));
3035           else
3036             return "Unrecognized bool constant.";
3037           /* Consume the 0 or 1.  */
3038           advance_char (dm);
3039           return STATUS_OK;
3040         }
3041       else if (code == 'i' || code == 'l')
3042         {
3043           /* It's an integer or long.  */
3044
3045           /* Consume the type character.  */
3046           advance_char (dm);
3047
3048           /* Demangle the number and write it out.  */
3049           value_string = dyn_string_new (0);
3050           status = demangle_number_literally (dm, value_string, 10, 1);
3051           if (STATUS_NO_ERROR (status))
3052             status = result_add_string (dm, value_string);
3053           /* For long integers, append an l.  */
3054           if (code == 'l' && STATUS_NO_ERROR (status))
3055             status = result_add_char (dm, code);
3056           dyn_string_delete (value_string);
3057
3058           RETURN_IF_ERROR (status);
3059           return STATUS_OK;
3060         }
3061       /* ...else code == ' ', so fall through to represent this
3062          literal's type explicitly using cast syntax.  */
3063     }
3064
3065   RETURN_IF_ERROR (result_add_char (dm, '('));
3066   RETURN_IF_ERROR (demangle_type (dm));
3067   RETURN_IF_ERROR (result_add_char (dm, ')'));
3068
3069   value_string = dyn_string_new (0);
3070   if (value_string == NULL)
3071     return STATUS_ALLOCATION_FAILED;
3072
3073   status = demangle_number_literally (dm, value_string, 10, 1);
3074   if (STATUS_NO_ERROR (status))
3075     status = result_add_string (dm, value_string);
3076   dyn_string_delete (value_string);
3077   RETURN_IF_ERROR (status);
3078
3079   return STATUS_OK;
3080 }
3081
3082 /* Demangles and emits a <template-arg>.  
3083
3084     <template-arg> ::= <type>                     # type
3085                    ::= L <type> <value number> E  # literal
3086                    ::= LZ <encoding> E            # external name
3087                    ::= X <expression> E           # expression  */
3088
3089 static status_t
3090 demangle_template_arg (dm)
3091      demangling_t dm;
3092 {
3093   DEMANGLE_TRACE ("template-arg", dm);
3094
3095   switch (peek_char (dm))
3096     {
3097     case 'L':
3098       advance_char (dm);
3099
3100       if (peek_char (dm) == 'Z')
3101         {
3102           /* External name.  */
3103           advance_char (dm);
3104           /* FIXME: Standard is contradictory here.  */
3105           RETURN_IF_ERROR (demangle_encoding (dm));
3106         }
3107       else
3108         RETURN_IF_ERROR (demangle_literal (dm));
3109       RETURN_IF_ERROR (demangle_char (dm, 'E'));
3110       break;
3111
3112     case 'X':
3113       /* Expression.  */
3114       advance_char (dm);
3115       RETURN_IF_ERROR (demangle_expression (dm));
3116       RETURN_IF_ERROR (demangle_char (dm, 'E'));
3117       break;
3118
3119     default:
3120       RETURN_IF_ERROR (demangle_type (dm));
3121       break;
3122     }
3123
3124   return STATUS_OK;
3125 }
3126
3127 /* Demangles and emits an <expression>.
3128
3129     <expression> ::= <unary operator-name> <expression>
3130                  ::= <binary operator-name> <expression> <expression>
3131                  ::= <expr-primary>  
3132                  ::= <scope-expression>  */
3133
3134 static status_t
3135 demangle_expression (dm)
3136      demangling_t dm;
3137 {
3138   char peek = peek_char (dm);
3139
3140   DEMANGLE_TRACE ("expression", dm);
3141
3142   if (peek == 'L' || peek == 'T')
3143     RETURN_IF_ERROR (demangle_expr_primary (dm));
3144   else if (peek == 's' && peek_char_next (dm) == 'r')
3145     RETURN_IF_ERROR (demangle_scope_expression (dm));
3146   else
3147     /* An operator expression.  */
3148     {
3149       int num_args;
3150       status_t status = STATUS_OK;
3151       dyn_string_t operator_name;
3152
3153       /* We have an operator name.  Since we want to output binary
3154          operations in infix notation, capture the operator name
3155          first.  */
3156       RETURN_IF_ERROR (result_push (dm));
3157       RETURN_IF_ERROR (demangle_operator_name (dm, 1, &num_args));
3158       operator_name = (dyn_string_t) result_pop (dm);
3159
3160       /* If it's binary, do an operand first.  */
3161       if (num_args > 1)
3162         {
3163           status = result_add_char (dm, '(');
3164           if (STATUS_NO_ERROR (status))
3165             status = demangle_expression (dm);
3166           if (STATUS_NO_ERROR (status))
3167             status = result_add_char (dm, ')');
3168         }
3169
3170       /* Emit the operator.  */  
3171       if (STATUS_NO_ERROR (status))
3172         status = result_add_string (dm, operator_name);
3173       dyn_string_delete (operator_name);
3174       RETURN_IF_ERROR (status);
3175       
3176       /* Emit its second (if binary) or only (if unary) operand.  */
3177       RETURN_IF_ERROR (result_add_char (dm, '('));
3178       RETURN_IF_ERROR (demangle_expression (dm));
3179       RETURN_IF_ERROR (result_add_char (dm, ')'));
3180
3181       /* The ternary operator takes a third operand.  */
3182       if (num_args == 3)
3183         {
3184           RETURN_IF_ERROR (result_add (dm, ":("));
3185           RETURN_IF_ERROR (demangle_expression (dm));
3186           RETURN_IF_ERROR (result_add_char (dm, ')'));
3187         }
3188     }
3189
3190   return STATUS_OK;
3191 }
3192
3193 /* Demangles and emits a <scope-expression>.  
3194
3195     <scope-expression> ::= sr <qualifying type> <source-name>
3196                        ::= sr <qualifying type> <encoding>  */
3197
3198 static status_t
3199 demangle_scope_expression (dm)
3200      demangling_t dm;
3201 {
3202   RETURN_IF_ERROR (demangle_char (dm, 's'));
3203   RETURN_IF_ERROR (demangle_char (dm, 'r'));
3204   RETURN_IF_ERROR (demangle_type (dm));
3205   RETURN_IF_ERROR (result_add (dm, "::"));
3206   RETURN_IF_ERROR (demangle_encoding (dm));
3207   return STATUS_OK;
3208 }
3209
3210 /* Demangles and emits an <expr-primary>.  
3211
3212     <expr-primary> ::= <template-param>
3213                    ::= L <type> <value number> E  # literal
3214                    ::= L <mangled-name> E         # external name  */
3215
3216 static status_t
3217 demangle_expr_primary (dm)
3218      demangling_t dm;
3219 {
3220   char peek = peek_char (dm);
3221
3222   DEMANGLE_TRACE ("expr-primary", dm);
3223
3224   if (peek == 'T')
3225     RETURN_IF_ERROR (demangle_template_param (dm));
3226   else if (peek == 'L')
3227     {
3228       /* Consume the `L'.  */
3229       advance_char (dm);
3230       peek = peek_char (dm);
3231
3232       if (peek == '_')
3233         RETURN_IF_ERROR (demangle_mangled_name (dm));
3234       else
3235         RETURN_IF_ERROR (demangle_literal (dm));
3236
3237       RETURN_IF_ERROR (demangle_char (dm, 'E'));
3238     }
3239   else
3240     return STATUS_ERROR;
3241
3242   return STATUS_OK;
3243 }
3244
3245 /* Demangles and emits a <substitution>.  Sets *TEMPLATE_P to non-zero
3246    if the substitution is the name of a template, zero otherwise. 
3247
3248      <substitution> ::= S <seq-id> _
3249                     ::= S_
3250
3251                     ::= St   # ::std::
3252                     ::= Sa   # ::std::allocator
3253                     ::= Sb   # ::std::basic_string
3254                     ::= Ss   # ::std::basic_string<char,
3255                                                    ::std::char_traits<char>,
3256                                                    ::std::allocator<char> >
3257                     ::= Si   # ::std::basic_istream<char,  
3258                                                     std::char_traits<char> >
3259                     ::= So   # ::std::basic_ostream<char,  
3260                                                     std::char_traits<char> >
3261                     ::= Sd   # ::std::basic_iostream<char, 
3262                                                     std::char_traits<char> >
3263 */
3264
3265 static status_t
3266 demangle_substitution (dm, template_p)
3267      demangling_t dm;
3268      int *template_p;
3269 {
3270   int seq_id;
3271   int peek;
3272   dyn_string_t text;
3273
3274   DEMANGLE_TRACE ("substitution", dm);
3275
3276   RETURN_IF_ERROR (demangle_char (dm, 'S'));
3277
3278   /* Scan the substitution sequence index.  A missing number denotes
3279      the first index.  */
3280   peek = peek_char (dm);
3281   if (peek == '_')
3282     seq_id = -1;
3283   /* If the following character is 0-9 or a capital letter, interpret
3284      the sequence up to the next underscore as a base-36 substitution
3285      index.  */
3286   else if (IS_DIGIT ((unsigned char) peek) 
3287            || (peek >= 'A' && peek <= 'Z'))
3288     RETURN_IF_ERROR (demangle_number (dm, &seq_id, 36, 0));
3289   else 
3290     {
3291       const char *new_last_source_name = NULL;
3292
3293       switch (peek)
3294         {
3295         case 't':
3296           RETURN_IF_ERROR (result_add (dm, "std"));
3297           break;
3298
3299         case 'a':
3300           RETURN_IF_ERROR (result_add (dm, "std::allocator"));
3301           new_last_source_name = "allocator";
3302           *template_p = 1;
3303           break;
3304
3305         case 'b':
3306           RETURN_IF_ERROR (result_add (dm, "std::basic_string"));
3307           new_last_source_name = "basic_string";
3308           *template_p = 1;
3309           break;
3310           
3311         case 's':
3312           if (!flag_verbose)
3313             {
3314               RETURN_IF_ERROR (result_add (dm, "std::string"));
3315               new_last_source_name = "string";
3316             }
3317           else
3318             {
3319               RETURN_IF_ERROR (result_add (dm, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"));
3320               new_last_source_name = "basic_string";
3321             }
3322           *template_p = 0;
3323           break;
3324
3325         case 'i':
3326           if (!flag_verbose)
3327             {
3328               RETURN_IF_ERROR (result_add (dm, "std::istream"));
3329               new_last_source_name = "istream";
3330             }
3331           else
3332             {
3333               RETURN_IF_ERROR (result_add (dm, "std::basic_istream<char, std::char_traints<char> >"));
3334               new_last_source_name = "basic_istream";
3335             }
3336           *template_p = 0;
3337           break;
3338
3339         case 'o':
3340           if (!flag_verbose)
3341             {
3342               RETURN_IF_ERROR (result_add (dm, "std::ostream"));
3343               new_last_source_name = "ostream";
3344             }
3345           else
3346             {
3347               RETURN_IF_ERROR (result_add (dm, "std::basic_ostream<char, std::char_traits<char> >"));
3348               new_last_source_name = "basic_ostream";
3349             }
3350           *template_p = 0;
3351           break;
3352
3353         case 'd':
3354           if (!flag_verbose) 
3355             {
3356               RETURN_IF_ERROR (result_add (dm, "std::iostream"));
3357               new_last_source_name = "iostream";
3358             }
3359           else
3360             {
3361               RETURN_IF_ERROR (result_add (dm, "std::basic_iostream<char, std::char_traits<char> >"));
3362               new_last_source_name = "basic_iostream";
3363             }
3364           *template_p = 0;
3365           break;
3366
3367         default:
3368           return "Unrecognized <substitution>.";
3369         }
3370       
3371       /* Consume the character we just processed.  */
3372       advance_char (dm);
3373
3374       if (new_last_source_name != NULL)
3375         {
3376           if (!dyn_string_copy_cstr (dm->last_source_name, 
3377                                      new_last_source_name))
3378             return STATUS_ALLOCATION_FAILED;
3379         }
3380
3381       return STATUS_OK;
3382     }
3383
3384   /* Look up the substitution text.  Since `S_' is the most recent
3385      substitution, `S0_' is the second-most-recent, etc., shift the
3386      numbering by one.  */
3387   text = substitution_get (dm, seq_id + 1, template_p);
3388   if (text == NULL) 
3389     return "Substitution number out of range.";
3390
3391   /* Emit the substitution text.  */
3392   RETURN_IF_ERROR (result_add_string (dm, text));
3393
3394   RETURN_IF_ERROR (demangle_char (dm, '_'));
3395   return STATUS_OK;
3396 }
3397
3398 /* Demangles and emits a <local-name>.  
3399
3400     <local-name> := Z <function encoding> E <entity name> [<discriminator>]
3401                  := Z <function encoding> E s [<discriminator>]  */
3402
3403 static status_t
3404 demangle_local_name (dm)
3405      demangling_t dm;
3406 {
3407   DEMANGLE_TRACE ("local-name", dm);
3408
3409   RETURN_IF_ERROR (demangle_char (dm, 'Z'));
3410   RETURN_IF_ERROR (demangle_encoding (dm));
3411   RETURN_IF_ERROR (demangle_char (dm, 'E'));
3412   RETURN_IF_ERROR (result_add (dm, "::"));
3413
3414   if (peek_char (dm) == 's')