Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /* Demangler for g++ V3 ABI.
  2.    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2014
  3.    Free Software Foundation, Inc.
  4.    Written by Ian Lance Taylor <ian@wasabisystems.com>.
  5.  
  6.    This file is part of the libiberty library, which is part of GCC.
  7.  
  8.    This file is free software; you can redistribute it and/or modify
  9.    it under the terms of the GNU General Public License as published by
  10.    the Free Software Foundation; either version 2 of the License, or
  11.    (at your option) any later version.
  12.  
  13.    In addition to the permissions in the GNU General Public License, the
  14.    Free Software Foundation gives you unlimited permission to link the
  15.    compiled version of this file into combinations with other programs,
  16.    and to distribute those combinations without any restriction coming
  17.    from the use of this file.  (The General Public License restrictions
  18.    do apply in other respects; for example, they cover modification of
  19.    the file, and distribution when not linked into a combined
  20.    executable.)
  21.  
  22.    This program is distributed in the hope that it will be useful,
  23.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25.    GNU General Public License for more details.
  26.  
  27.    You should have received a copy of the GNU General Public License
  28.    along with this program; if not, write to the Free Software
  29.    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  30. */
  31.  
  32. /* This code implements a demangler for the g++ V3 ABI.  The ABI is
  33.    described on this web page:
  34.        http://www.codesourcery.com/cxx-abi/abi.html#mangling
  35.  
  36.    This code was written while looking at the demangler written by
  37.    Alex Samuel <samuel@codesourcery.com>.
  38.  
  39.    This code first pulls the mangled name apart into a list of
  40.    components, and then walks the list generating the demangled
  41.    name.
  42.  
  43.    This file will normally define the following functions, q.v.:
  44.       char *cplus_demangle_v3(const char *mangled, int options)
  45.       char *java_demangle_v3(const char *mangled)
  46.       int cplus_demangle_v3_callback(const char *mangled, int options,
  47.                                      demangle_callbackref callback)
  48.       int java_demangle_v3_callback(const char *mangled,
  49.                                     demangle_callbackref callback)
  50.       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
  51.       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
  52.  
  53.    Also, the interface to the component list is public, and defined in
  54.    demangle.h.  The interface consists of these types, which are
  55.    defined in demangle.h:
  56.       enum demangle_component_type
  57.       struct demangle_component
  58.       demangle_callbackref
  59.    and these functions defined in this file:
  60.       cplus_demangle_fill_name
  61.       cplus_demangle_fill_extended_operator
  62.       cplus_demangle_fill_ctor
  63.       cplus_demangle_fill_dtor
  64.       cplus_demangle_print
  65.       cplus_demangle_print_callback
  66.    and other functions defined in the file cp-demint.c.
  67.  
  68.    This file also defines some other functions and variables which are
  69.    only to be used by the file cp-demint.c.
  70.  
  71.    Preprocessor macros you can define while compiling this file:
  72.  
  73.    IN_LIBGCC2
  74.       If defined, this file defines the following functions, q.v.:
  75.          char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
  76.                                int *status)
  77.          int __gcclibcxx_demangle_callback (const char *,
  78.                                             void (*)
  79.                                               (const char *, size_t, void *),
  80.                                             void *)
  81.       instead of cplus_demangle_v3[_callback]() and
  82.       java_demangle_v3[_callback]().
  83.  
  84.    IN_GLIBCPP_V3
  85.       If defined, this file defines only __cxa_demangle() and
  86.       __gcclibcxx_demangle_callback(), and no other publically visible
  87.       functions or variables.
  88.  
  89.    STANDALONE_DEMANGLER
  90.       If defined, this file defines a main() function which demangles
  91.       any arguments, or, if none, demangles stdin.
  92.  
  93.    CP_DEMANGLE_DEBUG
  94.       If defined, turns on debugging mode, which prints information on
  95.       stdout about the mangled string.  This is not generally useful.
  96. */
  97.  
  98. #if defined (_AIX) && !defined (__GNUC__)
  99.  #pragma alloca
  100. #endif
  101.  
  102. #ifdef HAVE_CONFIG_H
  103. #include "config.h"
  104. #endif
  105.  
  106. #include <stdio.h>
  107.  
  108. #ifdef HAVE_STDLIB_H
  109. #include <stdlib.h>
  110. #endif
  111. #ifdef HAVE_STRING_H
  112. #include <string.h>
  113. #endif
  114.  
  115. #ifdef HAVE_ALLOCA_H
  116. # include <alloca.h>
  117. #else
  118. # ifndef alloca
  119. #  ifdef __GNUC__
  120. #   define alloca __builtin_alloca
  121. #  else
  122. extern char *alloca ();
  123. #  endif /* __GNUC__ */
  124. # endif /* alloca */
  125. #endif /* HAVE_ALLOCA_H */
  126.  
  127. #ifdef HAVE_LIMITS_H
  128. #include <limits.h>
  129. #endif
  130. #ifndef INT_MAX
  131. # define INT_MAX       (int)(((unsigned int) ~0) >> 1)          /* 0x7FFFFFFF */
  132. #endif
  133.  
  134. #include "ansidecl.h"
  135. #include "libiberty.h"
  136. #include "demangle.h"
  137. #include "cp-demangle.h"
  138.  
  139. /* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
  140.    also rename them via #define to avoid compiler errors when the
  141.    static definition conflicts with the extern declaration in a header
  142.    file.  */
  143. #ifdef IN_GLIBCPP_V3
  144.  
  145. #define CP_STATIC_IF_GLIBCPP_V3 static
  146.  
  147. #define cplus_demangle_fill_name d_fill_name
  148. static int d_fill_name (struct demangle_component *, const char *, int);
  149.  
  150. #define cplus_demangle_fill_extended_operator d_fill_extended_operator
  151. static int
  152. d_fill_extended_operator (struct demangle_component *, int,
  153.                           struct demangle_component *);
  154.  
  155. #define cplus_demangle_fill_ctor d_fill_ctor
  156. static int
  157. d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
  158.              struct demangle_component *);
  159.  
  160. #define cplus_demangle_fill_dtor d_fill_dtor
  161. static int
  162. d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
  163.              struct demangle_component *);
  164.  
  165. #define cplus_demangle_mangled_name d_mangled_name
  166. static struct demangle_component *d_mangled_name (struct d_info *, int);
  167.  
  168. #define cplus_demangle_type d_type
  169. static struct demangle_component *d_type (struct d_info *);
  170.  
  171. #define cplus_demangle_print d_print
  172. static char *d_print (int, const struct demangle_component *, int, size_t *);
  173.  
  174. #define cplus_demangle_print_callback d_print_callback
  175. static int d_print_callback (int, const struct demangle_component *,
  176.                              demangle_callbackref, void *);
  177.  
  178. #define cplus_demangle_init_info d_init_info
  179. static void d_init_info (const char *, int, size_t, struct d_info *);
  180.  
  181. #else /* ! defined(IN_GLIBCPP_V3) */
  182. #define CP_STATIC_IF_GLIBCPP_V3
  183. #endif /* ! defined(IN_GLIBCPP_V3) */
  184.  
  185. /* See if the compiler supports dynamic arrays.  */
  186.  
  187. #ifdef __GNUC__
  188. #define CP_DYNAMIC_ARRAYS
  189. #else
  190. #ifdef __STDC__
  191. #ifdef __STDC_VERSION__
  192. #if __STDC_VERSION__ >= 199901L
  193. #define CP_DYNAMIC_ARRAYS
  194. #endif /* __STDC__VERSION >= 199901L */
  195. #endif /* defined (__STDC_VERSION__) */
  196. #endif /* defined (__STDC__) */
  197. #endif /* ! defined (__GNUC__) */
  198.  
  199. /* We avoid pulling in the ctype tables, to prevent pulling in
  200.    additional unresolved symbols when this code is used in a library.
  201.    FIXME: Is this really a valid reason?  This comes from the original
  202.    V3 demangler code.
  203.  
  204.    As of this writing this file has the following undefined references
  205.    when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
  206.    strcat, strlen.  */
  207.  
  208. #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
  209. #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
  210. #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
  211.  
  212. /* The prefix prepended by GCC to an identifier represnting the
  213.    anonymous namespace.  */
  214. #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
  215. #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
  216.   (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
  217.  
  218. /* Information we keep for the standard substitutions.  */
  219.  
  220. struct d_standard_sub_info
  221. {
  222.   /* The code for this substitution.  */
  223.   char code;
  224.   /* The simple string it expands to.  */
  225.   const char *simple_expansion;
  226.   /* The length of the simple expansion.  */
  227.   int simple_len;
  228.   /* The results of a full, verbose, expansion.  This is used when
  229.      qualifying a constructor/destructor, or when in verbose mode.  */
  230.   const char *full_expansion;
  231.   /* The length of the full expansion.  */
  232.   int full_len;
  233.   /* What to set the last_name field of d_info to; NULL if we should
  234.      not set it.  This is only relevant when qualifying a
  235.      constructor/destructor.  */
  236.   const char *set_last_name;
  237.   /* The length of set_last_name.  */
  238.   int set_last_name_len;
  239. };
  240.  
  241. /* Accessors for subtrees of struct demangle_component.  */
  242.  
  243. #define d_left(dc) ((dc)->u.s_binary.left)
  244. #define d_right(dc) ((dc)->u.s_binary.right)
  245.  
  246. /* A list of templates.  This is used while printing.  */
  247.  
  248. struct d_print_template
  249. {
  250.   /* Next template on the list.  */
  251.   struct d_print_template *next;
  252.   /* This template.  */
  253.   const struct demangle_component *template_decl;
  254. };
  255.  
  256. /* A list of type modifiers.  This is used while printing.  */
  257.  
  258. struct d_print_mod
  259. {
  260.   /* Next modifier on the list.  These are in the reverse of the order
  261.      in which they appeared in the mangled string.  */
  262.   struct d_print_mod *next;
  263.   /* The modifier.  */
  264.   const struct demangle_component *mod;
  265.   /* Whether this modifier was printed.  */
  266.   int printed;
  267.   /* The list of templates which applies to this modifier.  */
  268.   struct d_print_template *templates;
  269. };
  270.  
  271. /* We use these structures to hold information during printing.  */
  272.  
  273. struct d_growable_string
  274. {
  275.   /* Buffer holding the result.  */
  276.   char *buf;
  277.   /* Current length of data in buffer.  */
  278.   size_t len;
  279.   /* Allocated size of buffer.  */
  280.   size_t alc;
  281.   /* Set to 1 if we had a memory allocation failure.  */
  282.   int allocation_failure;
  283. };
  284.  
  285. /* Stack of components, innermost first, used to avoid loops.  */
  286.  
  287. struct d_component_stack
  288. {
  289.   /* This component.  */
  290.   const struct demangle_component *dc;
  291.   /* This component's parent.  */
  292.   const struct d_component_stack *parent;
  293. };
  294.  
  295. /* A demangle component and some scope captured when it was first
  296.    traversed.  */
  297.  
  298. struct d_saved_scope
  299. {
  300.   /* The component whose scope this is.  */
  301.   const struct demangle_component *container;
  302.   /* The list of templates, if any, that was current when this
  303.      scope was captured.  */
  304.   struct d_print_template *templates;
  305. };
  306.  
  307. /* Checkpoint structure to allow backtracking.  This holds copies
  308.    of the fields of struct d_info that need to be restored
  309.    if a trial parse needs to be backtracked over.  */
  310.  
  311. struct d_info_checkpoint
  312. {
  313.   const char *n;
  314.   int next_comp;
  315.   int next_sub;
  316.   int did_subs;
  317.   int expansion;
  318. };
  319.  
  320. enum { D_PRINT_BUFFER_LENGTH = 256 };
  321. struct d_print_info
  322. {
  323.   /* Fixed-length allocated buffer for demangled data, flushed to the
  324.      callback with a NUL termination once full.  */
  325.   char buf[D_PRINT_BUFFER_LENGTH];
  326.   /* Current length of data in buffer.  */
  327.   size_t len;
  328.   /* The last character printed, saved individually so that it survives
  329.      any buffer flush.  */
  330.   char last_char;
  331.   /* Callback function to handle demangled buffer flush.  */
  332.   demangle_callbackref callback;
  333.   /* Opaque callback argument.  */
  334.   void *opaque;
  335.   /* The current list of templates, if any.  */
  336.   struct d_print_template *templates;
  337.   /* The current list of modifiers (e.g., pointer, reference, etc.),
  338.      if any.  */
  339.   struct d_print_mod *modifiers;
  340.   /* Set to 1 if we saw a demangling error.  */
  341.   int demangle_failure;
  342.   /* The current index into any template argument packs we are using
  343.      for printing.  */
  344.   int pack_index;
  345.   /* Number of d_print_flush calls so far.  */
  346.   unsigned long int flush_count;
  347.   /* Stack of components, innermost first, used to avoid loops.  */
  348.   const struct d_component_stack *component_stack;
  349.   /* Array of saved scopes for evaluating substitutions.  */
  350.   struct d_saved_scope *saved_scopes;
  351.   /* Index of the next unused saved scope in the above array.  */
  352.   int next_saved_scope;
  353.   /* Number of saved scopes in the above array.  */
  354.   int num_saved_scopes;
  355.   /* Array of templates for saving into scopes.  */
  356.   struct d_print_template *copy_templates;
  357.   /* Index of the next unused copy template in the above array.  */
  358.   int next_copy_template;
  359.   /* Number of copy templates in the above array.  */
  360.   int num_copy_templates;
  361.   /* The nearest enclosing template, if any.  */
  362.   const struct demangle_component *current_template;
  363. };
  364.  
  365. #ifdef CP_DEMANGLE_DEBUG
  366. static void d_dump (struct demangle_component *, int);
  367. #endif
  368.  
  369. static struct demangle_component *
  370. d_make_empty (struct d_info *);
  371.  
  372. static struct demangle_component *
  373. d_make_comp (struct d_info *, enum demangle_component_type,
  374.              struct demangle_component *,
  375.              struct demangle_component *);
  376.  
  377. static struct demangle_component *
  378. d_make_name (struct d_info *, const char *, int);
  379.  
  380. static struct demangle_component *
  381. d_make_demangle_mangled_name (struct d_info *, const char *);
  382.  
  383. static struct demangle_component *
  384. d_make_builtin_type (struct d_info *,
  385.                      const struct demangle_builtin_type_info *);
  386.  
  387. static struct demangle_component *
  388. d_make_operator (struct d_info *,
  389.                  const struct demangle_operator_info *);
  390.  
  391. static struct demangle_component *
  392. d_make_extended_operator (struct d_info *, int,
  393.                           struct demangle_component *);
  394.  
  395. static struct demangle_component *
  396. d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
  397.              struct demangle_component *);
  398.  
  399. static struct demangle_component *
  400. d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
  401.              struct demangle_component *);
  402.  
  403. static struct demangle_component *
  404. d_make_template_param (struct d_info *, int);
  405.  
  406. static struct demangle_component *
  407. d_make_sub (struct d_info *, const char *, int);
  408.  
  409. static int
  410. has_return_type (struct demangle_component *);
  411.  
  412. static int
  413. is_ctor_dtor_or_conversion (struct demangle_component *);
  414.  
  415. static struct demangle_component *d_encoding (struct d_info *, int);
  416.  
  417. static struct demangle_component *d_name (struct d_info *);
  418.  
  419. static struct demangle_component *d_nested_name (struct d_info *);
  420.  
  421. static struct demangle_component *d_prefix (struct d_info *);
  422.  
  423. static struct demangle_component *d_unqualified_name (struct d_info *);
  424.  
  425. static struct demangle_component *d_source_name (struct d_info *);
  426.  
  427. static int d_number (struct d_info *);
  428.  
  429. static struct demangle_component *d_identifier (struct d_info *, int);
  430.  
  431. static struct demangle_component *d_operator_name (struct d_info *);
  432.  
  433. static struct demangle_component *d_special_name (struct d_info *);
  434.  
  435. static int d_call_offset (struct d_info *, int);
  436.  
  437. static struct demangle_component *d_ctor_dtor_name (struct d_info *);
  438.  
  439. static struct demangle_component **
  440. d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
  441.  
  442. static struct demangle_component *
  443. d_ref_qualifier (struct d_info *, struct demangle_component *);
  444.  
  445. static struct demangle_component *
  446. d_function_type (struct d_info *);
  447.  
  448. static struct demangle_component *
  449. d_bare_function_type (struct d_info *, int);
  450.  
  451. static struct demangle_component *
  452. d_class_enum_type (struct d_info *);
  453.  
  454. static struct demangle_component *d_array_type (struct d_info *);
  455.  
  456. static struct demangle_component *d_vector_type (struct d_info *);
  457.  
  458. static struct demangle_component *
  459. d_pointer_to_member_type (struct d_info *);
  460.  
  461. static struct demangle_component *
  462. d_template_param (struct d_info *);
  463.  
  464. static struct demangle_component *d_template_args (struct d_info *);
  465.  
  466. static struct demangle_component *
  467. d_template_arg (struct d_info *);
  468.  
  469. static struct demangle_component *d_expression (struct d_info *);
  470.  
  471. static struct demangle_component *d_expr_primary (struct d_info *);
  472.  
  473. static struct demangle_component *d_local_name (struct d_info *);
  474.  
  475. static int d_discriminator (struct d_info *);
  476.  
  477. static struct demangle_component *d_lambda (struct d_info *);
  478.  
  479. static struct demangle_component *d_unnamed_type (struct d_info *);
  480.  
  481. static struct demangle_component *
  482. d_clone_suffix (struct d_info *, struct demangle_component *);
  483.  
  484. static int
  485. d_add_substitution (struct d_info *, struct demangle_component *);
  486.  
  487. static struct demangle_component *d_substitution (struct d_info *, int);
  488.  
  489. static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
  490.  
  491. static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
  492.  
  493. static void d_growable_string_init (struct d_growable_string *, size_t);
  494.  
  495. static inline void
  496. d_growable_string_resize (struct d_growable_string *, size_t);
  497.  
  498. static inline void
  499. d_growable_string_append_buffer (struct d_growable_string *,
  500.                                  const char *, size_t);
  501. static void
  502. d_growable_string_callback_adapter (const char *, size_t, void *);
  503.  
  504. static void
  505. d_print_init (struct d_print_info *, demangle_callbackref, void *,
  506.               const struct demangle_component *);
  507.  
  508. static inline void d_print_error (struct d_print_info *);
  509.  
  510. static inline int d_print_saw_error (struct d_print_info *);
  511.  
  512. static inline void d_print_flush (struct d_print_info *);
  513.  
  514. static inline void d_append_char (struct d_print_info *, char);
  515.  
  516. static inline void d_append_buffer (struct d_print_info *,
  517.                                     const char *, size_t);
  518.  
  519. static inline void d_append_string (struct d_print_info *, const char *);
  520.  
  521. static inline char d_last_char (struct d_print_info *);
  522.  
  523. static void
  524. d_print_comp (struct d_print_info *, int, const struct demangle_component *);
  525.  
  526. static void
  527. d_print_java_identifier (struct d_print_info *, const char *, int);
  528.  
  529. static void
  530. d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
  531.  
  532. static void
  533. d_print_mod (struct d_print_info *, int, const struct demangle_component *);
  534.  
  535. static void
  536. d_print_function_type (struct d_print_info *, int,
  537.                        const struct demangle_component *,
  538.                        struct d_print_mod *);
  539.  
  540. static void
  541. d_print_array_type (struct d_print_info *, int,
  542.                     const struct demangle_component *,
  543.                     struct d_print_mod *);
  544.  
  545. static void
  546. d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);
  547.  
  548. static void d_print_cast (struct d_print_info *, int,
  549.                           const struct demangle_component *);
  550. static void d_print_conversion (struct d_print_info *, int,
  551.                                 const struct demangle_component *);
  552.  
  553. static int d_demangle_callback (const char *, int,
  554.                                 demangle_callbackref, void *);
  555. static char *d_demangle (const char *, int, size_t *);
  556.  
  557. #ifdef CP_DEMANGLE_DEBUG
  558.  
  559. static void
  560. d_dump (struct demangle_component *dc, int indent)
  561. {
  562.   int i;
  563.  
  564.   if (dc == NULL)
  565.     {
  566.       if (indent == 0)
  567.         printf ("failed demangling\n");
  568.       return;
  569.     }
  570.  
  571.   for (i = 0; i < indent; ++i)
  572.     putchar (' ');
  573.  
  574.   switch (dc->type)
  575.     {
  576.     case DEMANGLE_COMPONENT_NAME:
  577.       printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
  578.       return;
  579.     case DEMANGLE_COMPONENT_TAGGED_NAME:
  580.       printf ("tagged name\n");
  581.       d_dump (dc->u.s_binary.left, indent + 2);
  582.       d_dump (dc->u.s_binary.right, indent + 2);
  583.       return;
  584.     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
  585.       printf ("template parameter %ld\n", dc->u.s_number.number);
  586.       return;
  587.     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
  588.       printf ("function parameter %ld\n", dc->u.s_number.number);
  589.       return;
  590.     case DEMANGLE_COMPONENT_CTOR:
  591.       printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
  592.       d_dump (dc->u.s_ctor.name, indent + 2);
  593.       return;
  594.     case DEMANGLE_COMPONENT_DTOR:
  595.       printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
  596.       d_dump (dc->u.s_dtor.name, indent + 2);
  597.       return;
  598.     case DEMANGLE_COMPONENT_SUB_STD:
  599.       printf ("standard substitution %s\n", dc->u.s_string.string);
  600.       return;
  601.     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
  602.       printf ("builtin type %s\n", dc->u.s_builtin.type->name);
  603.       return;
  604.     case DEMANGLE_COMPONENT_OPERATOR:
  605.       printf ("operator %s\n", dc->u.s_operator.op->name);
  606.       return;
  607.     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
  608.       printf ("extended operator with %d args\n",
  609.               dc->u.s_extended_operator.args);
  610.       d_dump (dc->u.s_extended_operator.name, indent + 2);
  611.       return;
  612.  
  613.     case DEMANGLE_COMPONENT_QUAL_NAME:
  614.       printf ("qualified name\n");
  615.       break;
  616.     case DEMANGLE_COMPONENT_LOCAL_NAME:
  617.       printf ("local name\n");
  618.       break;
  619.     case DEMANGLE_COMPONENT_TYPED_NAME:
  620.       printf ("typed name\n");
  621.       break;
  622.     case DEMANGLE_COMPONENT_TEMPLATE:
  623.       printf ("template\n");
  624.       break;
  625.     case DEMANGLE_COMPONENT_VTABLE:
  626.       printf ("vtable\n");
  627.       break;
  628.     case DEMANGLE_COMPONENT_VTT:
  629.       printf ("VTT\n");
  630.       break;
  631.     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
  632.       printf ("construction vtable\n");
  633.       break;
  634.     case DEMANGLE_COMPONENT_TYPEINFO:
  635.       printf ("typeinfo\n");
  636.       break;
  637.     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
  638.       printf ("typeinfo name\n");
  639.       break;
  640.     case DEMANGLE_COMPONENT_TYPEINFO_FN:
  641.       printf ("typeinfo function\n");
  642.       break;
  643.     case DEMANGLE_COMPONENT_THUNK:
  644.       printf ("thunk\n");
  645.       break;
  646.     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
  647.       printf ("virtual thunk\n");
  648.       break;
  649.     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
  650.       printf ("covariant thunk\n");
  651.       break;
  652.     case DEMANGLE_COMPONENT_JAVA_CLASS:
  653.       printf ("java class\n");
  654.       break;
  655.     case DEMANGLE_COMPONENT_GUARD:
  656.       printf ("guard\n");
  657.       break;
  658.     case DEMANGLE_COMPONENT_REFTEMP:
  659.       printf ("reference temporary\n");
  660.       break;
  661.     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
  662.       printf ("hidden alias\n");
  663.       break;
  664.     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
  665.       printf ("transaction clone\n");
  666.       break;
  667.     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
  668.       printf ("non-transaction clone\n");
  669.       break;
  670.     case DEMANGLE_COMPONENT_RESTRICT:
  671.       printf ("restrict\n");
  672.       break;
  673.     case DEMANGLE_COMPONENT_VOLATILE:
  674.       printf ("volatile\n");
  675.       break;
  676.     case DEMANGLE_COMPONENT_CONST:
  677.       printf ("const\n");
  678.       break;
  679.     case DEMANGLE_COMPONENT_RESTRICT_THIS:
  680.       printf ("restrict this\n");
  681.       break;
  682.     case DEMANGLE_COMPONENT_VOLATILE_THIS:
  683.       printf ("volatile this\n");
  684.       break;
  685.     case DEMANGLE_COMPONENT_CONST_THIS:
  686.       printf ("const this\n");
  687.       break;
  688.     case DEMANGLE_COMPONENT_REFERENCE_THIS:
  689.       printf ("reference this\n");
  690.       break;
  691.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  692.       printf ("rvalue reference this\n");
  693.       break;
  694.     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  695.       printf ("vendor type qualifier\n");
  696.       break;
  697.     case DEMANGLE_COMPONENT_POINTER:
  698.       printf ("pointer\n");
  699.       break;
  700.     case DEMANGLE_COMPONENT_REFERENCE:
  701.       printf ("reference\n");
  702.       break;
  703.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
  704.       printf ("rvalue reference\n");
  705.       break;
  706.     case DEMANGLE_COMPONENT_COMPLEX:
  707.       printf ("complex\n");
  708.       break;
  709.     case DEMANGLE_COMPONENT_IMAGINARY:
  710.       printf ("imaginary\n");
  711.       break;
  712.     case DEMANGLE_COMPONENT_VENDOR_TYPE:
  713.       printf ("vendor type\n");
  714.       break;
  715.     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
  716.       printf ("function type\n");
  717.       break;
  718.     case DEMANGLE_COMPONENT_ARRAY_TYPE:
  719.       printf ("array type\n");
  720.       break;
  721.     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  722.       printf ("pointer to member type\n");
  723.       break;
  724.     case DEMANGLE_COMPONENT_FIXED_TYPE:
  725.       printf ("fixed-point type, accum? %d, sat? %d\n",
  726.               dc->u.s_fixed.accum, dc->u.s_fixed.sat);
  727.       d_dump (dc->u.s_fixed.length, indent + 2);
  728.       break;
  729.     case DEMANGLE_COMPONENT_ARGLIST:
  730.       printf ("argument list\n");
  731.       break;
  732.     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
  733.       printf ("template argument list\n");
  734.       break;
  735.     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
  736.       printf ("initializer list\n");
  737.       break;
  738.     case DEMANGLE_COMPONENT_CAST:
  739.       printf ("cast\n");
  740.       break;
  741.     case DEMANGLE_COMPONENT_CONVERSION:
  742.       printf ("conversion operator\n");
  743.       break;
  744.     case DEMANGLE_COMPONENT_NULLARY:
  745.       printf ("nullary operator\n");
  746.       break;
  747.     case DEMANGLE_COMPONENT_UNARY:
  748.       printf ("unary operator\n");
  749.       break;
  750.     case DEMANGLE_COMPONENT_BINARY:
  751.       printf ("binary operator\n");
  752.       break;
  753.     case DEMANGLE_COMPONENT_BINARY_ARGS:
  754.       printf ("binary operator arguments\n");
  755.       break;
  756.     case DEMANGLE_COMPONENT_TRINARY:
  757.       printf ("trinary operator\n");
  758.       break;
  759.     case DEMANGLE_COMPONENT_TRINARY_ARG1:
  760.       printf ("trinary operator arguments 1\n");
  761.       break;
  762.     case DEMANGLE_COMPONENT_TRINARY_ARG2:
  763.       printf ("trinary operator arguments 1\n");
  764.       break;
  765.     case DEMANGLE_COMPONENT_LITERAL:
  766.       printf ("literal\n");
  767.       break;
  768.     case DEMANGLE_COMPONENT_LITERAL_NEG:
  769.       printf ("negative literal\n");
  770.       break;
  771.     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
  772.       printf ("java resource\n");
  773.       break;
  774.     case DEMANGLE_COMPONENT_COMPOUND_NAME:
  775.       printf ("compound name\n");
  776.       break;
  777.     case DEMANGLE_COMPONENT_CHARACTER:
  778.       printf ("character '%c'\n",  dc->u.s_character.character);
  779.       return;
  780.     case DEMANGLE_COMPONENT_NUMBER:
  781.       printf ("number %ld\n", dc->u.s_number.number);
  782.       return;
  783.     case DEMANGLE_COMPONENT_DECLTYPE:
  784.       printf ("decltype\n");
  785.       break;
  786.     case DEMANGLE_COMPONENT_PACK_EXPANSION:
  787.       printf ("pack expansion\n");
  788.       break;
  789.     case DEMANGLE_COMPONENT_TLS_INIT:
  790.       printf ("tls init function\n");
  791.       break;
  792.     case DEMANGLE_COMPONENT_TLS_WRAPPER:
  793.       printf ("tls wrapper function\n");
  794.       break;
  795.     case DEMANGLE_COMPONENT_DEFAULT_ARG:
  796.       printf ("default argument %d\n", dc->u.s_unary_num.num);
  797.       d_dump (dc->u.s_unary_num.sub, indent+2);
  798.       return;
  799.     case DEMANGLE_COMPONENT_LAMBDA:
  800.       printf ("lambda %d\n", dc->u.s_unary_num.num);
  801.       d_dump (dc->u.s_unary_num.sub, indent+2);
  802.       return;
  803.     }
  804.  
  805.   d_dump (d_left (dc), indent + 2);
  806.   d_dump (d_right (dc), indent + 2);
  807. }
  808.  
  809. #endif /* CP_DEMANGLE_DEBUG */
  810.  
  811. /* Fill in a DEMANGLE_COMPONENT_NAME.  */
  812.  
  813. CP_STATIC_IF_GLIBCPP_V3
  814. int
  815. cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
  816. {
  817.   if (p == NULL || s == NULL || len == 0)
  818.     return 0;
  819.   p->type = DEMANGLE_COMPONENT_NAME;
  820.   p->u.s_name.s = s;
  821.   p->u.s_name.len = len;
  822.   return 1;
  823. }
  824.  
  825. /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
  826.  
  827. CP_STATIC_IF_GLIBCPP_V3
  828. int
  829. cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
  830.                                        struct demangle_component *name)
  831. {
  832.   if (p == NULL || args < 0 || name == NULL)
  833.     return 0;
  834.   p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
  835.   p->u.s_extended_operator.args = args;
  836.   p->u.s_extended_operator.name = name;
  837.   return 1;
  838. }
  839.  
  840. /* Fill in a DEMANGLE_COMPONENT_CTOR.  */
  841.  
  842. CP_STATIC_IF_GLIBCPP_V3
  843. int
  844. cplus_demangle_fill_ctor (struct demangle_component *p,
  845.                           enum gnu_v3_ctor_kinds kind,
  846.                           struct demangle_component *name)
  847. {
  848.   if (p == NULL
  849.       || name == NULL
  850.       || (int) kind < gnu_v3_complete_object_ctor
  851.       || (int) kind > gnu_v3_object_ctor_group)
  852.     return 0;
  853.   p->type = DEMANGLE_COMPONENT_CTOR;
  854.   p->u.s_ctor.kind = kind;
  855.   p->u.s_ctor.name = name;
  856.   return 1;
  857. }
  858.  
  859. /* Fill in a DEMANGLE_COMPONENT_DTOR.  */
  860.  
  861. CP_STATIC_IF_GLIBCPP_V3
  862. int
  863. cplus_demangle_fill_dtor (struct demangle_component *p,
  864.                           enum gnu_v3_dtor_kinds kind,
  865.                           struct demangle_component *name)
  866. {
  867.   if (p == NULL
  868.       || name == NULL
  869.       || (int) kind < gnu_v3_deleting_dtor
  870.       || (int) kind > gnu_v3_object_dtor_group)
  871.     return 0;
  872.   p->type = DEMANGLE_COMPONENT_DTOR;
  873.   p->u.s_dtor.kind = kind;
  874.   p->u.s_dtor.name = name;
  875.   return 1;
  876. }
  877.  
  878. /* Add a new component.  */
  879.  
  880. static struct demangle_component *
  881. d_make_empty (struct d_info *di)
  882. {
  883.   struct demangle_component *p;
  884.  
  885.   if (di->next_comp >= di->num_comps)
  886.     return NULL;
  887.   p = &di->comps[di->next_comp];
  888.   ++di->next_comp;
  889.   return p;
  890. }
  891.  
  892. /* Add a new generic component.  */
  893.  
  894. static struct demangle_component *
  895. d_make_comp (struct d_info *di, enum demangle_component_type type,
  896.              struct demangle_component *left,
  897.              struct demangle_component *right)
  898. {
  899.   struct demangle_component *p;
  900.  
  901.   /* We check for errors here.  A typical error would be a NULL return
  902.      from a subroutine.  We catch those here, and return NULL
  903.      upward.  */
  904.   switch (type)
  905.     {
  906.       /* These types require two parameters.  */
  907.     case DEMANGLE_COMPONENT_QUAL_NAME:
  908.     case DEMANGLE_COMPONENT_LOCAL_NAME:
  909.     case DEMANGLE_COMPONENT_TYPED_NAME:
  910.     case DEMANGLE_COMPONENT_TAGGED_NAME:
  911.     case DEMANGLE_COMPONENT_TEMPLATE:
  912.     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
  913.     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  914.     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  915.     case DEMANGLE_COMPONENT_UNARY:
  916.     case DEMANGLE_COMPONENT_BINARY:
  917.     case DEMANGLE_COMPONENT_BINARY_ARGS:
  918.     case DEMANGLE_COMPONENT_TRINARY:
  919.     case DEMANGLE_COMPONENT_TRINARY_ARG1:
  920.     case DEMANGLE_COMPONENT_LITERAL:
  921.     case DEMANGLE_COMPONENT_LITERAL_NEG:
  922.     case DEMANGLE_COMPONENT_COMPOUND_NAME:
  923.     case DEMANGLE_COMPONENT_VECTOR_TYPE:
  924.     case DEMANGLE_COMPONENT_CLONE:
  925.       if (left == NULL || right == NULL)
  926.         return NULL;
  927.       break;
  928.  
  929.       /* These types only require one parameter.  */
  930.     case DEMANGLE_COMPONENT_VTABLE:
  931.     case DEMANGLE_COMPONENT_VTT:
  932.     case DEMANGLE_COMPONENT_TYPEINFO:
  933.     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
  934.     case DEMANGLE_COMPONENT_TYPEINFO_FN:
  935.     case DEMANGLE_COMPONENT_THUNK:
  936.     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
  937.     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
  938.     case DEMANGLE_COMPONENT_JAVA_CLASS:
  939.     case DEMANGLE_COMPONENT_GUARD:
  940.     case DEMANGLE_COMPONENT_TLS_INIT:
  941.     case DEMANGLE_COMPONENT_TLS_WRAPPER:
  942.     case DEMANGLE_COMPONENT_REFTEMP:
  943.     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
  944.     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
  945.     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
  946.     case DEMANGLE_COMPONENT_POINTER:
  947.     case DEMANGLE_COMPONENT_REFERENCE:
  948.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
  949.     case DEMANGLE_COMPONENT_COMPLEX:
  950.     case DEMANGLE_COMPONENT_IMAGINARY:
  951.     case DEMANGLE_COMPONENT_VENDOR_TYPE:
  952.     case DEMANGLE_COMPONENT_CAST:
  953.     case DEMANGLE_COMPONENT_CONVERSION:
  954.     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
  955.     case DEMANGLE_COMPONENT_DECLTYPE:
  956.     case DEMANGLE_COMPONENT_PACK_EXPANSION:
  957.     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
  958.     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
  959.     case DEMANGLE_COMPONENT_NULLARY:
  960.     case DEMANGLE_COMPONENT_TRINARY_ARG2:
  961.       if (left == NULL)
  962.         return NULL;
  963.       break;
  964.  
  965.       /* This needs a right parameter, but the left parameter can be
  966.          empty.  */
  967.     case DEMANGLE_COMPONENT_ARRAY_TYPE:
  968.     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
  969.       if (right == NULL)
  970.         return NULL;
  971.       break;
  972.  
  973.       /* These are allowed to have no parameters--in some cases they
  974.          will be filled in later.  */
  975.     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
  976.     case DEMANGLE_COMPONENT_RESTRICT:
  977.     case DEMANGLE_COMPONENT_VOLATILE:
  978.     case DEMANGLE_COMPONENT_CONST:
  979.     case DEMANGLE_COMPONENT_RESTRICT_THIS:
  980.     case DEMANGLE_COMPONENT_VOLATILE_THIS:
  981.     case DEMANGLE_COMPONENT_CONST_THIS:
  982.     case DEMANGLE_COMPONENT_REFERENCE_THIS:
  983.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  984.     case DEMANGLE_COMPONENT_ARGLIST:
  985.     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
  986.       break;
  987.  
  988.       /* Other types should not be seen here.  */
  989.     default:
  990.       return NULL;
  991.     }
  992.  
  993.   p = d_make_empty (di);
  994.   if (p != NULL)
  995.     {
  996.       p->type = type;
  997.       p->u.s_binary.left = left;
  998.       p->u.s_binary.right = right;
  999.     }
  1000.   return p;
  1001. }
  1002.  
  1003. /* Add a new demangle mangled name component.  */
  1004.  
  1005. static struct demangle_component *
  1006. d_make_demangle_mangled_name (struct d_info *di, const char *s)
  1007. {
  1008.   if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
  1009.     return d_make_name (di, s, strlen (s));
  1010.   d_advance (di, 2);
  1011.   return d_encoding (di, 0);
  1012. }
  1013.  
  1014. /* Add a new name component.  */
  1015.  
  1016. static struct demangle_component *
  1017. d_make_name (struct d_info *di, const char *s, int len)
  1018. {
  1019.   struct demangle_component *p;
  1020.  
  1021.   p = d_make_empty (di);
  1022.   if (! cplus_demangle_fill_name (p, s, len))
  1023.     return NULL;
  1024.   return p;
  1025. }
  1026.  
  1027. /* Add a new builtin type component.  */
  1028.  
  1029. static struct demangle_component *
  1030. d_make_builtin_type (struct d_info *di,
  1031.                      const struct demangle_builtin_type_info *type)
  1032. {
  1033.   struct demangle_component *p;
  1034.  
  1035.   if (type == NULL)
  1036.     return NULL;
  1037.   p = d_make_empty (di);
  1038.   if (p != NULL)
  1039.     {
  1040.       p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
  1041.       p->u.s_builtin.type = type;
  1042.     }
  1043.   return p;
  1044. }
  1045.  
  1046. /* Add a new operator component.  */
  1047.  
  1048. static struct demangle_component *
  1049. d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
  1050. {
  1051.   struct demangle_component *p;
  1052.  
  1053.   p = d_make_empty (di);
  1054.   if (p != NULL)
  1055.     {
  1056.       p->type = DEMANGLE_COMPONENT_OPERATOR;
  1057.       p->u.s_operator.op = op;
  1058.     }
  1059.   return p;
  1060. }
  1061.  
  1062. /* Add a new extended operator component.  */
  1063.  
  1064. static struct demangle_component *
  1065. d_make_extended_operator (struct d_info *di, int args,
  1066.                           struct demangle_component *name)
  1067. {
  1068.   struct demangle_component *p;
  1069.  
  1070.   p = d_make_empty (di);
  1071.   if (! cplus_demangle_fill_extended_operator (p, args, name))
  1072.     return NULL;
  1073.   return p;
  1074. }
  1075.  
  1076. static struct demangle_component *
  1077. d_make_default_arg (struct d_info *di, int num,
  1078.                     struct demangle_component *sub)
  1079. {
  1080.   struct demangle_component *p = d_make_empty (di);
  1081.   if (p)
  1082.     {
  1083.       p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
  1084.       p->u.s_unary_num.num = num;
  1085.       p->u.s_unary_num.sub = sub;
  1086.     }
  1087.   return p;
  1088. }
  1089.  
  1090. /* Add a new constructor component.  */
  1091.  
  1092. static struct demangle_component *
  1093. d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
  1094.              struct demangle_component *name)
  1095. {
  1096.   struct demangle_component *p;
  1097.  
  1098.   p = d_make_empty (di);
  1099.   if (! cplus_demangle_fill_ctor (p, kind, name))
  1100.     return NULL;
  1101.   return p;
  1102. }
  1103.  
  1104. /* Add a new destructor component.  */
  1105.  
  1106. static struct demangle_component *
  1107. d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
  1108.              struct demangle_component *name)
  1109. {
  1110.   struct demangle_component *p;
  1111.  
  1112.   p = d_make_empty (di);
  1113.   if (! cplus_demangle_fill_dtor (p, kind, name))
  1114.     return NULL;
  1115.   return p;
  1116. }
  1117.  
  1118. /* Add a new template parameter.  */
  1119.  
  1120. static struct demangle_component *
  1121. d_make_template_param (struct d_info *di, int i)
  1122. {
  1123.   struct demangle_component *p;
  1124.  
  1125.   p = d_make_empty (di);
  1126.   if (p != NULL)
  1127.     {
  1128.       p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
  1129.       p->u.s_number.number = i;
  1130.     }
  1131.   return p;
  1132. }
  1133.  
  1134. /* Add a new function parameter.  */
  1135.  
  1136. static struct demangle_component *
  1137. d_make_function_param (struct d_info *di, int i)
  1138. {
  1139.   struct demangle_component *p;
  1140.  
  1141.   p = d_make_empty (di);
  1142.   if (p != NULL)
  1143.     {
  1144.       p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
  1145.       p->u.s_number.number = i;
  1146.     }
  1147.   return p;
  1148. }
  1149.  
  1150. /* Add a new standard substitution component.  */
  1151.  
  1152. static struct demangle_component *
  1153. d_make_sub (struct d_info *di, const char *name, int len)
  1154. {
  1155.   struct demangle_component *p;
  1156.  
  1157.   p = d_make_empty (di);
  1158.   if (p != NULL)
  1159.     {
  1160.       p->type = DEMANGLE_COMPONENT_SUB_STD;
  1161.       p->u.s_string.string = name;
  1162.       p->u.s_string.len = len;
  1163.     }
  1164.   return p;
  1165. }
  1166.  
  1167. /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
  1168.  
  1169.    TOP_LEVEL is non-zero when called at the top level.  */
  1170.  
  1171. CP_STATIC_IF_GLIBCPP_V3
  1172. struct demangle_component *
  1173. cplus_demangle_mangled_name (struct d_info *di, int top_level)
  1174. {
  1175.   struct demangle_component *p;
  1176.  
  1177.   if (! d_check_char (di, '_')
  1178.       /* Allow missing _ if not at toplevel to work around a
  1179.          bug in G++ abi-version=2 mangling; see the comment in
  1180.          write_template_arg.  */
  1181.       && top_level)
  1182.     return NULL;
  1183.   if (! d_check_char (di, 'Z'))
  1184.     return NULL;
  1185.   p = d_encoding (di, top_level);
  1186.  
  1187.   /* If at top level and parsing parameters, check for a clone
  1188.      suffix.  */
  1189.   if (top_level && (di->options & DMGL_PARAMS) != 0)
  1190.     while (d_peek_char (di) == '.'
  1191.            && (IS_LOWER (d_peek_next_char (di))
  1192.                || d_peek_next_char (di) == '_'
  1193.                || IS_DIGIT (d_peek_next_char (di))))
  1194.       p = d_clone_suffix (di, p);
  1195.  
  1196.   return p;
  1197. }
  1198.  
  1199. /* Return whether a function should have a return type.  The argument
  1200.    is the function name, which may be qualified in various ways.  The
  1201.    rules are that template functions have return types with some
  1202.    exceptions, function types which are not part of a function name
  1203.    mangling have return types with some exceptions, and non-template
  1204.    function names do not have return types.  The exceptions are that
  1205.    constructors, destructors, and conversion operators do not have
  1206.    return types.  */
  1207.  
  1208. static int
  1209. has_return_type (struct demangle_component *dc)
  1210. {
  1211.   if (dc == NULL)
  1212.     return 0;
  1213.   switch (dc->type)
  1214.     {
  1215.     default:
  1216.       return 0;
  1217.     case DEMANGLE_COMPONENT_TEMPLATE:
  1218.       return ! is_ctor_dtor_or_conversion (d_left (dc));
  1219.     case DEMANGLE_COMPONENT_RESTRICT_THIS:
  1220.     case DEMANGLE_COMPONENT_VOLATILE_THIS:
  1221.     case DEMANGLE_COMPONENT_CONST_THIS:
  1222.     case DEMANGLE_COMPONENT_REFERENCE_THIS:
  1223.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  1224.       return has_return_type (d_left (dc));
  1225.     }
  1226. }
  1227.  
  1228. /* Return whether a name is a constructor, a destructor, or a
  1229.    conversion operator.  */
  1230.  
  1231. static int
  1232. is_ctor_dtor_or_conversion (struct demangle_component *dc)
  1233. {
  1234.   if (dc == NULL)
  1235.     return 0;
  1236.   switch (dc->type)
  1237.     {
  1238.     default:
  1239.       return 0;
  1240.     case DEMANGLE_COMPONENT_QUAL_NAME:
  1241.     case DEMANGLE_COMPONENT_LOCAL_NAME:
  1242.       return is_ctor_dtor_or_conversion (d_right (dc));
  1243.     case DEMANGLE_COMPONENT_CTOR:
  1244.     case DEMANGLE_COMPONENT_DTOR:
  1245.     case DEMANGLE_COMPONENT_CONVERSION:
  1246.       return 1;
  1247.     }
  1248. }
  1249.  
  1250. /* <encoding> ::= <(function) name> <bare-function-type>
  1251.               ::= <(data) name>
  1252.               ::= <special-name>
  1253.  
  1254.    TOP_LEVEL is non-zero when called at the top level, in which case
  1255.    if DMGL_PARAMS is not set we do not demangle the function
  1256.    parameters.  We only set this at the top level, because otherwise
  1257.    we would not correctly demangle names in local scopes.  */
  1258.  
  1259. static struct demangle_component *
  1260. d_encoding (struct d_info *di, int top_level)
  1261. {
  1262.   char peek = d_peek_char (di);
  1263.  
  1264.   if (peek == 'G' || peek == 'T')
  1265.     return d_special_name (di);
  1266.   else
  1267.     {
  1268.       struct demangle_component *dc;
  1269.  
  1270.       dc = d_name (di);
  1271.  
  1272.       if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
  1273.         {
  1274.           /* Strip off any initial CV-qualifiers, as they really apply
  1275.              to the `this' parameter, and they were not output by the
  1276.              v2 demangler without DMGL_PARAMS.  */
  1277.           while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
  1278.                  || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
  1279.                  || dc->type == DEMANGLE_COMPONENT_CONST_THIS
  1280.                  || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
  1281.                  || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
  1282.             dc = d_left (dc);
  1283.  
  1284.           /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
  1285.              there may be CV-qualifiers on its right argument which
  1286.              really apply here; this happens when parsing a class
  1287.              which is local to a function.  */
  1288.           if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
  1289.             {
  1290.               struct demangle_component *dcr;
  1291.  
  1292.               dcr = d_right (dc);
  1293.               while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
  1294.                      || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
  1295.                      || dcr->type == DEMANGLE_COMPONENT_CONST_THIS
  1296.                      || dcr->type == DEMANGLE_COMPONENT_REFERENCE_THIS
  1297.                      || dcr->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
  1298.                 dcr = d_left (dcr);
  1299.               dc->u.s_binary.right = dcr;
  1300.             }
  1301.  
  1302.           return dc;
  1303.         }
  1304.  
  1305.       peek = d_peek_char (di);
  1306.       if (dc == NULL || peek == '\0' || peek == 'E')
  1307.         return dc;
  1308.       return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
  1309.                           d_bare_function_type (di, has_return_type (dc)));
  1310.     }
  1311. }
  1312.  
  1313. /* <tagged-name> ::= <name> B <source-name> */
  1314.  
  1315. static struct demangle_component *
  1316. d_abi_tags (struct d_info *di, struct demangle_component *dc)
  1317. {
  1318.   char peek;
  1319.   while (peek = d_peek_char (di),
  1320.          peek == 'B')
  1321.     {
  1322.       struct demangle_component *tag;
  1323.       d_advance (di, 1);
  1324.       tag = d_source_name (di);
  1325.       dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
  1326.     }
  1327.   return dc;
  1328. }
  1329.  
  1330. /* <name> ::= <nested-name>
  1331.           ::= <unscoped-name>
  1332.           ::= <unscoped-template-name> <template-args>
  1333.           ::= <local-name>
  1334.  
  1335.    <unscoped-name> ::= <unqualified-name>
  1336.                    ::= St <unqualified-name>
  1337.  
  1338.    <unscoped-template-name> ::= <unscoped-name>
  1339.                             ::= <substitution>
  1340. */
  1341.  
  1342. static struct demangle_component *
  1343. d_name (struct d_info *di)
  1344. {
  1345.   char peek = d_peek_char (di);
  1346.   struct demangle_component *dc;
  1347.  
  1348.   switch (peek)
  1349.     {
  1350.     case 'N':
  1351.       return d_nested_name (di);
  1352.  
  1353.     case 'Z':
  1354.       return d_local_name (di);
  1355.  
  1356.     case 'U':
  1357.       return d_unqualified_name (di);
  1358.  
  1359.     case 'S':
  1360.       {
  1361.         int subst;
  1362.  
  1363.         if (d_peek_next_char (di) != 't')
  1364.           {
  1365.             dc = d_substitution (di, 0);
  1366.             subst = 1;
  1367.           }
  1368.         else
  1369.           {
  1370.             d_advance (di, 2);
  1371.             dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
  1372.                               d_make_name (di, "std", 3),
  1373.                               d_unqualified_name (di));
  1374.             di->expansion += 3;
  1375.             subst = 0;
  1376.           }
  1377.  
  1378.         if (d_peek_char (di) != 'I')
  1379.           {
  1380.             /* The grammar does not permit this case to occur if we
  1381.                called d_substitution() above (i.e., subst == 1).  We
  1382.                don't bother to check.  */
  1383.           }
  1384.         else
  1385.           {
  1386.             /* This is <template-args>, which means that we just saw
  1387.                <unscoped-template-name>, which is a substitution
  1388.                candidate if we didn't just get it from a
  1389.                substitution.  */
  1390.             if (! subst)
  1391.               {
  1392.                 if (! d_add_substitution (di, dc))
  1393.                   return NULL;
  1394.               }
  1395.             dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
  1396.                               d_template_args (di));
  1397.           }
  1398.  
  1399.         return dc;
  1400.       }
  1401.  
  1402.     case 'L':
  1403.     default:
  1404.       dc = d_unqualified_name (di);
  1405.       if (d_peek_char (di) == 'I')
  1406.         {
  1407.           /* This is <template-args>, which means that we just saw
  1408.              <unscoped-template-name>, which is a substitution
  1409.              candidate.  */
  1410.           if (! d_add_substitution (di, dc))
  1411.             return NULL;
  1412.           dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
  1413.                             d_template_args (di));
  1414.         }
  1415.       return dc;
  1416.     }
  1417. }
  1418.  
  1419. /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
  1420.                  ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
  1421. */
  1422.  
  1423. static struct demangle_component *
  1424. d_nested_name (struct d_info *di)
  1425. {
  1426.   struct demangle_component *ret;
  1427.   struct demangle_component **pret;
  1428.   struct demangle_component *rqual;
  1429.  
  1430.   if (! d_check_char (di, 'N'))
  1431.     return NULL;
  1432.  
  1433.   pret = d_cv_qualifiers (di, &ret, 1);
  1434.   if (pret == NULL)
  1435.     return NULL;
  1436.  
  1437.   /* Parse the ref-qualifier now and then attach it
  1438.      once we have something to attach it to.  */
  1439.   rqual = d_ref_qualifier (di, NULL);
  1440.  
  1441.   *pret = d_prefix (di);
  1442.   if (*pret == NULL)
  1443.     return NULL;
  1444.  
  1445.   if (rqual)
  1446.     {
  1447.       d_left (rqual) = ret;
  1448.       ret = rqual;
  1449.     }
  1450.  
  1451.   if (! d_check_char (di, 'E'))
  1452.     return NULL;
  1453.  
  1454.   return ret;
  1455. }
  1456.  
  1457. /* <prefix> ::= <prefix> <unqualified-name>
  1458.             ::= <template-prefix> <template-args>
  1459.             ::= <template-param>
  1460.             ::= <decltype>
  1461.             ::=
  1462.             ::= <substitution>
  1463.  
  1464.    <template-prefix> ::= <prefix> <(template) unqualified-name>
  1465.                      ::= <template-param>
  1466.                      ::= <substitution>
  1467. */
  1468.  
  1469. static struct demangle_component *
  1470. d_prefix (struct d_info *di)
  1471. {
  1472.   struct demangle_component *ret = NULL;
  1473.  
  1474.   while (1)
  1475.     {
  1476.       char peek;
  1477.       enum demangle_component_type comb_type;
  1478.       struct demangle_component *dc;
  1479.  
  1480.       peek = d_peek_char (di);
  1481.       if (peek == '\0')
  1482.         return NULL;
  1483.  
  1484.       /* The older code accepts a <local-name> here, but I don't see
  1485.          that in the grammar.  The older code does not accept a
  1486.          <template-param> here.  */
  1487.  
  1488.       comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
  1489.       if (peek == 'D')
  1490.         {
  1491.           char peek2 = d_peek_next_char (di);
  1492.           if (peek2 == 'T' || peek2 == 't')
  1493.             /* Decltype.  */
  1494.             dc = cplus_demangle_type (di);
  1495.           else
  1496.             /* Destructor name.  */
  1497.             dc = d_unqualified_name (di);
  1498.         }
  1499.       else if (IS_DIGIT (peek)
  1500.           || IS_LOWER (peek)
  1501.           || peek == 'C'
  1502.           || peek == 'U'
  1503.           || peek == 'L')
  1504.         dc = d_unqualified_name (di);
  1505.       else if (peek == 'S')
  1506.         dc = d_substitution (di, 1);
  1507.       else if (peek == 'I')
  1508.         {
  1509.           if (ret == NULL)
  1510.             return NULL;
  1511.           comb_type = DEMANGLE_COMPONENT_TEMPLATE;
  1512.           dc = d_template_args (di);
  1513.         }
  1514.       else if (peek == 'T')
  1515.         dc = d_template_param (di);
  1516.       else if (peek == 'E')
  1517.         return ret;
  1518.       else if (peek == 'M')
  1519.         {
  1520.           /* Initializer scope for a lambda.  We don't need to represent
  1521.              this; the normal code will just treat the variable as a type
  1522.              scope, which gives appropriate output.  */
  1523.           if (ret == NULL)
  1524.             return NULL;
  1525.           d_advance (di, 1);
  1526.           continue;
  1527.         }
  1528.       else
  1529.         return NULL;
  1530.  
  1531.       if (ret == NULL)
  1532.         ret = dc;
  1533.       else
  1534.         ret = d_make_comp (di, comb_type, ret, dc);
  1535.  
  1536.       if (peek != 'S' && d_peek_char (di) != 'E')
  1537.         {
  1538.           if (! d_add_substitution (di, ret))
  1539.             return NULL;
  1540.         }
  1541.     }
  1542. }
  1543.  
  1544. /* <unqualified-name> ::= <operator-name>
  1545.                       ::= <ctor-dtor-name>
  1546.                       ::= <source-name>
  1547.                       ::= <local-source-name>
  1548.  
  1549.     <local-source-name> ::= L <source-name> <discriminator>
  1550. */
  1551.  
  1552. static struct demangle_component *
  1553. d_unqualified_name (struct d_info *di)
  1554. {
  1555.   struct demangle_component *ret;
  1556.   char peek;
  1557.  
  1558.   peek = d_peek_char (di);
  1559.   if (IS_DIGIT (peek))
  1560.     ret = d_source_name (di);
  1561.   else if (IS_LOWER (peek))
  1562.     {
  1563.       ret = d_operator_name (di);
  1564.       if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
  1565.         {
  1566.           di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
  1567.           if (!strcmp (ret->u.s_operator.op->code, "li"))
  1568.             ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
  1569.                                d_source_name (di));
  1570.         }
  1571.     }
  1572.   else if (peek == 'C' || peek == 'D')
  1573.     ret = d_ctor_dtor_name (di);
  1574.   else if (peek == 'L')
  1575.     {
  1576.       d_advance (di, 1);
  1577.  
  1578.       ret = d_source_name (di);
  1579.       if (ret == NULL)
  1580.         return NULL;
  1581.       if (! d_discriminator (di))
  1582.         return NULL;
  1583.     }
  1584.   else if (peek == 'U')
  1585.     {
  1586.       switch (d_peek_next_char (di))
  1587.         {
  1588.         case 'l':
  1589.           ret = d_lambda (di);
  1590.           break;
  1591.         case 't':
  1592.           ret = d_unnamed_type (di);
  1593.           break;
  1594.         default:
  1595.           return NULL;
  1596.         }
  1597.     }
  1598.   else
  1599.     return NULL;
  1600.  
  1601.   if (d_peek_char (di) == 'B')
  1602.     ret = d_abi_tags (di, ret);
  1603.   return ret;
  1604. }
  1605.  
  1606. /* <source-name> ::= <(positive length) number> <identifier>  */
  1607.  
  1608. static struct demangle_component *
  1609. d_source_name (struct d_info *di)
  1610. {
  1611.   int len;
  1612.   struct demangle_component *ret;
  1613.  
  1614.   len = d_number (di);
  1615.   if (len <= 0)
  1616.     return NULL;
  1617.   ret = d_identifier (di, len);
  1618.   di->last_name = ret;
  1619.   return ret;
  1620. }
  1621.  
  1622. /* number ::= [n] <(non-negative decimal integer)>  */
  1623.  
  1624. static int
  1625. d_number (struct d_info *di)
  1626. {
  1627.   int negative;
  1628.   char peek;
  1629.   int ret;
  1630.  
  1631.   negative = 0;
  1632.   peek = d_peek_char (di);
  1633.   if (peek == 'n')
  1634.     {
  1635.       negative = 1;
  1636.       d_advance (di, 1);
  1637.       peek = d_peek_char (di);
  1638.     }
  1639.  
  1640.   ret = 0;
  1641.   while (1)
  1642.     {
  1643.       if (! IS_DIGIT (peek))
  1644.         {
  1645.           if (negative)
  1646.             ret = - ret;
  1647.           return ret;
  1648.         }
  1649.       ret = ret * 10 + peek - '0';
  1650.       d_advance (di, 1);
  1651.       peek = d_peek_char (di);
  1652.     }
  1653. }
  1654.  
  1655. /* Like d_number, but returns a demangle_component.  */
  1656.  
  1657. static struct demangle_component *
  1658. d_number_component (struct d_info *di)
  1659. {
  1660.   struct demangle_component *ret = d_make_empty (di);
  1661.   if (ret)
  1662.     {
  1663.       ret->type = DEMANGLE_COMPONENT_NUMBER;
  1664.       ret->u.s_number.number = d_number (di);
  1665.     }
  1666.   return ret;
  1667. }
  1668.  
  1669. /* identifier ::= <(unqualified source code identifier)>  */
  1670.  
  1671. static struct demangle_component *
  1672. d_identifier (struct d_info *di, int len)
  1673. {
  1674.   const char *name;
  1675.  
  1676.   name = d_str (di);
  1677.  
  1678.   if (di->send - name < len)
  1679.     return NULL;
  1680.  
  1681.   d_advance (di, len);
  1682.  
  1683.   /* A Java mangled name may have a trailing '$' if it is a C++
  1684.      keyword.  This '$' is not included in the length count.  We just
  1685.      ignore the '$'.  */
  1686.   if ((di->options & DMGL_JAVA) != 0
  1687.       && d_peek_char (di) == '$')
  1688.     d_advance (di, 1);
  1689.  
  1690.   /* Look for something which looks like a gcc encoding of an
  1691.      anonymous namespace, and replace it with a more user friendly
  1692.      name.  */
  1693.   if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
  1694.       && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
  1695.                  ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
  1696.     {
  1697.       const char *s;
  1698.  
  1699.       s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
  1700.       if ((*s == '.' || *s == '_' || *s == '$')
  1701.           && s[1] == 'N')
  1702.         {
  1703.           di->expansion -= len - sizeof "(anonymous namespace)";
  1704.           return d_make_name (di, "(anonymous namespace)",
  1705.                               sizeof "(anonymous namespace)" - 1);
  1706.         }
  1707.     }
  1708.  
  1709.   return d_make_name (di, name, len);
  1710. }
  1711.  
  1712. /* operator_name ::= many different two character encodings.
  1713.                  ::= cv <type>
  1714.                  ::= v <digit> <source-name>
  1715.  
  1716.    This list is sorted for binary search.  */
  1717.  
  1718. #define NL(s) s, (sizeof s) - 1
  1719.  
  1720. CP_STATIC_IF_GLIBCPP_V3
  1721. const struct demangle_operator_info cplus_demangle_operators[] =
  1722. {
  1723.   { "aN", NL ("&="),        2 },
  1724.   { "aS", NL ("="),         2 },
  1725.   { "aa", NL ("&&"),        2 },
  1726.   { "ad", NL ("&"),         1 },
  1727.   { "an", NL ("&"),         2 },
  1728.   { "at", NL ("alignof "),   1 },
  1729.   { "az", NL ("alignof "),   1 },
  1730.   { "cc", NL ("const_cast"), 2 },
  1731.   { "cl", NL ("()"),        2 },
  1732.   { "cm", NL (","),         2 },
  1733.   { "co", NL ("~"),         1 },
  1734.   { "dV", NL ("/="),        2 },
  1735.   { "da", NL ("delete[] "), 1 },
  1736.   { "dc", NL ("dynamic_cast"), 2 },
  1737.   { "de", NL ("*"),         1 },
  1738.   { "dl", NL ("delete "),   1 },
  1739.   { "ds", NL (".*"),        2 },
  1740.   { "dt", NL ("."),         2 },
  1741.   { "dv", NL ("/"),         2 },
  1742.   { "eO", NL ("^="),        2 },
  1743.   { "eo", NL ("^"),         2 },
  1744.   { "eq", NL ("=="),        2 },
  1745.   { "ge", NL (">="),        2 },
  1746.   { "gs", NL ("::"),        1 },
  1747.   { "gt", NL (">"),         2 },
  1748.   { "ix", NL ("[]"),        2 },
  1749.   { "lS", NL ("<<="),       2 },
  1750.   { "le", NL ("<="),        2 },
  1751.   { "li", NL ("operator\"\" "), 1 },
  1752.   { "ls", NL ("<<"),        2 },
  1753.   { "lt", NL ("<"),         2 },
  1754.   { "mI", NL ("-="),        2 },
  1755.   { "mL", NL ("*="),        2 },
  1756.   { "mi", NL ("-"),         2 },
  1757.   { "ml", NL ("*"),         2 },
  1758.   { "mm", NL ("--"),        1 },
  1759.   { "na", NL ("new[]"),     3 },
  1760.   { "ne", NL ("!="),        2 },
  1761.   { "ng", NL ("-"),         1 },
  1762.   { "nt", NL ("!"),         1 },
  1763.   { "nw", NL ("new"),       3 },
  1764.   { "oR", NL ("|="),        2 },
  1765.   { "oo", NL ("||"),        2 },
  1766.   { "or", NL ("|"),         2 },
  1767.   { "pL", NL ("+="),        2 },
  1768.   { "pl", NL ("+"),         2 },
  1769.   { "pm", NL ("->*"),       2 },
  1770.   { "pp", NL ("++"),        1 },
  1771.   { "ps", NL ("+"),         1 },
  1772.   { "pt", NL ("->"),        2 },
  1773.   { "qu", NL ("?"),         3 },
  1774.   { "rM", NL ("%="),        2 },
  1775.   { "rS", NL (">>="),       2 },
  1776.   { "rc", NL ("reinterpret_cast"), 2 },
  1777.   { "rm", NL ("%"),         2 },
  1778.   { "rs", NL (">>"),        2 },
  1779.   { "sc", NL ("static_cast"), 2 },
  1780.   { "st", NL ("sizeof "),   1 },
  1781.   { "sz", NL ("sizeof "),   1 },
  1782.   { "tr", NL ("throw"),     0 },
  1783.   { "tw", NL ("throw "),    1 },
  1784.   { NULL, NULL, 0,          0 }
  1785. };
  1786.  
  1787. static struct demangle_component *
  1788. d_operator_name (struct d_info *di)
  1789. {
  1790.   char c1;
  1791.   char c2;
  1792.  
  1793.   c1 = d_next_char (di);
  1794.   c2 = d_next_char (di);
  1795.   if (c1 == 'v' && IS_DIGIT (c2))
  1796.     return d_make_extended_operator (di, c2 - '0', d_source_name (di));
  1797.   else if (c1 == 'c' && c2 == 'v')
  1798.     {
  1799.       struct demangle_component *type;
  1800.       int was_conversion = di->is_conversion;
  1801.       struct demangle_component *res;
  1802.  
  1803.       di->is_conversion = ! di->is_expression;
  1804.       type = cplus_demangle_type (di);
  1805.       if (di->is_conversion)
  1806.         res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
  1807.       else
  1808.         res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
  1809.       di->is_conversion = was_conversion;
  1810.       return res;
  1811.     }
  1812.   else
  1813.     {
  1814.       /* LOW is the inclusive lower bound.  */
  1815.       int low = 0;
  1816.       /* HIGH is the exclusive upper bound.  We subtract one to ignore
  1817.          the sentinel at the end of the array.  */
  1818.       int high = ((sizeof (cplus_demangle_operators)
  1819.                    / sizeof (cplus_demangle_operators[0]))
  1820.                   - 1);
  1821.  
  1822.       while (1)
  1823.         {
  1824.           int i;
  1825.           const struct demangle_operator_info *p;
  1826.  
  1827.           i = low + (high - low) / 2;
  1828.           p = cplus_demangle_operators + i;
  1829.  
  1830.           if (c1 == p->code[0] && c2 == p->code[1])
  1831.             return d_make_operator (di, p);
  1832.  
  1833.           if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
  1834.             high = i;
  1835.           else
  1836.             low = i + 1;
  1837.           if (low == high)
  1838.             return NULL;
  1839.         }
  1840.     }
  1841. }
  1842.  
  1843. static struct demangle_component *
  1844. d_make_character (struct d_info *di, int c)
  1845. {
  1846.   struct demangle_component *p;
  1847.   p = d_make_empty (di);
  1848.   if (p != NULL)
  1849.     {
  1850.       p->type = DEMANGLE_COMPONENT_CHARACTER;
  1851.       p->u.s_character.character = c;
  1852.     }
  1853.   return p;
  1854. }
  1855.  
  1856. static struct demangle_component *
  1857. d_java_resource (struct d_info *di)
  1858. {
  1859.   struct demangle_component *p = NULL;
  1860.   struct demangle_component *next = NULL;
  1861.   int len, i;
  1862.   char c;
  1863.   const char *str;
  1864.  
  1865.   len = d_number (di);
  1866.   if (len <= 1)
  1867.     return NULL;
  1868.  
  1869.   /* Eat the leading '_'.  */
  1870.   if (d_next_char (di) != '_')
  1871.     return NULL;
  1872.   len--;
  1873.  
  1874.   str = d_str (di);
  1875.   i = 0;
  1876.  
  1877.   while (len > 0)
  1878.     {
  1879.       c = str[i];
  1880.       if (!c)
  1881.         return NULL;
  1882.  
  1883.       /* Each chunk is either a '$' escape...  */
  1884.       if (c == '$')
  1885.         {
  1886.           i++;
  1887.           switch (str[i++])
  1888.             {
  1889.             case 'S':
  1890.               c = '/';
  1891.               break;
  1892.             case '_':
  1893.               c = '.';
  1894.               break;
  1895.             case '$':
  1896.               c = '$';
  1897.               break;
  1898.             default:
  1899.               return NULL;
  1900.             }
  1901.           next = d_make_character (di, c);
  1902.           d_advance (di, i);
  1903.           str = d_str (di);
  1904.           len -= i;
  1905.           i = 0;
  1906.           if (next == NULL)
  1907.             return NULL;
  1908.         }
  1909.       /* ... or a sequence of characters.  */
  1910.       else
  1911.         {
  1912.           while (i < len && str[i] && str[i] != '$')
  1913.             i++;
  1914.  
  1915.           next = d_make_name (di, str, i);
  1916.           d_advance (di, i);
  1917.           str = d_str (di);
  1918.           len -= i;
  1919.           i = 0;
  1920.           if (next == NULL)
  1921.             return NULL;
  1922.         }
  1923.  
  1924.       if (p == NULL)
  1925.         p = next;
  1926.       else
  1927.         {
  1928.           p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
  1929.           if (p == NULL)
  1930.             return NULL;
  1931.         }
  1932.     }
  1933.  
  1934.   p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
  1935.  
  1936.   return p;
  1937. }
  1938.  
  1939. /* <special-name> ::= TV <type>
  1940.                   ::= TT <type>
  1941.                   ::= TI <type>
  1942.                   ::= TS <type>
  1943.                   ::= GV <(object) name>
  1944.                   ::= T <call-offset> <(base) encoding>
  1945.                   ::= Tc <call-offset> <call-offset> <(base) encoding>
  1946.    Also g++ extensions:
  1947.                   ::= TC <type> <(offset) number> _ <(base) type>
  1948.                   ::= TF <type>
  1949.                   ::= TJ <type>
  1950.                   ::= GR <name>
  1951.                   ::= GA <encoding>
  1952.                   ::= Gr <resource name>
  1953.                   ::= GTt <encoding>
  1954.                   ::= GTn <encoding>
  1955. */
  1956.  
  1957. static struct demangle_component *
  1958. d_special_name (struct d_info *di)
  1959. {
  1960.   di->expansion += 20;
  1961.   if (d_check_char (di, 'T'))
  1962.     {
  1963.       switch (d_next_char (di))
  1964.         {
  1965.         case 'V':
  1966.           di->expansion -= 5;
  1967.           return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
  1968.                               cplus_demangle_type (di), NULL);
  1969.         case 'T':
  1970.           di->expansion -= 10;
  1971.           return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
  1972.                               cplus_demangle_type (di), NULL);
  1973.         case 'I':
  1974.           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
  1975.                               cplus_demangle_type (di), NULL);
  1976.         case 'S':
  1977.           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
  1978.                               cplus_demangle_type (di), NULL);
  1979.  
  1980.         case 'h':
  1981.           if (! d_call_offset (di, 'h'))
  1982.             return NULL;
  1983.           return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
  1984.                               d_encoding (di, 0), NULL);
  1985.  
  1986.         case 'v':
  1987.           if (! d_call_offset (di, 'v'))
  1988.             return NULL;
  1989.           return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
  1990.                               d_encoding (di, 0), NULL);
  1991.  
  1992.         case 'c':
  1993.           if (! d_call_offset (di, '\0'))
  1994.             return NULL;
  1995.           if (! d_call_offset (di, '\0'))
  1996.             return NULL;
  1997.           return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
  1998.                               d_encoding (di, 0), NULL);
  1999.  
  2000.         case 'C':
  2001.           {
  2002.             struct demangle_component *derived_type;
  2003.             int offset;
  2004.             struct demangle_component *base_type;
  2005.  
  2006.             derived_type = cplus_demangle_type (di);
  2007.             offset = d_number (di);
  2008.             if (offset < 0)
  2009.               return NULL;
  2010.             if (! d_check_char (di, '_'))
  2011.               return NULL;
  2012.             base_type = cplus_demangle_type (di);
  2013.             /* We don't display the offset.  FIXME: We should display
  2014.                it in verbose mode.  */
  2015.             di->expansion += 5;
  2016.             return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
  2017.                                 base_type, derived_type);
  2018.           }
  2019.  
  2020.         case 'F':
  2021.           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
  2022.                               cplus_demangle_type (di), NULL);
  2023.         case 'J':
  2024.           return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
  2025.                               cplus_demangle_type (di), NULL);
  2026.  
  2027.         case 'H':
  2028.           return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
  2029.                               d_name (di), NULL);
  2030.  
  2031.         case 'W':
  2032.           return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
  2033.                               d_name (di), NULL);
  2034.  
  2035.         default:
  2036.           return NULL;
  2037.         }
  2038.     }
  2039.   else if (d_check_char (di, 'G'))
  2040.     {
  2041.       switch (d_next_char (di))
  2042.         {
  2043.         case 'V':
  2044.           return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
  2045.  
  2046.         case 'R':
  2047.           {
  2048.             struct demangle_component *name = d_name (di);
  2049.             return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
  2050.                                 d_number_component (di));
  2051.           }
  2052.  
  2053.         case 'A':
  2054.           return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
  2055.                               d_encoding (di, 0), NULL);
  2056.  
  2057.         case 'T':
  2058.           switch (d_next_char (di))
  2059.             {
  2060.             case 'n':
  2061.               return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
  2062.                                   d_encoding (di, 0), NULL);
  2063.             default:
  2064.               /* ??? The proposal is that other letters (such as 'h') stand
  2065.                  for different variants of transaction cloning, such as
  2066.                  compiling directly for hardware transaction support.  But
  2067.                  they still should all be transactional clones of some sort
  2068.                  so go ahead and call them that.  */
  2069.             case 't':
  2070.               return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
  2071.                                   d_encoding (di, 0), NULL);
  2072.             }
  2073.  
  2074.         case 'r':
  2075.           return d_java_resource (di);
  2076.  
  2077.         default:
  2078.           return NULL;
  2079.         }
  2080.     }
  2081.   else
  2082.     return NULL;
  2083. }
  2084.  
  2085. /* <call-offset> ::= h <nv-offset> _
  2086.                  ::= v <v-offset> _
  2087.  
  2088.    <nv-offset> ::= <(offset) number>
  2089.  
  2090.    <v-offset> ::= <(offset) number> _ <(virtual offset) number>
  2091.  
  2092.    The C parameter, if not '\0', is a character we just read which is
  2093.    the start of the <call-offset>.
  2094.  
  2095.    We don't display the offset information anywhere.  FIXME: We should
  2096.    display it in verbose mode.  */
  2097.  
  2098. static int
  2099. d_call_offset (struct d_info *di, int c)
  2100. {
  2101.   if (c == '\0')
  2102.     c = d_next_char (di);
  2103.  
  2104.   if (c == 'h')
  2105.     d_number (di);
  2106.   else if (c == 'v')
  2107.     {
  2108.       d_number (di);
  2109.       if (! d_check_char (di, '_'))
  2110.         return 0;
  2111.       d_number (di);
  2112.     }
  2113.   else
  2114.     return 0;
  2115.  
  2116.   if (! d_check_char (di, '_'))
  2117.     return 0;
  2118.  
  2119.   return 1;
  2120. }
  2121.  
  2122. /* <ctor-dtor-name> ::= C1
  2123.                     ::= C2
  2124.                     ::= C3
  2125.                     ::= D0
  2126.                     ::= D1
  2127.                     ::= D2
  2128. */
  2129.  
  2130. static struct demangle_component *
  2131. d_ctor_dtor_name (struct d_info *di)
  2132. {
  2133.   if (di->last_name != NULL)
  2134.     {
  2135.       if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
  2136.         di->expansion += di->last_name->u.s_name.len;
  2137.       else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
  2138.         di->expansion += di->last_name->u.s_string.len;
  2139.     }
  2140.   switch (d_peek_char (di))
  2141.     {
  2142.     case 'C':
  2143.       {
  2144.         enum gnu_v3_ctor_kinds kind;
  2145.  
  2146.         switch (d_peek_next_char (di))
  2147.           {
  2148.           case '1':
  2149.             kind = gnu_v3_complete_object_ctor;
  2150.             break;
  2151.           case '2':
  2152.             kind = gnu_v3_base_object_ctor;
  2153.             break;
  2154.           case '3':
  2155.             kind = gnu_v3_complete_object_allocating_ctor;
  2156.             break;
  2157.           case '4':
  2158.             kind = gnu_v3_unified_ctor;
  2159.             break;
  2160.           case '5':
  2161.             kind = gnu_v3_object_ctor_group;
  2162.             break;
  2163.           default:
  2164.             return NULL;
  2165.           }
  2166.         d_advance (di, 2);
  2167.         return d_make_ctor (di, kind, di->last_name);
  2168.       }
  2169.  
  2170.     case 'D':
  2171.       {
  2172.         enum gnu_v3_dtor_kinds kind;
  2173.  
  2174.         switch (d_peek_next_char (di))
  2175.           {
  2176.           case '0':
  2177.             kind = gnu_v3_deleting_dtor;
  2178.             break;
  2179.           case '1':
  2180.             kind = gnu_v3_complete_object_dtor;
  2181.             break;
  2182.           case '2':
  2183.             kind = gnu_v3_base_object_dtor;
  2184.             break;
  2185.           /*  digit '3' is not used */
  2186.           case '4':
  2187.             kind = gnu_v3_unified_dtor;
  2188.             break;
  2189.           case '5':
  2190.             kind = gnu_v3_object_dtor_group;
  2191.             break;
  2192.           default:
  2193.             return NULL;
  2194.           }
  2195.         d_advance (di, 2);
  2196.         return d_make_dtor (di, kind, di->last_name);
  2197.       }
  2198.  
  2199.     default:
  2200.       return NULL;
  2201.     }
  2202. }
  2203.  
  2204. /* <type> ::= <builtin-type>
  2205.           ::= <function-type>
  2206.           ::= <class-enum-type>
  2207.           ::= <array-type>
  2208.           ::= <pointer-to-member-type>
  2209.           ::= <template-param>
  2210.           ::= <template-template-param> <template-args>
  2211.           ::= <substitution>
  2212.           ::= <CV-qualifiers> <type>
  2213.           ::= P <type>
  2214.           ::= R <type>
  2215.           ::= O <type> (C++0x)
  2216.           ::= C <type>
  2217.           ::= G <type>
  2218.           ::= U <source-name> <type>
  2219.  
  2220.    <builtin-type> ::= various one letter codes
  2221.                   ::= u <source-name>
  2222. */
  2223.  
  2224. CP_STATIC_IF_GLIBCPP_V3
  2225. const struct demangle_builtin_type_info
  2226. cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
  2227. {
  2228.   /* a */ { NL ("signed char"), NL ("signed char"),     D_PRINT_DEFAULT },
  2229.   /* b */ { NL ("bool"),        NL ("boolean"),         D_PRINT_BOOL },
  2230.   /* c */ { NL ("char"),        NL ("byte"),            D_PRINT_DEFAULT },
  2231.   /* d */ { NL ("double"),      NL ("double"),          D_PRINT_FLOAT },
  2232.   /* e */ { NL ("long double"), NL ("long double"),     D_PRINT_FLOAT },
  2233.   /* f */ { NL ("float"),       NL ("float"),           D_PRINT_FLOAT },
  2234.   /* g */ { NL ("__float128"),  NL ("__float128"),      D_PRINT_FLOAT },
  2235.   /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
  2236.   /* i */ { NL ("int"),         NL ("int"),             D_PRINT_INT },
  2237.   /* j */ { NL ("unsigned int"), NL ("unsigned"),       D_PRINT_UNSIGNED },
  2238.   /* k */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
  2239.   /* l */ { NL ("long"),        NL ("long"),            D_PRINT_LONG },
  2240.   /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
  2241.   /* n */ { NL ("__int128"),    NL ("__int128"),        D_PRINT_DEFAULT },
  2242.   /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
  2243.             D_PRINT_DEFAULT },
  2244.   /* p */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
  2245.   /* q */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
  2246.   /* r */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
  2247.   /* s */ { NL ("short"),       NL ("short"),           D_PRINT_DEFAULT },
  2248.   /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
  2249.   /* u */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
  2250.   /* v */ { NL ("void"),        NL ("void"),            D_PRINT_VOID },
  2251.   /* w */ { NL ("wchar_t"),     NL ("char"),            D_PRINT_DEFAULT },
  2252.   /* x */ { NL ("long long"),   NL ("long"),            D_PRINT_LONG_LONG },
  2253.   /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
  2254.             D_PRINT_UNSIGNED_LONG_LONG },
  2255.   /* z */ { NL ("..."),         NL ("..."),             D_PRINT_DEFAULT },
  2256.   /* 26 */ { NL ("decimal32"),  NL ("decimal32"),       D_PRINT_DEFAULT },
  2257.   /* 27 */ { NL ("decimal64"),  NL ("decimal64"),       D_PRINT_DEFAULT },
  2258.   /* 28 */ { NL ("decimal128"), NL ("decimal128"),      D_PRINT_DEFAULT },
  2259.   /* 29 */ { NL ("half"),       NL ("half"),            D_PRINT_FLOAT },
  2260.   /* 30 */ { NL ("char16_t"),   NL ("char16_t"),        D_PRINT_DEFAULT },
  2261.   /* 31 */ { NL ("char32_t"),   NL ("char32_t"),        D_PRINT_DEFAULT },
  2262.   /* 32 */ { NL ("decltype(nullptr)"),  NL ("decltype(nullptr)"),
  2263.              D_PRINT_DEFAULT },
  2264. };
  2265.  
  2266. CP_STATIC_IF_GLIBCPP_V3
  2267. struct demangle_component *
  2268. cplus_demangle_type (struct d_info *di)
  2269. {
  2270.   char peek;
  2271.   struct demangle_component *ret;
  2272.   int can_subst;
  2273.  
  2274.   /* The ABI specifies that when CV-qualifiers are used, the base type
  2275.      is substitutable, and the fully qualified type is substitutable,
  2276.      but the base type with a strict subset of the CV-qualifiers is
  2277.      not substitutable.  The natural recursive implementation of the
  2278.      CV-qualifiers would cause subsets to be substitutable, so instead
  2279.      we pull them all off now.
  2280.  
  2281.      FIXME: The ABI says that order-insensitive vendor qualifiers
  2282.      should be handled in the same way, but we have no way to tell
  2283.      which vendor qualifiers are order-insensitive and which are
  2284.      order-sensitive.  So we just assume that they are all
  2285.      order-sensitive.  g++ 3.4 supports only one vendor qualifier,
  2286.      __vector, and it treats it as order-sensitive when mangling
  2287.      names.  */
  2288.  
  2289.   peek = d_peek_char (di);
  2290.   if (peek == 'r' || peek == 'V' || peek == 'K')
  2291.     {
  2292.       struct demangle_component **pret;
  2293.  
  2294.       pret = d_cv_qualifiers (di, &ret, 0);
  2295.       if (pret == NULL)
  2296.         return NULL;
  2297.       if (d_peek_char (di) == 'F')
  2298.         {
  2299.           /* cv-qualifiers before a function type apply to 'this',
  2300.              so avoid adding the unqualified function type to
  2301.              the substitution list.  */
  2302.           *pret = d_function_type (di);
  2303.         }
  2304.       else
  2305.       *pret = cplus_demangle_type (di);
  2306.       if (!*pret)
  2307.         return NULL;
  2308.       if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
  2309.           || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
  2310.         {
  2311.           /* Move the ref-qualifier outside the cv-qualifiers so that
  2312.              they are printed in the right order.  */
  2313.           struct demangle_component *fn = d_left (*pret);
  2314.           d_left (*pret) = ret;
  2315.           ret = *pret;
  2316.           *pret = fn;
  2317.         }
  2318.       if (! d_add_substitution (di, ret))
  2319.         return NULL;
  2320.       return ret;
  2321.     }
  2322.  
  2323.   can_subst = 1;
  2324.  
  2325.   switch (peek)
  2326.     {
  2327.     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
  2328.     case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
  2329.     case 'o':                               case 's': case 't':
  2330.     case 'v': case 'w': case 'x': case 'y': case 'z':
  2331.       ret = d_make_builtin_type (di,
  2332.                                  &cplus_demangle_builtin_types[peek - 'a']);
  2333.       di->expansion += ret->u.s_builtin.type->len;
  2334.       can_subst = 0;
  2335.       d_advance (di, 1);
  2336.       break;
  2337.  
  2338.     case 'u':
  2339.       d_advance (di, 1);
  2340.       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
  2341.                          d_source_name (di), NULL);
  2342.       break;
  2343.  
  2344.     case 'F':
  2345.       ret = d_function_type (di);
  2346.       break;
  2347.  
  2348.     case '0': case '1': case '2': case '3': case '4':
  2349.     case '5': case '6': case '7': case '8': case '9':
  2350.     case 'N':
  2351.     case 'Z':
  2352.       ret = d_class_enum_type (di);
  2353.       break;
  2354.  
  2355.     case 'A':
  2356.       ret = d_array_type (di);
  2357.       break;
  2358.  
  2359.     case 'M':
  2360.       ret = d_pointer_to_member_type (di);
  2361.       break;
  2362.  
  2363.     case 'T':
  2364.       ret = d_template_param (di);
  2365.       if (d_peek_char (di) == 'I')
  2366.         {
  2367.           /* This may be <template-template-param> <template-args>.
  2368.              If this is the type for a conversion operator, we can
  2369.              have a <template-template-param> here only by following
  2370.              a derivation like this:
  2371.  
  2372.              <nested-name>
  2373.              -> <template-prefix> <template-args>
  2374.              -> <prefix> <template-unqualified-name> <template-args>
  2375.              -> <unqualified-name> <template-unqualified-name> <template-args>
  2376.              -> <source-name> <template-unqualified-name> <template-args>
  2377.              -> <source-name> <operator-name> <template-args>
  2378.              -> <source-name> cv <type> <template-args>
  2379.              -> <source-name> cv <template-template-param> <template-args> <template-args>
  2380.  
  2381.              where the <template-args> is followed by another.
  2382.              Otherwise, we must have a derivation like this:
  2383.  
  2384.              <nested-name>
  2385.              -> <template-prefix> <template-args>
  2386.              -> <prefix> <template-unqualified-name> <template-args>
  2387.              -> <unqualified-name> <template-unqualified-name> <template-args>
  2388.              -> <source-name> <template-unqualified-name> <template-args>
  2389.              -> <source-name> <operator-name> <template-args>
  2390.              -> <source-name> cv <type> <template-args>
  2391.              -> <source-name> cv <template-param> <template-args>
  2392.  
  2393.              where we need to leave the <template-args> to be processed
  2394.              by d_prefix (following the <template-prefix>).
  2395.  
  2396.              The <template-template-param> part is a substitution
  2397.              candidate.  */
  2398.           if (! di->is_conversion)
  2399.             {
  2400.           if (! d_add_substitution (di, ret))
  2401.             return NULL;
  2402.           ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
  2403.                              d_template_args (di));
  2404.         }
  2405.           else
  2406.             {
  2407.               struct demangle_component *args;
  2408.               struct d_info_checkpoint checkpoint;
  2409.  
  2410.               d_checkpoint (di, &checkpoint);
  2411.               args = d_template_args (di);
  2412.               if (d_peek_char (di) == 'I')
  2413.                 {
  2414.                   if (! d_add_substitution (di, ret))
  2415.                     return NULL;
  2416.                   ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
  2417.                                      args);
  2418.                 }
  2419.               else
  2420.                 d_backtrack (di, &checkpoint);
  2421.             }
  2422.         }
  2423.       break;
  2424.  
  2425.     case 'S':
  2426.       /* If this is a special substitution, then it is the start of
  2427.          <class-enum-type>.  */
  2428.       {
  2429.         char peek_next;
  2430.  
  2431.         peek_next = d_peek_next_char (di);
  2432.         if (IS_DIGIT (peek_next)
  2433.             || peek_next == '_'
  2434.             || IS_UPPER (peek_next))
  2435.           {
  2436.             ret = d_substitution (di, 0);
  2437.             /* The substituted name may have been a template name and
  2438.                may be followed by tepmlate args.  */
  2439.             if (d_peek_char (di) == 'I')
  2440.               ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
  2441.                                  d_template_args (di));
  2442.             else
  2443.               can_subst = 0;
  2444.           }
  2445.         else
  2446.           {
  2447.             ret = d_class_enum_type (di);
  2448.             /* If the substitution was a complete type, then it is not
  2449.                a new substitution candidate.  However, if the
  2450.                substitution was followed by template arguments, then
  2451.                the whole thing is a substitution candidate.  */
  2452.             if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
  2453.               can_subst = 0;
  2454.           }
  2455.       }
  2456.       break;
  2457.  
  2458.     case 'O':
  2459.       d_advance (di, 1);
  2460.       ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
  2461.                          cplus_demangle_type (di), NULL);
  2462.       break;
  2463.  
  2464.     case 'P':
  2465.       d_advance (di, 1);
  2466.       ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
  2467.                          cplus_demangle_type (di), NULL);
  2468.       break;
  2469.  
  2470.     case 'R':
  2471.       d_advance (di, 1);
  2472.       ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
  2473.                          cplus_demangle_type (di), NULL);
  2474.       break;
  2475.  
  2476.     case 'C':
  2477.       d_advance (di, 1);
  2478.       ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
  2479.                          cplus_demangle_type (di), NULL);
  2480.       break;
  2481.  
  2482.     case 'G':
  2483.       d_advance (di, 1);
  2484.       ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
  2485.                          cplus_demangle_type (di), NULL);
  2486.       break;
  2487.  
  2488.     case 'U':
  2489.       d_advance (di, 1);
  2490.       ret = d_source_name (di);
  2491.       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
  2492.                          cplus_demangle_type (di), ret);
  2493.       break;
  2494.  
  2495.     case 'D':
  2496.       can_subst = 0;
  2497.       d_advance (di, 1);
  2498.       peek = d_next_char (di);
  2499.       switch (peek)
  2500.         {
  2501.         case 'T':
  2502.         case 't':
  2503.           /* decltype (expression) */
  2504.           ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
  2505.                              d_expression (di), NULL);
  2506.           if (ret && d_next_char (di) != 'E')
  2507.             ret = NULL;
  2508.           can_subst = 1;
  2509.           break;
  2510.          
  2511.         case 'p':
  2512.           /* Pack expansion.  */
  2513.           ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
  2514.                              cplus_demangle_type (di), NULL);
  2515.           can_subst = 1;
  2516.           break;
  2517.  
  2518.         case 'a':
  2519.           /* auto */
  2520.           ret = d_make_name (di, "auto", 4);
  2521.           break;
  2522.          
  2523.         case 'f':
  2524.           /* 32-bit decimal floating point */
  2525.           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
  2526.           di->expansion += ret->u.s_builtin.type->len;
  2527.           break;
  2528.         case 'd':
  2529.           /* 64-bit DFP */
  2530.           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
  2531.           di->expansion += ret->u.s_builtin.type->len;
  2532.           break;
  2533.         case 'e':
  2534.           /* 128-bit DFP */
  2535.           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
  2536.           di->expansion += ret->u.s_builtin.type->len;
  2537.           break;
  2538.         case 'h':
  2539.           /* 16-bit half-precision FP */
  2540.           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
  2541.           di->expansion += ret->u.s_builtin.type->len;
  2542.           break;
  2543.         case 's':
  2544.           /* char16_t */
  2545.           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
  2546.           di->expansion += ret->u.s_builtin.type->len;
  2547.           break;
  2548.         case 'i':
  2549.           /* char32_t */
  2550.           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
  2551.           di->expansion += ret->u.s_builtin.type->len;
  2552.           break;
  2553.  
  2554.         case 'F':
  2555.           /* Fixed point types. DF<int bits><length><fract bits><sat>  */
  2556.           ret = d_make_empty (di);
  2557.           ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
  2558.           if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
  2559.             /* For demangling we don't care about the bits.  */
  2560.             d_number (di);
  2561.           ret->u.s_fixed.length = cplus_demangle_type (di);
  2562.           if (ret->u.s_fixed.length == NULL)
  2563.             return NULL;
  2564.           d_number (di);
  2565.           peek = d_next_char (di);
  2566.           ret->u.s_fixed.sat = (peek == 's');
  2567.           break;
  2568.  
  2569.         case 'v':
  2570.           ret = d_vector_type (di);
  2571.           can_subst = 1;
  2572.           break;
  2573.  
  2574.         case 'n':
  2575.           /* decltype(nullptr) */
  2576.           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
  2577.           di->expansion += ret->u.s_builtin.type->len;
  2578.           break;
  2579.  
  2580.         default:
  2581.           return NULL;
  2582.         }
  2583.       break;
  2584.  
  2585.     default:
  2586.       return NULL;
  2587.     }
  2588.  
  2589.   if (can_subst)
  2590.     {
  2591.       if (! d_add_substitution (di, ret))
  2592.         return NULL;
  2593.     }
  2594.  
  2595.   return ret;
  2596. }
  2597.  
  2598. /* <CV-qualifiers> ::= [r] [V] [K]  */
  2599.  
  2600. static struct demangle_component **
  2601. d_cv_qualifiers (struct d_info *di,
  2602.                  struct demangle_component **pret, int member_fn)
  2603. {
  2604.   struct demangle_component **pstart;
  2605.   char peek;
  2606.  
  2607.   pstart = pret;
  2608.   peek = d_peek_char (di);
  2609.   while (peek == 'r' || peek == 'V' || peek == 'K')
  2610.     {
  2611.       enum demangle_component_type t;
  2612.  
  2613.       d_advance (di, 1);
  2614.       if (peek == 'r')
  2615.         {
  2616.           t = (member_fn
  2617.                ? DEMANGLE_COMPONENT_RESTRICT_THIS
  2618.                : DEMANGLE_COMPONENT_RESTRICT);
  2619.           di->expansion += sizeof "restrict";
  2620.         }
  2621.       else if (peek == 'V')
  2622.         {
  2623.           t = (member_fn
  2624.                ? DEMANGLE_COMPONENT_VOLATILE_THIS
  2625.                : DEMANGLE_COMPONENT_VOLATILE);
  2626.           di->expansion += sizeof "volatile";
  2627.         }
  2628.       else
  2629.         {
  2630.           t = (member_fn
  2631.                ? DEMANGLE_COMPONENT_CONST_THIS
  2632.                : DEMANGLE_COMPONENT_CONST);
  2633.           di->expansion += sizeof "const";
  2634.         }
  2635.  
  2636.       *pret = d_make_comp (di, t, NULL, NULL);
  2637.       if (*pret == NULL)
  2638.         return NULL;
  2639.       pret = &d_left (*pret);
  2640.  
  2641.       peek = d_peek_char (di);
  2642.     }
  2643.  
  2644.   if (!member_fn && peek == 'F')
  2645.     {
  2646.       while (pstart != pret)
  2647.         {
  2648.           switch ((*pstart)->type)
  2649.             {
  2650.             case DEMANGLE_COMPONENT_RESTRICT:
  2651.               (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
  2652.               break;
  2653.             case DEMANGLE_COMPONENT_VOLATILE:
  2654.               (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
  2655.               break;
  2656.             case DEMANGLE_COMPONENT_CONST:
  2657.               (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
  2658.               break;
  2659.             default:
  2660.               break;
  2661.             }
  2662.           pstart = &d_left (*pstart);
  2663.         }
  2664.     }
  2665.  
  2666.   return pret;
  2667. }
  2668.  
  2669. /* <ref-qualifier> ::= R
  2670.                    ::= O */
  2671.  
  2672. static struct demangle_component *
  2673. d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
  2674. {
  2675.   struct demangle_component *ret = sub;
  2676.   char peek;
  2677.  
  2678.   peek = d_peek_char (di);
  2679.   if (peek == 'R' || peek == 'O')
  2680.     {
  2681.       enum demangle_component_type t;
  2682.       if (peek == 'R')
  2683.         {
  2684.           t = DEMANGLE_COMPONENT_REFERENCE_THIS;
  2685.           di->expansion += sizeof "&";
  2686.         }
  2687.       else
  2688.         {
  2689.           t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
  2690.           di->expansion += sizeof "&&";
  2691.         }
  2692.       d_advance (di, 1);
  2693.  
  2694.       ret = d_make_comp (di, t, ret, NULL);
  2695.     }
  2696.  
  2697.   return ret;
  2698. }
  2699.  
  2700. /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E  */
  2701.  
  2702. static struct demangle_component *
  2703. d_function_type (struct d_info *di)
  2704. {
  2705.   struct demangle_component *ret;
  2706.  
  2707.   if (! d_check_char (di, 'F'))
  2708.     return NULL;
  2709.   if (d_peek_char (di) == 'Y')
  2710.     {
  2711.       /* Function has C linkage.  We don't print this information.
  2712.          FIXME: We should print it in verbose mode.  */
  2713.       d_advance (di, 1);
  2714.     }
  2715.   ret = d_bare_function_type (di, 1);
  2716.   ret = d_ref_qualifier (di, ret);
  2717.  
  2718.   if (! d_check_char (di, 'E'))
  2719.     return NULL;
  2720.   return ret;
  2721. }
  2722.  
  2723. /* <type>+ */
  2724.  
  2725. static struct demangle_component *
  2726. d_parmlist (struct d_info *di)
  2727. {
  2728.   struct demangle_component *tl;
  2729.   struct demangle_component **ptl;
  2730.  
  2731.   tl = NULL;
  2732.   ptl = &tl;
  2733.   while (1)
  2734.     {
  2735.       struct demangle_component *type;
  2736.  
  2737.       char peek = d_peek_char (di);
  2738.       if (peek == '\0' || peek == 'E' || peek == '.')
  2739.         break;
  2740.       if ((peek == 'R' || peek == 'O')
  2741.           && d_peek_next_char (di) == 'E')
  2742.         /* Function ref-qualifier, not a ref prefix for a parameter type.  */
  2743.         break;
  2744.       type = cplus_demangle_type (di);
  2745.       if (type == NULL)
  2746.         return NULL;
  2747.       *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
  2748.       if (*ptl == NULL)
  2749.         return NULL;
  2750.       ptl = &d_right (*ptl);
  2751.     }
  2752.  
  2753.   /* There should be at least one parameter type besides the optional
  2754.      return type.  A function which takes no arguments will have a
  2755.      single parameter type void.  */
  2756.   if (tl == NULL)
  2757.     return NULL;
  2758.  
  2759.   /* If we have a single parameter type void, omit it.  */
  2760.   if (d_right (tl) == NULL
  2761.       && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
  2762.       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
  2763.     {
  2764.       di->expansion -= d_left (tl)->u.s_builtin.type->len;
  2765.       d_left (tl) = NULL;
  2766.     }
  2767.  
  2768.   return tl;
  2769. }
  2770.  
  2771. /* <bare-function-type> ::= [J]<type>+  */
  2772.  
  2773. static struct demangle_component *
  2774. d_bare_function_type (struct d_info *di, int has_return_type)
  2775. {
  2776.   struct demangle_component *return_type;
  2777.   struct demangle_component *tl;
  2778.   char peek;
  2779.  
  2780.   /* Detect special qualifier indicating that the first argument
  2781.      is the return type.  */
  2782.   peek = d_peek_char (di);
  2783.   if (peek == 'J')
  2784.     {
  2785.       d_advance (di, 1);
  2786.       has_return_type = 1;
  2787.     }
  2788.  
  2789.   if (has_return_type)
  2790.     {
  2791.       return_type = cplus_demangle_type (di);
  2792.       if (return_type == NULL)
  2793.         return NULL;
  2794.     }
  2795.   else
  2796.     return_type = NULL;
  2797.  
  2798.   tl = d_parmlist (di);
  2799.   if (tl == NULL)
  2800.     return NULL;
  2801.  
  2802.   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
  2803.                       return_type, tl);
  2804. }
  2805.  
  2806. /* <class-enum-type> ::= <name>  */
  2807.  
  2808. static struct demangle_component *
  2809. d_class_enum_type (struct d_info *di)
  2810. {
  2811.   return d_name (di);
  2812. }
  2813.  
  2814. /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
  2815.                 ::= A [<(dimension) expression>] _ <(element) type>
  2816. */
  2817.  
  2818. static struct demangle_component *
  2819. d_array_type (struct d_info *di)
  2820. {
  2821.   char peek;
  2822.   struct demangle_component *dim;
  2823.  
  2824.   if (! d_check_char (di, 'A'))
  2825.     return NULL;
  2826.  
  2827.   peek = d_peek_char (di);
  2828.   if (peek == '_')
  2829.     dim = NULL;
  2830.   else if (IS_DIGIT (peek))
  2831.     {
  2832.       const char *s;
  2833.  
  2834.       s = d_str (di);
  2835.       do
  2836.         {
  2837.           d_advance (di, 1);
  2838.           peek = d_peek_char (di);
  2839.         }
  2840.       while (IS_DIGIT (peek));
  2841.       dim = d_make_name (di, s, d_str (di) - s);
  2842.       if (dim == NULL)
  2843.         return NULL;
  2844.     }
  2845.   else
  2846.     {
  2847.       dim = d_expression (di);
  2848.       if (dim == NULL)
  2849.         return NULL;
  2850.     }
  2851.  
  2852.   if (! d_check_char (di, '_'))
  2853.     return NULL;
  2854.  
  2855.   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
  2856.                       cplus_demangle_type (di));
  2857. }
  2858.  
  2859. /* <vector-type> ::= Dv <number> _ <type>
  2860.                  ::= Dv _ <expression> _ <type> */
  2861.  
  2862. static struct demangle_component *
  2863. d_vector_type (struct d_info *di)
  2864. {
  2865.   char peek;
  2866.   struct demangle_component *dim;
  2867.  
  2868.   peek = d_peek_char (di);
  2869.   if (peek == '_')
  2870.     {
  2871.       d_advance (di, 1);
  2872.       dim = d_expression (di);
  2873.     }
  2874.   else
  2875.     dim = d_number_component (di);
  2876.  
  2877.   if (dim == NULL)
  2878.     return NULL;
  2879.  
  2880.   if (! d_check_char (di, '_'))
  2881.     return NULL;
  2882.  
  2883.   return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
  2884.                       cplus_demangle_type (di));
  2885. }
  2886.  
  2887. /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
  2888.  
  2889. static struct demangle_component *
  2890. d_pointer_to_member_type (struct d_info *di)
  2891. {
  2892.   struct demangle_component *cl;
  2893.   struct demangle_component *mem;
  2894.  
  2895.   if (! d_check_char (di, 'M'))
  2896.     return NULL;
  2897.  
  2898.   cl = cplus_demangle_type (di);
  2899.   if (cl == NULL)
  2900.     return NULL;
  2901.  
  2902.   /* The ABI says, "The type of a non-static member function is considered
  2903.      to be different, for the purposes of substitution, from the type of a
  2904.      namespace-scope or static member function whose type appears
  2905.      similar. The types of two non-static member functions are considered
  2906.      to be different, for the purposes of substitution, if the functions
  2907.      are members of different classes. In other words, for the purposes of
  2908.      substitution, the class of which the function is a member is
  2909.      considered part of the type of function."
  2910.  
  2911.      For a pointer to member function, this call to cplus_demangle_type
  2912.      will end up adding a (possibly qualified) non-member function type to
  2913.      the substitution table, which is not correct; however, the member
  2914.      function type will never be used in a substitution, so putting the
  2915.      wrong type in the substitution table is harmless.  */
  2916.  
  2917.   mem = cplus_demangle_type (di);
  2918.   if (mem == NULL)
  2919.     return NULL;
  2920.  
  2921.   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
  2922. }
  2923.  
  2924. /* <non-negative number> _ */
  2925.  
  2926. static int
  2927. d_compact_number (struct d_info *di)
  2928. {
  2929.   int num;
  2930.   if (d_peek_char (di) == '_')
  2931.     num = 0;
  2932.   else if (d_peek_char (di) == 'n')
  2933.     return -1;
  2934.   else
  2935.     num = d_number (di) + 1;
  2936.  
  2937.   if (num < 0 || ! d_check_char (di, '_'))
  2938.     return -1;
  2939.   return num;
  2940. }
  2941.  
  2942. /* <template-param> ::= T_
  2943.                     ::= T <(parameter-2 non-negative) number> _
  2944. */
  2945.  
  2946. static struct demangle_component *
  2947. d_template_param (struct d_info *di)
  2948. {
  2949.   int param;
  2950.  
  2951.   if (! d_check_char (di, 'T'))
  2952.     return NULL;
  2953.  
  2954.   param = d_compact_number (di);
  2955.   if (param < 0)
  2956.     return NULL;
  2957.  
  2958.   ++di->did_subs;
  2959.  
  2960.   return d_make_template_param (di, param);
  2961. }
  2962.  
  2963. /* <template-args> ::= I <template-arg>+ E  */
  2964.  
  2965. static struct demangle_component *
  2966. d_template_args (struct d_info *di)
  2967. {
  2968.   struct demangle_component *hold_last_name;
  2969.   struct demangle_component *al;
  2970.   struct demangle_component **pal;
  2971.  
  2972.   /* Preserve the last name we saw--don't let the template arguments
  2973.      clobber it, as that would give us the wrong name for a subsequent
  2974.      constructor or destructor.  */
  2975.   hold_last_name = di->last_name;
  2976.  
  2977.   if (d_peek_char (di) != 'I'
  2978.       && d_peek_char (di) != 'J')
  2979.     return NULL;
  2980.   d_advance (di, 1);
  2981.  
  2982.   if (d_peek_char (di) == 'E')
  2983.     {
  2984.       /* An argument pack can be empty.  */
  2985.       d_advance (di, 1);
  2986.       return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
  2987.     }
  2988.  
  2989.   al = NULL;
  2990.   pal = &al;
  2991.   while (1)
  2992.     {
  2993.       struct demangle_component *a;
  2994.  
  2995.       a = d_template_arg (di);
  2996.       if (a == NULL)
  2997.         return NULL;
  2998.  
  2999.       *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
  3000.       if (*pal == NULL)
  3001.         return NULL;
  3002.       pal = &d_right (*pal);
  3003.  
  3004.       if (d_peek_char (di) == 'E')
  3005.         {
  3006.           d_advance (di, 1);
  3007.           break;
  3008.         }
  3009.     }
  3010.  
  3011.   di->last_name = hold_last_name;
  3012.  
  3013.   return al;
  3014. }
  3015.  
  3016. /* <template-arg> ::= <type>
  3017.                   ::= X <expression> E
  3018.                   ::= <expr-primary>
  3019. */
  3020.  
  3021. static struct demangle_component *
  3022. d_template_arg (struct d_info *di)
  3023. {
  3024.   struct demangle_component *ret;
  3025.  
  3026.   switch (d_peek_char (di))
  3027.     {
  3028.     case 'X':
  3029.       d_advance (di, 1);
  3030.       ret = d_expression (di);
  3031.       if (! d_check_char (di, 'E'))
  3032.         return NULL;
  3033.       return ret;
  3034.  
  3035.     case 'L':
  3036.       return d_expr_primary (di);
  3037.  
  3038.     case 'I':
  3039.     case 'J':
  3040.       /* An argument pack.  */
  3041.       return d_template_args (di);
  3042.  
  3043.     default:
  3044.       return cplus_demangle_type (di);
  3045.     }
  3046. }
  3047.  
  3048. /* Parse a sequence of expressions until we hit the terminator
  3049.    character.  */
  3050.  
  3051. static struct demangle_component *
  3052. d_exprlist (struct d_info *di, char terminator)
  3053. {
  3054.   struct demangle_component *list = NULL;
  3055.   struct demangle_component **p = &list;
  3056.  
  3057.   if (d_peek_char (di) == terminator)
  3058.     {
  3059.       d_advance (di, 1);
  3060.       return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
  3061.     }
  3062.  
  3063.   while (1)
  3064.     {
  3065.       struct demangle_component *arg = d_expression (di);
  3066.       if (arg == NULL)
  3067.         return NULL;
  3068.  
  3069.       *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
  3070.       if (*p == NULL)
  3071.         return NULL;
  3072.       p = &d_right (*p);
  3073.  
  3074.       if (d_peek_char (di) == terminator)
  3075.         {
  3076.           d_advance (di, 1);
  3077.           break;
  3078.         }
  3079.     }
  3080.  
  3081.   return list;
  3082. }
  3083.  
  3084. /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
  3085.    dynamic_cast, static_cast or reinterpret_cast.  */
  3086.  
  3087. static int
  3088. op_is_new_cast (struct demangle_component *op)
  3089. {
  3090.   const char *code = op->u.s_operator.op->code;
  3091.   return (code[1] == 'c'
  3092.           && (code[0] == 's' || code[0] == 'd'
  3093.               || code[0] == 'c' || code[0] == 'r'));
  3094. }
  3095.  
  3096. /* <expression> ::= <(unary) operator-name> <expression>
  3097.                 ::= <(binary) operator-name> <expression> <expression>
  3098.                 ::= <(trinary) operator-name> <expression> <expression> <expression>
  3099.                 ::= cl <expression>+ E
  3100.                 ::= st <type>
  3101.                 ::= <template-param>
  3102.                 ::= sr <type> <unqualified-name>
  3103.                 ::= sr <type> <unqualified-name> <template-args>
  3104.                 ::= <expr-primary>
  3105. */
  3106.  
  3107. static inline struct demangle_component *
  3108. d_expression_1 (struct d_info *di)
  3109. {
  3110.   char peek;
  3111.  
  3112.   peek = d_peek_char (di);
  3113.   if (peek == 'L')
  3114.     return d_expr_primary (di);
  3115.   else if (peek == 'T')
  3116.     return d_template_param (di);
  3117.   else if (peek == 's' && d_peek_next_char (di) == 'r')
  3118.     {
  3119.       struct demangle_component *type;
  3120.       struct demangle_component *name;
  3121.  
  3122.       d_advance (di, 2);
  3123.       type = cplus_demangle_type (di);
  3124.       name = d_unqualified_name (di);
  3125.       if (d_peek_char (di) != 'I')
  3126.         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
  3127.       else
  3128.         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
  3129.                             d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
  3130.                                          d_template_args (di)));
  3131.     }
  3132.   else if (peek == 's' && d_peek_next_char (di) == 'p')
  3133.     {
  3134.       d_advance (di, 2);
  3135.       return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
  3136.                           d_expression_1 (di), NULL);
  3137.     }
  3138.   else if (peek == 'f' && d_peek_next_char (di) == 'p')
  3139.     {
  3140.       /* Function parameter used in a late-specified return type.  */
  3141.       int index;
  3142.       d_advance (di, 2);
  3143.       if (d_peek_char (di) == 'T')
  3144.         {
  3145.           /* 'this' parameter.  */
  3146.           d_advance (di, 1);
  3147.           index = 0;
  3148.         }
  3149.       else
  3150.         {
  3151.           index = d_compact_number (di);
  3152.           if (index == INT_MAX || index == -1)
  3153.             return NULL;
  3154.           index++;
  3155.         }
  3156.       return d_make_function_param (di, index);
  3157.     }
  3158.   else if (IS_DIGIT (peek)
  3159.            || (peek == 'o' && d_peek_next_char (di) == 'n'))
  3160.     {
  3161.       /* We can get an unqualified name as an expression in the case of
  3162.          a dependent function call, i.e. decltype(f(t)).  */
  3163.       struct demangle_component *name;
  3164.  
  3165.       if (peek == 'o')
  3166.         /* operator-function-id, i.e. operator+(t).  */
  3167.         d_advance (di, 2);
  3168.  
  3169.       name = d_unqualified_name (di);
  3170.       if (name == NULL)
  3171.         return NULL;
  3172.       if (d_peek_char (di) == 'I')
  3173.         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
  3174.                             d_template_args (di));
  3175.       else
  3176.         return name;
  3177.     }
  3178.   else if ((peek == 'i' || peek == 't')
  3179.            && d_peek_next_char (di) == 'l')
  3180.     {
  3181.       /* Brace-enclosed initializer list, untyped or typed.  */
  3182.       struct demangle_component *type = NULL;
  3183.       if (peek == 't')
  3184.         type = cplus_demangle_type (di);
  3185.       if (!d_peek_next_char (di))
  3186.         return NULL;
  3187.       d_advance (di, 2);
  3188.       return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
  3189.                           type, d_exprlist (di, 'E'));
  3190.     }
  3191.   else
  3192.     {
  3193.       struct demangle_component *op;
  3194.       const char *code = NULL;
  3195.       int args;
  3196.  
  3197.       op = d_operator_name (di);
  3198.       if (op == NULL)
  3199.         return NULL;
  3200.  
  3201.       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
  3202.         {
  3203.           code = op->u.s_operator.op->code;
  3204.           di->expansion += op->u.s_operator.op->len - 2;
  3205.           if (strcmp (code, "st") == 0)
  3206.             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
  3207.                                 cplus_demangle_type (di));
  3208.         }
  3209.  
  3210.       switch (op->type)
  3211.         {
  3212.         default:
  3213.           return NULL;
  3214.         case DEMANGLE_COMPONENT_OPERATOR:
  3215.           args = op->u.s_operator.op->args;
  3216.           break;
  3217.         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
  3218.           args = op->u.s_extended_operator.args;
  3219.           break;
  3220.         case DEMANGLE_COMPONENT_CAST:
  3221.           args = 1;
  3222.           break;
  3223.         }
  3224.  
  3225.       switch (args)
  3226.         {
  3227.         case 0:
  3228.           return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
  3229.  
  3230.         case 1:
  3231.           {
  3232.             struct demangle_component *operand;
  3233.             int suffix = 0;
  3234.  
  3235.             if (code && (code[0] == 'p' || code[0] == 'm')
  3236.                 && code[1] == code[0])
  3237.               /* pp_ and mm_ are the prefix variants.  */
  3238.               suffix = !d_check_char (di, '_');
  3239.  
  3240.             if (op->type == DEMANGLE_COMPONENT_CAST
  3241.                 && d_check_char (di, '_'))
  3242.               operand = d_exprlist (di, 'E');
  3243.             else
  3244.               operand = d_expression_1 (di);
  3245.  
  3246.             if (suffix)
  3247.               /* Indicate the suffix variant for d_print_comp.  */
  3248.               return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
  3249.                                   d_make_comp (di,
  3250.                                                DEMANGLE_COMPONENT_BINARY_ARGS,
  3251.                                                operand, operand));
  3252.             else
  3253.               return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
  3254.                                   operand);
  3255.           }
  3256.         case 2:
  3257.           {
  3258.             struct demangle_component *left;
  3259.             struct demangle_component *right;
  3260.  
  3261.             if (code == NULL)
  3262.               return NULL;
  3263.             if (op_is_new_cast (op))
  3264.               left = cplus_demangle_type (di);
  3265.             else
  3266.               left = d_expression_1 (di);
  3267.             if (!strcmp (code, "cl"))
  3268.               right = d_exprlist (di, 'E');
  3269.             else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
  3270.               {
  3271.                 right = d_unqualified_name (di);
  3272.                 if (d_peek_char (di) == 'I')
  3273.                   right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
  3274.                                        right, d_template_args (di));
  3275.               }
  3276.             else
  3277.               right = d_expression_1 (di);
  3278.  
  3279.             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
  3280.                                 d_make_comp (di,
  3281.                                              DEMANGLE_COMPONENT_BINARY_ARGS,
  3282.                                              left, right));
  3283.           }
  3284.         case 3:
  3285.           {
  3286.             struct demangle_component *first;
  3287.             struct demangle_component *second;
  3288.             struct demangle_component *third;
  3289.  
  3290.             if (code == NULL)
  3291.               return NULL;
  3292.             else if (!strcmp (code, "qu"))
  3293.               {
  3294.                 /* ?: expression.  */
  3295.                 first = d_expression_1 (di);
  3296.                 second = d_expression_1 (di);
  3297.                 third = d_expression_1 (di);
  3298.               }
  3299.             else if (code[0] == 'n')
  3300.               {
  3301.                 /* new-expression.  */
  3302.                 if (code[1] != 'w' && code[1] != 'a')
  3303.                   return NULL;
  3304.                 first = d_exprlist (di, '_');
  3305.                 second = cplus_demangle_type (di);
  3306.                 if (d_peek_char (di) == 'E')
  3307.                   {
  3308.                     d_advance (di, 1);
  3309.                     third = NULL;
  3310.                   }
  3311.                 else if (d_peek_char (di) == 'p'
  3312.                          && d_peek_next_char (di) == 'i')
  3313.                   {
  3314.                     /* Parenthesized initializer.  */
  3315.                     d_advance (di, 2);
  3316.                     third = d_exprlist (di, 'E');
  3317.                   }
  3318.                 else if (d_peek_char (di) == 'i'
  3319.                          && d_peek_next_char (di) == 'l')
  3320.                   /* initializer-list.  */
  3321.                   third = d_expression_1 (di);
  3322.                 else
  3323.                   return NULL;
  3324.               }
  3325.             else
  3326.               return NULL;
  3327.             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
  3328.                                 d_make_comp (di,
  3329.                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
  3330.                                              first,
  3331.                                              d_make_comp (di,
  3332.                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
  3333.                                                           second, third)));
  3334.           }
  3335.         default:
  3336.           return NULL;
  3337.         }
  3338.     }
  3339. }
  3340.  
  3341. static struct demangle_component *
  3342. d_expression (struct d_info *di)
  3343. {
  3344.   struct demangle_component *ret;
  3345.   int was_expression = di->is_expression;
  3346.  
  3347.   di->is_expression = 1;
  3348.   ret = d_expression_1 (di);
  3349.   di->is_expression = was_expression;
  3350.   return ret;
  3351. }
  3352.  
  3353. /* <expr-primary> ::= L <type> <(value) number> E
  3354.                   ::= L <type> <(value) float> E
  3355.                   ::= L <mangled-name> E
  3356. */
  3357.  
  3358. static struct demangle_component *
  3359. d_expr_primary (struct d_info *di)
  3360. {
  3361.   struct demangle_component *ret;
  3362.  
  3363.   if (! d_check_char (di, 'L'))
  3364.     return NULL;
  3365.   if (d_peek_char (di) == '_'
  3366.       /* Workaround for G++ bug; see comment in write_template_arg.  */
  3367.       || d_peek_char (di) == 'Z')
  3368.     ret = cplus_demangle_mangled_name (di, 0);
  3369.   else
  3370.     {
  3371.       struct demangle_component *type;
  3372.       enum demangle_component_type t;
  3373.       const char *s;
  3374.  
  3375.       type = cplus_demangle_type (di);
  3376.       if (type == NULL)
  3377.         return NULL;
  3378.  
  3379.       /* If we have a type we know how to print, we aren't going to
  3380.          print the type name itself.  */
  3381.       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
  3382.           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
  3383.         di->expansion -= type->u.s_builtin.type->len;
  3384.  
  3385.       /* Rather than try to interpret the literal value, we just
  3386.          collect it as a string.  Note that it's possible to have a
  3387.          floating point literal here.  The ABI specifies that the
  3388.          format of such literals is machine independent.  That's fine,
  3389.          but what's not fine is that versions of g++ up to 3.2 with
  3390.          -fabi-version=1 used upper case letters in the hex constant,
  3391.          and dumped out gcc's internal representation.  That makes it
  3392.          hard to tell where the constant ends, and hard to dump the
  3393.          constant in any readable form anyhow.  We don't attempt to
  3394.          handle these cases.  */
  3395.  
  3396.       t = DEMANGLE_COMPONENT_LITERAL;
  3397.       if (d_peek_char (di) == 'n')
  3398.         {
  3399.           t = DEMANGLE_COMPONENT_LITERAL_NEG;
  3400.           d_advance (di, 1);
  3401.         }
  3402.       s = d_str (di);
  3403.       while (d_peek_char (di) != 'E')
  3404.         {
  3405.           if (d_peek_char (di) == '\0')
  3406.             return NULL;
  3407.           d_advance (di, 1);
  3408.         }
  3409.       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
  3410.     }
  3411.   if (! d_check_char (di, 'E'))
  3412.     return NULL;
  3413.   return ret;
  3414. }
  3415.  
  3416. /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
  3417.                 ::= Z <(function) encoding> E s [<discriminator>]
  3418.                 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
  3419. */
  3420.  
  3421. static struct demangle_component *
  3422. d_local_name (struct d_info *di)
  3423. {
  3424.   struct demangle_component *function;
  3425.  
  3426.   if (! d_check_char (di, 'Z'))
  3427.     return NULL;
  3428.  
  3429.   function = d_encoding (di, 0);
  3430.  
  3431.   if (! d_check_char (di, 'E'))
  3432.     return NULL;
  3433.  
  3434.   if (d_peek_char (di) == 's')
  3435.     {
  3436.       d_advance (di, 1);
  3437.       if (! d_discriminator (di))
  3438.         return NULL;
  3439.       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
  3440.                           d_make_name (di, "string literal",
  3441.                                        sizeof "string literal" - 1));
  3442.     }
  3443.   else
  3444.     {
  3445.       struct demangle_component *name;
  3446.       int num = -1;
  3447.  
  3448.       if (d_peek_char (di) == 'd')
  3449.         {
  3450.           /* Default argument scope: d <number> _.  */
  3451.           d_advance (di, 1);
  3452.           num = d_compact_number (di);
  3453.           if (num < 0)
  3454.             return NULL;
  3455.         }
  3456.  
  3457.       name = d_name (di);
  3458.       if (name)
  3459.         switch (name->type)
  3460.           {
  3461.             /* Lambdas and unnamed types have internal discriminators.  */
  3462.           case DEMANGLE_COMPONENT_LAMBDA:
  3463.           case DEMANGLE_COMPONENT_UNNAMED_TYPE:
  3464.             break;
  3465.           default:
  3466.             if (! d_discriminator (di))
  3467.               return NULL;
  3468.           }
  3469.       if (num >= 0)
  3470.         name = d_make_default_arg (di, num, name);
  3471.       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
  3472.     }
  3473. }
  3474.  
  3475. /* <discriminator> ::= _ <(non-negative) number>
  3476.  
  3477.    We demangle the discriminator, but we don't print it out.  FIXME:
  3478.    We should print it out in verbose mode.  */
  3479.  
  3480. static int
  3481. d_discriminator (struct d_info *di)
  3482. {
  3483.   int discrim;
  3484.  
  3485.   if (d_peek_char (di) != '_')
  3486.     return 1;
  3487.   d_advance (di, 1);
  3488.   discrim = d_number (di);
  3489.   if (discrim < 0)
  3490.     return 0;
  3491.   return 1;
  3492. }
  3493.  
  3494. /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
  3495.  
  3496. static struct demangle_component *
  3497. d_lambda (struct d_info *di)
  3498. {
  3499.   struct demangle_component *tl;
  3500.   struct demangle_component *ret;
  3501.   int num;
  3502.  
  3503.   if (! d_check_char (di, 'U'))
  3504.     return NULL;
  3505.   if (! d_check_char (di, 'l'))
  3506.     return NULL;
  3507.  
  3508.   tl = d_parmlist (di);
  3509.   if (tl == NULL)
  3510.     return NULL;
  3511.  
  3512.   if (! d_check_char (di, 'E'))
  3513.     return NULL;
  3514.  
  3515.   num = d_compact_number (di);
  3516.   if (num < 0)
  3517.     return NULL;
  3518.  
  3519.   ret = d_make_empty (di);
  3520.   if (ret)
  3521.     {
  3522.       ret->type = DEMANGLE_COMPONENT_LAMBDA;
  3523.       ret->u.s_unary_num.sub = tl;
  3524.       ret->u.s_unary_num.num = num;
  3525.     }
  3526.  
  3527.   if (! d_add_substitution (di, ret))
  3528.     return NULL;
  3529.  
  3530.   return ret;
  3531. }
  3532.  
  3533. /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
  3534.  
  3535. static struct demangle_component *
  3536. d_unnamed_type (struct d_info *di)
  3537. {
  3538.   struct demangle_component *ret;
  3539.   int num;
  3540.  
  3541.   if (! d_check_char (di, 'U'))
  3542.     return NULL;
  3543.   if (! d_check_char (di, 't'))
  3544.     return NULL;
  3545.  
  3546.   num = d_compact_number (di);
  3547.   if (num < 0)
  3548.     return NULL;
  3549.  
  3550.   ret = d_make_empty (di);
  3551.   if (ret)
  3552.     {
  3553.       ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
  3554.       ret->u.s_number.number = num;
  3555.     }
  3556.  
  3557.   if (! d_add_substitution (di, ret))
  3558.     return NULL;
  3559.  
  3560.   return ret;
  3561. }
  3562.  
  3563. /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
  3564. */
  3565.  
  3566. static struct demangle_component *
  3567. d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
  3568. {
  3569.   const char *suffix = d_str (di);
  3570.   const char *pend = suffix;
  3571.   struct demangle_component *n;
  3572.  
  3573.   if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
  3574.     {
  3575.       pend += 2;
  3576.       while (IS_LOWER (*pend) || *pend == '_')
  3577.         ++pend;
  3578.     }
  3579.   while (*pend == '.' && IS_DIGIT (pend[1]))
  3580.     {
  3581.       pend += 2;
  3582.       while (IS_DIGIT (*pend))
  3583.         ++pend;
  3584.     }
  3585.   d_advance (di, pend - suffix);
  3586.   n = d_make_name (di, suffix, pend - suffix);
  3587.   return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
  3588. }
  3589.  
  3590. /* Add a new substitution.  */
  3591.  
  3592. static int
  3593. d_add_substitution (struct d_info *di, struct demangle_component *dc)
  3594. {
  3595.   if (dc == NULL)
  3596.     return 0;
  3597.   if (di->next_sub >= di->num_subs)
  3598.     return 0;
  3599.   di->subs[di->next_sub] = dc;
  3600.   ++di->next_sub;
  3601.   return 1;
  3602. }
  3603.  
  3604. /* <substitution> ::= S <seq-id> _
  3605.                   ::= S_
  3606.                   ::= St
  3607.                   ::= Sa
  3608.                   ::= Sb
  3609.                   ::= Ss
  3610.                   ::= Si
  3611.                   ::= So
  3612.                   ::= Sd
  3613.  
  3614.    If PREFIX is non-zero, then this type is being used as a prefix in
  3615.    a qualified name.  In this case, for the standard substitutions, we
  3616.    need to check whether we are being used as a prefix for a
  3617.    constructor or destructor, and return a full template name.
  3618.    Otherwise we will get something like std::iostream::~iostream()
  3619.    which does not correspond particularly well to any function which
  3620.    actually appears in the source.
  3621. */
  3622.  
  3623. static const struct d_standard_sub_info standard_subs[] =
  3624. {
  3625.   { 't', NL ("std"),
  3626.     NL ("std"),
  3627.     NULL, 0 },
  3628.   { 'a', NL ("std::allocator"),
  3629.     NL ("std::allocator"),
  3630.     NL ("allocator") },
  3631.   { 'b', NL ("std::basic_string"),
  3632.     NL ("std::basic_string"),
  3633.     NL ("basic_string") },
  3634.   { 's', NL ("std::string"),
  3635.     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
  3636.     NL ("basic_string") },
  3637.   { 'i', NL ("std::istream"),
  3638.     NL ("std::basic_istream<char, std::char_traits<char> >"),
  3639.     NL ("basic_istream") },
  3640.   { 'o', NL ("std::ostream"),
  3641.     NL ("std::basic_ostream<char, std::char_traits<char> >"),
  3642.     NL ("basic_ostream") },
  3643.   { 'd', NL ("std::iostream"),
  3644.     NL ("std::basic_iostream<char, std::char_traits<char> >"),
  3645.     NL ("basic_iostream") }
  3646. };
  3647.  
  3648. static struct demangle_component *
  3649. d_substitution (struct d_info *di, int prefix)
  3650. {
  3651.   char c;
  3652.  
  3653.   if (! d_check_char (di, 'S'))
  3654.     return NULL;
  3655.  
  3656.   c = d_next_char (di);
  3657.   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
  3658.     {
  3659.       unsigned int id;
  3660.  
  3661.       id = 0;
  3662.       if (c != '_')
  3663.         {
  3664.           do
  3665.             {
  3666.               unsigned int new_id;
  3667.  
  3668.               if (IS_DIGIT (c))
  3669.                 new_id = id * 36 + c - '0';
  3670.               else if (IS_UPPER (c))
  3671.                 new_id = id * 36 + c - 'A' + 10;
  3672.               else
  3673.                 return NULL;
  3674.               if (new_id < id)
  3675.                 return NULL;
  3676.               id = new_id;
  3677.               c = d_next_char (di);
  3678.             }
  3679.           while (c != '_');
  3680.  
  3681.           ++id;
  3682.         }
  3683.  
  3684.       if (id >= (unsigned int) di->next_sub)
  3685.         return NULL;
  3686.  
  3687.       ++di->did_subs;
  3688.  
  3689.       return di->subs[id];
  3690.     }
  3691.   else
  3692.     {
  3693.       int verbose;
  3694.       const struct d_standard_sub_info *p;
  3695.       const struct d_standard_sub_info *pend;
  3696.  
  3697.       verbose = (di->options & DMGL_VERBOSE) != 0;
  3698.       if (! verbose && prefix)
  3699.         {
  3700.           char peek;
  3701.  
  3702.           peek = d_peek_char (di);
  3703.           if (peek == 'C' || peek == 'D')
  3704.             verbose = 1;
  3705.         }
  3706.  
  3707.       pend = (&standard_subs[0]
  3708.               + sizeof standard_subs / sizeof standard_subs[0]);
  3709.       for (p = &standard_subs[0]; p < pend; ++p)
  3710.         {
  3711.           if (c == p->code)
  3712.             {
  3713.               const char *s;
  3714.               int len;
  3715.               struct demangle_component *c;
  3716.  
  3717.               if (p->set_last_name != NULL)
  3718.                 di->last_name = d_make_sub (di, p->set_last_name,
  3719.                                             p->set_last_name_len);
  3720.               if (verbose)
  3721.                 {
  3722.                   s = p->full_expansion;
  3723.                   len = p->full_len;
  3724.                 }
  3725.               else
  3726.                 {
  3727.                   s = p->simple_expansion;
  3728.                   len = p->simple_len;
  3729.                 }
  3730.               di->expansion += len;
  3731.               c = d_make_sub (di, s, len);
  3732.               if (d_peek_char (di) == 'B')
  3733.                 {
  3734.                   /* If there are ABI tags on the abbreviation, it becomes
  3735.                      a substitution candidate.  */
  3736.                   c = d_abi_tags (di, c);
  3737.                   d_add_substitution (di, c);
  3738.                 }
  3739.               return c;
  3740.             }
  3741.         }
  3742.  
  3743.       return NULL;
  3744.     }
  3745. }
  3746.  
  3747. static void
  3748. d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
  3749. {
  3750.   checkpoint->n = di->n;
  3751.   checkpoint->next_comp = di->next_comp;
  3752.   checkpoint->next_sub = di->next_sub;
  3753.   checkpoint->did_subs = di->did_subs;
  3754.   checkpoint->expansion = di->expansion;
  3755. }
  3756.  
  3757. static void
  3758. d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
  3759. {
  3760.   di->n = checkpoint->n;
  3761.   di->next_comp = checkpoint->next_comp;
  3762.   di->next_sub = checkpoint->next_sub;
  3763.   di->did_subs = checkpoint->did_subs;
  3764.   di->expansion = checkpoint->expansion;
  3765. }
  3766.  
  3767. /* Initialize a growable string.  */
  3768.  
  3769. static void
  3770. d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
  3771. {
  3772.   dgs->buf = NULL;
  3773.   dgs->len = 0;
  3774.   dgs->alc = 0;
  3775.   dgs->allocation_failure = 0;
  3776.  
  3777.   if (estimate > 0)
  3778.     d_growable_string_resize (dgs, estimate);
  3779. }
  3780.  
  3781. /* Grow a growable string to a given size.  */
  3782.  
  3783. static inline void
  3784. d_growable_string_resize (struct d_growable_string *dgs, size_t need)
  3785. {
  3786.   size_t newalc;
  3787.   char *newbuf;
  3788.  
  3789.   if (dgs->allocation_failure)
  3790.     return;
  3791.  
  3792.   /* Start allocation at two bytes to avoid any possibility of confusion
  3793.      with the special value of 1 used as a return in *palc to indicate
  3794.      allocation failures.  */
  3795.   newalc = dgs->alc > 0 ? dgs->alc : 2;
  3796.   while (newalc < need)
  3797.     newalc <<= 1;
  3798.  
  3799.   newbuf = (char *) realloc (dgs->buf, newalc);
  3800.   if (newbuf == NULL)
  3801.     {
  3802.       free (dgs->buf);
  3803.       dgs->buf = NULL;
  3804.       dgs->len = 0;
  3805.       dgs->alc = 0;
  3806.       dgs->allocation_failure = 1;
  3807.       return;
  3808.     }
  3809.   dgs->buf = newbuf;
  3810.   dgs->alc = newalc;
  3811. }
  3812.  
  3813. /* Append a buffer to a growable string.  */
  3814.  
  3815. static inline void
  3816. d_growable_string_append_buffer (struct d_growable_string *dgs,
  3817.                                  const char *s, size_t l)
  3818. {
  3819.   size_t need;
  3820.  
  3821.   need = dgs->len + l + 1;
  3822.   if (need > dgs->alc)
  3823.     d_growable_string_resize (dgs, need);
  3824.  
  3825.   if (dgs->allocation_failure)
  3826.     return;
  3827.  
  3828.   memcpy (dgs->buf + dgs->len, s, l);
  3829.   dgs->buf[dgs->len + l] = '\0';
  3830.   dgs->len += l;
  3831. }
  3832.  
  3833. /* Bridge growable strings to the callback mechanism.  */
  3834.  
  3835. static void
  3836. d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
  3837. {
  3838.   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
  3839.  
  3840.   d_growable_string_append_buffer (dgs, s, l);
  3841. }
  3842.  
  3843. /* Walk the tree, counting the number of templates encountered, and
  3844.    the number of times a scope might be saved.  These counts will be
  3845.    used to allocate data structures for d_print_comp, so the logic
  3846.    here must mirror the logic d_print_comp will use.  It is not
  3847.    important that the resulting numbers are exact, so long as they
  3848.    are larger than the actual numbers encountered.  */
  3849.  
  3850. static void
  3851. d_count_templates_scopes (int *num_templates, int *num_scopes,
  3852.                           const struct demangle_component *dc)
  3853. {
  3854.   if (dc == NULL)
  3855.     return;
  3856.  
  3857.   switch (dc->type)
  3858.     {
  3859.     case DEMANGLE_COMPONENT_NAME:
  3860.     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
  3861.     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
  3862.     case DEMANGLE_COMPONENT_SUB_STD:
  3863.     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
  3864.     case DEMANGLE_COMPONENT_OPERATOR:
  3865.     case DEMANGLE_COMPONENT_CHARACTER:
  3866.     case DEMANGLE_COMPONENT_NUMBER:
  3867.     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
  3868.       break;
  3869.  
  3870.     case DEMANGLE_COMPONENT_TEMPLATE:
  3871.       (*num_templates)++;
  3872.       goto recurse_left_right;
  3873.  
  3874.     case DEMANGLE_COMPONENT_REFERENCE:
  3875.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
  3876.       if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
  3877.         (*num_scopes)++;
  3878.       goto recurse_left_right;
  3879.  
  3880.     case DEMANGLE_COMPONENT_QUAL_NAME:
  3881.     case DEMANGLE_COMPONENT_LOCAL_NAME:
  3882.     case DEMANGLE_COMPONENT_TYPED_NAME:
  3883.     case DEMANGLE_COMPONENT_VTABLE:
  3884.     case DEMANGLE_COMPONENT_VTT:
  3885.     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
  3886.     case DEMANGLE_COMPONENT_TYPEINFO:
  3887.     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
  3888.     case DEMANGLE_COMPONENT_TYPEINFO_FN:
  3889.     case DEMANGLE_COMPONENT_THUNK:
  3890.     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
  3891.     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
  3892.     case DEMANGLE_COMPONENT_JAVA_CLASS:
  3893.     case DEMANGLE_COMPONENT_GUARD:
  3894.     case DEMANGLE_COMPONENT_TLS_INIT:
  3895.     case DEMANGLE_COMPONENT_TLS_WRAPPER:
  3896.     case DEMANGLE_COMPONENT_REFTEMP:
  3897.     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
  3898.     case DEMANGLE_COMPONENT_RESTRICT:
  3899.     case DEMANGLE_COMPONENT_VOLATILE:
  3900.     case DEMANGLE_COMPONENT_CONST:
  3901.     case DEMANGLE_COMPONENT_RESTRICT_THIS:
  3902.     case DEMANGLE_COMPONENT_VOLATILE_THIS:
  3903.     case DEMANGLE_COMPONENT_CONST_THIS:
  3904.     case DEMANGLE_COMPONENT_REFERENCE_THIS:
  3905.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  3906.     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  3907.     case DEMANGLE_COMPONENT_POINTER:
  3908.     case DEMANGLE_COMPONENT_COMPLEX:
  3909.     case DEMANGLE_COMPONENT_IMAGINARY:
  3910.     case DEMANGLE_COMPONENT_VENDOR_TYPE:
  3911.     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
  3912.     case DEMANGLE_COMPONENT_ARRAY_TYPE:
  3913.     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  3914.     case DEMANGLE_COMPONENT_VECTOR_TYPE:
  3915.     case DEMANGLE_COMPONENT_ARGLIST:
  3916.     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
  3917.     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
  3918.     case DEMANGLE_COMPONENT_CAST:
  3919.     case DEMANGLE_COMPONENT_CONVERSION:
  3920.     case DEMANGLE_COMPONENT_NULLARY:
  3921.     case DEMANGLE_COMPONENT_UNARY:
  3922.     case DEMANGLE_COMPONENT_BINARY:
  3923.     case DEMANGLE_COMPONENT_BINARY_ARGS:
  3924.     case DEMANGLE_COMPONENT_TRINARY:
  3925.     case DEMANGLE_COMPONENT_TRINARY_ARG1:
  3926.     case DEMANGLE_COMPONENT_TRINARY_ARG2:
  3927.     case DEMANGLE_COMPONENT_LITERAL:
  3928.     case DEMANGLE_COMPONENT_LITERAL_NEG:
  3929.     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
  3930.     case DEMANGLE_COMPONENT_COMPOUND_NAME:
  3931.     case DEMANGLE_COMPONENT_DECLTYPE:
  3932.     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
  3933.     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
  3934.     case DEMANGLE_COMPONENT_PACK_EXPANSION:
  3935.     case DEMANGLE_COMPONENT_TAGGED_NAME:
  3936.     case DEMANGLE_COMPONENT_CLONE:
  3937.     recurse_left_right:
  3938.       d_count_templates_scopes (num_templates, num_scopes,
  3939.                                 d_left (dc));
  3940.       d_count_templates_scopes (num_templates, num_scopes,
  3941.                                 d_right (dc));
  3942.       break;
  3943.  
  3944.     case DEMANGLE_COMPONENT_CTOR:
  3945.       d_count_templates_scopes (num_templates, num_scopes,
  3946.                                 dc->u.s_ctor.name);
  3947.       break;
  3948.  
  3949.     case DEMANGLE_COMPONENT_DTOR:
  3950.       d_count_templates_scopes (num_templates, num_scopes,
  3951.                                 dc->u.s_dtor.name);
  3952.       break;
  3953.  
  3954.     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
  3955.       d_count_templates_scopes (num_templates, num_scopes,
  3956.                                 dc->u.s_extended_operator.name);
  3957.       break;
  3958.  
  3959.     case DEMANGLE_COMPONENT_FIXED_TYPE:
  3960.       d_count_templates_scopes (num_templates, num_scopes,
  3961.                                 dc->u.s_fixed.length);
  3962.       break;
  3963.  
  3964.     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
  3965.     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
  3966.       d_count_templates_scopes (num_templates, num_scopes,
  3967.                                 d_left (dc));
  3968.       break;
  3969.  
  3970.     case DEMANGLE_COMPONENT_LAMBDA:
  3971.     case DEMANGLE_COMPONENT_DEFAULT_ARG:
  3972.       d_count_templates_scopes (num_templates, num_scopes,
  3973.                                 dc->u.s_unary_num.sub);
  3974.       break;
  3975.     }
  3976. }
  3977.  
  3978. /* Initialize a print information structure.  */
  3979.  
  3980. static void
  3981. d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
  3982.               void *opaque, const struct demangle_component *dc)
  3983. {
  3984.   dpi->len = 0;
  3985.   dpi->last_char = '\0';
  3986.   dpi->templates = NULL;
  3987.   dpi->modifiers = NULL;
  3988.   dpi->pack_index = 0;
  3989.   dpi->flush_count = 0;
  3990.  
  3991.   dpi->callback = callback;
  3992.   dpi->opaque = opaque;
  3993.  
  3994.   dpi->demangle_failure = 0;
  3995.  
  3996.   dpi->component_stack = NULL;
  3997.  
  3998.   dpi->saved_scopes = NULL;
  3999.   dpi->next_saved_scope = 0;
  4000.   dpi->num_saved_scopes = 0;
  4001.  
  4002.   dpi->copy_templates = NULL;
  4003.   dpi->next_copy_template = 0;
  4004.   dpi->num_copy_templates = 0;
  4005.  
  4006.   d_count_templates_scopes (&dpi->num_copy_templates,
  4007.                             &dpi->num_saved_scopes, dc);
  4008.   dpi->num_copy_templates *= dpi->num_saved_scopes;
  4009.  
  4010.   dpi->current_template = NULL;
  4011. }
  4012.  
  4013. /* Indicate that an error occurred during printing, and test for error.  */
  4014.  
  4015. static inline void
  4016. d_print_error (struct d_print_info *dpi)
  4017. {
  4018.   dpi->demangle_failure = 1;
  4019. }
  4020.  
  4021. static inline int
  4022. d_print_saw_error (struct d_print_info *dpi)
  4023. {
  4024.   return dpi->demangle_failure != 0;
  4025. }
  4026.  
  4027. /* Flush buffered characters to the callback.  */
  4028.  
  4029. static inline void
  4030. d_print_flush (struct d_print_info *dpi)
  4031. {
  4032.   dpi->buf[dpi->len] = '\0';
  4033.   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
  4034.   dpi->len = 0;
  4035.   dpi->flush_count++;
  4036. }
  4037.  
  4038. /* Append characters and buffers for printing.  */
  4039.  
  4040. static inline void
  4041. d_append_char (struct d_print_info *dpi, char c)
  4042. {
  4043.   if (dpi->len == sizeof (dpi->buf) - 1)
  4044.     d_print_flush (dpi);
  4045.  
  4046.   dpi->buf[dpi->len++] = c;
  4047.   dpi->last_char = c;
  4048. }
  4049.  
  4050. static inline void
  4051. d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
  4052. {
  4053.   size_t i;
  4054.  
  4055.   for (i = 0; i < l; i++)
  4056.     d_append_char (dpi, s[i]);
  4057. }
  4058.  
  4059. static inline void
  4060. d_append_string (struct d_print_info *dpi, const char *s)
  4061. {
  4062.   d_append_buffer (dpi, s, strlen (s));
  4063. }
  4064.  
  4065. static inline void
  4066. d_append_num (struct d_print_info *dpi, int l)
  4067. {
  4068.   char buf[25];
  4069.   sprintf (buf,"%d", l);
  4070.   d_append_string (dpi, buf);
  4071. }
  4072.  
  4073. static inline char
  4074. d_last_char (struct d_print_info *dpi)
  4075. {
  4076.   return dpi->last_char;
  4077. }
  4078.  
  4079. /* Turn components into a human readable string.  OPTIONS is the
  4080.    options bits passed to the demangler.  DC is the tree to print.
  4081.    CALLBACK is a function to call to flush demangled string segments
  4082.    as they fill the intermediate buffer, and OPAQUE is a generalized
  4083.    callback argument.  On success, this returns 1.  On failure,
  4084.    it returns 0, indicating a bad parse.  It does not use heap
  4085.    memory to build an output string, so cannot encounter memory
  4086.    allocation failure.  */
  4087.  
  4088. CP_STATIC_IF_GLIBCPP_V3
  4089. int
  4090. cplus_demangle_print_callback (int options,
  4091.                                const struct demangle_component *dc,
  4092.                                demangle_callbackref callback, void *opaque)
  4093. {
  4094.   struct d_print_info dpi;
  4095.  
  4096.   d_print_init (&dpi, callback, opaque, dc);
  4097.  
  4098.   {
  4099. #ifdef CP_DYNAMIC_ARRAYS
  4100.     __extension__ struct d_saved_scope scopes[dpi.num_saved_scopes];
  4101.     __extension__ struct d_print_template temps[dpi.num_copy_templates];
  4102.  
  4103.     dpi.saved_scopes = scopes;
  4104.     dpi.copy_templates = temps;
  4105. #else
  4106.     dpi.saved_scopes = alloca (dpi.num_saved_scopes
  4107.                                * sizeof (*dpi.saved_scopes));
  4108.     dpi.copy_templates = alloca (dpi.num_copy_templates
  4109.                                  * sizeof (*dpi.copy_templates));
  4110. #endif
  4111.  
  4112.   d_print_comp (&dpi, options, dc);
  4113.   }
  4114.  
  4115.   d_print_flush (&dpi);
  4116.  
  4117.   return ! d_print_saw_error (&dpi);
  4118. }
  4119.  
  4120. /* Turn components into a human readable string.  OPTIONS is the
  4121.    options bits passed to the demangler.  DC is the tree to print.
  4122.    ESTIMATE is a guess at the length of the result.  This returns a
  4123.    string allocated by malloc, or NULL on error.  On success, this
  4124.    sets *PALC to the size of the allocated buffer.  On failure, this
  4125.    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
  4126.    failure.  */
  4127.  
  4128. CP_STATIC_IF_GLIBCPP_V3
  4129. char *
  4130. cplus_demangle_print (int options, const struct demangle_component *dc,
  4131.                       int estimate, size_t *palc)
  4132. {
  4133.   struct d_growable_string dgs;
  4134.  
  4135.   d_growable_string_init (&dgs, estimate);
  4136.  
  4137.   if (! cplus_demangle_print_callback (options, dc,
  4138.                                        d_growable_string_callback_adapter,
  4139.                                        &dgs))
  4140.     {
  4141.       free (dgs.buf);
  4142.       *palc = 0;
  4143.       return NULL;
  4144.     }
  4145.  
  4146.   *palc = dgs.allocation_failure ? 1 : dgs.alc;
  4147.   return dgs.buf;
  4148. }
  4149.  
  4150. /* Returns the I'th element of the template arglist ARGS, or NULL on
  4151.    failure.  */
  4152.  
  4153. static struct demangle_component *
  4154. d_index_template_argument (struct demangle_component *args, int i)
  4155. {
  4156.   struct demangle_component *a;
  4157.  
  4158.   for (a = args;
  4159.        a != NULL;
  4160.        a = d_right (a))
  4161.     {
  4162.       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
  4163.         return NULL;
  4164.       if (i <= 0)
  4165.         break;
  4166.       --i;
  4167.     }
  4168.   if (i != 0 || a == NULL)
  4169.     return NULL;
  4170.  
  4171.   return d_left (a);
  4172. }
  4173.  
  4174. /* Returns the template argument from the current context indicated by DC,
  4175.    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
  4176.  
  4177. static struct demangle_component *
  4178. d_lookup_template_argument (struct d_print_info *dpi,
  4179.                             const struct demangle_component *dc)
  4180. {
  4181.   if (dpi->templates == NULL)
  4182.     {
  4183.       d_print_error (dpi);
  4184.       return NULL;
  4185.     }
  4186.        
  4187.   return d_index_template_argument
  4188.     (d_right (dpi->templates->template_decl),
  4189.      dc->u.s_number.number);
  4190. }
  4191.  
  4192. /* Returns a template argument pack used in DC (any will do), or NULL.  */
  4193.  
  4194. static struct demangle_component *
  4195. d_find_pack (struct d_print_info *dpi,
  4196.              const struct demangle_component *dc)
  4197. {
  4198.   struct demangle_component *a;
  4199.   if (dc == NULL)
  4200.     return NULL;
  4201.  
  4202.   switch (dc->type)
  4203.     {
  4204.     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
  4205.       a = d_lookup_template_argument (dpi, dc);
  4206.       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
  4207.         return a;
  4208.       return NULL;
  4209.  
  4210.     case DEMANGLE_COMPONENT_PACK_EXPANSION:
  4211.       return NULL;
  4212.      
  4213.     case DEMANGLE_COMPONENT_LAMBDA:
  4214.     case DEMANGLE_COMPONENT_NAME:
  4215.     case DEMANGLE_COMPONENT_TAGGED_NAME:
  4216.     case DEMANGLE_COMPONENT_OPERATOR:
  4217.     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
  4218.     case DEMANGLE_COMPONENT_SUB_STD:
  4219.     case DEMANGLE_COMPONENT_CHARACTER:
  4220.     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
  4221.     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
  4222.     case DEMANGLE_COMPONENT_FIXED_TYPE:
  4223.     case DEMANGLE_COMPONENT_DEFAULT_ARG:
  4224.     case DEMANGLE_COMPONENT_NUMBER:
  4225.       return NULL;
  4226.  
  4227.     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
  4228.       return d_find_pack (dpi, dc->u.s_extended_operator.name);
  4229.     case DEMANGLE_COMPONENT_CTOR:
  4230.       return d_find_pack (dpi, dc->u.s_ctor.name);
  4231.     case DEMANGLE_COMPONENT_DTOR:
  4232.       return d_find_pack (dpi, dc->u.s_dtor.name);
  4233.  
  4234.     default:
  4235.       a = d_find_pack (dpi, d_left (dc));
  4236.       if (a)
  4237.         return a;
  4238.       return d_find_pack (dpi, d_right (dc));
  4239.     }
  4240. }
  4241.  
  4242. /* Returns the length of the template argument pack DC.  */
  4243.  
  4244. static int
  4245. d_pack_length (const struct demangle_component *dc)
  4246. {
  4247.   int count = 0;
  4248.   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
  4249.          && d_left (dc) != NULL)
  4250.     {
  4251.       ++count;
  4252.       dc = d_right (dc);
  4253.     }
  4254.   return count;
  4255. }
  4256.  
  4257. /* DC is a component of a mangled expression.  Print it, wrapped in parens
  4258.    if needed.  */
  4259.  
  4260. static void
  4261. d_print_subexpr (struct d_print_info *dpi, int options,
  4262.                  const struct demangle_component *dc)
  4263. {
  4264.   int simple = 0;
  4265.   if (dc->type == DEMANGLE_COMPONENT_NAME
  4266.       || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
  4267.       || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
  4268.       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
  4269.     simple = 1;
  4270.   if (!simple)
  4271.     d_append_char (dpi, '(');
  4272.   d_print_comp (dpi, options, dc);
  4273.   if (!simple)
  4274.     d_append_char (dpi, ')');
  4275. }
  4276.  
  4277. /* Save the current scope.  */
  4278.  
  4279. static void
  4280. d_save_scope (struct d_print_info *dpi,
  4281.               const struct demangle_component *container)
  4282. {
  4283.   struct d_saved_scope *scope;
  4284.   struct d_print_template *src, **link;
  4285.  
  4286.   if (dpi->next_saved_scope >= dpi->num_saved_scopes)
  4287.     {
  4288.       d_print_error (dpi);
  4289.       return;
  4290.     }
  4291.   scope = &dpi->saved_scopes[dpi->next_saved_scope];
  4292.   dpi->next_saved_scope++;
  4293.  
  4294.   scope->container = container;
  4295.   link = &scope->templates;
  4296.  
  4297.   for (src = dpi->templates; src != NULL; src = src->next)
  4298.     {
  4299.       struct d_print_template *dst;
  4300.  
  4301.       if (dpi->next_copy_template >= dpi->num_copy_templates)
  4302.         {
  4303.           d_print_error (dpi);
  4304.           return;
  4305.         }
  4306.       dst = &dpi->copy_templates[dpi->next_copy_template];
  4307.       dpi->next_copy_template++;
  4308.  
  4309.       dst->template_decl = src->template_decl;
  4310.       *link = dst;
  4311.       link = &dst->next;
  4312.     }
  4313.  
  4314.   *link = NULL;
  4315. }
  4316.  
  4317. /* Attempt to locate a previously saved scope.  Returns NULL if no
  4318.    corresponding saved scope was found.  */
  4319.  
  4320. static struct d_saved_scope *
  4321. d_get_saved_scope (struct d_print_info *dpi,
  4322.                    const struct demangle_component *container)
  4323. {
  4324.   int i;
  4325.  
  4326.   for (i = 0; i < dpi->next_saved_scope; i++)
  4327.     if (dpi->saved_scopes[i].container == container)
  4328.       return &dpi->saved_scopes[i];
  4329.  
  4330.   return NULL;
  4331. }
  4332.  
  4333. /* Subroutine to handle components.  */
  4334.  
  4335. static void
  4336. d_print_comp_inner (struct d_print_info *dpi, int options,
  4337.               const struct demangle_component *dc)
  4338. {
  4339.   /* Magic variable to let reference smashing skip over the next modifier
  4340.      without needing to modify *dc.  */
  4341.   const struct demangle_component *mod_inner = NULL;
  4342.  
  4343.   /* Variable used to store the current templates while a previously
  4344.      captured scope is used.  */
  4345.   struct d_print_template *saved_templates;
  4346.  
  4347.   /* Nonzero if templates have been stored in the above variable.  */
  4348.   int need_template_restore = 0;
  4349.  
  4350.   if (dc == NULL)
  4351.     {
  4352.       d_print_error (dpi);
  4353.       return;
  4354.     }
  4355.   if (d_print_saw_error (dpi))
  4356.     return;
  4357.  
  4358.   switch (dc->type)
  4359.     {
  4360.     case DEMANGLE_COMPONENT_NAME:
  4361.       if ((options & DMGL_JAVA) == 0)
  4362.         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
  4363.       else
  4364.         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
  4365.       return;
  4366.  
  4367.     case DEMANGLE_COMPONENT_TAGGED_NAME:
  4368.       d_print_comp (dpi, options, d_left (dc));
  4369.       d_append_string (dpi, "[abi:");
  4370.       d_print_comp (dpi, options, d_right (dc));
  4371.       d_append_char (dpi, ']');
  4372.       return;
  4373.  
  4374.     case DEMANGLE_COMPONENT_QUAL_NAME:
  4375.     case DEMANGLE_COMPONENT_LOCAL_NAME:
  4376.       d_print_comp (dpi, options, d_left (dc));
  4377.       if ((options & DMGL_JAVA) == 0)
  4378.         d_append_string (dpi, "::");
  4379.       else
  4380.         d_append_char (dpi, '.');
  4381.       {
  4382.         struct demangle_component *local_name = d_right (dc);
  4383.         if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
  4384.           {
  4385.             d_append_string (dpi, "{default arg#");
  4386.             d_append_num (dpi, local_name->u.s_unary_num.num + 1);
  4387.             d_append_string (dpi, "}::");
  4388.             local_name = local_name->u.s_unary_num.sub;
  4389.           }
  4390.         d_print_comp (dpi, options, local_name);
  4391.       }
  4392.       return;
  4393.  
  4394.     case DEMANGLE_COMPONENT_TYPED_NAME:
  4395.       {
  4396.         struct d_print_mod *hold_modifiers;
  4397.         struct demangle_component *typed_name;
  4398.         struct d_print_mod adpm[4];
  4399.         unsigned int i;
  4400.         struct d_print_template dpt;
  4401.  
  4402.         /* Pass the name down to the type so that it can be printed in
  4403.            the right place for the type.  We also have to pass down
  4404.            any CV-qualifiers, which apply to the this parameter.  */
  4405.         hold_modifiers = dpi->modifiers;
  4406.         dpi->modifiers = 0;
  4407.         i = 0;
  4408.         typed_name = d_left (dc);
  4409.         while (typed_name != NULL)
  4410.           {
  4411.             if (i >= sizeof adpm / sizeof adpm[0])
  4412.               {
  4413.                 d_print_error (dpi);
  4414.                 return;
  4415.               }
  4416.  
  4417.             adpm[i].next = dpi->modifiers;
  4418.             dpi->modifiers = &adpm[i];
  4419.             adpm[i].mod = typed_name;
  4420.             adpm[i].printed = 0;
  4421.             adpm[i].templates = dpi->templates;
  4422.             ++i;
  4423.  
  4424.             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
  4425.                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
  4426.                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS
  4427.                 && typed_name->type != DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
  4428.                 && typed_name->type != DEMANGLE_COMPONENT_REFERENCE_THIS)
  4429.               break;
  4430.  
  4431.             typed_name = d_left (typed_name);
  4432.           }
  4433.  
  4434.         if (typed_name == NULL)
  4435.           {
  4436.             d_print_error (dpi);
  4437.             return;
  4438.           }
  4439.  
  4440.         /* If typed_name is a template, then it applies to the
  4441.            function type as well.  */
  4442.         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
  4443.           {
  4444.             dpt.next = dpi->templates;
  4445.             dpi->templates = &dpt;
  4446.             dpt.template_decl = typed_name;
  4447.           }
  4448.  
  4449.         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
  4450.            there may be CV-qualifiers on its right argument which
  4451.            really apply here; this happens when parsing a class which
  4452.            is local to a function.  */
  4453.         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
  4454.           {
  4455.             struct demangle_component *local_name;
  4456.  
  4457.             local_name = d_right (typed_name);
  4458.             if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
  4459.               local_name = local_name->u.s_unary_num.sub;
  4460.             if (local_name == NULL)
  4461.               {
  4462.                 d_print_error (dpi);
  4463.                 return;
  4464.               }
  4465.             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
  4466.                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
  4467.                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS
  4468.                    || local_name->type == DEMANGLE_COMPONENT_REFERENCE_THIS
  4469.                    || (local_name->type
  4470.                        == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))
  4471.               {
  4472.                 if (i >= sizeof adpm / sizeof adpm[0])
  4473.                   {
  4474.                     d_print_error (dpi);
  4475.                     return;
  4476.                   }
  4477.  
  4478.                 adpm[i] = adpm[i - 1];
  4479.                 adpm[i].next = &adpm[i - 1];
  4480.                 dpi->modifiers = &adpm[i];
  4481.  
  4482.                 adpm[i - 1].mod = local_name;
  4483.                 adpm[i - 1].printed = 0;
  4484.                 adpm[i - 1].templates = dpi->templates;
  4485.                 ++i;
  4486.  
  4487.                 local_name = d_left (local_name);
  4488.               }
  4489.           }
  4490.  
  4491.         d_print_comp (dpi, options, d_right (dc));
  4492.  
  4493.         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
  4494.           dpi->templates = dpt.next;
  4495.  
  4496.         /* If the modifiers didn't get printed by the type, print them
  4497.            now.  */
  4498.         while (i > 0)
  4499.           {
  4500.             --i;
  4501.             if (! adpm[i].printed)
  4502.               {
  4503.                 d_append_char (dpi, ' ');
  4504.                 d_print_mod (dpi, options, adpm[i].mod);
  4505.               }
  4506.           }
  4507.  
  4508.         dpi->modifiers = hold_modifiers;
  4509.  
  4510.         return;
  4511.       }
  4512.  
  4513.     case DEMANGLE_COMPONENT_TEMPLATE:
  4514.       {
  4515.         struct d_print_mod *hold_dpm;
  4516.         struct demangle_component *dcl;
  4517.         const struct demangle_component *hold_current;
  4518.  
  4519.         /* This template may need to be referenced by a cast operator
  4520.            contained in its subtree.  */
  4521.         hold_current = dpi->current_template;
  4522.         dpi->current_template = dc;
  4523.  
  4524.         /* Don't push modifiers into a template definition.  Doing so
  4525.            could give the wrong definition for a template argument.
  4526.            Instead, treat the template essentially as a name.  */
  4527.  
  4528.         hold_dpm = dpi->modifiers;
  4529.         dpi->modifiers = NULL;
  4530.  
  4531.         dcl = d_left (dc);
  4532.  
  4533.         if ((options & DMGL_JAVA) != 0
  4534.             && dcl->type == DEMANGLE_COMPONENT_NAME
  4535.             && dcl->u.s_name.len == 6
  4536.             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
  4537.           {
  4538.             /* Special-case Java arrays, so that JArray<TYPE> appears
  4539.                instead as TYPE[].  */
  4540.  
  4541.             d_print_comp (dpi, options, d_right (dc));
  4542.             d_append_string (dpi, "[]");
  4543.           }
  4544.         else
  4545.           {
  4546.             d_print_comp (dpi, options, dcl);
  4547.             if (d_last_char (dpi) == '<')
  4548.               d_append_char (dpi, ' ');
  4549.             d_append_char (dpi, '<');
  4550.             d_print_comp (dpi, options, d_right (dc));
  4551.             /* Avoid generating two consecutive '>' characters, to avoid
  4552.                the C++ syntactic ambiguity.  */
  4553.             if (d_last_char (dpi) == '>')
  4554.               d_append_char (dpi, ' ');
  4555.             d_append_char (dpi, '>');
  4556.           }
  4557.  
  4558.         dpi->modifiers = hold_dpm;
  4559.         dpi->current_template = hold_current;
  4560.  
  4561.         return;
  4562.       }
  4563.  
  4564.     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
  4565.       {
  4566.         struct d_print_template *hold_dpt;
  4567.         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
  4568.  
  4569.         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
  4570.           a = d_index_template_argument (a, dpi->pack_index);
  4571.  
  4572.         if (a == NULL)
  4573.           {
  4574.             d_print_error (dpi);
  4575.             return;
  4576.           }
  4577.  
  4578.         /* While processing this parameter, we need to pop the list of
  4579.            templates.  This is because the template parameter may
  4580.            itself be a reference to a parameter of an outer
  4581.            template.  */
  4582.  
  4583.         hold_dpt = dpi->templates;
  4584.         dpi->templates = hold_dpt->next;
  4585.  
  4586.         d_print_comp (dpi, options, a);
  4587.  
  4588.         dpi->templates = hold_dpt;
  4589.  
  4590.         return;
  4591.       }
  4592.  
  4593.     case DEMANGLE_COMPONENT_CTOR:
  4594.       d_print_comp (dpi, options, dc->u.s_ctor.name);
  4595.       return;
  4596.  
  4597.     case DEMANGLE_COMPONENT_DTOR:
  4598.       d_append_char (dpi, '~');
  4599.       d_print_comp (dpi, options, dc->u.s_dtor.name);
  4600.       return;
  4601.  
  4602.     case DEMANGLE_COMPONENT_VTABLE:
  4603.       d_append_string (dpi, "vtable for ");
  4604.       d_print_comp (dpi, options, d_left (dc));
  4605.       return;
  4606.  
  4607.     case DEMANGLE_COMPONENT_VTT:
  4608.       d_append_string (dpi, "VTT for ");
  4609.       d_print_comp (dpi, options, d_left (dc));
  4610.       return;
  4611.  
  4612.     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
  4613.       d_append_string (dpi, "construction vtable for ");
  4614.       d_print_comp (dpi, options, d_left (dc));
  4615.       d_append_string (dpi, "-in-");
  4616.       d_print_comp (dpi, options, d_right (dc));
  4617.       return;
  4618.  
  4619.     case DEMANGLE_COMPONENT_TYPEINFO:
  4620.       d_append_string (dpi, "typeinfo for ");
  4621.       d_print_comp (dpi, options, d_left (dc));
  4622.       return;
  4623.  
  4624.     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
  4625.       d_append_string (dpi, "typeinfo name for ");
  4626.       d_print_comp (dpi, options, d_left (dc));
  4627.       return;
  4628.  
  4629.     case DEMANGLE_COMPONENT_TYPEINFO_FN:
  4630.       d_append_string (dpi, "typeinfo fn for ");
  4631.       d_print_comp (dpi, options, d_left (dc));
  4632.       return;
  4633.  
  4634.     case DEMANGLE_COMPONENT_THUNK:
  4635.       d_append_string (dpi, "non-virtual thunk to ");
  4636.       d_print_comp (dpi, options, d_left (dc));
  4637.       return;
  4638.  
  4639.     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
  4640.       d_append_string (dpi, "virtual thunk to ");
  4641.       d_print_comp (dpi, options, d_left (dc));
  4642.       return;
  4643.  
  4644.     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
  4645.       d_append_string (dpi, "covariant return thunk to ");
  4646.       d_print_comp (dpi, options, d_left (dc));
  4647.       return;
  4648.  
  4649.     case DEMANGLE_COMPONENT_JAVA_CLASS:
  4650.       d_append_string (dpi, "java Class for ");
  4651.       d_print_comp (dpi, options, d_left (dc));
  4652.       return;
  4653.  
  4654.     case DEMANGLE_COMPONENT_GUARD:
  4655.       d_append_string (dpi, "guard variable for ");
  4656.       d_print_comp (dpi, options, d_left (dc));
  4657.       return;
  4658.  
  4659.     case DEMANGLE_COMPONENT_TLS_INIT:
  4660.       d_append_string (dpi, "TLS init function for ");
  4661.       d_print_comp (dpi, options, d_left (dc));
  4662.       return;
  4663.  
  4664.     case DEMANGLE_COMPONENT_TLS_WRAPPER:
  4665.       d_append_string (dpi, "TLS wrapper function for ");
  4666.       d_print_comp (dpi, options, d_left (dc));
  4667.       return;
  4668.  
  4669.     case DEMANGLE_COMPONENT_REFTEMP:
  4670.       d_append_string (dpi, "reference temporary #");
  4671.       d_print_comp (dpi, options, d_right (dc));
  4672.       d_append_string (dpi, " for ");
  4673.       d_print_comp (dpi, options, d_left (dc));
  4674.       return;
  4675.  
  4676.     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
  4677.       d_append_string (dpi, "hidden alias for ");
  4678.       d_print_comp (dpi, options, d_left (dc));
  4679.       return;
  4680.  
  4681.     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
  4682.       d_append_string (dpi, "transaction clone for ");
  4683.       d_print_comp (dpi, options, d_left (dc));
  4684.       return;
  4685.  
  4686.     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
  4687.       d_append_string (dpi, "non-transaction clone for ");
  4688.       d_print_comp (dpi, options, d_left (dc));
  4689.       return;
  4690.  
  4691.     case DEMANGLE_COMPONENT_SUB_STD:
  4692.       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
  4693.       return;
  4694.  
  4695.     case DEMANGLE_COMPONENT_RESTRICT:
  4696.     case DEMANGLE_COMPONENT_VOLATILE:
  4697.     case DEMANGLE_COMPONENT_CONST:
  4698.       {
  4699.         struct d_print_mod *pdpm;
  4700.  
  4701.         /* When printing arrays, it's possible to have cases where the
  4702.            same CV-qualifier gets pushed on the stack multiple times.
  4703.            We only need to print it once.  */
  4704.  
  4705.         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
  4706.           {
  4707.             if (! pdpm->printed)
  4708.               {
  4709.                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
  4710.                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
  4711.                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
  4712.                   break;
  4713.                 if (pdpm->mod->type == dc->type)
  4714.                   {
  4715.                     d_print_comp (dpi, options, d_left (dc));
  4716.                     return;
  4717.                   }
  4718.               }
  4719.           }
  4720.       }
  4721.       goto modifier;
  4722.  
  4723.     case DEMANGLE_COMPONENT_REFERENCE:
  4724.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
  4725.       {
  4726.         /* Handle reference smashing: & + && = &.  */
  4727.         const struct demangle_component *sub = d_left (dc);
  4728.         if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
  4729.           {
  4730.             struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
  4731.             struct demangle_component *a;
  4732.  
  4733.             if (scope == NULL)
  4734.               {
  4735.                 /* This is the first time SUB has been traversed.
  4736.                    We need to capture the current templates so
  4737.                    they can be restored if SUB is reentered as a
  4738.                    substitution.  */
  4739.                 d_save_scope (dpi, sub);
  4740.                 if (d_print_saw_error (dpi))
  4741.                   return;
  4742.               }
  4743.             else
  4744.               {
  4745.                 const struct d_component_stack *dcse;
  4746.                 int found_self_or_parent = 0;
  4747.  
  4748.                 /* This traversal is reentering SUB as a substition.
  4749.                    If we are not beneath SUB or DC in the tree then we
  4750.                    need to restore SUB's template stack temporarily.  */
  4751.                 for (dcse = dpi->component_stack; dcse != NULL;
  4752.                      dcse = dcse->parent)
  4753.                   {
  4754.                     if (dcse->dc == sub
  4755.                         || (dcse->dc == dc
  4756.                             && dcse != dpi->component_stack))
  4757.                       {
  4758.                         found_self_or_parent = 1;
  4759.                         break;
  4760.                       }
  4761.                   }
  4762.  
  4763.                 if (!found_self_or_parent)
  4764.                   {
  4765.                     saved_templates = dpi->templates;
  4766.                     dpi->templates = scope->templates;
  4767.                     need_template_restore = 1;
  4768.                   }
  4769.               }
  4770.  
  4771.             a = d_lookup_template_argument (dpi, sub);
  4772.             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
  4773.               a = d_index_template_argument (a, dpi->pack_index);
  4774.  
  4775.             if (a == NULL)
  4776.               {
  4777.                 if (need_template_restore)
  4778.                   dpi->templates = saved_templates;
  4779.  
  4780.                 d_print_error (dpi);
  4781.                 return;
  4782.               }
  4783.  
  4784.             sub = a;
  4785.           }
  4786.  
  4787.         if (sub->type == DEMANGLE_COMPONENT_REFERENCE
  4788.             || sub->type == dc->type)
  4789.           dc = sub;
  4790.         else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
  4791.           mod_inner = d_left (sub);
  4792.       }
  4793.       /* Fall through.  */
  4794.  
  4795.     case DEMANGLE_COMPONENT_RESTRICT_THIS:
  4796.     case DEMANGLE_COMPONENT_VOLATILE_THIS:
  4797.     case DEMANGLE_COMPONENT_CONST_THIS:
  4798.     case DEMANGLE_COMPONENT_REFERENCE_THIS:
  4799.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  4800.     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  4801.     case DEMANGLE_COMPONENT_POINTER:
  4802.     case DEMANGLE_COMPONENT_COMPLEX:
  4803.     case DEMANGLE_COMPONENT_IMAGINARY:
  4804.     modifier:
  4805.       {
  4806.         /* We keep a list of modifiers on the stack.  */
  4807.         struct d_print_mod dpm;
  4808.  
  4809.         dpm.next = dpi->modifiers;
  4810.         dpi->modifiers = &dpm;
  4811.         dpm.mod = dc;
  4812.         dpm.printed = 0;
  4813.         dpm.templates = dpi->templates;
  4814.  
  4815.         if (!mod_inner)
  4816.           mod_inner = d_left (dc);
  4817.  
  4818.         d_print_comp (dpi, options, mod_inner);
  4819.  
  4820.         /* If the modifier didn't get printed by the type, print it
  4821.            now.  */
  4822.         if (! dpm.printed)
  4823.           d_print_mod (dpi, options, dc);
  4824.  
  4825.         dpi->modifiers = dpm.next;
  4826.  
  4827.         if (need_template_restore)
  4828.           dpi->templates = saved_templates;
  4829.  
  4830.         return;
  4831.       }
  4832.  
  4833.     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
  4834.       if ((options & DMGL_JAVA) == 0)
  4835.         d_append_buffer (dpi, dc->u.s_builtin.type->name,
  4836.                          dc->u.s_builtin.type->len);
  4837.       else
  4838.         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
  4839.                          dc->u.s_builtin.type->java_len);
  4840.       return;
  4841.  
  4842.     case DEMANGLE_COMPONENT_VENDOR_TYPE:
  4843.       d_print_comp (dpi, options, d_left (dc));
  4844.       return;
  4845.  
  4846.     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
  4847.       {
  4848.         if ((options & DMGL_RET_POSTFIX) != 0)
  4849.           d_print_function_type (dpi,
  4850.                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
  4851.                                  dc, dpi->modifiers);
  4852.  
  4853.         /* Print return type if present */
  4854.         if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
  4855.           d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
  4856.                         d_left (dc));
  4857.         else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
  4858.           {
  4859.             struct d_print_mod dpm;
  4860.  
  4861.             /* We must pass this type down as a modifier in order to
  4862.                print it in the right location.  */
  4863.             dpm.next = dpi->modifiers;
  4864.             dpi->modifiers = &dpm;
  4865.             dpm.mod = dc;
  4866.             dpm.printed = 0;
  4867.             dpm.templates = dpi->templates;
  4868.  
  4869.             d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
  4870.                           d_left (dc));
  4871.  
  4872.             dpi->modifiers = dpm.next;
  4873.  
  4874.             if (dpm.printed)
  4875.               return;
  4876.  
  4877.             /* In standard prefix notation, there is a space between the
  4878.                return type and the function signature.  */
  4879.             if ((options & DMGL_RET_POSTFIX) == 0)
  4880.               d_append_char (dpi, ' ');
  4881.           }
  4882.  
  4883.         if ((options & DMGL_RET_POSTFIX) == 0)
  4884.           d_print_function_type (dpi,
  4885.                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
  4886.                                  dc, dpi->modifiers);
  4887.  
  4888.         return;
  4889.       }
  4890.  
  4891.     case DEMANGLE_COMPONENT_ARRAY_TYPE:
  4892.       {
  4893.         struct d_print_mod *hold_modifiers;
  4894.         struct d_print_mod adpm[4];
  4895.         unsigned int i;
  4896.         struct d_print_mod *pdpm;
  4897.  
  4898.         /* We must pass this type down as a modifier in order to print
  4899.            multi-dimensional arrays correctly.  If the array itself is
  4900.            CV-qualified, we act as though the element type were
  4901.            CV-qualified.  We do this by copying the modifiers down
  4902.            rather than fiddling pointers, so that we don't wind up
  4903.            with a d_print_mod higher on the stack pointing into our
  4904.            stack frame after we return.  */
  4905.  
  4906.         hold_modifiers = dpi->modifiers;
  4907.  
  4908.         adpm[0].next = hold_modifiers;
  4909.         dpi->modifiers = &adpm[0];
  4910.         adpm[0].mod = dc;
  4911.         adpm[0].printed = 0;
  4912.         adpm[0].templates = dpi->templates;
  4913.  
  4914.         i = 1;
  4915.         pdpm = hold_modifiers;
  4916.         while (pdpm != NULL
  4917.                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
  4918.                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
  4919.                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
  4920.           {
  4921.             if (! pdpm->printed)
  4922.               {
  4923.                 if (i >= sizeof adpm / sizeof adpm[0])
  4924.                   {
  4925.                     d_print_error (dpi);
  4926.                     return;
  4927.                   }
  4928.  
  4929.                 adpm[i] = *pdpm;
  4930.                 adpm[i].next = dpi->modifiers;
  4931.                 dpi->modifiers = &adpm[i];
  4932.                 pdpm->printed = 1;
  4933.                 ++i;
  4934.               }
  4935.  
  4936.             pdpm = pdpm->next;
  4937.           }
  4938.  
  4939.         d_print_comp (dpi, options, d_right (dc));
  4940.  
  4941.         dpi->modifiers = hold_modifiers;
  4942.  
  4943.         if (adpm[0].printed)
  4944.           return;
  4945.  
  4946.         while (i > 1)
  4947.           {
  4948.             --i;
  4949.             d_print_mod (dpi, options, adpm[i].mod);
  4950.           }
  4951.  
  4952.         d_print_array_type (dpi, options, dc, dpi->modifiers);
  4953.  
  4954.         return;
  4955.       }
  4956.  
  4957.     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  4958.     case DEMANGLE_COMPONENT_VECTOR_TYPE:
  4959.       {
  4960.         struct d_print_mod dpm;
  4961.  
  4962.         dpm.next = dpi->modifiers;
  4963.         dpi->modifiers = &dpm;
  4964.         dpm.mod = dc;
  4965.         dpm.printed = 0;
  4966.         dpm.templates = dpi->templates;
  4967.  
  4968.         d_print_comp (dpi, options, d_right (dc));
  4969.  
  4970.         /* If the modifier didn't get printed by the type, print it
  4971.            now.  */
  4972.         if (! dpm.printed)
  4973.           d_print_mod (dpi, options, dc);
  4974.  
  4975.         dpi->modifiers = dpm.next;
  4976.  
  4977.         return;
  4978.       }
  4979.  
  4980.     case DEMANGLE_COMPONENT_FIXED_TYPE:
  4981.       if (dc->u.s_fixed.sat)
  4982.         d_append_string (dpi, "_Sat ");
  4983.       /* Don't print "int _Accum".  */
  4984.       if (dc->u.s_fixed.length->u.s_builtin.type
  4985.           != &cplus_demangle_builtin_types['i'-'a'])
  4986.         {
  4987.           d_print_comp (dpi, options, dc->u.s_fixed.length);
  4988.           d_append_char (dpi, ' ');
  4989.         }
  4990.       if (dc->u.s_fixed.accum)
  4991.         d_append_string (dpi, "_Accum");
  4992.       else
  4993.         d_append_string (dpi, "_Fract");
  4994.       return;
  4995.  
  4996.     case DEMANGLE_COMPONENT_ARGLIST:
  4997.     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
  4998.       if (d_left (dc) != NULL)
  4999.         d_print_comp (dpi, options, d_left (dc));
  5000.       if (d_right (dc) != NULL)
  5001.         {
  5002.           size_t len;
  5003.           unsigned long int flush_count;
  5004.           /* Make sure ", " isn't flushed by d_append_string, otherwise
  5005.              dpi->len -= 2 wouldn't work.  */
  5006.           if (dpi->len >= sizeof (dpi->buf) - 2)
  5007.             d_print_flush (dpi);
  5008.           d_append_string (dpi, ", ");
  5009.           len = dpi->len;
  5010.           flush_count = dpi->flush_count;
  5011.           d_print_comp (dpi, options, d_right (dc));
  5012.           /* If that didn't print anything (which can happen with empty
  5013.              template argument packs), remove the comma and space.  */
  5014.           if (dpi->flush_count == flush_count && dpi->len == len)
  5015.             dpi->len -= 2;
  5016.         }
  5017.       return;
  5018.  
  5019.     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
  5020.       {
  5021.         struct demangle_component *type = d_left (dc);
  5022.         struct demangle_component *list = d_right (dc);
  5023.  
  5024.         if (type)
  5025.           d_print_comp (dpi, options, type);
  5026.         d_append_char (dpi, '{');
  5027.         d_print_comp (dpi, options, list);
  5028.         d_append_char (dpi, '}');
  5029.       }
  5030.       return;
  5031.  
  5032.     case DEMANGLE_COMPONENT_OPERATOR:
  5033.       {
  5034.         const struct demangle_operator_info *op = dc->u.s_operator.op;
  5035.         int len = op->len;
  5036.  
  5037.         d_append_string (dpi, "operator");
  5038.         /* Add a space before new/delete.  */
  5039.         if (IS_LOWER (op->name[0]))
  5040.           d_append_char (dpi, ' ');
  5041.         /* Omit a trailing space.  */
  5042.         if (op->name[len-1] == ' ')
  5043.           --len;
  5044.         d_append_buffer (dpi, op->name, len);
  5045.         return;
  5046.       }
  5047.  
  5048.     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
  5049.       d_append_string (dpi, "operator ");
  5050.       d_print_comp (dpi, options, dc->u.s_extended_operator.name);
  5051.       return;
  5052.  
  5053.     case DEMANGLE_COMPONENT_CONVERSION:
  5054.       d_append_string (dpi, "operator ");
  5055.       d_print_conversion (dpi, options, dc);
  5056.       return;
  5057.  
  5058.     case DEMANGLE_COMPONENT_NULLARY:
  5059.       d_print_expr_op (dpi, options, d_left (dc));
  5060.       return;
  5061.  
  5062.     case DEMANGLE_COMPONENT_UNARY:
  5063.       {
  5064.         struct demangle_component *op = d_left (dc);
  5065.         struct demangle_component *operand = d_right (dc);
  5066.         const char *code = NULL;
  5067.  
  5068.         if (op->type == DEMANGLE_COMPONENT_OPERATOR)
  5069.           {
  5070.             code = op->u.s_operator.op->code;
  5071.             if (!strcmp (code, "ad"))
  5072.               {
  5073.                 /* Don't print the argument list for the address of a
  5074.                    function.  */
  5075.                 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
  5076.                     && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
  5077.                     && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
  5078.                   operand = d_left (operand);
  5079.               }
  5080.             if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
  5081.               {
  5082.                 /* This indicates a suffix operator.  */
  5083.                 operand = d_left (operand);
  5084.                 d_print_subexpr (dpi, options, operand);
  5085.                 d_print_expr_op (dpi, options, op);
  5086.                 return;
  5087.               }
  5088.           }
  5089.  
  5090.         if (op->type != DEMANGLE_COMPONENT_CAST)
  5091.           d_print_expr_op (dpi, options, op);
  5092.         else
  5093.           {
  5094.             d_append_char (dpi, '(');
  5095.             d_print_cast (dpi, options, op);
  5096.             d_append_char (dpi, ')');
  5097.           }
  5098.         if (code && !strcmp (code, "gs"))
  5099.           /* Avoid parens after '::'.  */
  5100.           d_print_comp (dpi, options, operand);
  5101.         else if (code && !strcmp (code, "st"))
  5102.           /* Always print parens for sizeof (type).  */
  5103.           {
  5104.             d_append_char (dpi, '(');
  5105.             d_print_comp (dpi, options, operand);
  5106.             d_append_char (dpi, ')');
  5107.           }
  5108.         else
  5109.           d_print_subexpr (dpi, options, operand);
  5110.       }
  5111.       return;
  5112.  
  5113.     case DEMANGLE_COMPONENT_BINARY:
  5114.       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
  5115.         {
  5116.           d_print_error (dpi);
  5117.           return;
  5118.         }
  5119.  
  5120.       if (op_is_new_cast (d_left (dc)))
  5121.         {
  5122.           d_print_expr_op (dpi, options, d_left (dc));
  5123.           d_append_char (dpi, '<');
  5124.           d_print_comp (dpi, options, d_left (d_right (dc)));
  5125.           d_append_string (dpi, ">(");
  5126.           d_print_comp (dpi, options, d_right (d_right (dc)));
  5127.           d_append_char (dpi, ')');
  5128.           return;
  5129.         }
  5130.  
  5131.       /* We wrap an expression which uses the greater-than operator in
  5132.          an extra layer of parens so that it does not get confused
  5133.          with the '>' which ends the template parameters.  */
  5134.       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
  5135.           && d_left (dc)->u.s_operator.op->len == 1
  5136.           && d_left (dc)->u.s_operator.op->name[0] == '>')
  5137.         d_append_char (dpi, '(');
  5138.  
  5139.       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
  5140.           && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
  5141.         {
  5142.           /* Function call used in an expression should not have printed types
  5143.              of the function arguments.  Values of the function arguments still
  5144.              get printed below.  */
  5145.  
  5146.           const struct demangle_component *func = d_left (d_right (dc));
  5147.  
  5148.           if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
  5149.             d_print_error (dpi);
  5150.           d_print_subexpr (dpi, options, d_left (func));
  5151.         }
  5152.       else
  5153.         d_print_subexpr (dpi, options, d_left (d_right (dc)));
  5154.       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
  5155.         {
  5156.           d_append_char (dpi, '[');
  5157.           d_print_comp (dpi, options, d_right (d_right (dc)));
  5158.           d_append_char (dpi, ']');
  5159.         }
  5160.       else
  5161.         {
  5162.           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
  5163.             d_print_expr_op (dpi, options, d_left (dc));
  5164.           d_print_subexpr (dpi, options, d_right (d_right (dc)));
  5165.         }
  5166.  
  5167.       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
  5168.           && d_left (dc)->u.s_operator.op->len == 1
  5169.           && d_left (dc)->u.s_operator.op->name[0] == '>')
  5170.         d_append_char (dpi, ')');
  5171.  
  5172.       return;
  5173.  
  5174.     case DEMANGLE_COMPONENT_BINARY_ARGS:
  5175.       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
  5176.       d_print_error (dpi);
  5177.       return;
  5178.  
  5179.     case DEMANGLE_COMPONENT_TRINARY:
  5180.       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
  5181.           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
  5182.         {
  5183.           d_print_error (dpi);
  5184.           return;
  5185.         }
  5186.       {
  5187.         struct demangle_component *op = d_left (dc);
  5188.         struct demangle_component *first = d_left (d_right (dc));
  5189.         struct demangle_component *second = d_left (d_right (d_right (dc)));
  5190.         struct demangle_component *third = d_right (d_right (d_right (dc)));
  5191.  
  5192.         if (!strcmp (op->u.s_operator.op->code, "qu"))
  5193.           {
  5194.             d_print_subexpr (dpi, options, first);
  5195.             d_print_expr_op (dpi, options, op);
  5196.             d_print_subexpr (dpi, options, second);
  5197.             d_append_string (dpi, " : ");
  5198.             d_print_subexpr (dpi, options, third);
  5199.           }
  5200.         else
  5201.           {
  5202.             d_append_string (dpi, "new ");
  5203.             if (d_left (first) != NULL)
  5204.               {
  5205.                 d_print_subexpr (dpi, options, first);
  5206.                 d_append_char (dpi, ' ');
  5207.               }
  5208.             d_print_comp (dpi, options, second);
  5209.             if (third)
  5210.               d_print_subexpr (dpi, options, third);
  5211.           }
  5212.       }
  5213.       return;
  5214.  
  5215.     case DEMANGLE_COMPONENT_TRINARY_ARG1:
  5216.     case DEMANGLE_COMPONENT_TRINARY_ARG2:
  5217.       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
  5218.       d_print_error (dpi);
  5219.       return;
  5220.  
  5221.     case DEMANGLE_COMPONENT_LITERAL:
  5222.     case DEMANGLE_COMPONENT_LITERAL_NEG:
  5223.       {
  5224.         enum d_builtin_type_print tp;
  5225.  
  5226.         /* For some builtin types, produce simpler output.  */
  5227.         tp = D_PRINT_DEFAULT;
  5228.         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
  5229.           {
  5230.             tp = d_left (dc)->u.s_builtin.type->print;
  5231.             switch (tp)
  5232.               {
  5233.               case D_PRINT_INT:
  5234.               case D_PRINT_UNSIGNED:
  5235.               case D_PRINT_LONG:
  5236.               case D_PRINT_UNSIGNED_LONG:
  5237.               case D_PRINT_LONG_LONG:
  5238.               case D_PRINT_UNSIGNED_LONG_LONG:
  5239.                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
  5240.                   {
  5241.                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
  5242.                       d_append_char (dpi, '-');
  5243.                     d_print_comp (dpi, options, d_right (dc));
  5244.                     switch (tp)
  5245.                       {
  5246.                       default:
  5247.                         break;
  5248.                       case D_PRINT_UNSIGNED:
  5249.                         d_append_char (dpi, 'u');
  5250.                         break;
  5251.                       case D_PRINT_LONG:
  5252.                         d_append_char (dpi, 'l');
  5253.                         break;
  5254.                       case D_PRINT_UNSIGNED_LONG:
  5255.                         d_append_string (dpi, "ul");
  5256.                         break;
  5257.                       case D_PRINT_LONG_LONG:
  5258.                         d_append_string (dpi, "ll");
  5259.                         break;
  5260.                       case D_PRINT_UNSIGNED_LONG_LONG:
  5261.                         d_append_string (dpi, "ull");
  5262.                         break;
  5263.                       }
  5264.                     return;
  5265.                   }
  5266.                 break;
  5267.  
  5268.               case D_PRINT_BOOL:
  5269.                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
  5270.                     && d_right (dc)->u.s_name.len == 1
  5271.                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
  5272.                   {
  5273.                     switch (d_right (dc)->u.s_name.s[0])
  5274.                       {
  5275.                       case '0':
  5276.                         d_append_string (dpi, "false");
  5277.                         return;
  5278.                       case '1':
  5279.                         d_append_string (dpi, "true");
  5280.                         return;
  5281.                       default:
  5282.                         break;
  5283.                       }
  5284.                   }
  5285.                 break;
  5286.  
  5287.               default:
  5288.                 break;
  5289.               }
  5290.           }
  5291.  
  5292.         d_append_char (dpi, '(');
  5293.         d_print_comp (dpi, options, d_left (dc));
  5294.         d_append_char (dpi, ')');
  5295.         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
  5296.           d_append_char (dpi, '-');
  5297.         if (tp == D_PRINT_FLOAT)
  5298.           d_append_char (dpi, '[');
  5299.         d_print_comp (dpi, options, d_right (dc));
  5300.         if (tp == D_PRINT_FLOAT)
  5301.           d_append_char (dpi, ']');
  5302.       }
  5303.       return;
  5304.  
  5305.     case DEMANGLE_COMPONENT_NUMBER:
  5306.       d_append_num (dpi, dc->u.s_number.number);
  5307.       return;
  5308.  
  5309.     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
  5310.       d_append_string (dpi, "java resource ");
  5311.       d_print_comp (dpi, options, d_left (dc));
  5312.       return;
  5313.  
  5314.     case DEMANGLE_COMPONENT_COMPOUND_NAME:
  5315.       d_print_comp (dpi, options, d_left (dc));
  5316.       d_print_comp (dpi, options, d_right (dc));
  5317.       return;
  5318.  
  5319.     case DEMANGLE_COMPONENT_CHARACTER:
  5320.       d_append_char (dpi, dc->u.s_character.character);
  5321.       return;
  5322.  
  5323.     case DEMANGLE_COMPONENT_DECLTYPE:
  5324.       d_append_string (dpi, "decltype (");
  5325.       d_print_comp (dpi, options, d_left (dc));
  5326.       d_append_char (dpi, ')');
  5327.       return;
  5328.  
  5329.     case DEMANGLE_COMPONENT_PACK_EXPANSION:
  5330.       {
  5331.         int len;
  5332.         int i;
  5333.         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
  5334.         if (a == NULL)
  5335.           {
  5336.             /* d_find_pack won't find anything if the only packs involved
  5337.                in this expansion are function parameter packs; in that
  5338.                case, just print the pattern and "...".  */
  5339.             d_print_subexpr (dpi, options, d_left (dc));
  5340.             d_append_string (dpi, "...");
  5341.             return;
  5342.           }
  5343.  
  5344.         len = d_pack_length (a);
  5345.         dc = d_left (dc);
  5346.         for (i = 0; i < len; ++i)
  5347.           {
  5348.             dpi->pack_index = i;
  5349.             d_print_comp (dpi, options, dc);
  5350.             if (i < len-1)
  5351.               d_append_string (dpi, ", ");
  5352.           }
  5353.       }
  5354.       return;
  5355.  
  5356.     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
  5357.       {
  5358.         long num = dc->u.s_number.number;
  5359.         if (num == 0)
  5360.           d_append_string (dpi, "this");
  5361.         else
  5362.           {
  5363.             d_append_string (dpi, "{parm#");
  5364.             d_append_num (dpi, num);
  5365.             d_append_char (dpi, '}');
  5366.           }
  5367.       }
  5368.       return;
  5369.  
  5370.     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
  5371.       d_append_string (dpi, "global constructors keyed to ");
  5372.       d_print_comp (dpi, options, dc->u.s_binary.left);
  5373.       return;
  5374.  
  5375.     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
  5376.       d_append_string (dpi, "global destructors keyed to ");
  5377.       d_print_comp (dpi, options, dc->u.s_binary.left);
  5378.       return;
  5379.  
  5380.     case DEMANGLE_COMPONENT_LAMBDA:
  5381.       d_append_string (dpi, "{lambda(");
  5382.       d_print_comp (dpi, options, dc->u.s_unary_num.sub);
  5383.       d_append_string (dpi, ")#");
  5384.       d_append_num (dpi, dc->u.s_unary_num.num + 1);
  5385.       d_append_char (dpi, '}');
  5386.       return;
  5387.  
  5388.     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
  5389.       d_append_string (dpi, "{unnamed type#");
  5390.       d_append_num (dpi, dc->u.s_number.number + 1);
  5391.       d_append_char (dpi, '}');
  5392.       return;
  5393.  
  5394.     case DEMANGLE_COMPONENT_CLONE:
  5395.       d_print_comp (dpi, options, d_left (dc));
  5396.       d_append_string (dpi, " [clone ");
  5397.       d_print_comp (dpi, options, d_right (dc));
  5398.       d_append_char (dpi, ']');
  5399.       return;
  5400.  
  5401.     default:
  5402.       d_print_error (dpi);
  5403.       return;
  5404.     }
  5405. }
  5406.  
  5407. static void
  5408. d_print_comp (struct d_print_info *dpi, int options,
  5409.               const struct demangle_component *dc)
  5410. {
  5411.   struct d_component_stack self;
  5412.  
  5413.   self.dc = dc;
  5414.   self.parent = dpi->component_stack;
  5415.   dpi->component_stack = &self;
  5416.  
  5417.   d_print_comp_inner (dpi, options, dc);
  5418.  
  5419.   dpi->component_stack = self.parent;
  5420. }
  5421.  
  5422. /* Print a Java dentifier.  For Java we try to handle encoded extended
  5423.    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
  5424.    so we don't it for C++.  Characters are encoded as
  5425.    __U<hex-char>+_.  */
  5426.  
  5427. static void
  5428. d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
  5429. {
  5430.   const char *p;
  5431.   const char *end;
  5432.  
  5433.   end = name + len;
  5434.   for (p = name; p < end; ++p)
  5435.     {
  5436.       if (end - p > 3
  5437.           && p[0] == '_'
  5438.           && p[1] == '_'
  5439.           && p[2] == 'U')
  5440.         {
  5441.           unsigned long c;
  5442.           const char *q;
  5443.  
  5444.           c = 0;
  5445.           for (q = p + 3; q < end; ++q)
  5446.             {
  5447.               int dig;
  5448.  
  5449.               if (IS_DIGIT (*q))
  5450.                 dig = *q - '0';
  5451.               else if (*q >= 'A' && *q <= 'F')
  5452.                 dig = *q - 'A' + 10;
  5453.               else if (*q >= 'a' && *q <= 'f')
  5454.                 dig = *q - 'a' + 10;
  5455.               else
  5456.                 break;
  5457.  
  5458.               c = c * 16 + dig;
  5459.             }
  5460.           /* If the Unicode character is larger than 256, we don't try
  5461.              to deal with it here.  FIXME.  */
  5462.           if (q < end && *q == '_' && c < 256)
  5463.             {
  5464.               d_append_char (dpi, c);
  5465.               p = q;
  5466.               continue;
  5467.             }
  5468.         }
  5469.  
  5470.       d_append_char (dpi, *p);
  5471.     }
  5472. }
  5473.  
  5474. /* Print a list of modifiers.  SUFFIX is 1 if we are printing
  5475.    qualifiers on this after printing a function.  */
  5476.  
  5477. static void
  5478. d_print_mod_list (struct d_print_info *dpi, int options,
  5479.                   struct d_print_mod *mods, int suffix)
  5480. {
  5481.   struct d_print_template *hold_dpt;
  5482.  
  5483.   if (mods == NULL || d_print_saw_error (dpi))
  5484.     return;
  5485.  
  5486.   if (mods->printed
  5487.       || (! suffix
  5488.           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
  5489.               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
  5490.               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS
  5491.               || mods->mod->type == DEMANGLE_COMPONENT_REFERENCE_THIS
  5492.               || (mods->mod->type
  5493.                   == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))))
  5494.     {
  5495.       d_print_mod_list (dpi, options, mods->next, suffix);
  5496.       return;
  5497.     }
  5498.  
  5499.   mods->printed = 1;
  5500.  
  5501.   hold_dpt = dpi->templates;
  5502.   dpi->templates = mods->templates;
  5503.  
  5504.   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
  5505.     {
  5506.       d_print_function_type (dpi, options, mods->mod, mods->next);
  5507.       dpi->templates = hold_dpt;
  5508.       return;
  5509.     }
  5510.   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
  5511.     {
  5512.       d_print_array_type (dpi, options, mods->mod, mods->next);
  5513.       dpi->templates = hold_dpt;
  5514.       return;
  5515.     }
  5516.   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
  5517.     {
  5518.       struct d_print_mod *hold_modifiers;
  5519.       struct demangle_component *dc;
  5520.  
  5521.       /* When this is on the modifier stack, we have pulled any
  5522.          qualifiers off the right argument already.  Otherwise, we
  5523.          print it as usual, but don't let the left argument see any
  5524.          modifiers.  */
  5525.  
  5526.       hold_modifiers = dpi->modifiers;
  5527.       dpi->modifiers = NULL;
  5528.       d_print_comp (dpi, options, d_left (mods->mod));
  5529.       dpi->modifiers = hold_modifiers;
  5530.  
  5531.       if ((options & DMGL_JAVA) == 0)
  5532.         d_append_string (dpi, "::");
  5533.       else
  5534.         d_append_char (dpi, '.');
  5535.  
  5536.       dc = d_right (mods->mod);
  5537.  
  5538.       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
  5539.         {
  5540.           d_append_string (dpi, "{default arg#");
  5541.           d_append_num (dpi, dc->u.s_unary_num.num + 1);
  5542.           d_append_string (dpi, "}::");
  5543.           dc = dc->u.s_unary_num.sub;
  5544.         }
  5545.  
  5546.       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
  5547.              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
  5548.              || dc->type == DEMANGLE_COMPONENT_CONST_THIS
  5549.              || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
  5550.              || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
  5551.         dc = d_left (dc);
  5552.  
  5553.       d_print_comp (dpi, options, dc);
  5554.  
  5555.       dpi->templates = hold_dpt;
  5556.       return;
  5557.     }
  5558.  
  5559.   d_print_mod (dpi, options, mods->mod);
  5560.  
  5561.   dpi->templates = hold_dpt;
  5562.  
  5563.   d_print_mod_list (dpi, options, mods->next, suffix);
  5564. }
  5565.  
  5566. /* Print a modifier.  */
  5567.  
  5568. static void
  5569. d_print_mod (struct d_print_info *dpi, int options,
  5570.              const struct demangle_component *mod)
  5571. {
  5572.   switch (mod->type)
  5573.     {
  5574.     case DEMANGLE_COMPONENT_RESTRICT:
  5575.     case DEMANGLE_COMPONENT_RESTRICT_THIS:
  5576.       d_append_string (dpi, " restrict");
  5577.       return;
  5578.     case DEMANGLE_COMPONENT_VOLATILE:
  5579.     case DEMANGLE_COMPONENT_VOLATILE_THIS:
  5580.       d_append_string (dpi, " volatile");
  5581.       return;
  5582.     case DEMANGLE_COMPONENT_CONST:
  5583.     case DEMANGLE_COMPONENT_CONST_THIS:
  5584.       d_append_string (dpi, " const");
  5585.       return;
  5586.     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  5587.       d_append_char (dpi, ' ');
  5588.       d_print_comp (dpi, options, d_right (mod));
  5589.       return;
  5590.     case DEMANGLE_COMPONENT_POINTER:
  5591.       /* There is no pointer symbol in Java.  */
  5592.       if ((options & DMGL_JAVA) == 0)
  5593.         d_append_char (dpi, '*');
  5594.       return;
  5595.     case DEMANGLE_COMPONENT_REFERENCE_THIS:
  5596.       /* For the ref-qualifier, put a space before the &.  */
  5597.       d_append_char (dpi, ' ');
  5598.     case DEMANGLE_COMPONENT_REFERENCE:
  5599.       d_append_char (dpi, '&');
  5600.       return;
  5601.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  5602.       d_append_char (dpi, ' ');
  5603.     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
  5604.       d_append_string (dpi, "&&");
  5605.       return;
  5606.     case DEMANGLE_COMPONENT_COMPLEX:
  5607.       d_append_string (dpi, "complex ");
  5608.       return;
  5609.     case DEMANGLE_COMPONENT_IMAGINARY:
  5610.       d_append_string (dpi, "imaginary ");
  5611.       return;
  5612.     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  5613.       if (d_last_char (dpi) != '(')
  5614.         d_append_char (dpi, ' ');
  5615.       d_print_comp (dpi, options, d_left (mod));
  5616.       d_append_string (dpi, "::*");
  5617.       return;
  5618.     case DEMANGLE_COMPONENT_TYPED_NAME:
  5619.       d_print_comp (dpi, options, d_left (mod));
  5620.       return;
  5621.     case DEMANGLE_COMPONENT_VECTOR_TYPE:
  5622.       d_append_string (dpi, " __vector(");
  5623.       d_print_comp (dpi, options, d_left (mod));
  5624.       d_append_char (dpi, ')');
  5625.       return;
  5626.  
  5627.     default:
  5628.       /* Otherwise, we have something that won't go back on the
  5629.          modifier stack, so we can just print it.  */
  5630.       d_print_comp (dpi, options, mod);
  5631.       return;
  5632.     }
  5633. }
  5634.  
  5635. /* Print a function type, except for the return type.  */
  5636.  
  5637. static void
  5638. d_print_function_type (struct d_print_info *dpi, int options,
  5639.                        const struct demangle_component *dc,
  5640.                        struct d_print_mod *mods)
  5641. {
  5642.   int need_paren;
  5643.   int need_space;
  5644.   struct d_print_mod *p;
  5645.   struct d_print_mod *hold_modifiers;
  5646.  
  5647.   need_paren = 0;
  5648.   need_space = 0;
  5649.   for (p = mods; p != NULL; p = p->next)
  5650.     {
  5651.       if (p->printed)
  5652.         break;
  5653.  
  5654.       switch (p->mod->type)
  5655.         {
  5656.         case DEMANGLE_COMPONENT_POINTER:
  5657.         case DEMANGLE_COMPONENT_REFERENCE:
  5658.         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
  5659.           need_paren = 1;
  5660.           break;
  5661.         case DEMANGLE_COMPONENT_RESTRICT:
  5662.         case DEMANGLE_COMPONENT_VOLATILE:
  5663.         case DEMANGLE_COMPONENT_CONST:
  5664.         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  5665.         case DEMANGLE_COMPONENT_COMPLEX:
  5666.         case DEMANGLE_COMPONENT_IMAGINARY:
  5667.         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  5668.           need_space = 1;
  5669.           need_paren = 1;
  5670.           break;
  5671.         case DEMANGLE_COMPONENT_RESTRICT_THIS:
  5672.         case DEMANGLE_COMPONENT_VOLATILE_THIS:
  5673.         case DEMANGLE_COMPONENT_CONST_THIS:
  5674.         case DEMANGLE_COMPONENT_REFERENCE_THIS:
  5675.         case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  5676.           break;
  5677.         default:
  5678.           break;
  5679.         }
  5680.       if (need_paren)
  5681.         break;
  5682.     }
  5683.  
  5684.   if (need_paren)
  5685.     {
  5686.       if (! need_space)
  5687.         {
  5688.           if (d_last_char (dpi) != '('
  5689.               && d_last_char (dpi) != '*')
  5690.             need_space = 1;
  5691.         }
  5692.       if (need_space && d_last_char (dpi) != ' ')
  5693.         d_append_char (dpi, ' ');
  5694.       d_append_char (dpi, '(');
  5695.     }
  5696.  
  5697.   hold_modifiers = dpi->modifiers;
  5698.   dpi->modifiers = NULL;
  5699.  
  5700.   d_print_mod_list (dpi, options, mods, 0);
  5701.  
  5702.   if (need_paren)
  5703.     d_append_char (dpi, ')');
  5704.  
  5705.   d_append_char (dpi, '(');
  5706.  
  5707.   if (d_right (dc) != NULL)
  5708.     d_print_comp (dpi, options, d_right (dc));
  5709.  
  5710.   d_append_char (dpi, ')');
  5711.  
  5712.   d_print_mod_list (dpi, options, mods, 1);
  5713.  
  5714.   dpi->modifiers = hold_modifiers;
  5715. }
  5716.  
  5717. /* Print an array type, except for the element type.  */
  5718.  
  5719. static void
  5720. d_print_array_type (struct d_print_info *dpi, int options,
  5721.                     const struct demangle_component *dc,
  5722.                     struct d_print_mod *mods)
  5723. {
  5724.   int need_space;
  5725.  
  5726.   need_space = 1;
  5727.   if (mods != NULL)
  5728.     {
  5729.       int need_paren;
  5730.       struct d_print_mod *p;
  5731.  
  5732.       need_paren = 0;
  5733.       for (p = mods; p != NULL; p = p->next)
  5734.         {
  5735.           if (! p->printed)
  5736.             {
  5737.               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
  5738.                 {
  5739.                   need_space = 0;
  5740.                   break;
  5741.                 }
  5742.               else
  5743.                 {
  5744.                   need_paren = 1;
  5745.                   need_space = 1;
  5746.                   break;
  5747.                 }
  5748.             }
  5749.         }
  5750.  
  5751.       if (need_paren)
  5752.         d_append_string (dpi, " (");
  5753.  
  5754.       d_print_mod_list (dpi, options, mods, 0);
  5755.  
  5756.       if (need_paren)
  5757.         d_append_char (dpi, ')');
  5758.     }
  5759.  
  5760.   if (need_space)
  5761.     d_append_char (dpi, ' ');
  5762.  
  5763.   d_append_char (dpi, '[');
  5764.  
  5765.   if (d_left (dc) != NULL)
  5766.     d_print_comp (dpi, options, d_left (dc));
  5767.  
  5768.   d_append_char (dpi, ']');
  5769. }
  5770.  
  5771. /* Print an operator in an expression.  */
  5772.  
  5773. static void
  5774. d_print_expr_op (struct d_print_info *dpi, int options,
  5775.                  const struct demangle_component *dc)
  5776. {
  5777.   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
  5778.     d_append_buffer (dpi, dc->u.s_operator.op->name,
  5779.                      dc->u.s_operator.op->len);
  5780.   else
  5781.     d_print_comp (dpi, options, dc);
  5782. }
  5783.  
  5784. /* Print a cast.  */
  5785.  
  5786. static void
  5787. d_print_cast (struct d_print_info *dpi, int options,
  5788.               const struct demangle_component *dc)
  5789. {
  5790.     d_print_comp (dpi, options, d_left (dc));
  5791. }
  5792.  
  5793. /* Print a conversion operator.  */
  5794.  
  5795. static void
  5796. d_print_conversion (struct d_print_info *dpi, int options,
  5797.                     const struct demangle_component *dc)
  5798. {
  5799.   struct d_print_template dpt;
  5800.  
  5801.   /* For a conversion operator, we need the template parameters from
  5802.      the enclosing template in scope for processing the type.  */
  5803.   if (dpi->current_template != NULL)
  5804.     {
  5805.       dpt.next = dpi->templates;
  5806.       dpi->templates = &dpt;
  5807.       dpt.template_decl = dpi->current_template;
  5808.     }
  5809.  
  5810.   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
  5811.     {
  5812.       d_print_comp (dpi, options, d_left (dc));
  5813.       if (dpi->current_template != NULL)
  5814.         dpi->templates = dpt.next;
  5815.     }
  5816.   else
  5817.     {
  5818.       d_print_comp (dpi, options, d_left (d_left (dc)));
  5819.  
  5820.       /* For a templated cast operator, we need to remove the template
  5821.          parameters from scope after printing the operator name,
  5822.          so we need to handle the template printing here.  */
  5823.       if (dpi->current_template != NULL)
  5824.       dpi->templates = dpt.next;
  5825.  
  5826.       if (d_last_char (dpi) == '<')
  5827.         d_append_char (dpi, ' ');
  5828.       d_append_char (dpi, '<');
  5829.       d_print_comp (dpi, options, d_right (d_left (dc)));
  5830.       /* Avoid generating two consecutive '>' characters, to avoid
  5831.          the C++ syntactic ambiguity.  */
  5832.       if (d_last_char (dpi) == '>')
  5833.         d_append_char (dpi, ' ');
  5834.       d_append_char (dpi, '>');
  5835.     }
  5836. }
  5837.  
  5838. /* Initialize the information structure we use to pass around
  5839.    information.  */
  5840.  
  5841. CP_STATIC_IF_GLIBCPP_V3
  5842. void
  5843. cplus_demangle_init_info (const char *mangled, int options, size_t len,
  5844.                           struct d_info *di)
  5845. {
  5846.   di->s = mangled;
  5847.   di->send = mangled + len;
  5848.   di->options = options;
  5849.  
  5850.   di->n = mangled;
  5851.  
  5852.   /* We can not need more components than twice the number of chars in
  5853.      the mangled string.  Most components correspond directly to
  5854.      chars, but the ARGLIST types are exceptions.  */
  5855.   di->num_comps = 2 * len;
  5856.   di->next_comp = 0;
  5857.  
  5858.   /* Similarly, we can not need more substitutions than there are
  5859.      chars in the mangled string.  */
  5860.   di->num_subs = len;
  5861.   di->next_sub = 0;
  5862.   di->did_subs = 0;
  5863.  
  5864.   di->last_name = NULL;
  5865.  
  5866.   di->expansion = 0;
  5867.   di->is_expression = 0;
  5868.   di->is_conversion = 0;
  5869. }
  5870.  
  5871. /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
  5872.    mangled name, return strings in repeated callback giving the demangled
  5873.    name.  OPTIONS is the usual libiberty demangler options.  On success,
  5874.    this returns 1.  On failure, returns 0.  */
  5875.  
  5876. static int
  5877. d_demangle_callback (const char *mangled, int options,
  5878.                      demangle_callbackref callback, void *opaque)
  5879. {
  5880.   enum
  5881.     {
  5882.       DCT_TYPE,
  5883.       DCT_MANGLED,
  5884.       DCT_GLOBAL_CTORS,
  5885.       DCT_GLOBAL_DTORS
  5886.     }
  5887.   type;
  5888.   struct d_info di;
  5889.   struct demangle_component *dc;
  5890.   int status;
  5891.  
  5892.   if (mangled[0] == '_' && mangled[1] == 'Z')
  5893.     type = DCT_MANGLED;
  5894.   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
  5895.            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
  5896.            && (mangled[9] == 'D' || mangled[9] == 'I')
  5897.            && mangled[10] == '_')
  5898.     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
  5899.   else
  5900.     {
  5901.       if ((options & DMGL_TYPES) == 0)
  5902.         return 0;
  5903.       type = DCT_TYPE;
  5904.     }
  5905.  
  5906.   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
  5907.  
  5908.   {
  5909. #ifdef CP_DYNAMIC_ARRAYS
  5910.     __extension__ struct demangle_component comps[di.num_comps];
  5911.     __extension__ struct demangle_component *subs[di.num_subs];
  5912.  
  5913.     di.comps = comps;
  5914.     di.subs = subs;
  5915. #else
  5916.     di.comps = alloca (di.num_comps * sizeof (*di.comps));
  5917.     di.subs = alloca (di.num_subs * sizeof (*di.subs));
  5918. #endif
  5919.  
  5920.     switch (type)
  5921.       {
  5922.       case DCT_TYPE:
  5923.         dc = cplus_demangle_type (&di);
  5924.         break;
  5925.       case DCT_MANGLED:
  5926.         dc = cplus_demangle_mangled_name (&di, 1);
  5927.         break;
  5928.       case DCT_GLOBAL_CTORS:
  5929.       case DCT_GLOBAL_DTORS:
  5930.         d_advance (&di, 11);
  5931.         dc = d_make_comp (&di,
  5932.                           (type == DCT_GLOBAL_CTORS
  5933.                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
  5934.                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
  5935.                           d_make_demangle_mangled_name (&di, d_str (&di)),
  5936.                           NULL);
  5937.         d_advance (&di, strlen (d_str (&di)));
  5938.         break;
  5939.       default:
  5940.         abort (); /* We have listed all the cases.  */
  5941.       }
  5942.  
  5943.     /* If DMGL_PARAMS is set, then if we didn't consume the entire
  5944.        mangled string, then we didn't successfully demangle it.  If
  5945.        DMGL_PARAMS is not set, we didn't look at the trailing
  5946.        parameters.  */
  5947.     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
  5948.       dc = NULL;
  5949.  
  5950. #ifdef CP_DEMANGLE_DEBUG
  5951.     d_dump (dc, 0);
  5952. #endif
  5953.  
  5954.     status = (dc != NULL)
  5955.              ? cplus_demangle_print_callback (options, dc, callback, opaque)
  5956.              : 0;
  5957.   }
  5958.  
  5959.   return status;
  5960. }
  5961.  
  5962. /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
  5963.    name, return a buffer allocated with malloc holding the demangled
  5964.    name.  OPTIONS is the usual libiberty demangler options.  On
  5965.    success, this sets *PALC to the allocated size of the returned
  5966.    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
  5967.    a memory allocation failure, and returns NULL.  */
  5968.  
  5969. static char *
  5970. d_demangle (const char *mangled, int options, size_t *palc)
  5971. {
  5972.   struct d_growable_string dgs;
  5973.   int status;
  5974.  
  5975.   d_growable_string_init (&dgs, 0);
  5976.  
  5977.   status = d_demangle_callback (mangled, options,
  5978.                                 d_growable_string_callback_adapter, &dgs);
  5979.   if (status == 0)
  5980.     {
  5981.       free (dgs.buf);
  5982.       *palc = 0;
  5983.       return NULL;
  5984.     }
  5985.  
  5986.   *palc = dgs.allocation_failure ? 1 : dgs.alc;
  5987.   return dgs.buf;
  5988. }
  5989.  
  5990. #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
  5991.  
  5992. extern char *__cxa_demangle (const char *, char *, size_t *, int *);
  5993.  
  5994. /* ia64 ABI-mandated entry point in the C++ runtime library for
  5995.    performing demangling.  MANGLED_NAME is a NUL-terminated character
  5996.    string containing the name to be demangled.
  5997.  
  5998.    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
  5999.    *LENGTH bytes, into which the demangled name is stored.  If
  6000.    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
  6001.    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
  6002.    is placed in a region of memory allocated with malloc.
  6003.  
  6004.    If LENGTH is non-NULL, the length of the buffer containing the
  6005.    demangled name, is placed in *LENGTH.
  6006.  
  6007.    The return value is a pointer to the start of the NUL-terminated
  6008.    demangled name, or NULL if the demangling fails.  The caller is
  6009.    responsible for deallocating this memory using free.
  6010.  
  6011.    *STATUS is set to one of the following values:
  6012.       0: The demangling operation succeeded.
  6013.      -1: A memory allocation failure occurred.
  6014.      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
  6015.      -3: One of the arguments is invalid.
  6016.  
  6017.    The demangling is performed using the C++ ABI mangling rules, with
  6018.    GNU extensions.  */
  6019.  
  6020. char *
  6021. __cxa_demangle (const char *mangled_name, char *output_buffer,
  6022.                 size_t *length, int *status)
  6023. {
  6024.   char *demangled;
  6025.   size_t alc;
  6026.  
  6027.   if (mangled_name == NULL)
  6028.     {
  6029.       if (status != NULL)
  6030.         *status = -3;
  6031.       return NULL;
  6032.     }
  6033.  
  6034.   if (output_buffer != NULL && length == NULL)
  6035.     {
  6036.       if (status != NULL)
  6037.         *status = -3;
  6038.       return NULL;
  6039.     }
  6040.  
  6041.   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
  6042.  
  6043.   if (demangled == NULL)
  6044.     {
  6045.       if (status != NULL)
  6046.         {
  6047.           if (alc == 1)
  6048.             *status = -1;
  6049.           else
  6050.             *status = -2;
  6051.         }
  6052.       return NULL;
  6053.     }
  6054.  
  6055.   if (output_buffer == NULL)
  6056.     {
  6057.       if (length != NULL)
  6058.         *length = alc;
  6059.     }
  6060.   else
  6061.     {
  6062.       if (strlen (demangled) < *length)
  6063.         {
  6064.           strcpy (output_buffer, demangled);
  6065.           free (demangled);
  6066.           demangled = output_buffer;
  6067.         }
  6068.       else
  6069.         {
  6070.           free (output_buffer);
  6071.           *length = alc;
  6072.         }
  6073.     }
  6074.  
  6075.   if (status != NULL)
  6076.     *status = 0;
  6077.  
  6078.   return demangled;
  6079. }
  6080.  
  6081. extern int __gcclibcxx_demangle_callback (const char *,
  6082.                                           void (*)
  6083.                                             (const char *, size_t, void *),
  6084.                                           void *);
  6085.  
  6086. /* Alternative, allocationless entry point in the C++ runtime library
  6087.    for performing demangling.  MANGLED_NAME is a NUL-terminated character
  6088.    string containing the name to be demangled.
  6089.  
  6090.    CALLBACK is a callback function, called with demangled string
  6091.    segments as demangling progresses; it is called at least once,
  6092.    but may be called more than once.  OPAQUE is a generalized pointer
  6093.    used as a callback argument.
  6094.  
  6095.    The return code is one of the following values, equivalent to
  6096.    the STATUS values of __cxa_demangle() (excluding -1, since this
  6097.    function performs no memory allocations):
  6098.       0: The demangling operation succeeded.
  6099.      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
  6100.      -3: One of the arguments is invalid.
  6101.  
  6102.    The demangling is performed using the C++ ABI mangling rules, with
  6103.    GNU extensions.  */
  6104.  
  6105. int
  6106. __gcclibcxx_demangle_callback (const char *mangled_name,
  6107.                                void (*callback) (const char *, size_t, void *),
  6108.                                void *opaque)
  6109. {
  6110.   int status;
  6111.  
  6112.   if (mangled_name == NULL || callback == NULL)
  6113.     return -3;
  6114.  
  6115.   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
  6116.                                 callback, opaque);
  6117.   if (status == 0)
  6118.     return -2;
  6119.  
  6120.   return 0;
  6121. }
  6122.  
  6123. #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
  6124.  
  6125. /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
  6126.    mangled name, return a buffer allocated with malloc holding the
  6127.    demangled name.  Otherwise, return NULL.  */
  6128.  
  6129. char *
  6130. cplus_demangle_v3 (const char *mangled, int options)
  6131. {
  6132.   size_t alc;
  6133.  
  6134.   return d_demangle (mangled, options, &alc);
  6135. }
  6136.  
  6137. int
  6138. cplus_demangle_v3_callback (const char *mangled, int options,
  6139.                             demangle_callbackref callback, void *opaque)
  6140. {
  6141.   return d_demangle_callback (mangled, options, callback, opaque);
  6142. }
  6143.  
  6144. /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
  6145.    conventions, but the output formatting is a little different.
  6146.    This instructs the C++ demangler not to emit pointer characters ("*"), to
  6147.    use Java's namespace separator symbol ("." instead of "::"), and to output
  6148.    JArray<TYPE> as TYPE[].  */
  6149.  
  6150. char *
  6151. java_demangle_v3 (const char *mangled)
  6152. {
  6153.   size_t alc;
  6154.  
  6155.   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
  6156. }
  6157.  
  6158. int
  6159. java_demangle_v3_callback (const char *mangled,
  6160.                            demangle_callbackref callback, void *opaque)
  6161. {
  6162.   return d_demangle_callback (mangled,
  6163.                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
  6164.                               callback, opaque);
  6165. }
  6166.  
  6167. #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
  6168.  
  6169. #ifndef IN_GLIBCPP_V3
  6170.  
  6171. /* Demangle a string in order to find out whether it is a constructor
  6172.    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
  6173.    *DTOR_KIND appropriately.  */
  6174.  
  6175. static int
  6176. is_ctor_or_dtor (const char *mangled,
  6177.                  enum gnu_v3_ctor_kinds *ctor_kind,
  6178.                  enum gnu_v3_dtor_kinds *dtor_kind)
  6179. {
  6180.   struct d_info di;
  6181.   struct demangle_component *dc;
  6182.   int ret;
  6183.  
  6184.   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
  6185.   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
  6186.  
  6187.   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
  6188.  
  6189.   {
  6190. #ifdef CP_DYNAMIC_ARRAYS
  6191.     __extension__ struct demangle_component comps[di.num_comps];
  6192.     __extension__ struct demangle_component *subs[di.num_subs];
  6193.  
  6194.     di.comps = comps;
  6195.     di.subs = subs;
  6196. #else
  6197.     di.comps = alloca (di.num_comps * sizeof (*di.comps));
  6198.     di.subs = alloca (di.num_subs * sizeof (*di.subs));
  6199. #endif
  6200.  
  6201.     dc = cplus_demangle_mangled_name (&di, 1);
  6202.  
  6203.     /* Note that because we did not pass DMGL_PARAMS, we don't expect
  6204.        to demangle the entire string.  */
  6205.  
  6206.     ret = 0;
  6207.     while (dc != NULL)
  6208.       {
  6209.         switch (dc->type)
  6210.           {
  6211.             /* These cannot appear on a constructor or destructor.  */
  6212.           case DEMANGLE_COMPONENT_RESTRICT_THIS:
  6213.           case DEMANGLE_COMPONENT_VOLATILE_THIS:
  6214.           case DEMANGLE_COMPONENT_CONST_THIS:
  6215.           case DEMANGLE_COMPONENT_REFERENCE_THIS:
  6216.           case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  6217.           default:
  6218.             dc = NULL;
  6219.             break;
  6220.           case DEMANGLE_COMPONENT_TYPED_NAME:
  6221.           case DEMANGLE_COMPONENT_TEMPLATE:
  6222.             dc = d_left (dc);
  6223.             break;
  6224.           case DEMANGLE_COMPONENT_QUAL_NAME:
  6225.           case DEMANGLE_COMPONENT_LOCAL_NAME:
  6226.             dc = d_right (dc);
  6227.             break;
  6228.           case DEMANGLE_COMPONENT_CTOR:
  6229.             *ctor_kind = dc->u.s_ctor.kind;
  6230.             ret = 1;
  6231.             dc = NULL;
  6232.             break;
  6233.           case DEMANGLE_COMPONENT_DTOR:
  6234.             *dtor_kind = dc->u.s_dtor.kind;
  6235.             ret = 1;
  6236.             dc = NULL;
  6237.             break;
  6238.           }
  6239.       }
  6240.   }
  6241.  
  6242.   return ret;
  6243. }
  6244.  
  6245. /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
  6246.    name.  A non-zero return indicates the type of constructor.  */
  6247.  
  6248. enum gnu_v3_ctor_kinds
  6249. is_gnu_v3_mangled_ctor (const char *name)
  6250. {
  6251.   enum gnu_v3_ctor_kinds ctor_kind;
  6252.   enum gnu_v3_dtor_kinds dtor_kind;
  6253.  
  6254.   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
  6255.     return (enum gnu_v3_ctor_kinds) 0;
  6256.   return ctor_kind;
  6257. }
  6258.  
  6259.  
  6260. /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
  6261.    name.  A non-zero return indicates the type of destructor.  */
  6262.  
  6263. enum gnu_v3_dtor_kinds
  6264. is_gnu_v3_mangled_dtor (const char *name)
  6265. {
  6266.   enum gnu_v3_ctor_kinds ctor_kind;
  6267.   enum gnu_v3_dtor_kinds dtor_kind;
  6268.  
  6269.   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
  6270.     return (enum gnu_v3_dtor_kinds) 0;
  6271.   return dtor_kind;
  6272. }
  6273.  
  6274. #endif /* IN_GLIBCPP_V3 */
  6275.  
  6276. #ifdef STANDALONE_DEMANGLER
  6277.  
  6278. #include "getopt.h"
  6279. #include "dyn-string.h"
  6280.  
  6281. static void print_usage (FILE* fp, int exit_value);
  6282.  
  6283. #define IS_ALPHA(CHAR)                                                  \
  6284.   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
  6285.    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
  6286.  
  6287. /* Non-zero if CHAR is a character than can occur in a mangled name.  */
  6288. #define is_mangled_char(CHAR)                                           \
  6289.   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
  6290.    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
  6291.  
  6292. /* The name of this program, as invoked.  */
  6293. const char* program_name;
  6294.  
  6295. /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
  6296.  
  6297. static void
  6298. print_usage (FILE* fp, int exit_value)
  6299. {
  6300.   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
  6301.   fprintf (fp, "Options:\n");
  6302.   fprintf (fp, "  -h,--help       Display this message.\n");
  6303.   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
  6304.   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
  6305.   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
  6306.  
  6307.   exit (exit_value);
  6308. }
  6309.  
  6310. /* Option specification for getopt_long.  */
  6311. static const struct option long_options[] =
  6312. {
  6313.   { "help",      no_argument, NULL, 'h' },
  6314.   { "no-params", no_argument, NULL, 'p' },
  6315.   { "verbose",   no_argument, NULL, 'v' },
  6316.   { NULL,        no_argument, NULL, 0   },
  6317. };
  6318.  
  6319. /* Main entry for a demangling filter executable.  It will demangle
  6320.    its command line arguments, if any.  If none are provided, it will
  6321.    filter stdin to stdout, replacing any recognized mangled C++ names
  6322.    with their demangled equivalents.  */
  6323.  
  6324. int
  6325. main (int argc, char *argv[])
  6326. {
  6327.   int i;
  6328.   int opt_char;
  6329.   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
  6330.  
  6331.   /* Use the program name of this program, as invoked.  */
  6332.   program_name = argv[0];
  6333.  
  6334.   /* Parse options.  */
  6335.   do
  6336.     {
  6337.       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
  6338.       switch (opt_char)
  6339.         {
  6340.         case '?':  /* Unrecognized option.  */
  6341.           print_usage (stderr, 1);
  6342.           break;
  6343.  
  6344.         case 'h':
  6345.           print_usage (stdout, 0);
  6346.           break;
  6347.  
  6348.         case 'p':
  6349.           options &= ~ DMGL_PARAMS;
  6350.           break;
  6351.  
  6352.         case 'v':
  6353.           options |= DMGL_VERBOSE;
  6354.           break;
  6355.         }
  6356.     }
  6357.   while (opt_char != -1);
  6358.  
  6359.   if (optind == argc)
  6360.     /* No command line arguments were provided.  Filter stdin.  */
  6361.     {
  6362.       dyn_string_t mangled = dyn_string_new (3);
  6363.       char *s;
  6364.  
  6365.       /* Read all of input.  */
  6366.       while (!feof (stdin))
  6367.         {
  6368.           char c;
  6369.  
  6370.           /* Pile characters into mangled until we hit one that can't
  6371.              occur in a mangled name.  */
  6372.           c = getchar ();
  6373.           while (!feof (stdin) && is_mangled_char (c))
  6374.             {
  6375.               dyn_string_append_char (mangled, c);
  6376.               if (feof (stdin))
  6377.                 break;
  6378.               c = getchar ();
  6379.             }
  6380.  
  6381.           if (dyn_string_length (mangled) > 0)
  6382.             {
  6383. #ifdef IN_GLIBCPP_V3
  6384.               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
  6385. #else
  6386.               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
  6387. #endif
  6388.  
  6389.               if (s != NULL)
  6390.                 {
  6391.                   fputs (s, stdout);
  6392.                   free (s);
  6393.                 }
  6394.               else
  6395.                 {
  6396.                   /* It might not have been a mangled name.  Print the
  6397.                      original text.  */
  6398.                   fputs (dyn_string_buf (mangled), stdout);
  6399.                 }
  6400.  
  6401.               dyn_string_clear (mangled);
  6402.             }
  6403.  
  6404.           /* If we haven't hit EOF yet, we've read one character that
  6405.              can't occur in a mangled name, so print it out.  */
  6406.           if (!feof (stdin))
  6407.             putchar (c);
  6408.         }
  6409.  
  6410.       dyn_string_delete (mangled);
  6411.     }
  6412.   else
  6413.     /* Demangle command line arguments.  */
  6414.     {
  6415.       /* Loop over command line arguments.  */
  6416.       for (i = optind; i < argc; ++i)
  6417.         {
  6418.           char *s;
  6419. #ifdef IN_GLIBCPP_V3
  6420.           int status;
  6421. #endif
  6422.  
  6423.           /* Attempt to demangle.  */
  6424. #ifdef IN_GLIBCPP_V3
  6425.           s = __cxa_demangle (argv[i], NULL, NULL, &status);
  6426. #else
  6427.           s = cplus_demangle_v3 (argv[i], options);
  6428. #endif
  6429.  
  6430.           /* If it worked, print the demangled name.  */
  6431.           if (s != NULL)
  6432.             {
  6433.               printf ("%s\n", s);
  6434.               free (s);
  6435.             }
  6436.           else
  6437.             {
  6438. #ifdef IN_GLIBCPP_V3
  6439.               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
  6440. #else
  6441.               fprintf (stderr, "Failed: %s\n", argv[i]);
  6442. #endif
  6443.             }
  6444.         }
  6445.     }
  6446.  
  6447.   return 0;
  6448. }
  6449.  
  6450. #endif /* STANDALONE_DEMANGLER */
  6451.