/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/cp-demangle.c

Bug Summary

File:	build/libiberty/cp-demangle.c
Warning:	line 5196, column 19 Assigned value is garbage or undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cp-demangle.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 1 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libiberty -resource-dir /usr/lib64/clang/15.0.7 -D HAVE_CONFIG_H -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/../include -D _GNU_SOURCE -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wwrite-strings -fconst-strings -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libiberty -ferror-limit 19 -fcf-protection=full -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-tefCWL.plist -x c /buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/cp-demangle.c
1/* Demangler for g++ V3 ABI.
 Copyright (C) 2003-2023 Free Software Foundation, Inc.
 Written by Ian Lance Taylor <ian@wasabisystems.com>.

 This file is part of the libiberty library, which is part of GCC.

 This file is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 In addition to the permissions in the GNU General Public License, the
 Free Software Foundation gives you unlimited permission to link the
 compiled version of this file into combinations with other programs,
 and to distribute those combinations without any restriction coming
 from the use of this file.  (The General Public License restrictions
 do apply in other respects; for example, they cover modification of
 the file, and distribution when not linked into a combined
 executable.)

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. 
29*/

31/* This code implements a demangler for the g++ V3 ABI.  The ABI is
 described on this web page:
     https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling

 This code was written while looking at the demangler written by
 Alex Samuel <samuel@codesourcery.com>.

 This code first pulls the mangled name apart into a list of
 components, and then walks the list generating the demangled
 name.

 This file will normally define the following functions, q.v.:
    char *cplus_demangle_v3(const char *mangled, int options)
    char *java_demangle_v3(const char *mangled)
    int cplus_demangle_v3_callback(const char *mangled, int options,
                                   demangle_callbackref callback)
    int java_demangle_v3_callback(const char *mangled,
                                  demangle_callbackref callback)
    enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
    enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)

 Also, the interface to the component list is public, and defined in
 demangle.h.  The interface consists of these types, which are
 defined in demangle.h:
    enum demangle_component_type
    struct demangle_component
    demangle_callbackref
 and these functions defined in this file:
    cplus_demangle_fill_name
    cplus_demangle_fill_extended_operator
    cplus_demangle_fill_ctor
    cplus_demangle_fill_dtor
    cplus_demangle_print
    cplus_demangle_print_callback
 and other functions defined in the file cp-demint.c.

 This file also defines some other functions and variables which are
 only to be used by the file cp-demint.c.

 Preprocessor macros you can define while compiling this file:

 IN_LIBGCC2
    If defined, this file defines the following functions, q.v.:
       char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
                             int *status)
       int __gcclibcxx_demangle_callback (const char *,
                                          void (*)
                                            (const char *, size_t, void *),
                                          void *)
    instead of cplus_demangle_v3[_callback]() and
    java_demangle_v3[_callback]().

 IN_GLIBCPP_V3
    If defined, this file defines only __cxa_demangle() and
    __gcclibcxx_demangle_callback(), and no other publically visible
    functions or variables.

 STANDALONE_DEMANGLER
    If defined, this file defines a main() function which demangles
    any arguments, or, if none, demangles stdin.

 CP_DEMANGLE_DEBUG
    If defined, turns on debugging mode, which prints information on
    stdout about the mangled string.  This is not generally useful.

 CHECK_DEMANGLER
    If defined, additional sanity checks will be performed.  It will
    cause some slowdown, but will allow to catch out-of-bound access
    errors earlier.  This macro is intended for testing and debugging.  */

101#if defined (_AIX) && !defined (__GNUC__4)
#pragma alloca
103#endif

105#ifdef HAVE_CONFIG_H1
106#include "config.h"
107#endif

109#include <stdio.h>

111#ifdef HAVE_STDLIB_H1
112#include <stdlib.h>
113#endif
114#ifdef HAVE_STRING_H1
115#include <string.h>
116#endif

118#ifdef HAVE_ALLOCA_H1
119# include <alloca.h>
120#else
121# ifndef alloca
122#  ifdef __GNUC__4
123#   define alloca __builtin_alloca
124#  else
125extern char *alloca ()__builtin_alloca();
126#  endif /* __GNUC__ */
127# endif /* alloca */
128#endif /* HAVE_ALLOCA_H */

130#ifdef HAVE_LIMITS_H1
131#include <limits.h>
132#endif
133#ifndef INT_MAX2147483647
134# define INT_MAX2147483647       (int)(((unsigned int) ~0) >> 1)          /* 0x7FFFFFFF */ 
135#endif

137#include "ansidecl.h"
138#include "libiberty.h"
139#include "demangle.h"
140#include "cp-demangle.h"

142/* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
 also rename them via #define to avoid compiler errors when the
 static definition conflicts with the extern declaration in a header
 file.  */
146#ifdef IN_GLIBCPP_V3

148#define CP_STATIC_IF_GLIBCPP_V3 static

150#define cplus_demangle_fill_name d_fill_name
151static int d_fill_name (struct demangle_component *, const char *, int);

153#define cplus_demangle_fill_extended_operator d_fill_extended_operator
154static int
155d_fill_extended_operator (struct demangle_component *, int,
                        struct demangle_component *);

158#define cplus_demangle_fill_ctor d_fill_ctor
159static int
160d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
           struct demangle_component *);

163#define cplus_demangle_fill_dtor d_fill_dtor
164static int
165d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
           struct demangle_component *);

168#define cplus_demangle_mangled_name d_mangled_name
169static struct demangle_component *d_mangled_name (struct d_info *, int);

171#define cplus_demangle_type d_type
172static struct demangle_component *d_type (struct d_info *);

174#define cplus_demangle_print d_print
175static char *d_print (int, struct demangle_component *, int, size_t *);

177#define cplus_demangle_print_callback d_print_callback
178static int d_print_callback (int, struct demangle_component *,
                           demangle_callbackref, void *);

181#define cplus_demangle_init_info d_init_info
182static void d_init_info (const char *, int, size_t, struct d_info *);

184#else /* ! defined(IN_GLIBCPP_V3) */
185#define CP_STATIC_IF_GLIBCPP_V3
186#endif /* ! defined(IN_GLIBCPP_V3) */

188/* See if the compiler supports dynamic arrays.  */

190#ifdef __GNUC__4
191#define CP_DYNAMIC_ARRAYS
192#else
193#ifdef __STDC__1
194#ifdef __STDC_VERSION__201710L
195#if __STDC_VERSION__201710L >= 199901L && !__STDC_NO_VLA__
196#define CP_DYNAMIC_ARRAYS
197#endif /* __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ */
198#endif /* defined (__STDC_VERSION__) */
199#endif /* defined (__STDC__) */
200#endif /* ! defined (__GNUC__) */

202/* We avoid pulling in the ctype tables, to prevent pulling in
 additional unresolved symbols when this code is used in a library.
 FIXME: Is this really a valid reason?  This comes from the original
 V3 demangler code.

 As of this writing this file has the following undefined references
 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
 strcat, strlen.  */

211#define IS_DIGIT(c)((c) >= '0' && (c) <= '9') ((c) >= '0' && (c) <= '9')
212#define IS_UPPER(c)((c) >= 'A' && (c) <= 'Z') ((c) >= 'A' && (c) <= 'Z')
213#define IS_LOWER(c)((c) >= 'a' && (c) <= 'z') ((c) >= 'a' && (c) <= 'z')

215/* The prefix prepended by GCC to an identifier represnting the
 anonymous namespace.  */
217#define ANONYMOUS_NAMESPACE_PREFIX"_GLOBAL_" "_GLOBAL_"
218#define ANONYMOUS_NAMESPACE_PREFIX_LEN(sizeof ("_GLOBAL_") - 1) \
(sizeof (ANONYMOUS_NAMESPACE_PREFIX"_GLOBAL_") - 1)

221/* Information we keep for the standard substitutions.  */

223struct d_standard_sub_info
224{
/* The code for this substitution.  */
char code;
/* The simple string it expands to.  */
const char *simple_expansion;
/* The length of the simple expansion.  */
int simple_len;
/* The results of a full, verbose, expansion.  This is used when
   qualifying a constructor/destructor, or when in verbose mode.  */
const char *full_expansion;
/* The length of the full expansion.  */
int full_len;
/* What to set the last_name field of d_info to; NULL if we should
   not set it.  This is only relevant when qualifying a
   constructor/destructor.  */
const char *set_last_name;
/* The length of set_last_name.  */
int set_last_name_len;
242};

244/* Accessors for subtrees of struct demangle_component.  */

246#define d_left(dc)((dc)->u.s_binary.left) ((dc)->u.s_binary.left)
247#define d_right(dc)((dc)->u.s_binary.right) ((dc)->u.s_binary.right)

249/* A list of templates.  This is used while printing.  */

251struct d_print_template
252{
/* Next template on the list.  */
struct d_print_template *next;
/* This template.  */
const struct demangle_component *template_decl;
257};

259/* A list of type modifiers.  This is used while printing.  */

261struct d_print_mod
262{
/* Next modifier on the list.  These are in the reverse of the order
   in which they appeared in the mangled string.  */
struct d_print_mod *next;
/* The modifier.  */
struct demangle_component *mod;
/* Whether this modifier was printed.  */
int printed;
/* The list of templates which applies to this modifier.  */
struct d_print_template *templates;
272};

274/* We use these structures to hold information during printing.  */

276struct d_growable_string
277{
/* Buffer holding the result.  */
char *buf;
/* Current length of data in buffer.  */
size_t len;
/* Allocated size of buffer.  */
size_t alc;
/* Set to 1 if we had a memory allocation failure.  */
int allocation_failure;
286};

288/* Stack of components, innermost first, used to avoid loops.  */

290struct d_component_stack
291{
/* This component.  */
const struct demangle_component *dc;
/* This component's parent.  */
const struct d_component_stack *parent;
296};

298/* A demangle component and some scope captured when it was first
 traversed.  */

301struct d_saved_scope
302{
/* The component whose scope this is.  */
const struct demangle_component *container;
/* The list of templates, if any, that was current when this
   scope was captured.  */
struct d_print_template *templates;
308};

310/* Checkpoint structure to allow backtracking.  This holds copies
 of the fields of struct d_info that need to be restored
 if a trial parse needs to be backtracked over.  */

314struct d_info_checkpoint
315{
const char *n;
int next_comp;
int next_sub;
int expansion;
320};

322/* Maximum number of times d_print_comp may be called recursively.  */
323#define MAX_RECURSION_COUNT1024 1024

325enum { D_PRINT_BUFFER_LENGTH = 256 };
326struct d_print_info
327{
/* Fixed-length allocated buffer for demangled data, flushed to the
   callback with a NUL termination once full.  */
char buf[D_PRINT_BUFFER_LENGTH];
/* Current length of data in buffer.  */
size_t len;
/* The last character printed, saved individually so that it survives
   any buffer flush.  */
char last_char;
/* Callback function to handle demangled buffer flush.  */
demangle_callbackref callback;
/* Opaque callback argument.  */
void *opaque;
/* The current list of templates, if any.  */
struct d_print_template *templates;
/* The current list of modifiers (e.g., pointer, reference, etc.),
   if any.  */
struct d_print_mod *modifiers;
/* Set to 1 if we saw a demangling error.  */
int demangle_failure;
/* Number of times d_print_comp was recursively called.  Should not
   be bigger than MAX_RECURSION_COUNT.  */
int recursion;
/* 1 more than the number of explicit template parms of a lambda.  Template
   parm references >= are actually 'auto'.  */
int lambda_tpl_parms;
/* The current index into any template argument packs we are using
   for printing, or -1 to print the whole pack.  */
int pack_index;
/* Number of d_print_flush calls so far.  */
unsigned long int flush_count;
/* Stack of components, innermost first, used to avoid loops.  */
const struct d_component_stack *component_stack;
/* Array of saved scopes for evaluating substitutions.  */
struct d_saved_scope *saved_scopes;
/* Index of the next unused saved scope in the above array.  */
int next_saved_scope;
/* Number of saved scopes in the above array.  */
int num_saved_scopes;
/* Array of templates for saving into scopes.  */
struct d_print_template *copy_templates;
/* Index of the next unused copy template in the above array.  */
int next_copy_template;
/* Number of copy templates in the above array.  */
int num_copy_templates;
/* The nearest enclosing template, if any.  */
const struct demangle_component *current_template;
374};

376#ifdef CP_DEMANGLE_DEBUG
377static void d_dump (struct demangle_component *, int);
378#endif

380static struct demangle_component *
381d_make_empty (struct d_info *);

383static struct demangle_component *
384d_make_comp (struct d_info *, enum demangle_component_type,
           struct demangle_component *,
           struct demangle_component *);

388static struct demangle_component *
389d_make_name (struct d_info *, const char *, int);

391static struct demangle_component *
392d_make_demangle_mangled_name (struct d_info *, const char *);

394static struct demangle_component *
395d_make_builtin_type (struct d_info *,
                   const struct demangle_builtin_type_info *);

398static struct demangle_component *
399d_make_operator (struct d_info *,
               const struct demangle_operator_info *);

402static struct demangle_component *
403d_make_extended_operator (struct d_info *, int,
                        struct demangle_component *);

406static struct demangle_component *
407d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
           struct demangle_component *);

410static struct demangle_component *
411d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
           struct demangle_component *);

414static struct demangle_component *
415d_make_template_param (struct d_info *, int);

417static struct demangle_component *
418d_make_sub (struct d_info *, const char *, int);

420static int
421has_return_type (struct demangle_component *);

423static int
424is_ctor_dtor_or_conversion (struct demangle_component *);

426static struct demangle_component *d_encoding (struct d_info *, int);

428static struct demangle_component *d_name (struct d_info *, int substable);

430static struct demangle_component *d_nested_name (struct d_info *);

432static int d_maybe_module_name (struct d_info *, struct demangle_component **);

434static struct demangle_component *d_prefix (struct d_info *, int);

436static struct demangle_component *d_unqualified_name (struct d_info *,
struct demangle_component *scope, struct demangle_component *module);

439static struct demangle_component *d_source_name (struct d_info *);

441static int d_number (struct d_info *);

443static struct demangle_component *d_identifier (struct d_info *, int);

445static struct demangle_component *d_operator_name (struct d_info *);

447static struct demangle_component *d_special_name (struct d_info *);

449static struct demangle_component *d_parmlist (struct d_info *);

451static int d_call_offset (struct d_info *, int);

453static struct demangle_component *d_ctor_dtor_name (struct d_info *);

455static struct demangle_component **
456d_cv_qualifiers (struct d_info *, struct demangle_component **, int);

458static struct demangle_component *
459d_ref_qualifier (struct d_info *, struct demangle_component *);

461static struct demangle_component *
462d_function_type (struct d_info *);

464static struct demangle_component *
465d_bare_function_type (struct d_info *, int);

467static struct demangle_component *
468d_class_enum_type (struct d_info *, int);

470static struct demangle_component *d_array_type (struct d_info *);

472static struct demangle_component *d_vector_type (struct d_info *);

474static struct demangle_component *
475d_pointer_to_member_type (struct d_info *);

477static struct demangle_component *
478d_template_param (struct d_info *);

480static struct demangle_component *d_template_args (struct d_info *);
481static struct demangle_component *d_template_args_1 (struct d_info *);

483static struct demangle_component *
484d_template_arg (struct d_info *);

486static struct demangle_component *d_expression (struct d_info *);

488static struct demangle_component *d_expr_primary (struct d_info *);

490static struct demangle_component *d_local_name (struct d_info *);

492static int d_discriminator (struct d_info *);

494static struct demangle_component *d_template_parm (struct d_info *, int *bad);

496static struct demangle_component *d_template_head (struct d_info *, int *bad);

498static struct demangle_component *d_lambda (struct d_info *);

500static struct demangle_component *d_unnamed_type (struct d_info *);

502static struct demangle_component *
503d_clone_suffix (struct d_info *, struct demangle_component *);

505static int
506d_add_substitution (struct d_info *, struct demangle_component *);

508static struct demangle_component *d_substitution (struct d_info *, int);

510static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);

512static void d_backtrack (struct d_info *, struct d_info_checkpoint *);

514static void d_growable_string_init (struct d_growable_string *, size_t);

516static inline void
517d_growable_string_resize (struct d_growable_string *, size_t);

519static inline void
520d_growable_string_append_buffer (struct d_growable_string *,
                               const char *, size_t);
522static void
523d_growable_string_callback_adapter (const char *, size_t, void *);

525static void
526d_print_init (struct d_print_info *, demangle_callbackref, void *,
     struct demangle_component *);

529static inline void d_print_error (struct d_print_info *);

531static inline int d_print_saw_error (struct d_print_info *);

533static inline void d_print_flush (struct d_print_info *);

535static inline void d_append_char (struct d_print_info *, char);

537static inline void d_append_buffer (struct d_print_info *,
                                  const char *, size_t);

540static inline void d_append_string (struct d_print_info *, const char *);

542static inline char d_last_char (struct d_print_info *);

544static void
545d_print_comp (struct d_print_info *, int, struct demangle_component *);

547static void
548d_print_java_identifier (struct d_print_info *, const char *, int);

550static void
551d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);

553static void
554d_print_mod (struct d_print_info *, int, struct demangle_component *);

556static void
557d_print_function_type (struct d_print_info *, int,
                     struct demangle_component *,
                     struct d_print_mod *);

561static void
562d_print_array_type (struct d_print_info *, int,
                  struct demangle_component *,
                  struct d_print_mod *);

566static void
567d_print_expr_op (struct d_print_info *, int, struct demangle_component *);

569static void d_print_cast (struct d_print_info *, int,
	  struct demangle_component *);
571static void d_print_conversion (struct d_print_info *, int,
		struct demangle_component *);

574static int d_demangle_callback (const char *, int,
                              demangle_callbackref, void *);
576static char *d_demangle (const char *, int, size_t *);

578#define FNQUAL_COMPONENT_CASEcase DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS
: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_REFERENCE_THIS
: case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: case DEMANGLE_COMPONENT_TRANSACTION_SAFE
: case DEMANGLE_COMPONENT_NOEXCEPT: case DEMANGLE_COMPONENT_THROW_SPEC				\
  case DEMANGLE_COMPONENT_RESTRICT_THIS:		\
  case DEMANGLE_COMPONENT_VOLATILE_THIS:		\
  case DEMANGLE_COMPONENT_CONST_THIS:			\
  case DEMANGLE_COMPONENT_REFERENCE_THIS:		\
  case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:	\
  case DEMANGLE_COMPONENT_TRANSACTION_SAFE:		\
  case DEMANGLE_COMPONENT_NOEXCEPT:			\
  case DEMANGLE_COMPONENT_THROW_SPEC

588/* True iff TYPE is a demangling component representing a
 function-type-qualifier.  */

591static int
592is_fnqual_component_type (enum demangle_component_type type)
593{
switch (type)
  {
  FNQUAL_COMPONENT_CASEcase DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS
: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_REFERENCE_THIS
: case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: case DEMANGLE_COMPONENT_TRANSACTION_SAFE
: case DEMANGLE_COMPONENT_NOEXCEPT: case DEMANGLE_COMPONENT_THROW_SPEC:
    return 1;
  default:
    break;
  }
return 0;
602}


605#ifdef CP_DEMANGLE_DEBUG

607static void
608d_dump (struct demangle_component *dc, int indent)
609{
int i;

if (dc == NULL((void*)0))
  {
    if (indent == 0)
      printf ("failed demangling\n");
    return;
  }

for (i = 0; i < indent; ++i)
  putchar (' ');

switch (dc->type)
  {
  case DEMANGLE_COMPONENT_NAME:
    printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
    return;
  case DEMANGLE_COMPONENT_TAGGED_NAME:
    printf ("tagged name\n");
    d_dump (dc->u.s_binary.left, indent + 2);
    d_dump (dc->u.s_binary.right, indent + 2);
    return;
  case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
    printf ("template parameter %ld\n", dc->u.s_number.number);
    return;
  case DEMANGLE_COMPONENT_TPARM_OBJ:
    printf ("template parameter object\n");
    break;
  case DEMANGLE_COMPONENT_FUNCTION_PARAM:
    printf ("function parameter %ld\n", dc->u.s_number.number);
    return;
  case DEMANGLE_COMPONENT_CTOR:
    printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
    d_dump (dc->u.s_ctor.name, indent + 2);
    return;
  case DEMANGLE_COMPONENT_DTOR:
    printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
    d_dump (dc->u.s_dtor.name, indent + 2);
    return;
  case DEMANGLE_COMPONENT_SUB_STD:
    printf ("standard substitution %s\n", dc->u.s_string.string);
    return;
  case DEMANGLE_COMPONENT_BUILTIN_TYPE:
    printf ("builtin type %s\n", dc->u.s_builtin.type->name);
    return;
  case DEMANGLE_COMPONENT_EXTENDED_BUILTIN_TYPE:
    {
char suffix[2] = { dc->u.s_extended_builtin.type->suffix, 0 };
printf ("builtin type %s%d%s\n", dc->u.s_extended_builtin.type->name,
dc->u.s_extended_builtin.type->arg, suffix);
    }
    return;
  case DEMANGLE_COMPONENT_OPERATOR:
    printf ("operator %s\n", dc->u.s_operator.op->name);
    return;
  case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
    printf ("extended operator with %d args\n",
     dc->u.s_extended_operator.args);
    d_dump (dc->u.s_extended_operator.name, indent + 2);
    return;

  case DEMANGLE_COMPONENT_QUAL_NAME:
    printf ("qualified name\n");
    break;
  case DEMANGLE_COMPONENT_LOCAL_NAME:
    printf ("local name\n");
    break;
  case DEMANGLE_COMPONENT_TYPED_NAME:
    printf ("typed name\n");
    break;
  case DEMANGLE_COMPONENT_TEMPLATE:
    printf ("template\n");
    break;
  case DEMANGLE_COMPONENT_VTABLE:
    printf ("vtable\n");
    break;
  case DEMANGLE_COMPONENT_VTT:
    printf ("VTT\n");
    break;
  case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
    printf ("construction vtable\n");
    break;
  case DEMANGLE_COMPONENT_TYPEINFO:
    printf ("typeinfo\n");
    break;
  case DEMANGLE_COMPONENT_TYPEINFO_NAME:
    printf ("typeinfo name\n");
    break;
  case DEMANGLE_COMPONENT_TYPEINFO_FN:
    printf ("typeinfo function\n");
    break;
  case DEMANGLE_COMPONENT_THUNK:
    printf ("thunk\n");
    break;
  case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
    printf ("virtual thunk\n");
    break;
  case DEMANGLE_COMPONENT_COVARIANT_THUNK:
    printf ("covariant thunk\n");
    break;
  case DEMANGLE_COMPONENT_JAVA_CLASS:
    printf ("java class\n");
    break;
  case DEMANGLE_COMPONENT_GUARD:
    printf ("guard\n");
    break;
  case DEMANGLE_COMPONENT_REFTEMP:
    printf ("reference temporary\n");
    break;
  case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
    printf ("hidden alias\n");
    break;
  case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
    printf ("transaction clone\n");
    break;
  case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
    printf ("non-transaction clone\n");
    break;
  case DEMANGLE_COMPONENT_RESTRICT:
    printf ("restrict\n");
    break;
  case DEMANGLE_COMPONENT_VOLATILE:
    printf ("volatile\n");
    break;
  case DEMANGLE_COMPONENT_CONST:
    printf ("const\n");
    break;
  case DEMANGLE_COMPONENT_RESTRICT_THIS:
    printf ("restrict this\n");
    break;
  case DEMANGLE_COMPONENT_VOLATILE_THIS:
    printf ("volatile this\n");
    break;
  case DEMANGLE_COMPONENT_CONST_THIS:
    printf ("const this\n");
    break;
  case DEMANGLE_COMPONENT_REFERENCE_THIS:
    printf ("reference this\n");
    break;
  case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
    printf ("rvalue reference this\n");
    break;
  case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
    printf ("transaction_safe this\n");
    break;
  case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
    printf ("vendor type qualifier\n");
    break;
  case DEMANGLE_COMPONENT_POINTER:
    printf ("pointer\n");
    break;
  case DEMANGLE_COMPONENT_REFERENCE:
    printf ("reference\n");
    break;
  case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
    printf ("rvalue reference\n");
    break;
  case DEMANGLE_COMPONENT_COMPLEX:
    printf ("complex\n");
    break;
  case DEMANGLE_COMPONENT_IMAGINARY:
    printf ("imaginary\n");
    break;
  case DEMANGLE_COMPONENT_VENDOR_TYPE:
    printf ("vendor type\n");
    break;
  case DEMANGLE_COMPONENT_FUNCTION_TYPE:
    printf ("function type\n");
    break;
  case DEMANGLE_COMPONENT_ARRAY_TYPE:
    printf ("array type\n");
    break;
  case DEMANGLE_COMPONENT_PTRMEM_TYPE:
    printf ("pointer to member type\n");
    break;
  case DEMANGLE_COMPONENT_ARGLIST:
    printf ("argument list\n");
    break;
  case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
    printf ("template argument list\n");
    break;
  case DEMANGLE_COMPONENT_INITIALIZER_LIST:
    printf ("initializer list\n");
    break;
  case DEMANGLE_COMPONENT_CAST:
    printf ("cast\n");
    break;
  case DEMANGLE_COMPONENT_CONVERSION:
    printf ("conversion operator\n");
    break;
  case DEMANGLE_COMPONENT_NULLARY:
    printf ("nullary operator\n");
    break;
  case DEMANGLE_COMPONENT_UNARY:
    printf ("unary operator\n");
    break;
  case DEMANGLE_COMPONENT_BINARY:
    printf ("binary operator\n");
    break;
  case DEMANGLE_COMPONENT_BINARY_ARGS:
    printf ("binary operator arguments\n");
    break;
  case DEMANGLE_COMPONENT_TRINARY:
    printf ("trinary operator\n");
    break;
  case DEMANGLE_COMPONENT_TRINARY_ARG1:
    printf ("trinary operator arguments 1\n");
    break;
  case DEMANGLE_COMPONENT_TRINARY_ARG2:
    printf ("trinary operator arguments 1\n");
    break;
  case DEMANGLE_COMPONENT_LITERAL:
    printf ("literal\n");
    break;
  case DEMANGLE_COMPONENT_LITERAL_NEG:
    printf ("negative literal\n");
    break;
  case DEMANGLE_COMPONENT_VENDOR_EXPR:
    printf ("vendor expression\n");
    break;
  case DEMANGLE_COMPONENT_JAVA_RESOURCE:
    printf ("java resource\n");
    break;
  case DEMANGLE_COMPONENT_COMPOUND_NAME:
    printf ("compound name\n");
    break;
  case DEMANGLE_COMPONENT_CHARACTER:
    printf ("character '%c'\n",  dc->u.s_character.character);
    return;
  case DEMANGLE_COMPONENT_NUMBER:
    printf ("number %ld\n", dc->u.s_number.number);
    return;
  case DEMANGLE_COMPONENT_DECLTYPE:
    printf ("decltype\n");
    break;
  case DEMANGLE_COMPONENT_PACK_EXPANSION:
    printf ("pack expansion\n");
    break;
  case DEMANGLE_COMPONENT_TLS_INIT:
    printf ("tls init function\n");
    break;
  case DEMANGLE_COMPONENT_TLS_WRAPPER:
    printf ("tls wrapper function\n");
    break;
  case DEMANGLE_COMPONENT_DEFAULT_ARG:
    printf ("default argument %d\n", dc->u.s_unary_num.num);
    d_dump (dc->u.s_unary_num.sub, indent+2);
    return;
  case DEMANGLE_COMPONENT_LAMBDA:
    printf ("lambda %d\n", dc->u.s_unary_num.num);
    d_dump (dc->u.s_unary_num.sub, indent+2);
    return;
  }

d_dump (d_left (dc)((dc)->u.s_binary.left), indent + 2);
d_dump (d_right (dc)((dc)->u.s_binary.right), indent + 2);
866}

868#endif /* CP_DEMANGLE_DEBUG */

870/* Fill in a DEMANGLE_COMPONENT_NAME.  */

872CP_STATIC_IF_GLIBCPP_V3
873int
874cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
875{
if (p == NULL((void*)0) || s == NULL((void*)0) || len <= 0)
  return 0;
p->d_printing = 0;
p->d_counting = 0;
p->type = DEMANGLE_COMPONENT_NAME;
p->u.s_name.s = s;
p->u.s_name.len = len;
return 1;
884}

886/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */

888CP_STATIC_IF_GLIBCPP_V3
889int
890cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
                                     struct demangle_component *name)
892{
if (p == NULL((void*)0) || args < 0 || name == NULL((void*)0))
  return 0;
p->d_printing = 0;
p->d_counting = 0;
p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
p->u.s_extended_operator.args = args;
p->u.s_extended_operator.name = name;
return 1;
901}

903/* Fill in a DEMANGLE_COMPONENT_CTOR.  */

905CP_STATIC_IF_GLIBCPP_V3
906int
907cplus_demangle_fill_ctor (struct demangle_component *p,
                        enum gnu_v3_ctor_kinds kind,
                        struct demangle_component *name)
910{
if (p == NULL((void*)0)
    || name == NULL((void*)0)
    || (int) kind < gnu_v3_complete_object_ctor
    || (int) kind > gnu_v3_object_ctor_group)
  return 0;
p->d_printing = 0;
p->d_counting = 0;
p->type = DEMANGLE_COMPONENT_CTOR;
p->u.s_ctor.kind = kind;
p->u.s_ctor.name = name;
return 1;
922}

924/* Fill in a DEMANGLE_COMPONENT_DTOR.  */

926CP_STATIC_IF_GLIBCPP_V3
927int
928cplus_demangle_fill_dtor (struct demangle_component *p,
                        enum gnu_v3_dtor_kinds kind,
                        struct demangle_component *name)
931{
if (p == NULL((void*)0)
    || name == NULL((void*)0)
    || (int) kind < gnu_v3_deleting_dtor
    || (int) kind > gnu_v3_object_dtor_group)
  return 0;
p->d_printing = 0;
p->d_counting = 0;
p->type = DEMANGLE_COMPONENT_DTOR;
p->u.s_dtor.kind = kind;
p->u.s_dtor.name = name;
return 1;
943}

945/* Add a new component.  */

947static struct demangle_component *
948d_make_empty (struct d_info *di)
949{
struct demangle_component *p;

if (di->next_comp >= di->num_comps)
  return NULL((void*)0);
p = &di->comps[di->next_comp];
p->d_printing = 0;
p->d_counting = 0;
++di->next_comp;
return p;
959}

961/* Add a new generic component.  */

963static struct demangle_component *
964d_make_comp (struct d_info *di, enum demangle_component_type type,
           struct demangle_component *left,
           struct demangle_component *right)
967{
struct demangle_component *p;

/* We check for errors here.  A typical error would be a NULL return
   from a subroutine.  We catch those here, and return NULL
   upward.  */
switch (type)
  {
    /* These types require two parameters.  */
  case DEMANGLE_COMPONENT_QUAL_NAME:
  case DEMANGLE_COMPONENT_LOCAL_NAME:
  case DEMANGLE_COMPONENT_TYPED_NAME:
  case DEMANGLE_COMPONENT_TAGGED_NAME:
  case DEMANGLE_COMPONENT_TEMPLATE:
  case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
  case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  case DEMANGLE_COMPONENT_UNARY:
  case DEMANGLE_COMPONENT_BINARY:
  case DEMANGLE_COMPONENT_BINARY_ARGS:
  case DEMANGLE_COMPONENT_TRINARY:
  case DEMANGLE_COMPONENT_TRINARY_ARG1:
  case DEMANGLE_COMPONENT_LITERAL:
  case DEMANGLE_COMPONENT_LITERAL_NEG:
  case DEMANGLE_COMPONENT_VENDOR_EXPR:
  case DEMANGLE_COMPONENT_COMPOUND_NAME:
  case DEMANGLE_COMPONENT_VECTOR_TYPE:
  case DEMANGLE_COMPONENT_CLONE:
  case DEMANGLE_COMPONENT_MODULE_ENTITY:
    if (left == NULL((void*)0) || right == NULL((void*)0))
return NULL((void*)0);
    break;

    /* These types only require one parameter.  */
  case DEMANGLE_COMPONENT_VTABLE:
  case DEMANGLE_COMPONENT_VTT:
  case DEMANGLE_COMPONENT_TYPEINFO:
  case DEMANGLE_COMPONENT_TYPEINFO_NAME:
  case DEMANGLE_COMPONENT_TYPEINFO_FN:
  case DEMANGLE_COMPONENT_THUNK:
  case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
  case DEMANGLE_COMPONENT_COVARIANT_THUNK:
  case DEMANGLE_COMPONENT_JAVA_CLASS:
  case DEMANGLE_COMPONENT_GUARD:
  case DEMANGLE_COMPONENT_TLS_INIT:
  case DEMANGLE_COMPONENT_TLS_WRAPPER:
  case DEMANGLE_COMPONENT_REFTEMP:
  case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
  case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
  case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
  case DEMANGLE_COMPONENT_POINTER:
  case DEMANGLE_COMPONENT_REFERENCE:
  case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
  case DEMANGLE_COMPONENT_COMPLEX:
  case DEMANGLE_COMPONENT_IMAGINARY:
  case DEMANGLE_COMPONENT_VENDOR_TYPE:
  case DEMANGLE_COMPONENT_CAST:
  case DEMANGLE_COMPONENT_CONVERSION:
  case DEMANGLE_COMPONENT_JAVA_RESOURCE:
  case DEMANGLE_COMPONENT_DECLTYPE:
  case DEMANGLE_COMPONENT_PACK_EXPANSION:
  case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
  case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
  case DEMANGLE_COMPONENT_NULLARY:
  case DEMANGLE_COMPONENT_TRINARY_ARG2:
  case DEMANGLE_COMPONENT_TPARM_OBJ:
  case DEMANGLE_COMPONENT_STRUCTURED_BINDING:
  case DEMANGLE_COMPONENT_MODULE_INIT:
  case DEMANGLE_COMPONENT_TEMPLATE_HEAD:
  case DEMANGLE_COMPONENT_TEMPLATE_NON_TYPE_PARM:
  case DEMANGLE_COMPONENT_TEMPLATE_TEMPLATE_PARM:
  case DEMANGLE_COMPONENT_TEMPLATE_PACK_PARM:
    if (left == NULL((void*)0))
return NULL((void*)0);
    break;

    /* This needs a right parameter, but the left parameter can be
empty.  */
  case DEMANGLE_COMPONENT_ARRAY_TYPE:
  case DEMANGLE_COMPONENT_INITIALIZER_LIST:
  case DEMANGLE_COMPONENT_MODULE_NAME:
  case DEMANGLE_COMPONENT_MODULE_PARTITION:
    if (right == NULL((void*)0))
return NULL((void*)0);
    break;

    /* These are allowed to have no parameters--in some cases they
will be filled in later.  */
  case DEMANGLE_COMPONENT_FUNCTION_TYPE:
  case DEMANGLE_COMPONENT_RESTRICT:
  case DEMANGLE_COMPONENT_VOLATILE:
  case DEMANGLE_COMPONENT_CONST:
  case DEMANGLE_COMPONENT_ARGLIST:
  case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
  case DEMANGLE_COMPONENT_TEMPLATE_TYPE_PARM:
  FNQUAL_COMPONENT_CASEcase DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS
: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_REFERENCE_THIS
: case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: case DEMANGLE_COMPONENT_TRANSACTION_SAFE
: case DEMANGLE_COMPONENT_NOEXCEPT: case DEMANGLE_COMPONENT_THROW_SPEC:
    break;

    /* Other types should not be seen here.  */
  default:
    return NULL((void*)0);
  }

p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = type;
    p->u.s_binary.left = left;
    p->u.s_binary.right = right;
  }
return p;
1078}

1080/* Add a new demangle mangled name component.  */

1082static struct demangle_component *
1083d_make_demangle_mangled_name (struct d_info *di, const char *s)
1084{
if (d_peek_char (di)(*((di)->n)) != '_' || d_peek_next_char (di)((di)->n[1]) != 'Z')
  return d_make_name (di, s, strlen (s));
d_advance (di, 2)((di)->n += (2));
return d_encoding (di, 0);
1089}

1091/* Add a new name component.  */

1093static struct demangle_component *
1094d_make_name (struct d_info *di, const char *s, int len)
1095{
struct demangle_component *p;

p = d_make_empty (di);
if (! cplus_demangle_fill_name (p, s, len))
  return NULL((void*)0);
return p;
1102}

1104/* Add a new builtin type component.  */

1106static struct demangle_component *
1107d_make_builtin_type (struct d_info *di,
                   const struct demangle_builtin_type_info *type)
1109{
struct demangle_component *p;

if (type == NULL((void*)0))
  return NULL((void*)0);
p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
    p->u.s_builtin.type = type;
  }
return p;
1121}

1123/* Add a new extended builtin type component.  */

1125static struct demangle_component *
1126d_make_extended_builtin_type (struct d_info *di,
	      const struct demangle_builtin_type_info *type,
	      short arg, char suffix)
1129{
struct demangle_component *p;

if (type == NULL((void*)0))
  return NULL((void*)0);
p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = DEMANGLE_COMPONENT_EXTENDED_BUILTIN_TYPE;
    p->u.s_extended_builtin.type = type;
    p->u.s_extended_builtin.arg = arg;
    p->u.s_extended_builtin.suffix = suffix;
  }
return p;
1143}

1145/* Add a new operator component.  */

1147static struct demangle_component *
1148d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
1149{
struct demangle_component *p;

p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = DEMANGLE_COMPONENT_OPERATOR;
    p->u.s_operator.op = op;
  }
return p;
1159}

1161/* Add a new extended operator component.  */

1163static struct demangle_component *
1164d_make_extended_operator (struct d_info *di, int args,
                        struct demangle_component *name)
1166{
struct demangle_component *p;

p = d_make_empty (di);
if (! cplus_demangle_fill_extended_operator (p, args, name))
  return NULL((void*)0);
return p;
1173}

1175static struct demangle_component *
1176d_make_default_arg (struct d_info *di, int num,
    struct demangle_component *sub)
1178{
struct demangle_component *p = d_make_empty (di);
if (p)
  {
    p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
    p->u.s_unary_num.num = num;
    p->u.s_unary_num.sub = sub;
  }
return p;
1187}

1189/* Add a new constructor component.  */

1191static struct demangle_component *
1192d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
           struct demangle_component *name)
1194{
struct demangle_component *p;

p = d_make_empty (di);
if (! cplus_demangle_fill_ctor (p, kind, name))
  return NULL((void*)0);
return p;
1201}

1203/* Add a new destructor component.  */

1205static struct demangle_component *
1206d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
           struct demangle_component *name)
1208{
struct demangle_component *p;

p = d_make_empty (di);
if (! cplus_demangle_fill_dtor (p, kind, name))
  return NULL((void*)0);
return p;
1215}

1217/* Add a new template parameter.  */

1219static struct demangle_component *
1220d_make_template_param (struct d_info *di, int i)
1221{
struct demangle_component *p;

p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
    p->u.s_number.number = i;
  }
return p;
1231}

1233/* Add a new function parameter.  */

1235static struct demangle_component *
1236d_make_function_param (struct d_info *di, int i)
1237{
struct demangle_component *p;

p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
    p->u.s_number.number = i;
  }
return p;
1247}

1249/* Add a new standard substitution component.  */

1251static struct demangle_component *
1252d_make_sub (struct d_info *di, const char *name, int len)
1253{
struct demangle_component *p;

p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = DEMANGLE_COMPONENT_SUB_STD;
    p->u.s_string.string = name;
    p->u.s_string.len = len;
  }
return p;
1264}

1266/* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*

 TOP_LEVEL is non-zero when called at the top level.  */

1270CP_STATIC_IF_GLIBCPP_V3
1271struct demangle_component *
1272cplus_demangle_mangled_name (struct d_info *di, int top_level)
1273{
struct demangle_component *p;

if (! d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0)
    /* Allow missing _ if not at toplevel to work around a
bug in G++ abi-version=2 mangling; see the comment in
write_template_arg.  */
    && top_level)
  return NULL((void*)0);
if (! d_check_char (di, 'Z')((*((di)->n)) == 'Z' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);
p = d_encoding (di, top_level);

/* If at top level and parsing parameters, check for a clone
   suffix.  */
if (top_level && (di->options & DMGL_PARAMS(1 << 0)) != 0)
  while (d_peek_char (di)(*((di)->n)) == '.'
  && (IS_LOWER (d_peek_next_char (di))((((di)->n[1])) >= 'a' && (((di)->n[1])) <=
 'z')
      || d_peek_next_char (di)((di)->n[1]) == '_'
      || IS_DIGIT (d_peek_next_char (di))((((di)->n[1])) >= '0' && (((di)->n[1])) <=
 '9')))
    p = d_clone_suffix (di, p);

return p;
1296}

1298/* Return whether a function should have a return type.  The argument
 is the function name, which may be qualified in various ways.  The
 rules are that template functions have return types with some
 exceptions, function types which are not part of a function name
 mangling have return types with some exceptions, and non-template
 function names do not have return types.  The exceptions are that
 constructors, destructors, and conversion operators do not have
 return types.  */

1307static int
1308has_return_type (struct demangle_component *dc)
1309{
if (dc == NULL((void*)0))
  return 0;
switch (dc->type)
  {
  default:
    return 0;
  case DEMANGLE_COMPONENT_LOCAL_NAME:
    return has_return_type (d_right (dc)((dc)->u.s_binary.right));
  case DEMANGLE_COMPONENT_TEMPLATE:
    return ! is_ctor_dtor_or_conversion (d_left (dc)((dc)->u.s_binary.left));
  FNQUAL_COMPONENT_CASEcase DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS
: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_REFERENCE_THIS
: case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: case DEMANGLE_COMPONENT_TRANSACTION_SAFE
: case DEMANGLE_COMPONENT_NOEXCEPT: case DEMANGLE_COMPONENT_THROW_SPEC:
    return has_return_type (d_left (dc)((dc)->u.s_binary.left));
  }
1323}

1325/* Return whether a name is a constructor, a destructor, or a
 conversion operator.  */

1328static int
1329is_ctor_dtor_or_conversion (struct demangle_component *dc)
1330{
if (dc == NULL((void*)0))
  return 0;
switch (dc->type)
  {
  default:
    return 0;
  case DEMANGLE_COMPONENT_QUAL_NAME:
  case DEMANGLE_COMPONENT_LOCAL_NAME:
    return is_ctor_dtor_or_conversion (d_right (dc)((dc)->u.s_binary.right));
  case DEMANGLE_COMPONENT_CTOR:
  case DEMANGLE_COMPONENT_DTOR:
  case DEMANGLE_COMPONENT_CONVERSION:
    return 1;
  }
1345}

1347/* <encoding> ::= <(function) name> <bare-function-type>
            ::= <(data) name>
            ::= <special-name>

 TOP_LEVEL is non-zero when called at the top level, in which case
 if DMGL_PARAMS is not set we do not demangle the function
 parameters.  We only set this at the top level, because otherwise
 we would not correctly demangle names in local scopes.  */

1356static struct demangle_component *
1357d_encoding (struct d_info *di, int top_level)
1358{
char peek = d_peek_char (di)(*((di)->n));
struct demangle_component *dc;

if (peek == 'G' || peek == 'T')
  dc = d_special_name (di);
else
  {
    dc = d_name (di, 0);

    if (!dc)
/* Failed already.  */;
    else if (top_level && (di->options & DMGL_PARAMS(1 << 0)) == 0)
{
 /* Strip off any initial CV-qualifiers, as they really apply
    to the `this' parameter, and they were not output by the
    v2 demangler without DMGL_PARAMS.  */
 while (is_fnqual_component_type (dc->type))
   dc = d_left (dc)((dc)->u.s_binary.left);

 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
    there may be function-qualifiers on its right argument which
    really apply here; this happens when parsing a class
    which is local to a function.  */
 if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
   {
     while (d_right (dc)((dc)->u.s_binary.right) != NULL((void*)0)
     && is_fnqual_component_type (d_right (dc)((dc)->u.s_binary.right)->type))
d_right (dc)((dc)->u.s_binary.right) = d_left (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.left);

     if (d_right (dc)((dc)->u.s_binary.right) == NULL((void*)0))
dc = NULL((void*)0);
   }
}
    else
{
 peek = d_peek_char (di)(*((di)->n));
 if (peek != '\0' && peek != 'E')
   {
     struct demangle_component *ftype;

     ftype = d_bare_function_type (di, has_return_type (dc));
     if (ftype)
{
  /* If this is a non-top-level local-name, clear the
     return type, so it doesn't confuse the user by
     being confused with the return type of whaever
     this is nested within.  */
  if (!top_level && dc->type == DEMANGLE_COMPONENT_LOCAL_NAME
      && ftype->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
    d_left (ftype)((ftype)->u.s_binary.left) = NULL((void*)0);

  dc = d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME,
		    dc, ftype);
}
     else
dc = NULL((void*)0);
   }
}
  }

return dc;
1420}

1422/* <tagged-name> ::= <name> B <source-name> */

1424static struct demangle_component *
1425d_abi_tags (struct d_info *di, struct demangle_component *dc)
1426{
struct demangle_component *hold_last_name;
char peek;

/* Preserve the last name, so the ABI tag doesn't clobber it.  */
hold_last_name = di->last_name;

while (peek = d_peek_char (di)(*((di)->n)),
peek == 'B')
  {
    struct demangle_component *tag;
    d_advance (di, 1)((di)->n += (1));
    tag = d_source_name (di);
    dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
  }

di->last_name = hold_last_name;

return dc;
1445}

1447/* <name> ::= <nested-name>
        ::= <unscoped-name>
        ::= <unscoped-template-name> <template-args>
        ::= <local-name>

 <unscoped-name> ::= <unqualified-name>
                 ::= St <unqualified-name>

 <unscoped-template-name> ::= <unscoped-name>
                          ::= <substitution>
1457*/

1459static struct demangle_component *
1460d_name (struct d_info *di, int substable)
1461{
char peek = d_peek_char (di)(*((di)->n));
struct demangle_component *dc = NULL((void*)0);
struct demangle_component *module = NULL((void*)0);
int subst = 0;

switch (peek)
  {
  case 'N':
    dc = d_nested_name (di);
    break;

  case 'Z':
    dc = d_local_name (di);
    break;

  case 'U':
    dc = d_unqualified_name (di, NULL((void*)0), NULL((void*)0));
    break;

  case 'S':
    {
if (d_peek_next_char (di)((di)->n[1]) == 't')
 {
   d_advance (di, 2)((di)->n += (2));
   dc = d_make_name (di, "std", 3);
   di->expansion += 3;
 }

if (d_peek_char (di)(*((di)->n)) == 'S')
 {
   module = d_substitution (di, 0);
   if (!module)
     return NULL((void*)0);
   if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME
  || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION))
     {
if (dc)
  return NULL((void*)0);
subst = 1;
dc = module;
module = NULL((void*)0);
     }
 }
    }
    /* FALLTHROUGH */

  case 'L':
  default:
    if (!subst)
dc = d_unqualified_name (di, dc, module);
    if (d_peek_char (di)(*((di)->n)) == 'I')
{
 /* This is <template-args>, which means that we just saw
    <unscoped-template-name>, which is a substitution
    candidate.  */
 if (!subst && !d_add_substitution (di, dc))
   return NULL((void*)0);
 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
	    d_template_args (di));
 subst = 0;
}
    break;
  }
if (substable && !subst && !d_add_substitution (di, dc))
  return NULL((void*)0);
return dc;
1528}

1530/* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
               ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1532*/

1534static struct demangle_component *
1535d_nested_name (struct d_info *di)
1536{
struct demangle_component *ret;
struct demangle_component **pret;
struct demangle_component *rqual;

if (! d_check_char (di, 'N')((*((di)->n)) == 'N' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

pret = d_cv_qualifiers (di, &ret, 1);
if (pret == NULL((void*)0))
  return NULL((void*)0);

/* Parse the ref-qualifier now and then attach it
   once we have something to attach it to.  */
rqual = d_ref_qualifier (di, NULL((void*)0));

*pret = d_prefix (di, 1);
if (*pret == NULL((void*)0))
  return NULL((void*)0);

if (rqual)
  {
    d_left (rqual)((rqual)->u.s_binary.left) = ret;
    ret = rqual;
  }

if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

return ret;
1566}

1568/* <prefix> ::= <prefix> <unqualified-name>
          ::= <template-prefix> <template-args>
          ::= <template-param>
          ::= <decltype>
          ::=
          ::= <substitution>

 <template-prefix> ::= <prefix> <(template) unqualified-name>
                   ::= <template-param>
                   ::= <substitution>

 SUBST is true if we should add substitutions (as normal), false
 if not (in an unresolved-name).  */

1582static struct demangle_component *
1583d_prefix (struct d_info *di, int substable)
1584{
struct demangle_component *ret = NULL((void*)0);

for (;;)
  {
    char peek = d_peek_char (di)(*((di)->n));

    /* The older code accepts a <local-name> here, but I don't see
that in the grammar.  The older code does not accept a
<template-param> here.  */

    if (peek == 'D'
 && (d_peek_next_char (di)((di)->n[1]) == 'T'
     || d_peek_next_char (di)((di)->n[1]) == 't'))
{
 /* Decltype.  */
 if (ret)
   return NULL((void*)0);
 ret = cplus_demangle_type (di);
}
    else if (peek == 'I')
{
 if (ret == NULL((void*)0))
   return NULL((void*)0);
 struct demangle_component *dc = d_template_args (di);
 if (!dc)
   return NULL((void*)0);
 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, dc);
}
    else if (peek == 'T')
{
 if (ret)
   return NULL((void*)0);
 ret = d_template_param (di);
}
    else if (peek == 'M')
{
 /* Initializer scope for a lambda.  We already added it as a
	     substitution candidate, don't do that again.  */
 d_advance (di, 1)((di)->n += (1));
 continue;
}
    else
{
 struct demangle_component *module = NULL((void*)0);
 if (peek == 'S')
   {
     module = d_substitution (di, 1);
     if (!module)
return NULL((void*)0);
     if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME
    || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION))
{
  if (ret)
    return NULL((void*)0);
  ret = module;
  continue;
}
   }
 ret = d_unqualified_name (di, ret, module);
}

    if (!ret)
break;

    if (d_peek_char (di)(*((di)->n)) == 'E')
break;

    if (substable && !d_add_substitution (di, ret))
return NULL((void*)0);
  }

return ret;
1657}

1659static int
1660d_maybe_module_name (struct d_info *di, struct demangle_component **name)
1661{
while (d_peek_char (di)(*((di)->n)) == 'W')
  {
    d_advance (di, 1)((di)->n += (1));
    enum demangle_component_type code = DEMANGLE_COMPONENT_MODULE_NAME;
    if (d_peek_char (di)(*((di)->n)) == 'P')
{
 code = DEMANGLE_COMPONENT_MODULE_PARTITION;
 d_advance (di, 1)((di)->n += (1));
}

    *name = d_make_comp (di, code, *name, d_source_name (di));
    if (!*name)
return 0;
    if (!d_add_substitution (di, *name))
return 0;
  }
return 1;
1679}

1681/* <unqualified-name> ::= [<module-name>] <operator-name> [<abi-tags>]
                    ::= [<module-name>] <ctor-dtor-name> [<abi-tags>]
                    ::= [<module-name>] <source-name> [<abi-tags>]
      ::= [<module-name>] <local-source-name>  [<abi-tags>]
                    ::= [<module-name>] DC <source-name>+ E [<abi-tags>]
  <local-source-name>	::= L <source-name> <discriminator> [<abi-tags>]
1687*/

1689static struct demangle_component *
1690d_unqualified_name (struct d_info *di, struct demangle_component *scope,
    struct demangle_component *module)
1692{
struct demangle_component *ret;
char peek;

if (!d_maybe_module_name (di, &module))
  return NULL((void*)0);

peek = d_peek_char (di)(*((di)->n));
if (IS_DIGIT (peek)((peek) >= '0' && (peek) <= '9'))
  ret = d_source_name (di);
else if (IS_LOWER (peek)((peek) >= 'a' && (peek) <= 'z'))
  {
    int was_expr = di->is_expression;
    if (peek == 'o' && d_peek_next_char (di)((di)->n[1]) == 'n')
{
 d_advance (di, 2)((di)->n += (2));
 /* Treat cv as naming a conversion operator.  */
 di->is_expression = 0;
}
    ret = d_operator_name (di);
    di->is_expression = was_expr;
    if (ret != NULL((void*)0) && ret->type == DEMANGLE_COMPONENT_OPERATOR)
{
 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
 if (!strcmp (ret->u.s_operator.op->code, "li"))
   ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
	       d_source_name (di));
}
  }
else if (peek == 'D' && d_peek_next_char (di)((di)->n[1]) == 'C')
  {
    // structured binding
    d_advance (di, 2)((di)->n += (2));
    struct demangle_component *prev = NULL((void*)0);
    do
{
 struct demangle_component *next = 
   d_make_comp (di, DEMANGLE_COMPONENT_STRUCTURED_BINDING,
	 d_source_name (di), NULL((void*)0));
 if (prev)
   d_right (prev)((prev)->u.s_binary.right) = next;
 else
   ret = next;
 prev = next;
}
    while (prev && d_peek_char (di)(*((di)->n)) != 'E');
    if (prev)
d_advance (di, 1)((di)->n += (1));
    else
ret = NULL((void*)0);
  }
else if (peek == 'C' || peek == 'D')
  ret = d_ctor_dtor_name (di);
else if (peek == 'L')
  {
    d_advance (di, 1)((di)->n += (1));

    ret = d_source_name (di);
    if (ret == NULL((void*)0))
return NULL((void*)0);
    if (! d_discriminator (di))
return NULL((void*)0);
  }
else if (peek == 'U')
  {
    switch (d_peek_next_char (di)((di)->n[1]))
{
case 'l':
 ret = d_lambda (di);
 break;
case 't':
 ret = d_unnamed_type (di);
 break;
default:
 return NULL((void*)0);
}
  }
else
  return NULL((void*)0);

if (module)
  ret = d_make_comp (di, DEMANGLE_COMPONENT_MODULE_ENTITY, ret, module);
if (d_peek_char (di)(*((di)->n)) == 'B')
  ret = d_abi_tags (di, ret);
if (scope)
  ret = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, scope, ret);

return ret;
1780}

1782/* <source-name> ::= <(positive length) number> <identifier>  */

1784static struct demangle_component *
1785d_source_name (struct d_info *di)
1786{
int len;
struct demangle_component *ret;

len = d_number (di);
if (len <= 0)
  return NULL((void*)0);
ret = d_identifier (di, len);
di->last_name = ret;
return ret;
1796}

1798/* number ::= [n] <(non-negative decimal integer)>  */

1800static int
1801d_number (struct d_info *di)
1802{
int negative;
char peek;
int ret;

negative = 0;
peek = d_peek_char (di)(*((di)->n));
if (peek == 'n')
  {
    negative = 1;
    d_advance (di, 1)((di)->n += (1));
    peek = d_peek_char (di)(*((di)->n));
  }

ret = 0;
while (1)
  {
    if (! IS_DIGIT (peek)((peek) >= '0' && (peek) <= '9'))
{
 if (negative)
   ret = - ret;
 return ret;
}
    if (ret > ((INT_MAX2147483647 - (peek - '0')) / 10))
      return -1;
    ret = ret * 10 + (peek - '0');
    d_advance (di, 1)((di)->n += (1));
    peek = d_peek_char (di)(*((di)->n));
  }
1831}

1833/* Like d_number, but returns a demangle_component.  */

1835static struct demangle_component *
1836d_number_component (struct d_info *di)
1837{
struct demangle_component *ret = d_make_empty (di);
if (ret)
  {
    ret->type = DEMANGLE_COMPONENT_NUMBER;
    ret->u.s_number.number = d_number (di);
  }
return ret;
1845}

1847/* identifier ::= <(unqualified source code identifier)>  */

1849static struct demangle_component *
1850d_identifier (struct d_info *di, int len)
1851{
const char *name;

name = d_str (di)((di)->n);

if (di->send - name < len)
  return NULL((void*)0);

d_advance (di, len)((di)->n += (len));

/* A Java mangled name may have a trailing '$' if it is a C++
   keyword.  This '$' is not included in the length count.  We just
   ignore the '$'.  */
if ((di->options & DMGL_JAVA(1 << 2)) != 0
    && d_peek_char (di)(*((di)->n)) == '$')
  d_advance (di, 1)((di)->n += (1));

/* Look for something which looks like a gcc encoding of an
   anonymous namespace, and replace it with a more user friendly
   name.  */
if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN(sizeof ("_GLOBAL_") - 1) + 2
    && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX"_GLOBAL_",
 ANONYMOUS_NAMESPACE_PREFIX_LEN(sizeof ("_GLOBAL_") - 1)) == 0)
  {
    const char *s;

    s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN(sizeof ("_GLOBAL_") - 1);
    if ((*s == '.' || *s == '_' || *s == '$')
 && s[1] == 'N')
{
 di->expansion -= len - sizeof "(anonymous namespace)";
 return d_make_name (di, "(anonymous namespace)",
	      sizeof "(anonymous namespace)" - 1);
}
  }

return d_make_name (di, name, len);
1888}

1890/* operator_name ::= many different two character encodings.
               ::= cv <type>
               ::= v <digit> <source-name>

 This list is sorted for binary search.  */

1896#define NL(s)s, (sizeof s) - 1 s, (sizeof s) - 1

1898CP_STATIC_IF_GLIBCPP_V3
1899const struct demangle_operator_info cplus_demangle_operators[] =
1900{
{ "aN", NL ("&=")"&=", (sizeof "&=") - 1,        2 },
{ "aS", NL ("=")"=", (sizeof "=") - 1,         2 },
{ "aa", NL ("&&")"&&", (sizeof "&&") - 1,        2 },
{ "ad", NL ("&")"&", (sizeof "&") - 1,         1 },
{ "an", NL ("&")"&", (sizeof "&") - 1,         2 },
{ "at", NL ("alignof ")"alignof ", (sizeof "alignof ") - 1,   1 },
{ "aw", NL ("co_await ")"co_await ", (sizeof "co_await ") - 1, 1 },
{ "az", NL ("alignof ")"alignof ", (sizeof "alignof ") - 1,   1 },
{ "cc", NL ("const_cast")"const_cast", (sizeof "const_cast") - 1, 2 },
{ "cl", NL ("()")"()", (sizeof "()") - 1,        2 },
{ "cm", NL (",")",", (sizeof ",") - 1,         2 },
{ "co", NL ("~")"~", (sizeof "~") - 1,         1 },
{ "dV", NL ("/=")"/=", (sizeof "/=") - 1,        2 },
{ "dX", NL ("[...]=")"[...]=", (sizeof "[...]=") - 1,     3 }, /* [expr...expr] = expr */
{ "da", NL ("delete[] ")"delete[] ", (sizeof "delete[] ") - 1, 1 },
{ "dc", NL ("dynamic_cast")"dynamic_cast", (sizeof "dynamic_cast") - 1, 2 },
{ "de", NL ("*")"*", (sizeof "*") - 1,         1 },
{ "di", NL ("=")"=", (sizeof "=") - 1,         2 }, /* .name = expr */
{ "dl", NL ("delete ")"delete ", (sizeof "delete ") - 1,   1 },
{ "ds", NL (".*")".*", (sizeof ".*") - 1,        2 },
{ "dt", NL (".")".", (sizeof ".") - 1,         2 },
{ "dv", NL ("/")"/", (sizeof "/") - 1,         2 },
{ "dx", NL ("]=")"]=", (sizeof "]=") - 1,        2 }, /* [expr] = expr */
{ "eO", NL ("^=")"^=", (sizeof "^=") - 1,        2 },
{ "eo", NL ("^")"^", (sizeof "^") - 1,         2 },
{ "eq", NL ("==")"==", (sizeof "==") - 1,        2 },
{ "fL", NL ("...")"...", (sizeof "...") - 1,       3 },
{ "fR", NL ("...")"...", (sizeof "...") - 1,       3 },
{ "fl", NL ("...")"...", (sizeof "...") - 1,       2 },
{ "fr", NL ("...")"...", (sizeof "...") - 1,       2 },
{ "ge", NL (">=")">=", (sizeof ">=") - 1,        2 },
{ "gs", NL ("::")"::", (sizeof "::") - 1,	    1 },
{ "gt", NL (">")">", (sizeof ">") - 1,         2 },
{ "ix", NL ("[]")"[]", (sizeof "[]") - 1,        2 },
{ "lS", NL ("<<=")"<<=", (sizeof "<<=") - 1,       2 },
{ "le", NL ("<=")"<=", (sizeof "<=") - 1,        2 },
{ "li", NL ("operator\"\" ")"operator\"\" ", (sizeof "operator\"\" ") - 1, 1 },
{ "ls", NL ("<<")"<<", (sizeof "<<") - 1,        2 },
{ "lt", NL ("<")"<", (sizeof "<") - 1,         2 },
{ "mI", NL ("-=")"-=", (sizeof "-=") - 1,        2 },
{ "mL", NL ("*=")"*=", (sizeof "*=") - 1,        2 },
{ "mi", NL ("-")"-", (sizeof "-") - 1,         2 },
{ "ml", NL ("*")"*", (sizeof "*") - 1,         2 },
{ "mm", NL ("--")"--", (sizeof "--") - 1,        1 },
{ "na", NL ("new[]")"new[]", (sizeof "new[]") - 1,     3 },
{ "ne", NL ("!=")"!=", (sizeof "!=") - 1,        2 },
{ "ng", NL ("-")"-", (sizeof "-") - 1,         1 },
{ "nt", NL ("!")"!", (sizeof "!") - 1,         1 },
{ "nw", NL ("new")"new", (sizeof "new") - 1,       3 },
{ "oR", NL ("|=")"|=", (sizeof "|=") - 1,        2 },
{ "oo", NL ("||")"||", (sizeof "||") - 1,        2 },
{ "or", NL ("|")"|", (sizeof "|") - 1,         2 },
{ "pL", NL ("+=")"+=", (sizeof "+=") - 1,        2 },
{ "pl", NL ("+")"+", (sizeof "+") - 1,         2 },
{ "pm", NL ("->*")"->*", (sizeof "->*") - 1,       2 },
{ "pp", NL ("++")"++", (sizeof "++") - 1,        1 },
{ "ps", NL ("+")"+", (sizeof "+") - 1,         1 },
{ "pt", NL ("->")"->", (sizeof "->") - 1,        2 },
{ "qu", NL ("?")"?", (sizeof "?") - 1,         3 },
{ "rM", NL ("%=")"%=", (sizeof "%=") - 1,        2 },
{ "rS", NL (">>=")">>=", (sizeof ">>=") - 1,       2 },
{ "rc", NL ("reinterpret_cast")"reinterpret_cast", (sizeof "reinterpret_cast") - 1, 2 },
{ "rm", NL ("%")"%", (sizeof "%") - 1,         2 },
{ "rs", NL (">>")">>", (sizeof ">>") - 1,        2 },
{ "sP", NL ("sizeof...")"sizeof...", (sizeof "sizeof...") - 1, 1 },
{ "sZ", NL ("sizeof...")"sizeof...", (sizeof "sizeof...") - 1, 1 },
{ "sc", NL ("static_cast")"static_cast", (sizeof "static_cast") - 1, 2 },
{ "ss", NL ("<=>")"<=>", (sizeof "<=>") - 1,       2 },
{ "st", NL ("sizeof ")"sizeof ", (sizeof "sizeof ") - 1,   1 },
{ "sz", NL ("sizeof ")"sizeof ", (sizeof "sizeof ") - 1,   1 },
{ "tr", NL ("throw")"throw", (sizeof "throw") - 1,     0 },
{ "tw", NL ("throw ")"throw ", (sizeof "throw ") - 1,    1 },
{ NULL((void*)0), NULL((void*)0), 0,          0 }
1974};

1976static struct demangle_component *
1977d_operator_name (struct d_info *di)
1978{
char c1;
char c2;

c1 = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));
c2 = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));
if (c1 == 'v' && IS_DIGIT (c2)((c2) >= '0' && (c2) <= '9'))
  return d_make_extended_operator (di, c2 - '0', d_source_name (di));
else if (c1 == 'c' && c2 == 'v')
  {
    struct demangle_component *type;
    int was_conversion = di->is_conversion;
    struct demangle_component *res;

    di->is_conversion = ! di->is_expression;
    type = cplus_demangle_type (di);
    if (di->is_conversion)
res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL((void*)0));
    else
res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL((void*)0));
    di->is_conversion = was_conversion;
    return res;
  }
else
  {
    /* LOW is the inclusive lower bound.  */
    int low = 0;
    /* HIGH is the exclusive upper bound.  We subtract one to ignore
the sentinel at the end of the array.  */
    int high = ((sizeof (cplus_demangle_operators)
   / sizeof (cplus_demangle_operators[0]))
  - 1);

    while (1)
{
 int i;
 const struct demangle_operator_info *p;

 i = low + (high - low) / 2;
 p = cplus_demangle_operators + i;

 if (c1 == p->code[0] && c2 == p->code[1])
   return d_make_operator (di, p);

 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
   high = i;
 else
   low = i + 1;
 if (low == high)
   return NULL((void*)0);
}
  }
2030}

2032static struct demangle_component *
2033d_make_character (struct d_info *di, int c)
2034{
struct demangle_component *p;
p = d_make_empty (di);
if (p != NULL((void*)0))
  {
    p->type = DEMANGLE_COMPONENT_CHARACTER;
    p->u.s_character.character = c;
  }
return p;
2043}

2045static struct demangle_component *
2046d_java_resource (struct d_info *di)
2047{
struct demangle_component *p = NULL((void*)0);
struct demangle_component *next = NULL((void*)0);
int len, i;
char c;
const char *str;

len = d_number (di);
if (len <= 1)
  return NULL((void*)0);

/* Eat the leading '_'.  */
if (d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++)) != '_')
  return NULL((void*)0);
len--;

str = d_str (di)((di)->n);
i = 0;

while (len > 0)
  {
    c = str[i];
    if (!c)
return NULL((void*)0);

    /* Each chunk is either a '$' escape...  */
    if (c == '$')
{
 i++;
 switch (str[i++])
   {
   case 'S':
     c = '/';
     break;
   case '_':
     c = '.';
     break;
   case '$':
     c = '$';
     break;
   default:
     return NULL((void*)0);
   }
 next = d_make_character (di, c);
 d_advance (di, i)((di)->n += (i));
 str = d_str (di)((di)->n);
 len -= i;
 i = 0;
 if (next == NULL((void*)0))
   return NULL((void*)0);
}
    /* ... or a sequence of characters.  */
    else
{
 while (i < len && str[i] && str[i] != '$')
   i++;

 next = d_make_name (di, str, i);
 d_advance (di, i)((di)->n += (i));
 str = d_str (di)((di)->n);
 len -= i;
 i = 0;
 if (next == NULL((void*)0))
   return NULL((void*)0);
}

    if (p == NULL((void*)0))
p = next;
    else
{
 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
 if (p == NULL((void*)0))
   return NULL((void*)0);
}
  }

p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL((void*)0));

return p;
2126}

2128/* <special-name> ::= TV <type>
                ::= TT <type>
                ::= TI <type>
                ::= TS <type>
  ::= TA <template-arg>
                ::= GV <(object) name>
                ::= T <call-offset> <(base) encoding>
                ::= Tc <call-offset> <call-offset> <(base) encoding>
 Also g++ extensions:
                ::= TC <type> <(offset) number> _ <(base) type>
                ::= TF <type>
                ::= TJ <type>
                ::= GR <name>
  ::= GA <encoding>
  ::= Gr <resource name>
  ::= GTt <encoding>
  ::= GTn <encoding>
2145*/

2147static struct demangle_component *
2148d_special_name (struct d_info *di)
2149{
di->expansion += 20;
if (d_check_char (di, 'T')((*((di)->n)) == 'T' ? ((di)->n++, 1) : 0))
  {
    switch (d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++)))
{
case 'V':
 di->expansion -= 5;
 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
	      cplus_demangle_type (di), NULL((void*)0));
case 'T':
 di->expansion -= 10;
 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
	      cplus_demangle_type (di), NULL((void*)0));
case 'I':
 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
	      cplus_demangle_type (di), NULL((void*)0));
case 'S':
 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
	      cplus_demangle_type (di), NULL((void*)0));

case 'h':
 if (! d_call_offset (di, 'h'))
   return NULL((void*)0);
 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
	      d_encoding (di, 0), NULL((void*)0));

case 'v':
 if (! d_call_offset (di, 'v'))
   return NULL((void*)0);
 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
	      d_encoding (di, 0), NULL((void*)0));

case 'c':
 if (! d_call_offset (di, '\0'))
   return NULL((void*)0);
 if (! d_call_offset (di, '\0'))
   return NULL((void*)0);
 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
	      d_encoding (di, 0), NULL((void*)0));

case 'C':
 {
   struct demangle_component *derived_type;
   int offset;
   struct demangle_component *base_type;

   derived_type = cplus_demangle_type (di);
   offset = d_number (di);
   if (offset < 0)
     return NULL((void*)0);
   if (! d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0))
     return NULL((void*)0);
   base_type = cplus_demangle_type (di);
   /* We don't display the offset.  FIXME: We should display
      it in verbose mode.  */
   di->expansion += 5;
   return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
		base_type, derived_type);
 }

case 'F':
 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
	      cplus_demangle_type (di), NULL((void*)0));
case 'J':
 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
	      cplus_demangle_type (di), NULL((void*)0));

case 'H':
 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
	      d_name (di, 0), NULL((void*)0));

case 'W':
 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
	      d_name (di, 0), NULL((void*)0));

case 'A':
 return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
	      d_template_arg (di), NULL((void*)0));

default:
 return NULL((void*)0);
}
  }
else if (d_check_char (di, 'G')((*((di)->n)) == 'G' ? ((di)->n++, 1) : 0))
  {
    switch (d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++)))
{
case 'V':
 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
	      d_name (di, 0), NULL((void*)0));

case 'R':
 {
   struct demangle_component *name = d_name (di, 0);
   return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
		d_number_component (di));
 }

case 'A':
 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
	      d_encoding (di, 0), NULL((void*)0));

case 'I':
 {
   struct demangle_component *module = NULL((void*)0);
   if (!d_maybe_module_name (di, &module) || !module)
     return NULL((void*)0);
   return d_make_comp (di, DEMANGLE_COMPONENT_MODULE_INIT,
		module, NULL((void*)0));
 }
case 'T':
 switch (d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++)))
   {
   case 'n':
     return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
		  d_encoding (di, 0), NULL((void*)0));
   default:
     /* ??? The proposal is that other letters (such as 'h') stand
 for different variants of transaction cloning, such as
 compiling directly for hardware transaction support.  But
 they still should all be transactional clones of some sort
 so go ahead and call them that.  */
   case 't':
     return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
		  d_encoding (di, 0), NULL((void*)0));
   }

case 'r':
 return d_java_resource (di);

default:
 return NULL((void*)0);
}
  }
else
  return NULL((void*)0);
2286}

2288/* <call-offset> ::= h <nv-offset> _
               ::= v <v-offset> _

 <nv-offset> ::= <(offset) number>

 <v-offset> ::= <(offset) number> _ <(virtual offset) number>

 The C parameter, if not '\0', is a character we just read which is
 the start of the <call-offset>.

 We don't display the offset information anywhere.  FIXME: We should
 display it in verbose mode.  */

2301static int
2302d_call_offset (struct d_info *di, int c)
2303{
if (c == '\0')
  c = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));

if (c == 'h')
  d_number (di);
else if (c == 'v')
  {
    d_number (di);
    if (! d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0))
return 0;
    d_number (di);
  }
else
  return 0;

if (! d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0))
  return 0;

return 1;
2323}

2325/* <ctor-dtor-name> ::= C1
                  ::= C2
                  ::= C3
                  ::= D0
                  ::= D1
                  ::= D2
2331*/

2333static struct demangle_component *
2334d_ctor_dtor_name (struct d_info *di)
2335{
if (di->last_name != NULL((void*)0))
  {
    if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
di->expansion += di->last_name->u.s_name.len;
    else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
di->expansion += di->last_name->u.s_string.len;
  }
switch (d_peek_char (di)(*((di)->n)))
  {
  case 'C':
    {
enum gnu_v3_ctor_kinds kind;
int inheriting = 0;

if (d_peek_next_char (di)((di)->n[1]) == 'I')
 {
   inheriting = 1;
   d_advance (di, 1)((di)->n += (1));
 }

switch (d_peek_next_char (di)((di)->n[1]))
 {
 case '1':
   kind = gnu_v3_complete_object_ctor;
   break;
 case '2':
   kind = gnu_v3_base_object_ctor;
   break;
 case '3':
   kind = gnu_v3_complete_object_allocating_ctor;
   break;
        case '4':
   kind = gnu_v3_unified_ctor;
   break;
 case '5':
   kind = gnu_v3_object_ctor_group;
   break;
 default:
   return NULL((void*)0);
 }

d_advance (di, 2)((di)->n += (2));

if (inheriting)
 cplus_demangle_type (di);

return d_make_ctor (di, kind, di->last_name);
    }

  case 'D':
    {
enum gnu_v3_dtor_kinds kind;

switch (d_peek_next_char (di)((di)->n[1]))
 {
 case '0':
   kind = gnu_v3_deleting_dtor;
   break;
 case '1':
   kind = gnu_v3_complete_object_dtor;
   break;
 case '2':
   kind = gnu_v3_base_object_dtor;
   break;
        /*  digit '3' is not used */
 case '4':
   kind = gnu_v3_unified_dtor;
   break;
 case '5':
   kind = gnu_v3_object_dtor_group;
   break;
 default:
   return NULL((void*)0);
 }
d_advance (di, 2)((di)->n += (2));
return d_make_dtor (di, kind, di->last_name);
    }

  default:
    return NULL((void*)0);
  }
2417}

2419/* True iff we're looking at an order-insensitive type-qualifier, including
 function-type-qualifiers.  */

2422static int
2423next_is_type_qual (struct d_info *di)
2424{
char peek = d_peek_char (di)(*((di)->n));
if (peek == 'r' || peek == 'V' || peek == 'K')
  return 1;
if (peek == 'D')
  {
    peek = d_peek_next_char (di)((di)->n[1]);
    if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
return 1;
  }
return 0;
2435}

2437/* <type> ::= <builtin-type>
        ::= <function-type>
        ::= <class-enum-type>
        ::= <array-type>
        ::= <pointer-to-member-type>
        ::= <template-param>
        ::= <template-template-param> <template-args>
        ::= <substitution>
        ::= <CV-qualifiers> <type>
        ::= P <type>
        ::= R <type>
        ::= O <type> (C++0x)
        ::= C <type>
        ::= G <type>
        ::= U <source-name> <type>

 <builtin-type> ::= various one letter codes
                ::= u <source-name>
2455*/

2457CP_STATIC_IF_GLIBCPP_V3
2458const struct demangle_builtin_type_info
2459cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT(36)] =
2460{
/* a */ { NL ("signed char")"signed char", (sizeof "signed char") - 1,	NL ("signed char")"signed char", (sizeof "signed char") - 1,	D_PRINT_DEFAULT },
/* b */ { NL ("bool")"bool", (sizeof "bool") - 1,	NL ("boolean")"boolean", (sizeof "boolean") - 1,		D_PRINT_BOOL },
/* c */ { NL ("char")"char", (sizeof "char") - 1,	NL ("byte")"byte", (sizeof "byte") - 1,		D_PRINT_DEFAULT },
/* d */ { NL ("double")"double", (sizeof "double") - 1,	NL ("double")"double", (sizeof "double") - 1,		D_PRINT_FLOAT },
/* e */ { NL ("long double")"long double", (sizeof "long double") - 1,	NL ("long double")"long double", (sizeof "long double") - 1,	D_PRINT_FLOAT },
/* f */ { NL ("float")"float", (sizeof "float") - 1,	NL ("float")"float", (sizeof "float") - 1,		D_PRINT_FLOAT },
/* g */ { NL ("__float128")"__float128", (sizeof "__float128") - 1,	NL ("__float128")"__float128", (sizeof "__float128") - 1,	D_PRINT_FLOAT },
/* h */ { NL ("unsigned char")"unsigned char", (sizeof "unsigned char") - 1, NL ("unsigned char")"unsigned char", (sizeof "unsigned char") - 1,	D_PRINT_DEFAULT },
/* i */ { NL ("int")"int", (sizeof "int") - 1,		NL ("int")"int", (sizeof "int") - 1,		D_PRINT_INT },
/* j */ { NL ("unsigned int")"unsigned int", (sizeof "unsigned int") - 1, NL ("unsigned")"unsigned", (sizeof "unsigned") - 1,	D_PRINT_UNSIGNED },
/* k */ { NULL((void*)0), 0,		NULL((void*)0), 0,		D_PRINT_DEFAULT },
/* l */ { NL ("long")"long", (sizeof "long") - 1,	NL ("long")"long", (sizeof "long") - 1,		D_PRINT_LONG },
/* m */ { NL ("unsigned long")"unsigned long", (sizeof "unsigned long") - 1, NL ("unsigned long")"unsigned long", (sizeof "unsigned long") - 1,	D_PRINT_UNSIGNED_LONG },
/* n */ { NL ("__int128")"__int128", (sizeof "__int128") - 1,	NL ("__int128")"__int128", (sizeof "__int128") - 1,	D_PRINT_DEFAULT },
/* o */ { NL ("unsigned __int128")"unsigned __int128", (sizeof "unsigned __int128") - 1, NL ("unsigned __int128")"unsigned __int128", (sizeof "unsigned __int128") - 1,
   D_PRINT_DEFAULT },
/* p */ { NULL((void*)0), 0,		NULL((void*)0), 0,		D_PRINT_DEFAULT },
/* q */ { NULL((void*)0), 0,		NULL((void*)0), 0,		D_PRINT_DEFAULT },
/* r */ { NULL((void*)0), 0,		NULL((void*)0), 0,		D_PRINT_DEFAULT },
/* s */ { NL ("short")"short", (sizeof "short") - 1,	NL ("short")"short", (sizeof "short") - 1,		D_PRINT_DEFAULT },
/* t */ { NL ("unsigned short")"unsigned short", (sizeof "unsigned short") - 1, NL ("unsigned short")"unsigned short", (sizeof "unsigned short") - 1, D_PRINT_DEFAULT },
/* u */ { NULL((void*)0), 0,		NULL((void*)0), 0,		D_PRINT_DEFAULT },
/* v */ { NL ("void")"void", (sizeof "void") - 1,	NL ("void")"void", (sizeof "void") - 1,		D_PRINT_VOID },
/* w */ { NL ("wchar_t")"wchar_t", (sizeof "wchar_t") - 1,	NL ("char")"char", (sizeof "char") - 1,		D_PRINT_DEFAULT },
/* x */ { NL ("long long")"long long", (sizeof "long long") - 1,	NL ("long")"long", (sizeof "long") - 1,		D_PRINT_LONG_LONG },
/* y */ { NL ("unsigned long long")"unsigned long long", (sizeof "unsigned long long") - 1, NL ("unsigned long long")"unsigned long long", (sizeof "unsigned long long") - 1,
   D_PRINT_UNSIGNED_LONG_LONG },
/* z */ { NL ("...")"...", (sizeof "...") - 1,		NL ("...")"...", (sizeof "...") - 1,		D_PRINT_DEFAULT },
/* 26 */ { NL ("decimal32")"decimal32", (sizeof "decimal32") - 1,	NL ("decimal32")"decimal32", (sizeof "decimal32") - 1,	D_PRINT_DEFAULT },
/* 27 */ { NL ("decimal64")"decimal64", (sizeof "decimal64") - 1,	NL ("decimal64")"decimal64", (sizeof "decimal64") - 1,	D_PRINT_DEFAULT },
/* 28 */ { NL ("decimal128")"decimal128", (sizeof "decimal128") - 1,	NL ("decimal128")"decimal128", (sizeof "decimal128") - 1,	D_PRINT_DEFAULT },
/* 29 */ { NL ("half")"half", (sizeof "half") - 1,	NL ("half")"half", (sizeof "half") - 1,		D_PRINT_FLOAT },
/* 30 */ { NL ("char8_t")"char8_t", (sizeof "char8_t") - 1,	NL ("char8_t")"char8_t", (sizeof "char8_t") - 1,		D_PRINT_DEFAULT },
/* 31 */ { NL ("char16_t")"char16_t", (sizeof "char16_t") - 1,	NL ("char16_t")"char16_t", (sizeof "char16_t") - 1,	D_PRINT_DEFAULT },
/* 32 */ { NL ("char32_t")"char32_t", (sizeof "char32_t") - 1,	NL ("char32_t")"char32_t", (sizeof "char32_t") - 1,	D_PRINT_DEFAULT },
/* 33 */ { NL ("decltype(nullptr)")"decltype(nullptr)", (sizeof "decltype(nullptr)") - 1,	NL ("decltype(nullptr)")"decltype(nullptr)", (sizeof "decltype(nullptr)") - 1,
    D_PRINT_DEFAULT },
/* 34 */ { NL ("_Float")"_Float", (sizeof "_Float") - 1,	NL ("_Float")"_Float", (sizeof "_Float") - 1,		D_PRINT_FLOAT },
/* 35 */ { NL ("std::bfloat16_t")"std::bfloat16_t", (sizeof "std::bfloat16_t") - 1, NL ("std::bfloat16_t")"std::bfloat16_t", (sizeof "std::bfloat16_t") - 1, D_PRINT_FLOAT },
2500};

2502CP_STATIC_IF_GLIBCPP_V3
2503struct demangle_component *
2504cplus_demangle_type (struct d_info *di)
2505{
char peek;
struct demangle_component *ret;
int can_subst;

/* The ABI specifies that when CV-qualifiers are used, the base type
   is substitutable, and the fully qualified type is substitutable,
   but the base type with a strict subset of the CV-qualifiers is
   not substitutable.  The natural recursive implementation of the
   CV-qualifiers would cause subsets to be substitutable, so instead
   we pull them all off now.

   FIXME: The ABI says that order-insensitive vendor qualifiers
   should be handled in the same way, but we have no way to tell
   which vendor qualifiers are order-insensitive and which are
   order-sensitive.  So we just assume that they are all
   order-sensitive.  g++ 3.4 supports only one vendor qualifier,
   __vector, and it treats it as order-sensitive when mangling
   names.  */

if (next_is_type_qual (di))
  {
    struct demangle_component **pret;

    pret = d_cv_qualifiers (di, &ret, 0);
    if (pret == NULL((void*)0))
return NULL((void*)0);
    if (d_peek_char (di)(*((di)->n)) == 'F')
{
 /* cv-qualifiers before a function type apply to 'this',
    so avoid adding the unqualified function type to
    the substitution list.  */
 *pret = d_function_type (di);
}
    else
*pret = cplus_demangle_type (di);
    if (!*pret)
return NULL((void*)0);
    if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
 || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
{
 /* Move the ref-qualifier outside the cv-qualifiers so that
    they are printed in the right order.  */
 struct demangle_component *fn = d_left (*pret)((*pret)->u.s_binary.left);
 d_left (*pret)((*pret)->u.s_binary.left) = ret;
 ret = *pret;
 *pret = fn;
}
    if (! d_add_substitution (di, ret))
return NULL((void*)0);
    return ret;
  }

can_subst = 1;

peek = d_peek_char (di)(*((di)->n));
switch (peek)
  {
  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
  case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
  case 'o':                               case 's': case 't':
  case 'v': case 'w': case 'x': case 'y': case 'z':
    ret = d_make_builtin_type (di,
		 &cplus_demangle_builtin_types[peek - 'a']);
    di->expansion += ret->u.s_builtin.type->len;
    can_subst = 0;
    d_advance (di, 1)((di)->n += (1));
    break;

  case 'u':
    d_advance (di, 1)((di)->n += (1));
    ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
	 d_source_name (di), NULL((void*)0));
    break;

  case 'F':
    ret = d_function_type (di);
    break;

  case 'A':
    ret = d_array_type (di);
    break;

  case 'M':
    ret = d_pointer_to_member_type (di);
    break;

  case 'T':
    ret = d_template_param (di);
    if (d_peek_char (di)(*((di)->n)) == 'I')
{
 /* This may be <template-template-param> <template-args>.
    If this is the type for a conversion operator, we can
    have a <template-template-param> here only by following
    a derivation like this:

    <nested-name>
    -> <template-prefix> <template-args>
    -> <prefix> <template-unqualified-name> <template-args>
    -> <unqualified-name> <template-unqualified-name> <template-args>
    -> <source-name> <template-unqualified-name> <template-args>
    -> <source-name> <operator-name> <template-args>
    -> <source-name> cv <type> <template-args>
    -> <source-name> cv <template-template-param> <template-args> <template-args>

    where the <template-args> is followed by another.
    Otherwise, we must have a derivation like this:

    <nested-name>
    -> <template-prefix> <template-args>
    -> <prefix> <template-unqualified-name> <template-args>
    -> <unqualified-name> <template-unqualified-name> <template-args>
    -> <source-name> <template-unqualified-name> <template-args>
    -> <source-name> <operator-name> <template-args>
    -> <source-name> cv <type> <template-args>
    -> <source-name> cv <template-param> <template-args>

    where we need to leave the <template-args> to be processed
    by d_prefix (following the <template-prefix>).

    The <template-template-param> part is a substitution
    candidate.  */
 if (! di->is_conversion)
   {
     if (! d_add_substitution (di, ret))
return NULL((void*)0);
     ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
		 d_template_args (di));
   }
 else
   {
     struct demangle_component *args;
     struct d_info_checkpoint checkpoint;

     d_checkpoint (di, &checkpoint);
     args = d_template_args (di);
     if (d_peek_char (di)(*((di)->n)) == 'I')
{
  if (! d_add_substitution (di, ret))
    return NULL((void*)0);
  ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
		     args);
}
     else
d_backtrack (di, &checkpoint);
   }
}
    break;

  case 'O':
    d_advance (di, 1)((di)->n += (1));
    ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
                       cplus_demangle_type (di), NULL((void*)0));
    break;

  case 'P':
    d_advance (di, 1)((di)->n += (1));
    ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
	 cplus_demangle_type (di), NULL((void*)0));
    break;

  case 'R':
    d_advance (di, 1)((di)->n += (1));
    ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
                       cplus_demangle_type (di), NULL((void*)0));
    break;

  case 'C':
    d_advance (di, 1)((di)->n += (1));
    ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
	 cplus_demangle_type (di), NULL((void*)0));
    break;

  case 'G':
    d_advance (di, 1)((di)->n += (1));
    ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
	 cplus_demangle_type (di), NULL((void*)0));
    break;

  case 'U':
    d_advance (di, 1)((di)->n += (1));
    ret = d_source_name (di);
    if (d_peek_char (di)(*((di)->n)) == 'I')
ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
	   d_template_args (di));
    ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
	 cplus_demangle_type (di), ret);
    break;

  case 'D':
    can_subst = 0;
    d_advance (di, 1)((di)->n += (1));
    peek = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));
    switch (peek)
{
case 'T':
case 't':
 /* decltype (expression) */
 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
	     d_expression (di), NULL((void*)0));
 if (ret && d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++)) != 'E')
   ret = NULL((void*)0);
 can_subst = 1;
 break;
 
case 'p':
 /* Pack expansion.  */
 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
	     cplus_demangle_type (di), NULL((void*)0));
 can_subst = 1;
 break;

case 'a':
 /* auto */
 ret = d_make_name (di, "auto", 4);
 break;
case 'c':
 /* decltype(auto) */
 ret = d_make_name (di, "decltype(auto)", 14);
 break;

case 'f':
 /* 32-bit decimal floating point */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
 di->expansion += ret->u.s_builtin.type->len;
 break;
case 'd':
 /* 64-bit DFP */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
 di->expansion += ret->u.s_builtin.type->len;
 break;
case 'e':
 /* 128-bit DFP */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
 di->expansion += ret->u.s_builtin.type->len;
 break;
case 'h':
 /* 16-bit half-precision FP */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
 di->expansion += ret->u.s_builtin.type->len;
 break;
case 'u':
 /* char8_t */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
 di->expansion += ret->u.s_builtin.type->len;
 break;
case 's':
 /* char16_t */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
 di->expansion += ret->u.s_builtin.type->len;
 break;
case 'i':
 /* char32_t */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
 di->expansion += ret->u.s_builtin.type->len;
 break;

case 'F':
 /* DF<number>_ - _Float<number>.
    DF<number>x - _Float<number>x
    DF16b - std::bfloat16_t.  */
 {
   int arg = d_number (di);
   char buf[12];
   char suffix = 0;
   if (d_peek_char (di)(*((di)->n)) == 'b')
     {
if (arg != 16)
  return NULL((void*)0);
d_advance (di, 1)((di)->n += (1));
ret = d_make_builtin_type (di,
			   &cplus_demangle_builtin_types[35]);
di->expansion += ret->u.s_builtin.type->len;
break;
     }
   if (d_peek_char (di)(*((di)->n)) == 'x')
     suffix = 'x';
   if (!suffix && d_peek_char (di)(*((di)->n)) != '_')
     return NULL((void*)0);
   ret
     = d_make_extended_builtin_type (di,
			      &cplus_demangle_builtin_types[34],
			      arg, suffix);
   d_advance (di, 1)((di)->n += (1));
   sprintf (buf, "%d", arg);
   di->expansion += ret->u.s_extended_builtin.type->len
	     + strlen (buf) + (suffix != 0);
   break;
 }

case 'v':
 ret = d_vector_type (di);
 can_subst = 1;
 break;

      case 'n':
        /* decltype(nullptr) */
 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]);
 di->expansion += ret->u.s_builtin.type->len;
 break;

default:
 return NULL((void*)0);
}
    break;

  default:
    return d_class_enum_type (di, 1);
  }

if (can_subst)
  {
    if (! d_add_substitution (di, ret))
return NULL((void*)0);
  }

return ret;
2822}

2824/* <CV-qualifiers> ::= [r] [V] [K] [Dx] */

2826static struct demangle_component **
2827d_cv_qualifiers (struct d_info *di,
               struct demangle_component **pret, int member_fn)
2829{
struct demangle_component **pstart;
char peek;

pstart = pret;
peek = d_peek_char (di)(*((di)->n));
while (next_is_type_qual (di))
  {
    enum demangle_component_type t;
    struct demangle_component *right = NULL((void*)0);

    d_advance (di, 1)((di)->n += (1));
    if (peek == 'r')
{
 t = (member_fn
      ? DEMANGLE_COMPONENT_RESTRICT_THIS
      : DEMANGLE_COMPONENT_RESTRICT);
 di->expansion += sizeof "restrict";
}
    else if (peek == 'V')
{
 t = (member_fn
      ? DEMANGLE_COMPONENT_VOLATILE_THIS
      : DEMANGLE_COMPONENT_VOLATILE);
 di->expansion += sizeof "volatile";
}
    else if (peek == 'K')
{
 t = (member_fn
      ? DEMANGLE_COMPONENT_CONST_THIS
      : DEMANGLE_COMPONENT_CONST);
 di->expansion += sizeof "const";
}
    else
{
 peek = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));
 if (peek == 'x')
   {
     t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
     di->expansion += sizeof "transaction_safe";
   }
 else if (peek == 'o'
   || peek == 'O')
   {
     t = DEMANGLE_COMPONENT_NOEXCEPT;
     di->expansion += sizeof "noexcept";
     if (peek == 'O')
{
  right = d_expression (di);
  if (right == NULL((void*)0))
    return NULL((void*)0);
  if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
    return NULL((void*)0);
}
   }
 else if (peek == 'w')
   {
     t = DEMANGLE_COMPONENT_THROW_SPEC;
     di->expansion += sizeof "throw";
     right = d_parmlist (di);
     if (right == NULL((void*)0))
return NULL((void*)0);
     if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
return NULL((void*)0);
   }
 else
   return NULL((void*)0);
}

    *pret = d_make_comp (di, t, NULL((void*)0), right);
    if (*pret == NULL((void*)0))
return NULL((void*)0);
    pret = &d_left (*pret)((*pret)->u.s_binary.left);

    peek = d_peek_char (di)(*((di)->n));
  }

if (!member_fn && peek == 'F')
  {
    while (pstart != pret)
{
 switch ((*pstart)->type)
   {
   case DEMANGLE_COMPONENT_RESTRICT:
     (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
     break;
   case DEMANGLE_COMPONENT_VOLATILE:
     (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
     break;
   case DEMANGLE_COMPONENT_CONST:
     (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
     break;
   default:
     break;
   }
 pstart = &d_left (*pstart)((*pstart)->u.s_binary.left);
}
  }

return pret;
2929}

2931/* <ref-qualifier> ::= R
                 ::= O */

2934static struct demangle_component *
2935d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2936{
struct demangle_component *ret = sub;
char peek;

peek = d_peek_char (di)(*((di)->n));
if (peek == 'R' || peek == 'O')
  {
    enum demangle_component_type t;
    if (peek == 'R')
{
 t = DEMANGLE_COMPONENT_REFERENCE_THIS;
 di->expansion += sizeof "&";
}
    else
{
 t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
 di->expansion += sizeof "&&";
}
    d_advance (di, 1)((di)->n += (1));

    ret = d_make_comp (di, t, ret, NULL((void*)0));
  }

return ret;
2960}

2962/* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E  */

2964static struct demangle_component *
2965d_function_type (struct d_info *di)
2966{
struct demangle_component *ret = NULL((void*)0);

if ((di->options & DMGL_NO_RECURSE_LIMIT(1 << 18)) == 0)
  {
    if (di->recursion_level > DEMANGLE_RECURSION_LIMIT2048)
/* FIXME: There ought to be a way to report
  that the recursion limit has been reached.  */
return NULL((void*)0);

    di->recursion_level ++;
  }

if (d_check_char (di, 'F')((*((di)->n)) == 'F' ? ((di)->n++, 1) : 0))
  {
    if (d_peek_char (di)(*((di)->n)) == 'Y')
{
 /* Function has C linkage.  We don't print this information.
    FIXME: We should print it in verbose mode.  */
 d_advance (di, 1)((di)->n += (1));
}
    ret = d_bare_function_type (di, 1);
    ret = d_ref_qualifier (di, ret);
    
    if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
ret = NULL((void*)0);
  }

if ((di->options & DMGL_NO_RECURSE_LIMIT(1 << 18)) == 0)
  di->recursion_level --;
return ret;
2997}

2999/* <type>+ */

3001static struct demangle_component *
3002d_parmlist (struct d_info *di)
3003{
struct demangle_component *tl;
struct demangle_component **ptl;

tl = NULL((void*)0);
ptl = &tl;
while (1)
  {
    struct demangle_component *type;

    char peek = d_peek_char (di)(*((di)->n));
    if (peek == '\0' || peek == 'E' || peek == '.')
break;
    if ((peek == 'R' || peek == 'O')
 && d_peek_next_char (di)((di)->n[1]) == 'E')
/* Function ref-qualifier, not a ref prefix for a parameter type.  */
break;
    type = cplus_demangle_type (di);
    if (type == NULL((void*)0))
return NULL((void*)0);
    *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL((void*)0));
    if (*ptl == NULL((void*)0))
return NULL((void*)0);
    ptl = &d_right (*ptl)((*ptl)->u.s_binary.right);
  }

/* There should be at least one parameter type besides the optional
   return type.  A function which takes no arguments will have a
   single parameter type void.  */
if (tl == NULL((void*)0))
  return NULL((void*)0);

/* If we have a single parameter type void, omit it.  */
if (d_right (tl)((tl)->u.s_binary.right) == NULL((void*)0)
    && d_left (tl)((tl)->u.s_binary.left)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
    && d_left (tl)((tl)->u.s_binary.left)->u.s_builtin.type->print == D_PRINT_VOID)
  {
    di->expansion -= d_left (tl)((tl)->u.s_binary.left)->u.s_builtin.type->len;
    d_left (tl)((tl)->u.s_binary.left) = NULL((void*)0);
  }

return tl;
3045}

3047/* <bare-function-type> ::= [J]<type>+  */

3049static struct demangle_component *
3050d_bare_function_type (struct d_info *di, int has_return_type)
3051{
struct demangle_component *return_type;
struct demangle_component *tl;
char peek;

/* Detect special qualifier indicating that the first argument
   is the return type.  */
peek = d_peek_char (di)(*((di)->n));
if (peek == 'J')
  {
    d_advance (di, 1)((di)->n += (1));
    has_return_type = 1;
  }

if (has_return_type)
  {
    return_type = cplus_demangle_type (di);
    if (return_type == NULL((void*)0))
return NULL((void*)0);
  }
else
  return_type = NULL((void*)0);

tl = d_parmlist (di);
if (tl == NULL((void*)0))
  return NULL((void*)0);

return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
      return_type, tl);
3080}

3082/* <class-enum-type> ::= <name>  */

3084static struct demangle_component *
3085d_class_enum_type (struct d_info *di, int substable)
3086{
return d_name (di, substable);
3088}

3090/* <array-type> ::= A <(positive dimension) number> _ <(element) type>
              ::= A [<(dimension) expression>] _ <(element) type>
3092*/

3094static struct demangle_component *
3095d_array_type (struct d_info *di)
3096{
char peek;
struct demangle_component *dim;

if (! d_check_char (di, 'A')((*((di)->n)) == 'A' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

peek = d_peek_char (di)(*((di)->n));
if (peek == '_')
  dim = NULL((void*)0);
else if (IS_DIGIT (peek)((peek) >= '0' && (peek) <= '9'))
  {
    const char *s;

    s = d_str (di)((di)->n);
    do
{
 d_advance (di, 1)((di)->n += (1));
 peek = d_peek_char (di)(*((di)->n));
}
    while (IS_DIGIT (peek)((peek) >= '0' && (peek) <= '9'));
    dim = d_make_name (di, s, d_str (di)((di)->n) - s);
    if (dim == NULL((void*)0))
return NULL((void*)0);
  }
else
  {
    dim = d_expression (di);
    if (dim == NULL((void*)0))
return NULL((void*)0);
  }

if (! d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
      cplus_demangle_type (di));
3133}

3135/* <vector-type> ::= Dv <number> _ <type>
               ::= Dv _ <expression> _ <type> */

3138static struct demangle_component *
3139d_vector_type (struct d_info *di)
3140{
char peek;
struct demangle_component *dim;

peek = d_peek_char (di)(*((di)->n));
if (peek == '_')
  {
    d_advance (di, 1)((di)->n += (1));
    dim = d_expression (di);
  }
else
  dim = d_number_component (di);

if (dim == NULL((void*)0))
  return NULL((void*)0);

if (! d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
      cplus_demangle_type (di));
3161}

3163/* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */

3165static struct demangle_component *
3166d_pointer_to_member_type (struct d_info *di)
3167{
struct demangle_component *cl;
struct demangle_component *mem;

if (! d_check_char (di, 'M')((*((di)->n)) == 'M' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

cl = cplus_demangle_type (di);
if (cl == NULL((void*)0))
  return NULL((void*)0);

/* The ABI says, "The type of a non-static member function is considered
   to be different, for the purposes of substitution, from the type of a
   namespace-scope or static member function whose type appears
   similar. The types of two non-static member functions are considered
   to be different, for the purposes of substitution, if the functions
   are members of different classes. In other words, for the purposes of
   substitution, the class of which the function is a member is
   considered part of the type of function."

   For a pointer to member function, this call to cplus_demangle_type
   will end up adding a (possibly qualified) non-member function type to
   the substitution table, which is not correct; however, the member
   function type will never be used in a substitution, so putting the
   wrong type in the substitution table is harmless.  */

mem = cplus_demangle_type (di);
if (mem == NULL((void*)0))
  return NULL((void*)0);

return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
3198}

3200/* <non-negative number> _ */

3202static int
3203d_compact_number (struct d_info *di)
3204{
int num;
if (d_peek_char (di)(*((di)->n)) == '_')
  num = 0;
else if (d_peek_char (di)(*((di)->n)) == 'n')
  return -1;
else
  num = d_number (di) + 1;

if (num < 0 || ! d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0))
  return -1;
return num;
3216}

3218/* <template-param> ::= T_
                  ::= T <(parameter-2 non-negative) number> _
3220*/

3222static struct demangle_component *
3223d_template_param (struct d_info *di)
3224{
int param;

if (! d_check_char (di, 'T')((*((di)->n)) == 'T' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

param = d_compact_number (di);
if (param < 0)
  return NULL((void*)0);

return d_make_template_param (di, param);
3235}

3237/* <template-args> ::= I <template-arg>+ E  */

3239static struct demangle_component *
3240d_template_args (struct d_info *di)
3241{
if (d_peek_char (di)(*((di)->n)) != 'I'
    && d_peek_char (di)(*((di)->n)) != 'J')
  return NULL((void*)0);
d_advance (di, 1)((di)->n += (1));

return d_template_args_1 (di);
3248}

3250/* <template-arg>* E  */

3252static struct demangle_component *
3253d_template_args_1 (struct d_info *di)
3254{
struct demangle_component *hold_last_name;
struct demangle_component *al;
struct demangle_component **pal;

/* Preserve the last name we saw--don't let the template arguments
   clobber it, as that would give us the wrong name for a subsequent
   constructor or destructor.  */
hold_last_name = di->last_name;

if (d_peek_char (di)(*((di)->n)) == 'E')
  {
    /* An argument pack can be empty.  */
    d_advance (di, 1)((di)->n += (1));
    return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL((void*)0), NULL((void*)0));
  }

al = NULL((void*)0);
pal = &al;
while (1)
  {
    struct demangle_component *a;

    a = d_template_arg (di);
    if (a == NULL((void*)0))
return NULL((void*)0);

    *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL((void*)0));
    if (*pal == NULL((void*)0))
return NULL((void*)0);
    pal = &d_right (*pal)((*pal)->u.s_binary.right);

    if (d_peek_char (di)(*((di)->n)) == 'E')
{
 d_advance (di, 1)((di)->n += (1));
 break;
}
  }

di->last_name = hold_last_name;

return al;
3296}

3298/* <template-arg> ::= <type>
                ::= X <expression> E
                ::= <expr-primary>
3301*/

3303static struct demangle_component *
3304d_template_arg (struct d_info *di)
3305{
struct demangle_component *ret;

switch (d_peek_char (di)(*((di)->n)))
  {
  case 'X':
    d_advance (di, 1)((di)->n += (1));
    ret = d_expression (di);
    if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
return NULL((void*)0);
    return ret;

  case 'L':
    return d_expr_primary (di);

  case 'I':
  case 'J':
    /* An argument pack.  */
    return d_template_args (di);

  default:
    return cplus_demangle_type (di);
  }
3328}

3330/* Parse a sequence of expressions until we hit the terminator
 character.  */

3333static struct demangle_component *
3334d_exprlist (struct d_info *di, char terminator)
3335{
struct demangle_component *list = NULL((void*)0);
struct demangle_component **p = &list;

if (d_peek_char (di)(*((di)->n)) == terminator)
  {
    d_advance (di, 1)((di)->n += (1));
    return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL((void*)0), NULL((void*)0));
  }

while (1)
  {
    struct demangle_component *arg = d_expression (di);
    if (arg == NULL((void*)0))
return NULL((void*)0);

    *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL((void*)0));
    if (*p == NULL((void*)0))
return NULL((void*)0);
    p = &d_right (*p)((*p)->u.s_binary.right);

    if (d_peek_char (di)(*((di)->n)) == terminator)
{
 d_advance (di, 1)((di)->n += (1));
 break;
}
  }

return list;
3364}

3366/* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
 dynamic_cast, static_cast or reinterpret_cast.  */

3369static int
3370op_is_new_cast (struct demangle_component *op)
3371{
const char *code = op->u.s_operator.op->code;
return (code[1] == 'c'
 && (code[0] == 's' || code[0] == 'd'
     || code[0] == 'c' || code[0] == 'r'));
3376}

3378/*   <unresolved-name> ::= [gs] <base-unresolved-name> # x or (with "gs") ::x
     ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x
     # T::N::x /decltype(p)::N::x
     ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
     # A::x, N::y, A<T>::z; "gs" means leading "::"
     ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>

   "gs" is handled elsewhere, as a unary operator.  */

3387static struct demangle_component *
3388d_unresolved_name (struct d_info *di)
3389{
struct demangle_component *type;
struct demangle_component *name;
char peek;

/* Consume the "sr".  */
d_advance (di, 2)((di)->n += (2));

peek = d_peek_char (di)(*((di)->n));
if (di->unresolved_name_state
    && (IS_DIGIT (peek)((peek) >= '0' && (peek) <= '9')
 || IS_LOWER (peek)((peek) >= 'a' && (peek) <= 'z')
 || peek == 'C'
 || peek == 'U'
 || peek == 'L'))
  {
    /* The third production is ambiguous with the old unresolved-name syntax
of <type> <base-unresolved-name>; in the old mangling, A::x was mangled
as sr1A1x, now sr1AE1x.  So we first try to demangle using the new
mangling, then with the old if that fails.  */
    di->unresolved_name_state = -1;
    type = d_prefix (di, 0);
    if (d_peek_char (di)(*((di)->n)) == 'E')
d_advance (di, 1)((di)->n += (1));
  }
else
  type = cplus_demangle_type (di);
name = d_unqualified_name (di, type, NULL((void*)0));
if (d_peek_char (di)(*((di)->n)) == 'I')
  name = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
	d_template_args (di));
return name;
3421}

3423/* <expression> ::= <(unary) operator-name> <expression>
              ::= <(binary) operator-name> <expression> <expression>
              ::= <(trinary) operator-name> <expression> <expression> <expression>
::= cl <expression>+ E
              ::= st <type>
              ::= <template-param>
::= u <source-name> <template-arg>* E # vendor extended expression
::= <unresolved-name>
              ::= <expr-primary>

<braced-expression> ::= <expression>
      ::= di <field source-name> <braced-expression>	# .name = expr
      ::= dx <index expression> <braced-expression>	# [expr] = expr
      ::= dX <range begin expression> <range end expression> <braced-expression>
							# [expr ... expr] = expr
3438*/

3440static struct demangle_component *
3441d_expression_1 (struct d_info *di)
3442{
char peek;

peek = d_peek_char (di)(*((di)->n));
if (peek == 'L')
  return d_expr_primary (di);
else if (peek == 'T')
  return d_template_param (di);
else if (peek == 's' && d_peek_next_char (di)((di)->n[1]) == 'r')
  return d_unresolved_name (di);
else if (peek == 's' && d_peek_next_char (di)((di)->n[1]) == 'p')
  {
    d_advance (di, 2)((di)->n += (2));
    return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
	  d_expression_1 (di), NULL((void*)0));
  }
else if (peek == 'f' && d_peek_next_char (di)((di)->n[1]) == 'p')
  {
    /* Function parameter used in a late-specified return type.  */
    int index;
    d_advance (di, 2)((di)->n += (2));
    if (d_peek_char (di)(*((di)->n)) == 'T')
{
 /* 'this' parameter.  */
 d_advance (di, 1)((di)->n += (1));
 index = 0;
}
    else
{
 index = d_compact_number (di);
 if (index == INT_MAX2147483647 || index == -1)
   return NULL((void*)0);
 index++;
}
    return d_make_function_param (di, index);
  }
else if (IS_DIGIT (peek)((peek) >= '0' && (peek) <= '9')
  || (peek == 'o' && d_peek_next_char (di)((di)->n[1]) == 'n'))
  {
    /* We can get an unqualified name as an expression in the case of
       a dependent function call, i.e. decltype(f(t)).  */
    struct demangle_component *name;

    if (peek == 'o')
/* operator-function-id, i.e. operator+(t).  */
d_advance (di, 2)((di)->n += (2));

    name = d_unqualified_name (di, NULL((void*)0), NULL((void*)0));
    if (name == NULL((void*)0))
return NULL((void*)0);
    if (d_peek_char (di)(*((di)->n)) == 'I')
return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
	    d_template_args (di));
    else
return name;
  }
else if ((peek == 'i' || peek == 't')
  && d_peek_next_char (di)((di)->n[1]) == 'l')
  {
    /* Brace-enclosed initializer list, untyped or typed.  */
    struct demangle_component *type = NULL((void*)0);
    d_advance (di, 2)((di)->n += (2));
    if (peek == 't')
type = cplus_demangle_type (di);
    if (!d_peek_char (di)(*((di)->n)) || !d_peek_next_char (di)((di)->n[1]))
return NULL((void*)0);
    return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
	  type, d_exprlist (di, 'E'));
  }
else if (peek == 'u')
  {
    /* A vendor extended expression.  */
    struct demangle_component *name, *args;
    d_advance (di, 1)((di)->n += (1));
    name = d_source_name (di);
    args = d_template_args_1 (di);
    return d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_EXPR, name, args);
  }
else
  {
    struct demangle_component *op;
    const char *code = NULL((void*)0);
    int args;

    op = d_operator_name (di);
    if (op == NULL((void*)0))
return NULL((void*)0);

    if (op->type == DEMANGLE_COMPONENT_OPERATOR)
{
 code = op->u.s_operator.op->code;
 di->expansion += op->u.s_operator.op->len - 2;
 if (strcmp (code, "st") == 0)
   return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
		cplus_demangle_type (di));
}

    switch (op->type)
{
default:
 return NULL((void*)0);
case DEMANGLE_COMPONENT_OPERATOR:
 args = op->u.s_operator.op->args;
 break;
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 args = op->u.s_extended_operator.args;
 break;
case DEMANGLE_COMPONENT_CAST:
 args = 1;
 break;
}

    switch (args)
{
case 0:
 return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL((void*)0));

case 1:
 {
   struct demangle_component *operand;
   int suffix = 0;

   if (code && (code[0] == 'p' || code[0] == 'm')
&& code[1] == code[0])
     /* pp_ and mm_ are the prefix variants.  */
     suffix = !d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0);

   if (op->type == DEMANGLE_COMPONENT_CAST
&& d_check_char (di, '_')((*((di)->n)) == '_' ? ((di)->n++, 1) : 0))
     operand = d_exprlist (di, 'E');
   else if (code && !strcmp (code, "sP"))
     operand = d_template_args_1 (di);
   else
     operand = d_expression_1 (di);

   if (suffix)
     /* Indicate the suffix variant for d_print_comp.  */
     operand = d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS,
		     operand, operand);

   return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, operand);
 }
case 2:
 {
   struct demangle_component *left;
   struct demangle_component *right;

   if (code == NULL((void*)0))
     return NULL((void*)0);
   if (op_is_new_cast (op))
     left = cplus_demangle_type (di);
   else if (code[0] == 'f')
     /* fold-expression.  */
     left = d_operator_name (di);
   else if (!strcmp (code, "di"))
     left = d_unqualified_name (di, NULL((void*)0), NULL((void*)0));
   else
     left = d_expression_1 (di);
   if (!strcmp (code, "cl"))
     right = d_exprlist (di, 'E');
   else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
     {
peek = d_peek_char (di)(*((di)->n));
/* These codes start a qualified name.  */
if ((peek == 'g' && d_peek_next_char (di)((di)->n[1]) == 's')
    || (peek == 's' && d_peek_next_char (di)((di)->n[1]) == 'r'))
  right = d_expression_1 (di);
else
  {
    /* Otherwise it's an unqualified name.  We use
       d_unqualified_name rather than d_expression_1 here for
       old mangled names that didn't add 'on' before operator
       names.  */
    right = d_unqualified_name (di, NULL((void*)0), NULL((void*)0));
    if (d_peek_char (di)(*((di)->n)) == 'I')
      right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
			   right, d_template_args (di));
  }
     }
   else
     right = d_expression_1 (di);

   return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
		d_make_comp (di,
			     DEMANGLE_COMPONENT_BINARY_ARGS,
			     left, right));
 }
case 3:
 {
   struct demangle_component *first;
   struct demangle_component *second;
   struct demangle_component *third;

   if (code == NULL((void*)0))
     return NULL((void*)0);
   else if (!strcmp (code, "qu")
     || !strcmp (code, "dX"))
     {
/* ?: expression.  */
first = d_expression_1 (di);
second = d_expression_1 (di);
third = d_expression_1 (di);
if (third == NULL((void*)0))
  return NULL((void*)0);
     }
   else if (code[0] == 'f')
     {
/* fold-expression.  */
first = d_operator_name (di);
second = d_expression_1 (di);
third = d_expression_1 (di);
if (third == NULL((void*)0))
  return NULL((void*)0);
     }
   else if (code[0] == 'n')
     {
/* new-expression.  */
if (code[1] != 'w' && code[1] != 'a')
  return NULL((void*)0);
first = d_exprlist (di, '_');
second = cplus_demangle_type (di);
if (d_peek_char (di)(*((di)->n)) == 'E')
  {
    d_advance (di, 1)((di)->n += (1));
    third = NULL((void*)0);
  }
else if (d_peek_char (di)(*((di)->n)) == 'p'
	 && d_peek_next_char (di)((di)->n[1]) == 'i')
  {
    /* Parenthesized initializer.  */
    d_advance (di, 2)((di)->n += (2));
    third = d_exprlist (di, 'E');
  }
else if (d_peek_char (di)(*((di)->n)) == 'i'
	 && d_peek_next_char (di)((di)->n[1]) == 'l')
  /* initializer-list.  */
  third = d_expression_1 (di);
else
  return NULL((void*)0);
     }
   else
     return NULL((void*)0);
   return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
		d_make_comp (di,
			     DEMANGLE_COMPONENT_TRINARY_ARG1,
			     first,
			     d_make_comp (di,
					  DEMANGLE_COMPONENT_TRINARY_ARG2,
					  second, third)));
 }
default:
 return NULL((void*)0);
}
  }
3696}

3698static struct demangle_component *
3699d_expression (struct d_info *di)
3700{
struct demangle_component *ret;
int was_expression = di->is_expression;

di->is_expression = 1;
ret = d_expression_1 (di);
di->is_expression = was_expression;
return ret;
3708}

3710/* <expr-primary> ::= L <type> <(value) number> E
                ::= L <type> <(value) float> E
                ::= L <mangled-name> E
3713*/

3715static struct demangle_component *
3716d_expr_primary (struct d_info *di)
3717{
struct demangle_component *ret;

if (! d_check_char (di, 'L')((*((di)->n)) == 'L' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);
if (d_peek_char (di)(*((di)->n)) == '_'
    /* Workaround for G++ bug; see comment in write_template_arg.  */
    || d_peek_char (di)(*((di)->n)) == 'Z')
  ret = cplus_demangle_mangled_name (di, 0);
else
  {
    struct demangle_component *type;
    enum demangle_component_type t;
    const char *s;

    type = cplus_demangle_type (di);
    if (type == NULL((void*)0))
return NULL((void*)0);

    /* If we have a type we know how to print, we aren't going to
print the type name itself.  */
    if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
di->expansion -= type->u.s_builtin.type->len;

    if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
 && strcmp (type->u.s_builtin.type->name,
     cplus_demangle_builtin_types[33].name) == 0)
{
 if (d_peek_char (di)(*((di)->n)) == 'E')
   {
     d_advance (di, 1)((di)->n += (1));
     return type;
   }
}

    /* Rather than try to interpret the literal value, we just
collect it as a string.  Note that it's possible to have a
floating point literal here.  The ABI specifies that the
format of such literals is machine independent.  That's fine,
but what's not fine is that versions of g++ up to 3.2 with
-fabi-version=1 used upper case letters in the hex constant,
and dumped out gcc's internal representation.  That makes it
hard to tell where the constant ends, and hard to dump the
constant in any readable form anyhow.  We don't attempt to
handle these cases.  */

    t = DEMANGLE_COMPONENT_LITERAL;
    if (d_peek_char (di)(*((di)->n)) == 'n')
{
 t = DEMANGLE_COMPONENT_LITERAL_NEG;
 d_advance (di, 1)((di)->n += (1));
}
    s = d_str (di)((di)->n);
    while (d_peek_char (di)(*((di)->n)) != 'E')
{
 if (d_peek_char (di)(*((di)->n)) == '\0')
   return NULL((void*)0);
 d_advance (di, 1)((di)->n += (1));
}
    ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di)((di)->n) - s));
  }
if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);
return ret;
3782}

3784/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
              ::= Z <(function) encoding> E s [<discriminator>]
              ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3787*/

3789static struct demangle_component *
3790d_local_name (struct d_info *di)
3791{
struct demangle_component *function;
struct demangle_component *name;

if (! d_check_char (di, 'Z')((*((di)->n)) == 'Z' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

function = d_encoding (di, 0);
if (!function)
  return NULL((void*)0);

if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

if (d_peek_char (di)(*((di)->n)) == 's')
  {
    d_advance (di, 1)((di)->n += (1));
    if (! d_discriminator (di))
return NULL((void*)0);
    name = d_make_name (di, "string literal", sizeof "string literal" - 1);
  }
else
  {
    int num = -1;

    if (d_peek_char (di)(*((di)->n)) == 'd')
{
 /* Default argument scope: d <number> _.  */
 d_advance (di, 1)((di)->n += (1));
 num = d_compact_number (di);
 if (num < 0)
   return NULL((void*)0);
}

    name = d_name (di, 0);

    if (name
 /* Lambdas and unnamed types have internal discriminators
    and are not functions.  */
 && name->type != DEMANGLE_COMPONENT_LAMBDA
 && name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE)
{
 /* Read and ignore an optional discriminator.  */
 if (! d_discriminator (di))
   return NULL((void*)0);
}

    if (num >= 0)
name = d_make_default_arg (di, num, name);
  }

/* Elide the return type of the containing function so as to not
   confuse the user thinking it is the return type of whatever local
   function we might be containing.  */
if (function->type == DEMANGLE_COMPONENT_TYPED_NAME
    && d_right (function)((function)->u.s_binary.right)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
  d_left (d_right (function))((((function)->u.s_binary.right))->u.s_binary.left) = NULL((void*)0);

return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3850}

3852/* <discriminator> ::= _ <number>    # when number < 10
                 ::= __ <number> _ # when number >= 10

 <discriminator> ::= _ <number>    # when number >=10
 is also accepted to support gcc versions that wrongly mangled that way.

 We demangle the discriminator, but we don't print it out.  FIXME:
 We should print it out in verbose mode.  */

3861static int
3862d_discriminator (struct d_info *di)
3863{
int discrim, num_underscores = 1;

if (d_peek_char (di)(*((di)->n)) != '_')
  return 1;
d_advance (di, 1)((di)->n += (1));
if (d_peek_char (di)(*((di)->n)) == '_')
  {
    ++num_underscores;
    d_advance (di, 1)((di)->n += (1));
  }

discrim = d_number (di);
if (discrim < 0)
  return 0;
if (num_underscores > 1 && discrim >= 10)
  {
    if (d_peek_char (di)(*((di)->n)) == '_')
d_advance (di, 1)((di)->n += (1));
    else
return 0;
  }

return 1;
3887}

3889/* <template-parm> ::= Ty
                 ::= Tn <type>
   ::= Tt <template-head> E
   ::= Tp <template-parm>  */

3894static struct demangle_component *
3895d_template_parm (struct d_info *di, int *bad)
3896{
if (d_peek_char (di)(*((di)->n)) != 'T')
  return NULL((void*)0);

struct demangle_component *op;
enum demangle_component_type kind;
switch (d_peek_next_char (di)((di)->n[1]))
  {
  default:
    return NULL((void*)0);

  case 'p': /* Pack  */
    d_advance (di, 2)((di)->n += (2));
    op = d_template_parm (di, bad);
    kind = DEMANGLE_COMPONENT_TEMPLATE_PACK_PARM;
    if (!op)
{
 *bad = 1;
 return NULL((void*)0);
}
    break;

  case 'y': /* Typename  */
    d_advance (di, 2)((di)->n += (2));
    op = NULL((void*)0);
    kind = DEMANGLE_COMPONENT_TEMPLATE_TYPE_PARM;
    break;

  case 'n': /* Non-Type  */
    d_advance (di, 2)((di)->n += (2));
    op = cplus_demangle_type (di);
    kind = DEMANGLE_COMPONENT_TEMPLATE_NON_TYPE_PARM;
    if (!op)
{
 *bad = 1;
 return NULL((void*)0);
}
    break;

  case 't': /* Template */
    d_advance (di, 2)((di)->n += (2));
    op = d_template_head (di, bad);
    kind = DEMANGLE_COMPONENT_TEMPLATE_TEMPLATE_PARM;
    if (!op || !d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
{
 *bad = 1;
 return NULL((void*)0);
}
  }

return d_make_comp (di, kind, op, NULL((void*)0));
3947}

3949/* <template-head> ::= <template-head>? <template-parm>  */

3951static struct demangle_component *
3952d_template_head (struct d_info *di, int *bad)
3953{
struct demangle_component *res = NULL((void*)0), **slot = &res;
struct demangle_component *op;

while ((op = d_template_parm (di, bad)))
  {
    *slot = op;
    slot = &d_right (op)((op)->u.s_binary.right);
  }

/* Wrap it in a template head, to make concatenating with any parm list, and
   printing simpler.  */
if (res)
  res = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_HEAD, res, NULL((void*)0));

return res;
3969}

3971/* <closure-type-name> ::= Ul <template-head>? <lambda-sig> E [ <nonnegative number> ] _ */

3973static struct demangle_component *
3974d_lambda (struct d_info *di)
3975{
if (! d_check_char (di, 'U')((*((di)->n)) == 'U' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);
if (! d_check_char (di, 'l')((*((di)->n)) == 'l' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

int bad = 0;
struct demangle_component *head = d_template_head (di, &bad);
if (bad)
  return NULL((void*)0);

struct demangle_component *tl = d_parmlist (di);
if (tl == NULL((void*)0))
  return NULL((void*)0);
if (head)
  {
    d_right (head)((head)->u.s_binary.right) = tl;
    tl = head;
  }

if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

int num = d_compact_number (di);
if (num < 0)
  return NULL((void*)0);

struct demangle_component *ret = d_make_empty (di);
if (ret)
  {
    ret->type = DEMANGLE_COMPONENT_LAMBDA;
    ret->u.s_unary_num.sub = tl;
    ret->u.s_unary_num.num = num;
  }

return ret;
4011}

4013/* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */

4015static struct demangle_component *
4016d_unnamed_type (struct d_info *di)
4017{
struct demangle_component *ret;
int num;

if (! d_check_char (di, 'U')((*((di)->n)) == 'U' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);
if (! d_check_char (di, 't')((*((di)->n)) == 't' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

num = d_compact_number (di);
if (num < 0)
  return NULL((void*)0);

ret = d_make_empty (di);
if (ret)
  {
    ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
    ret->u.s_number.number = num;
  }

if (! d_add_substitution (di, ret))
  return NULL((void*)0);

return ret;
4041}

4043/* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
4044*/

4046static struct demangle_component *
4047d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
4048{
const char *suffix = d_str (di)((di)->n);
const char *pend = suffix;
struct demangle_component *n;

if (*pend == '.' && (IS_LOWER (pend[1])((pend[1]) >= 'a' && (pend[1]) <= 'z') || IS_DIGIT (pend[1])((pend[1]) >= '0' && (pend[1]) <= '9')
       || pend[1] == '_'))
  {
    pend += 2;
    while (IS_LOWER (*pend)((*pend) >= 'a' && (*pend) <= 'z') || IS_DIGIT (*pend)((*pend) >= '0' && (*pend) <= '9') || *pend == '_')
++pend;
  }
while (*pend == '.' && IS_DIGIT (pend[1])((pend[1]) >= '0' && (pend[1]) <= '9'))
  {
    pend += 2;
    while (IS_DIGIT (*pend)((*pend) >= '0' && (*pend) <= '9'))
++pend;
  }
d_advance (di, pend - suffix)((di)->n += (pend - suffix));
n = d_make_name (di, suffix, pend - suffix);
return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
4069}

4071/* Add a new substitution.  */

4073static int
4074d_add_substitution (struct d_info *di, struct demangle_component *dc)
4075{
if (dc == NULL((void*)0))
  return 0;
if (di->next_sub >= di->num_subs)
  return 0;
di->subs[di->next_sub] = dc;
++di->next_sub;
return 1;
4083}

4085/* <substitution> ::= S <seq-id> _
                ::= S_
                ::= St
                ::= Sa
                ::= Sb
                ::= Ss
                ::= Si
                ::= So
                ::= Sd

 If PREFIX is non-zero, then this type is being used as a prefix in
 a qualified name.  In this case, for the standard substitutions, we
 need to check whether we are being used as a prefix for a
 constructor or destructor, and return a full template name.
 Otherwise we will get something like std::iostream::~iostream()
 which does not correspond particularly well to any function which
 actually appears in the source.
4102*/

4104static const struct d_standard_sub_info standard_subs[] =
4105{
{ 't', NL ("std")"std", (sizeof "std") - 1,
  NL ("std")"std", (sizeof "std") - 1,
  NULL((void*)0), 0 },
{ 'a', NL ("std::allocator")"std::allocator", (sizeof "std::allocator") - 1,
  NL ("std::allocator")"std::allocator", (sizeof "std::allocator") - 1,
  NL ("allocator")"allocator", (sizeof "allocator") - 1 },
{ 'b', NL ("std::basic_string")"std::basic_string", (sizeof "std::basic_string") - 1,
  NL ("std::basic_string")"std::basic_string", (sizeof "std::basic_string") - 1,
  NL ("basic_string")"basic_string", (sizeof "basic_string") - 1 },
{ 's', NL ("std::string")"std::string", (sizeof "std::string") - 1,
  NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >")"std::basic_string<char, std::char_traits<char>, std::allocator<char> >"
, (sizeof "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"
) - 1,
  NL ("basic_string")"basic_string", (sizeof "basic_string") - 1 },
{ 'i', NL ("std::istream")"std::istream", (sizeof "std::istream") - 1,
  NL ("std::basic_istream<char, std::char_traits<char> >")"std::basic_istream<char, std::char_traits<char> >"
, (sizeof "std::basic_istream<char, std::char_traits<char> >"
) - 1,
  NL ("basic_istream")"basic_istream", (sizeof "basic_istream") - 1 },
{ 'o', NL ("std::ostream")"std::ostream", (sizeof "std::ostream") - 1,
  NL ("std::basic_ostream<char, std::char_traits<char> >")"std::basic_ostream<char, std::char_traits<char> >"
, (sizeof "std::basic_ostream<char, std::char_traits<char> >"
) - 1,
  NL ("basic_ostream")"basic_ostream", (sizeof "basic_ostream") - 1 },
{ 'd', NL ("std::iostream")"std::iostream", (sizeof "std::iostream") - 1,
  NL ("std::basic_iostream<char, std::char_traits<char> >")"std::basic_iostream<char, std::char_traits<char> >"
, (sizeof "std::basic_iostream<char, std::char_traits<char> >"
) - 1,
  NL ("basic_iostream")"basic_iostream", (sizeof "basic_iostream") - 1 }
4127};

4129static struct demangle_component *
4130d_substitution (struct d_info *di, int prefix)
4131{
char c;

if (! d_check_char (di, 'S')((*((di)->n)) == 'S' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

c = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));
if (c == '_' || IS_DIGIT (c)((c) >= '0' && (c) <= '9') || IS_UPPER (c)((c) >= 'A' && (c) <= 'Z'))
  {
    unsigned int id;

    id = 0;
    if (c != '_')
{
 do
   {
     unsigned int new_id;

     if (IS_DIGIT (c)((c) >= '0' && (c) <= '9'))
new_id = id * 36 + c - '0';
     else if (IS_UPPER (c)((c) >= 'A' && (c) <= 'Z'))
new_id = id * 36 + c - 'A' + 10;
     else
return NULL((void*)0);
     if (new_id < id)
return NULL((void*)0);
     id = new_id;
     c = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));
   }
 while (c != '_');

 ++id;
}

    if (id >= (unsigned int) di->next_sub)
return NULL((void*)0);

    return di->subs[id];
  }
else
  {
    int verbose;
    const struct d_standard_sub_info *p;
    const struct d_standard_sub_info *pend;

    verbose = (di->options & DMGL_VERBOSE(1 << 3)) != 0;
    if (! verbose && prefix)
{
 char peek;

 peek = d_peek_char (di)(*((di)->n));
 if (peek == 'C' || peek == 'D')
   verbose = 1;
}

    pend = (&standard_subs[0]
     + sizeof standard_subs / sizeof standard_subs[0]);
    for (p = &standard_subs[0]; p < pend; ++p)
{
 if (c == p->code)
   {
     const char *s;
     int len;
     struct demangle_component *dc;

     if (p->set_last_name != NULL((void*)0))
di->last_name = d_make_sub (di, p->set_last_name,
			    p->set_last_name_len);
     if (verbose)
{
  s = p->full_expansion;
  len = p->full_len;
}
     else
{
  s = p->simple_expansion;
  len = p->simple_len;
}
     di->expansion += len;
     dc = d_make_sub (di, s, len);
     if (d_peek_char (di)(*((di)->n)) == 'B')
{
  /* If there are ABI tags on the abbreviation, it becomes
     a substitution candidate.  */
  dc = d_abi_tags (di, dc);
  if (! d_add_substitution (di, dc))
    return NULL((void*)0);
}
     return dc;
   }
}

    return NULL((void*)0);
  }
4225}

4227static void
4228d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
4229{
checkpoint->n = di->n;
checkpoint->next_comp = di->next_comp;
checkpoint->next_sub = di->next_sub;
checkpoint->expansion = di->expansion;
4234}

4236static void
4237d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
4238{
di->n = checkpoint->n;
di->next_comp = checkpoint->next_comp;
di->next_sub = checkpoint->next_sub;
di->expansion = checkpoint->expansion;
4243}

4245/* Initialize a growable string.  */

4247static void
4248d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
4249{
dgs->buf = NULL((void*)0);
dgs->len = 0;
dgs->alc = 0;
dgs->allocation_failure = 0;

if (estimate > 0)
  d_growable_string_resize (dgs, estimate);
4257}

4259/* Grow a growable string to a given size.  */

4261static inline void
4262d_growable_string_resize (struct d_growable_string *dgs, size_t need)
4263{
size_t newalc;
char *newbuf;

if (dgs->allocation_failure)
  return;

/* Start allocation at two bytes to avoid any possibility of confusion
   with the special value of 1 used as a return in *palc to indicate
   allocation failures.  */
newalc = dgs->alc > 0 ? dgs->alc : 2;
while (newalc < need)
  newalc <<= 1;

newbuf = (char *) realloc (dgs->buf, newalc);
if (newbuf == NULL((void*)0))
  {
    free (dgs->buf);
    dgs->buf = NULL((void*)0);
    dgs->len = 0;
    dgs->alc = 0;
    dgs->allocation_failure = 1;
    return;
  }
dgs->buf = newbuf;
dgs->alc = newalc;
4289}

4291/* Append a buffer to a growable string.  */

4293static inline void
4294d_growable_string_append_buffer (struct d_growable_string *dgs,
                               const char *s, size_t l)
4296{
size_t need;

need = dgs->len + l + 1;
if (need > dgs->alc)
  d_growable_string_resize (dgs, need);

if (dgs->allocation_failure)
  return;

memcpy (dgs->buf + dgs->len, s, l);
dgs->buf[dgs->len + l] = '\0';
dgs->len += l;
4309}

4311/* Bridge growable strings to the callback mechanism.  */

4313static void
4314d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
4315{
struct d_growable_string *dgs = (struct d_growable_string*) opaque;

d_growable_string_append_buffer (dgs, s, l);
4319}

4321/* Walk the tree, counting the number of templates encountered, and
 the number of times a scope might be saved.  These counts will be
 used to allocate data structures for d_print_comp, so the logic
 here must mirror the logic d_print_comp will use.  It is not
 important that the resulting numbers are exact, so long as they
 are larger than the actual numbers encountered.  */

4328static void
4329d_count_templates_scopes (struct d_print_info *dpi,
	  struct demangle_component *dc)
4331{
if (dc == NULL((void*)0) || dc->d_counting > 1 || dpi->recursion > MAX_RECURSION_COUNT1024)
  return;

++ dc->d_counting;

switch (dc->type)
  {
  case DEMANGLE_COMPONENT_NAME:
  case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
  case DEMANGLE_COMPONENT_FUNCTION_PARAM:
  case DEMANGLE_COMPONENT_SUB_STD:
  case DEMANGLE_COMPONENT_BUILTIN_TYPE:
  case DEMANGLE_COMPONENT_EXTENDED_BUILTIN_TYPE:
  case DEMANGLE_COMPONENT_OPERATOR:
  case DEMANGLE_COMPONENT_CHARACTER:
  case DEMANGLE_COMPONENT_NUMBER:
  case DEMANGLE_COMPONENT_UNNAMED_TYPE:
  case DEMANGLE_COMPONENT_STRUCTURED_BINDING:
  case DEMANGLE_COMPONENT_MODULE_NAME:
  case DEMANGLE_COMPONENT_MODULE_PARTITION:
  case DEMANGLE_COMPONENT_MODULE_INIT:
  case DEMANGLE_COMPONENT_FIXED_TYPE:
  case DEMANGLE_COMPONENT_TEMPLATE_HEAD:
  case DEMANGLE_COMPONENT_TEMPLATE_TYPE_PARM:
  case DEMANGLE_COMPONENT_TEMPLATE_NON_TYPE_PARM:
  case DEMANGLE_COMPONENT_TEMPLATE_TEMPLATE_PARM:
  case DEMANGLE_COMPONENT_TEMPLATE_PACK_PARM:
    break;

  case DEMANGLE_COMPONENT_TEMPLATE:
    dpi->num_copy_templates++;
    goto recurse_left_right;

  case DEMANGLE_COMPONENT_REFERENCE:
  case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
    if (d_left (dc)((dc)->u.s_binary.left)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
dpi->num_saved_scopes++;
    goto recurse_left_right;

  case DEMANGLE_COMPONENT_QUAL_NAME:
  case DEMANGLE_COMPONENT_LOCAL_NAME:
  case DEMANGLE_COMPONENT_TYPED_NAME:
  case DEMANGLE_COMPONENT_VTABLE:
  case DEMANGLE_COMPONENT_VTT:
  case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
  case DEMANGLE_COMPONENT_TYPEINFO:
  case DEMANGLE_COMPONENT_TYPEINFO_NAME:
  case DEMANGLE_COMPONENT_TYPEINFO_FN:
  case DEMANGLE_COMPONENT_THUNK:
  case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
  case DEMANGLE_COMPONENT_COVARIANT_THUNK:
  case DEMANGLE_COMPONENT_JAVA_CLASS:
  case DEMANGLE_COMPONENT_GUARD:
  case DEMANGLE_COMPONENT_TLS_INIT:
  case DEMANGLE_COMPONENT_TLS_WRAPPER:
  case DEMANGLE_COMPONENT_REFTEMP:
  case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
  case DEMANGLE_COMPONENT_RESTRICT:
  case DEMANGLE_COMPONENT_VOLATILE:
  case DEMANGLE_COMPONENT_CONST:
  case DEMANGLE_COMPONENT_RESTRICT_THIS:
  case DEMANGLE_COMPONENT_VOLATILE_THIS:
  case DEMANGLE_COMPONENT_CONST_THIS:
  case DEMANGLE_COMPONENT_REFERENCE_THIS:
  case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
  case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
  case DEMANGLE_COMPONENT_NOEXCEPT:
  case DEMANGLE_COMPONENT_THROW_SPEC:
  case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  case DEMANGLE_COMPONENT_POINTER:
  case DEMANGLE_COMPONENT_COMPLEX:
  case DEMANGLE_COMPONENT_IMAGINARY:
  case DEMANGLE_COMPONENT_VENDOR_TYPE:
  case DEMANGLE_COMPONENT_FUNCTION_TYPE:
  case DEMANGLE_COMPONENT_ARRAY_TYPE:
  case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  case DEMANGLE_COMPONENT_VECTOR_TYPE:
  case DEMANGLE_COMPONENT_ARGLIST:
  case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
  case DEMANGLE_COMPONENT_TPARM_OBJ:
  case DEMANGLE_COMPONENT_INITIALIZER_LIST:
  case DEMANGLE_COMPONENT_CAST:
  case DEMANGLE_COMPONENT_CONVERSION:
  case DEMANGLE_COMPONENT_NULLARY:
  case DEMANGLE_COMPONENT_UNARY:
  case DEMANGLE_COMPONENT_BINARY:
  case DEMANGLE_COMPONENT_BINARY_ARGS:
  case DEMANGLE_COMPONENT_TRINARY:
  case DEMANGLE_COMPONENT_TRINARY_ARG1:
  case DEMANGLE_COMPONENT_TRINARY_ARG2:
  case DEMANGLE_COMPONENT_LITERAL:
  case DEMANGLE_COMPONENT_LITERAL_NEG:
  case DEMANGLE_COMPONENT_VENDOR_EXPR:
  case DEMANGLE_COMPONENT_JAVA_RESOURCE:
  case DEMANGLE_COMPONENT_COMPOUND_NAME:
  case DEMANGLE_COMPONENT_DECLTYPE:
  case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
  case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
  case DEMANGLE_COMPONENT_PACK_EXPANSION:
  case DEMANGLE_COMPONENT_TAGGED_NAME:
  case DEMANGLE_COMPONENT_CLONE:
  recurse_left_right:
    /* PR 89394 - Check for too much recursion.  */
    if (dpi->recursion > DEMANGLE_RECURSION_LIMIT2048)
/* FIXME: There ought to be a way to report to the
  user that the recursion limit has been reached.  */
return;

    ++ dpi->recursion;
    d_count_templates_scopes (dpi, d_left (dc)((dc)->u.s_binary.left));
    d_count_templates_scopes (dpi, d_right (dc)((dc)->u.s_binary.right));
    -- dpi->recursion;
    break;

  case DEMANGLE_COMPONENT_CTOR:
    d_count_templates_scopes (dpi, dc->u.s_ctor.name);
    break;

  case DEMANGLE_COMPONENT_DTOR:
    d_count_templates_scopes (dpi, dc->u.s_dtor.name);
    break;

  case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
    d_count_templates_scopes (dpi, dc->u.s_extended_operator.name);
    break;

  case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
  case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
  case DEMANGLE_COMPONENT_MODULE_ENTITY:
    d_count_templates_scopes (dpi, d_left (dc)((dc)->u.s_binary.left));
    break;

  case DEMANGLE_COMPONENT_LAMBDA:
  case DEMANGLE_COMPONENT_DEFAULT_ARG:
    d_count_templates_scopes (dpi, dc->u.s_unary_num.sub);
    break;
  }
4469}

4471/* Initialize a print information structure.  */

4473static void
4474d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
     void *opaque, struct demangle_component *dc)
4476{
dpi->len = 0;
dpi->last_char = '\0';
dpi->templates = NULL((void*)0);
dpi->modifiers = NULL((void*)0);
dpi->pack_index = 0;
dpi->flush_count = 0;

dpi->callback = callback;
dpi->opaque = opaque;

dpi->demangle_failure = 0;
dpi->recursion = 0;
dpi->lambda_tpl_parms = 0;

dpi->component_stack = NULL((void*)0);

dpi->saved_scopes = NULL((void*)0);
dpi->next_saved_scope = 0;
dpi->num_saved_scopes = 0;

dpi->copy_templates = NULL((void*)0);
dpi->next_copy_template = 0;
dpi->num_copy_templates = 0;

d_count_templates_scopes (dpi, dc);
/* If we did not reach the recursion limit, then reset the
   current recursion value back to 0, so that we can print
   the templates.  */
if (dpi->recursion < DEMANGLE_RECURSION_LIMIT2048)
  dpi->recursion = 0;
dpi->num_copy_templates *= dpi->num_saved_scopes;

dpi->current_template = NULL((void*)0);
4510}

4512/* Indicate that an error occurred during printing, and test for error.  */

4514static inline void
4515d_print_error (struct d_print_info *dpi)
4516{
dpi->demangle_failure = 1;
4518}

4520static inline int
4521d_print_saw_error (struct d_print_info *dpi)
4522{
return dpi->demangle_failure != 0;
4524}

4526/* Flush buffered characters to the callback.  */

4528static inline void
4529d_print_flush (struct d_print_info *dpi)
4530{
dpi->buf[dpi->len] = '\0';
dpi->callback (dpi->buf, dpi->len, dpi->opaque);
dpi->len = 0;
dpi->flush_count++;
4535}

4537/* Append characters and buffers for printing.  */

4539static inline void
4540d_append_char (struct d_print_info *dpi, char c)
4541{
if (dpi->len == sizeof (dpi->buf) - 1)
  d_print_flush (dpi);

dpi->buf[dpi->len++] = c;
dpi->last_char = c;
4547}

4549static inline void
4550d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4551{
size_t i;

for (i = 0; i < l; i++)
  d_append_char (dpi, s[i]);
4556}

4558static inline void
4559d_append_string (struct d_print_info *dpi, const char *s)
4560{
d_append_buffer (dpi, s, strlen (s));
4562}

4564static inline void
4565d_append_num (struct d_print_info *dpi, int l)
4566{
char buf[25];
sprintf (buf,"%d", l);
d_append_string (dpi, buf);
4570}

4572static inline char
4573d_last_char (struct d_print_info *dpi)
4574{
return dpi->last_char;
4576}

4578/* Turn components into a human readable string.  OPTIONS is the
 options bits passed to the demangler.  DC is the tree to print.
 CALLBACK is a function to call to flush demangled string segments
 as they fill the intermediate buffer, and OPAQUE is a generalized
 callback argument.  On success, this returns 1.  On failure,
 it returns 0, indicating a bad parse.  It does not use heap
 memory to build an output string, so cannot encounter memory
 allocation failure.  */

4587CP_STATIC_IF_GLIBCPP_V3
4588int
4589cplus_demangle_print_callback (int options,
                             struct demangle_component *dc,
                             demangle_callbackref callback, void *opaque)
4592{
struct d_print_info dpi;

d_print_init (&dpi, callback, opaque, dc);

{
4598#ifdef CP_DYNAMIC_ARRAYS
  /* Avoid zero-length VLAs, which are prohibited by the C99 standard
     and flagged as errors by Address Sanitizer.  */
  __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
                                            ? dpi.num_saved_scopes : 1];
  __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
                                              ? dpi.num_copy_templates : 1];

  dpi.saved_scopes = scopes;
  dpi.copy_templates = temps;
4608#else
  dpi.saved_scopes = alloca (dpi.num_saved_scopes__builtin_alloca(dpi.num_saved_scopes * sizeof (*dpi.saved_scopes
))
	       * sizeof (*dpi.saved_scopes))__builtin_alloca(dpi.num_saved_scopes * sizeof (*dpi.saved_scopes
));
  dpi.copy_templates = alloca (dpi.num_copy_templates__builtin_alloca(dpi.num_copy_templates * sizeof (*dpi.copy_templates
))
		 * sizeof (*dpi.copy_templates))__builtin_alloca(dpi.num_copy_templates * sizeof (*dpi.copy_templates
));
4613#endif

  d_print_comp (&dpi, options, dc);
}

d_print_flush (&dpi);

return ! d_print_saw_error (&dpi);
4621}

4623/* Turn components into a human readable string.  OPTIONS is the
 options bits passed to the demangler.  DC is the tree to print.
 ESTIMATE is a guess at the length of the result.  This returns a
 string allocated by malloc, or NULL on error.  On success, this
 sets *PALC to the size of the allocated buffer.  On failure, this
 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
 failure.  */

4631CP_STATIC_IF_GLIBCPP_V3
4632char *
4633cplus_demangle_print (int options, struct demangle_component *dc,
                    int estimate, size_t *palc)
4635{
struct d_growable_string dgs;

d_growable_string_init (&dgs, estimate);

if (! cplus_demangle_print_callback (options, dc,
                                     d_growable_string_callback_adapter,
                                     &dgs))
  {
    free (dgs.buf);
    *palc = 0;
    return NULL((void*)0);
  }

*palc = dgs.allocation_failure ? 1 : dgs.alc;
return dgs.buf;
4651}

4653/* Returns the I'th element of the template arglist ARGS, or NULL on
 failure.  If I is negative, return the entire arglist.  */

4656static struct demangle_component *
4657d_index_template_argument (struct demangle_component *args, int i)
4658{
struct demangle_component *a;

if (i < 0)
  /* Print the whole argument pack.  */
  return args;

for (a = args;
     a != NULL((void*)0);
     a = d_right (a)((a)->u.s_binary.right))
  {
    if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
return NULL((void*)0);
    if (i <= 0)
break;
    --i;
  }
if (i != 0 || a == NULL((void*)0))
  return NULL((void*)0);

return d_left (a)((a)->u.s_binary.left);
4679}

4681/* Returns the template argument from the current context indicated by DC,
 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */

4684static struct demangle_component *
4685d_lookup_template_argument (struct d_print_info *dpi,
	    const struct demangle_component *dc)
4687{
if (dpi->templates == NULL((void*)0))
  {
    d_print_error (dpi);
    return NULL((void*)0);
  }

return d_index_template_argument
  (d_right (dpi->templates->template_decl)((dpi->templates->template_decl)->u.s_binary.right),
   dc->u.s_number.number);
4697}

4699/* Returns a template argument pack used in DC (any will do), or NULL.  */

4701static struct demangle_component *
4702d_find_pack (struct d_print_info *dpi,
    const struct demangle_component *dc)
4704{
struct demangle_component *a;
if (dc == NULL((void*)0))
  return NULL((void*)0);

switch (dc->type)
  {
  case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
    a = d_lookup_template_argument (dpi, dc);
    if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
return a;
    return NULL((void*)0);

  case DEMANGLE_COMPONENT_PACK_EXPANSION:
    return NULL((void*)0);
    
  case DEMANGLE_COMPONENT_LAMBDA:
  case DEMANGLE_COMPONENT_NAME:
  case DEMANGLE_COMPONENT_TAGGED_NAME:
  case DEMANGLE_COMPONENT_OPERATOR:
  case DEMANGLE_COMPONENT_BUILTIN_TYPE:
  case DEMANGLE_COMPONENT_EXTENDED_BUILTIN_TYPE:
  case DEMANGLE_COMPONENT_SUB_STD:
  case DEMANGLE_COMPONENT_CHARACTER:
  case DEMANGLE_COMPONENT_FUNCTION_PARAM:
  case DEMANGLE_COMPONENT_UNNAMED_TYPE:
  case DEMANGLE_COMPONENT_DEFAULT_ARG:
  case DEMANGLE_COMPONENT_NUMBER:
    return NULL((void*)0);

  case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
    return d_find_pack (dpi, dc->u.s_extended_operator.name);
  case DEMANGLE_COMPONENT_CTOR:
    return d_find_pack (dpi, dc->u.s_ctor.name);
  case DEMANGLE_COMPONENT_DTOR:
    return d_find_pack (dpi, dc->u.s_dtor.name);

  default:
    a = d_find_pack (dpi, d_left (dc)((dc)->u.s_binary.left));
    if (a)
return a;
    return d_find_pack (dpi, d_right (dc)((dc)->u.s_binary.right));
  }
4747}

4749/* Returns the length of the template argument pack DC.  */

4751static int
4752d_pack_length (const struct demangle_component *dc)
4753{
int count = 0;
while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
&& d_left (dc)((dc)->u.s_binary.left) != NULL((void*)0))
  {
    ++count;
    dc = d_right (dc)((dc)->u.s_binary.right);
  }
return count;
4762}

4764/* Returns the number of template args in DC, expanding any pack expansions
 found there.  */

4767static int
4768d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
4769{
int count = 0;
for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
     dc = d_right (dc)((dc)->u.s_binary.right))
  {
    struct demangle_component *elt = d_left (dc)((dc)->u.s_binary.left);
    if (elt == NULL((void*)0))
break;
    if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
{
 struct demangle_component *a = d_find_pack (dpi, d_left (elt)((elt)->u.s_binary.left));
 count += d_pack_length (a);
}
    else
++count;
  }
return count;
4786}

4788/* DC is a component of a mangled expression.  Print it, wrapped in parens
 if needed.  */

4791static void
4792d_print_subexpr (struct d_print_info *dpi, int options,
 struct demangle_component *dc)
4794{
int simple = 0;
if (dc->type == DEMANGLE_COMPONENT_NAME
    || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
    || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
    || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
  simple = 1;
if (!simple)
  d_append_char (dpi, '(');
d_print_comp (dpi, options, dc);
if (!simple)
  d_append_char (dpi, ')');
4806}

4808/* Save the current scope.  */

4810static void
4811d_save_scope (struct d_print_info *dpi,
     const struct demangle_component *container)
4813{
struct d_saved_scope *scope;
struct d_print_template *src, **link;

if (dpi->next_saved_scope >= dpi->num_saved_scopes)
  {
    d_print_error (dpi);
    return;
  }
scope = &dpi->saved_scopes[dpi->next_saved_scope];
dpi->next_saved_scope++;

scope->container = container;
link = &scope->templates;

for (src = dpi->templates; src != NULL((void*)0); src = src->next)
  {
    struct d_print_template *dst;

    if (dpi->next_copy_template >= dpi->num_copy_templates)
{
 d_print_error (dpi);
 return;
}
    dst = &dpi->copy_templates[dpi->next_copy_template];
    dpi->next_copy_template++;

    dst->template_decl = src->template_decl;
    *link = dst;
    link = &dst->next;
  }

*link = NULL((void*)0);
4846}

4848/* Attempt to locate a previously saved scope.  Returns NULL if no
 corresponding saved scope was found.  */

4851static struct d_saved_scope *
4852d_get_saved_scope (struct d_print_info *dpi,
   const struct demangle_component *container)
4854{
int i;

for (i = 0; i < dpi->next_saved_scope; i++)
  if (dpi->saved_scopes[i].container == container)
    return &dpi->saved_scopes[i];

return NULL((void*)0);
4862}

4864/* If DC is a C++17 fold-expression, print it and return true; otherwise
 return false.  */

4867static int
4868d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
	       struct demangle_component *dc)
4870{
struct demangle_component *ops, *operator_, *op1, *op2;
int save_idx;

const char *fold_code = d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->code;
if (fold_code[0] != 'f')
  return 0;

ops = d_right (dc)((dc)->u.s_binary.right);
operator_ = d_left (ops)((ops)->u.s_binary.left);
op1 = d_right (ops)((ops)->u.s_binary.right);
op2 = 0;
if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
  {
    op2 = d_right (op1)((op1)->u.s_binary.right);
    op1 = d_left (op1)((op1)->u.s_binary.left);
  }

/* Print the whole pack.  */
save_idx = dpi->pack_index;
dpi->pack_index = -1;

switch (fold_code[1])
  {
    /* Unary left fold, (... + X).  */
  case 'l':
    d_append_string (dpi, "(...");
    d_print_expr_op (dpi, options, operator_);
    d_print_subexpr (dpi, options, op1);
    d_append_char (dpi, ')');
    break;

    /* Unary right fold, (X + ...).  */
  case 'r':
    d_append_char (dpi, '(');
    d_print_subexpr (dpi, options, op1);
    d_print_expr_op (dpi, options, operator_);
    d_append_string (dpi, "...)");
    break;

    /* Binary left fold, (42 + ... + X).  */
  case 'L':
    /* Binary right fold, (X + ... + 42).  */
  case 'R':
    d_append_char (dpi, '(');
    d_print_subexpr (dpi, options, op1);
    d_print_expr_op (dpi, options, operator_);
    d_append_string (dpi, "...");
    d_print_expr_op (dpi, options, operator_);
    d_print_subexpr (dpi, options, op2);
    d_append_char (dpi, ')');
    break;
  }

dpi->pack_index = save_idx;
return 1;
4926}

4928/* True iff DC represents a C99-style designated initializer.  */

4930static int
4931is_designated_init (struct demangle_component *dc)
4932{
if (dc->type != DEMANGLE_COMPONENT_BINARY
    && dc->type != DEMANGLE_COMPONENT_TRINARY)
  return 0;

struct demangle_component *op = d_left (dc)((dc)->u.s_binary.left);
const char *code = op->u.s_operator.op->code;
return (code[0] == 'd'
 && (code[1] == 'i' || code[1] == 'x' || code[1] == 'X'));
4941}

4943/* If DC represents a C99-style designated initializer, print it and return
 true; otherwise, return false.  */

4946static int
4947d_maybe_print_designated_init (struct d_print_info *dpi, int options,
	       struct demangle_component *dc)
4949{
if (!is_designated_init (dc))
  return 0;

const char *code = d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->code;

struct demangle_component *operands = d_right (dc)((dc)->u.s_binary.right);
struct demangle_component *op1 = d_left (operands)((operands)->u.s_binary.left);
struct demangle_component *op2 = d_right (operands)((operands)->u.s_binary.right);

if (code[1] == 'i')
  d_append_char (dpi, '.');
else
  d_append_char (dpi, '[');

d_print_comp (dpi, options, op1);
if (code[1] == 'X')
  {
    d_append_string (dpi, " ... ");
    d_print_comp (dpi, options, d_left (op2)((op2)->u.s_binary.left));
    op2 = d_right (op2)((op2)->u.s_binary.right);
  }
if (code[1] != 'i')
  d_append_char (dpi, ']');
if (is_designated_init (op2))
  {
    /* Don't put '=' or '(' between chained designators.  */
    d_print_comp (dpi, options, op2);
  }
else
  {
    d_append_char (dpi, '=');
    d_print_subexpr (dpi, options, op2);
  }
return 1;
4984}

4986static void
4987d_print_lambda_parm_name (struct d_print_info *dpi, int type, unsigned index)
4988{
const char *str;
switch (type)
  {
  default:
    dpi->demangle_failure = 1;
    str = "";
    break;

  case DEMANGLE_COMPONENT_TEMPLATE_TYPE_PARM:
    str = "$T";
    break;

  case DEMANGLE_COMPONENT_TEMPLATE_NON_TYPE_PARM:
    str = "$N";
    break;

  case DEMANGLE_COMPONENT_TEMPLATE_TEMPLATE_PARM:
    str = "$TT";
    break;
  }
d_append_string (dpi, str);
d_append_num (dpi, index);
5011}

5013/* Subroutine to handle components.  */

5015static void
5016d_print_comp_inner (struct d_print_info *dpi, int options,
    struct demangle_component *dc)
5018{
/* Magic variable to let reference smashing skip over the next modifier
   without needing to modify *dc.  */
struct demangle_component *mod_inner = NULL((void*)0);

/* Variable used to store the current templates while a previously
   captured scope is used.  */
struct d_print_template *saved_templates;

/* Nonzero if templates have been stored in the above variable.  */
int need_template_restore = 0;

if (dc == NULL((void*)0))
1
Assuming 'dc' is not equal to NULL→
2
←
Taking false branch→
  {
    d_print_error (dpi);
    return;
  }
if (d_print_saw_error (dpi))
3
←
Taking false branch→
  return;

switch (dc->type)
4
←
Control jumps to 'case DEMANGLE_COMPONENT_TYPED_NAME:'  at line 5106→
  {
  case DEMANGLE_COMPONENT_NAME:
    if ((options & DMGL_JAVA(1 << 2)) == 0)
d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
    else
d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
    return;

  case DEMANGLE_COMPONENT_TAGGED_NAME:
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    d_append_string (dpi, "[abi:");
    d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
    d_append_char (dpi, ']');
    return;

  case DEMANGLE_COMPONENT_STRUCTURED_BINDING:
    d_append_char (dpi, '[');
    for (;;)
{
 d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
 dc = d_right (dc)((dc)->u.s_binary.right);
 if (!dc)
   break;
 d_append_string (dpi, ", ");
}
    d_append_char (dpi, ']');
    return;

  case DEMANGLE_COMPONENT_MODULE_ENTITY:
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    d_append_char (dpi, '@');
    d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
    return;

  case DEMANGLE_COMPONENT_MODULE_NAME:
  case DEMANGLE_COMPONENT_MODULE_PARTITION:
    {
if (d_left (dc)((dc)->u.s_binary.left))
 d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
char c = dc->type == DEMANGLE_COMPONENT_MODULE_PARTITION
 ? ':' : d_left (dc)((dc)->u.s_binary.left) ? '.' : 0;
if (c)
 d_append_char (dpi, c);
d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
    }
    return;

  case DEMANGLE_COMPONENT_QUAL_NAME:
  case DEMANGLE_COMPONENT_LOCAL_NAME:
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    if ((options & DMGL_JAVA(1 << 2)) == 0)
d_append_string (dpi, "::");
    else
d_append_char (dpi, '.');
    {
struct demangle_component *local_name = d_right (dc)((dc)->u.s_binary.right);
if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
 {
   d_append_string (dpi, "{default arg#");
   d_append_num (dpi, local_name->u.s_unary_num.num + 1);
   d_append_string (dpi, "}::");
   local_name = local_name->u.s_unary_num.sub;
 }
d_print_comp (dpi, options, local_name);
    }
    return;

  case DEMANGLE_COMPONENT_TYPED_NAME:
    {
struct d_print_mod *hold_modifiers;
struct demangle_component *typed_name;
struct d_print_mod adpm[4];
unsigned int i;
struct d_print_template dpt;

/* Pass the name down to the type so that it can be printed in
  the right place for the type.  We also have to pass down
  any CV-qualifiers, which apply to the this parameter.  */
hold_modifiers = dpi->modifiers;
dpi->modifiers = 0;
i = 0;
typed_name = d_left (dc)((dc)->u.s_binary.left);
while (typed_name != NULL((void*)0))
5
←
Assuming 'typed_name' is not equal to NULL→
6
←
Loop condition is true.  Entering loop body→
 {
   if (i >= sizeof adpm / sizeof adpm[0])
7
←
Taking false branch→
     {
d_print_error (dpi);
return;
     }

   adpm[i].next = dpi->modifiers;
   dpi->modifiers = &adpm[i];
   adpm[i].mod = typed_name;
   adpm[i].printed = 0;
   adpm[i].templates = dpi->templates;
   ++i;

   if (!is_fnqual_component_type (typed_name->type))
8
←
Taking true branch→
     break;

   typed_name = d_left (typed_name)((typed_name)->u.s_binary.left);
 }

if (typed_name9.1
'typed_name' is not equal to NULL
 == NULL((void*)0))
9
←
 Execution continues on line 5142→
10
←
Taking false branch→
 {
   d_print_error (dpi);
   return;
 }

/* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
  there may be CV-qualifiers on its right argument which
  really apply here; this happens when parsing a class that
  is local to a function.  */
if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
11
←
Assuming field 'type' is not equal to DEMANGLE_COMPONENT_LOCAL_NAME→
12
←
Taking false branch→
 {
   typed_name = d_right (typed_name)((typed_name)->u.s_binary.right);
   if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
     typed_name = typed_name->u.s_unary_num.sub;
   while (typed_name != NULL((void*)0)
   && is_fnqual_component_type (typed_name->type))
     {
if (i >= sizeof adpm / sizeof adpm[0])
  {
    d_print_error (dpi);
    return;
  }

adpm[i] = adpm[i - 1];
adpm[i].next = &adpm[i - 1];
dpi->modifiers = &adpm[i];

adpm[i - 1].mod = typed_name;
adpm[i - 1].printed = 0;
adpm[i - 1].templates = dpi->templates;
++i;

typed_name = d_left (typed_name)((typed_name)->u.s_binary.left);
     }
   if (typed_name == NULL((void*)0))
     {
d_print_error (dpi);
return;
     }
 }

/* If typed_name is a template, then it applies to the
  function type as well.  */
if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
13
←
Assuming field 'type' is not equal to DEMANGLE_COMPONENT_TEMPLATE→
14
←
Taking false branch→
 {
   dpt.next = dpi->templates;
   dpi->templates = &dpt;
   dpt.template_decl = typed_name;
 }

d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));

if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
15
←
Assuming field 'type' is equal to DEMANGLE_COMPONENT_TEMPLATE→
16
←
Taking true branch→
 dpi->templates = dpt.next;
17
←
Assigned value is garbage or undefined

/* If the modifiers didn't get printed by the type, print them
  now.  */
while (i > 0)
 {
   --i;
   if (! adpm[i].printed)
     {
d_append_char (dpi, ' ');
d_print_mod (dpi, options, adpm[i].mod);
     }
 }

dpi->modifiers = hold_modifiers;

return;
    }

  case DEMANGLE_COMPONENT_TEMPLATE:
    {
struct d_print_mod *hold_dpm;
struct demangle_component *dcl;
const struct demangle_component *hold_current;

/* This template may need to be referenced by a cast operator
  contained in its subtree.  */
hold_current = dpi->current_template;
dpi->current_template = dc;

/* Don't push modifiers into a template definition.  Doing so
  could give the wrong definition for a template argument.
  Instead, treat the template essentially as a name.  */

hold_dpm = dpi->modifiers;
dpi->modifiers = NULL((void*)0);

      dcl = d_left (dc)((dc)->u.s_binary.left);

      if ((options & DMGL_JAVA(1 << 2)) != 0
          && dcl->type == DEMANGLE_COMPONENT_NAME
          && dcl->u.s_name.len == 6
          && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
        {
          /* Special-case Java arrays, so that JArray<TYPE> appears
             instead as TYPE[].  */

          d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
          d_append_string (dpi, "[]");
        }
      else
        {
   d_print_comp (dpi, options, dcl);
   if (d_last_char (dpi) == '<')
     d_append_char (dpi, ' ');
   d_append_char (dpi, '<');
   d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
   /* Avoid generating two consecutive '>' characters, to avoid
      the C++ syntactic ambiguity.  */
   if (d_last_char (dpi) == '>')
     d_append_char (dpi, ' ');
   d_append_char (dpi, '>');
        }

dpi->modifiers = hold_dpm;
dpi->current_template = hold_current;

return;
    }

  case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
    if (dpi->lambda_tpl_parms > dc->u.s_number.number + 1)
{
 const struct demangle_component *a
   = d_left (dpi->templates->template_decl)((dpi->templates->template_decl)->u.s_binary.left);
 unsigned c;
 for (c = dc->u.s_number.number; a && c; c--)
   a = d_right (a)((a)->u.s_binary.right);
 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_PACK_PARM)
   a = d_left (a)((a)->u.s_binary.left);
 if (!a)
   dpi->demangle_failure = 1;
 else
   d_print_lambda_parm_name (dpi, a->type, dc->u.s_number.number);
}
    else if (dpi->lambda_tpl_parms)
{
 /* Show the template parm index, as that's how g++ displays
    these, and future proofs us against potential
    '[]<typename T> (T *a, T *b) {...}'.  */
 d_append_buffer (dpi, "auto:", 5);
 d_append_num (dpi, dc->u.s_number.number + 1);
}
    else
{
 struct d_print_template *hold_dpt;
 struct demangle_component *a = d_lookup_template_argument (dpi, dc);

 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
   a = d_index_template_argument (a, dpi->pack_index);

 if (a == NULL((void*)0))
   {
     d_print_error (dpi);
     return;
   }

 /* While processing this parameter, we need to pop the list
    of templates.  This is because the template parameter may
    itself be a reference to a parameter of an outer
    template.  */

 hold_dpt = dpi->templates;
 dpi->templates = hold_dpt->next;

 d_print_comp (dpi, options, a);

 dpi->templates = hold_dpt;
}
    return;

  case DEMANGLE_COMPONENT_TPARM_OBJ:
    d_append_string (dpi, "template parameter object for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_CTOR:
    d_print_comp (dpi, options, dc->u.s_ctor.name);
    return;

  case DEMANGLE_COMPONENT_DTOR:
    d_append_char (dpi, '~');
    d_print_comp (dpi, options, dc->u.s_dtor.name);
    return;

  case DEMANGLE_COMPONENT_MODULE_INIT:
    d_append_string (dpi, "initializer for module ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_VTABLE:
    d_append_string (dpi, "vtable for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_VTT:
    d_append_string (dpi, "VTT for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
    d_append_string (dpi, "construction vtable for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    d_append_string (dpi, "-in-");
    d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
    return;

  case DEMANGLE_COMPONENT_TYPEINFO:
    d_append_string (dpi, "typeinfo for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_TYPEINFO_NAME:
    d_append_string (dpi, "typeinfo name for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_TYPEINFO_FN:
    d_append_string (dpi, "typeinfo fn for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_THUNK:
    d_append_string (dpi, "non-virtual thunk to ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
    d_append_string (dpi, "virtual thunk to ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_COVARIANT_THUNK:
    d_append_string (dpi, "covariant return thunk to ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_JAVA_CLASS:
    d_append_string (dpi, "java Class for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_GUARD:
    d_append_string (dpi, "guard variable for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_TLS_INIT:
    d_append_string (dpi, "TLS init function for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_TLS_WRAPPER:
    d_append_string (dpi, "TLS wrapper function for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_REFTEMP:
    d_append_string (dpi, "reference temporary #");
    d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
    d_append_string (dpi, " for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
    d_append_string (dpi, "hidden alias for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
    d_append_string (dpi, "transaction clone for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
    d_append_string (dpi, "non-transaction clone for ");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_SUB_STD:
    d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
    return;

  case DEMANGLE_COMPONENT_RESTRICT:
  case DEMANGLE_COMPONENT_VOLATILE:
  case DEMANGLE_COMPONENT_CONST:
    {
struct d_print_mod *pdpm;

/* When printing arrays, it's possible to have cases where the
  same CV-qualifier gets pushed on the stack multiple times.
  We only need to print it once.  */

for (pdpm = dpi->modifiers; pdpm != NULL((void*)0); pdpm = pdpm->next)
 {
   if (! pdpm->printed)
     {
if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
    && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
    && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
  break;
if (pdpm->mod->type == dc->type)
  {
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;
  }
     }
 }
    }
    goto modifier;

  case DEMANGLE_COMPONENT_REFERENCE:
  case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
    {
/* Handle reference smashing: & + && = &.  */
struct demangle_component *sub = d_left (dc)((dc)->u.s_binary.left);
if (!dpi->lambda_tpl_parms
   && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
 {
   struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
   struct demangle_component *a;

   if (scope == NULL((void*)0))
     {
/* This is the first time SUB has been traversed.
   We need to capture the current templates so
   they can be restored if SUB is reentered as a
   substitution.  */
d_save_scope (dpi, sub);
if (d_print_saw_error (dpi))
  return;
     }
   else
     {
const struct d_component_stack *dcse;
int found_self_or_parent = 0;

/* This traversal is reentering SUB as a substition.
   If we are not beneath SUB or DC in the tree then we
   need to restore SUB's template stack temporarily.  */
for (dcse = dpi->component_stack; dcse != NULL((void*)0);
     dcse = dcse->parent)
  {
    if (dcse->dc == sub
	|| (dcse->dc == dc
	    && dcse != dpi->component_stack))
      {
	found_self_or_parent = 1;
	break;
      }
  }

if (!found_self_or_parent)
  {
    saved_templates = dpi->templates;
    dpi->templates = scope->templates;
    need_template_restore = 1;
  }
     }

   a = d_lookup_template_argument (dpi, sub);
   if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
     a = d_index_template_argument (a, dpi->pack_index);

   if (a == NULL((void*)0))
     {
if (need_template_restore)
  dpi->templates = saved_templates;

d_print_error (dpi);
return;
     }

   sub = a;
 }

if (sub->type == DEMANGLE_COMPONENT_REFERENCE
   || sub->type == dc->type)
 dc = sub;
else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
 mod_inner = d_left (sub)((sub)->u.s_binary.left);
    }
    /* Fall through.  */

  case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
  case DEMANGLE_COMPONENT_POINTER:
  case DEMANGLE_COMPONENT_COMPLEX:
  case DEMANGLE_COMPONENT_IMAGINARY:
  FNQUAL_COMPONENT_CASEcase DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS
: case DEMANGLE_COMPONENT_CONST_THIS: case DEMANGLE_COMPONENT_REFERENCE_THIS
: case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: case DEMANGLE_COMPONENT_TRANSACTION_SAFE
: case DEMANGLE_COMPONENT_NOEXCEPT: case DEMANGLE_COMPONENT_THROW_SPEC:
  modifier:
    {
/* We keep a list of modifiers on the stack.  */
struct d_print_mod dpm;

dpm.next = dpi->modifiers;
dpi->modifiers = &dpm;
dpm.mod = dc;
dpm.printed = 0;
dpm.templates = dpi->templates;

if (!mod_inner)
 mod_inner = d_left (dc)((dc)->u.s_binary.left);

d_print_comp (dpi, options, mod_inner);

/* If the modifier didn't get printed by the type, print it
  now.  */
if (! dpm.printed)
 d_print_mod (dpi, options, dc);

dpi->modifiers = dpm.next;

if (need_template_restore)
 dpi->templates = saved_templates;

return;
    }

  case DEMANGLE_COMPONENT_BUILTIN_TYPE:
    if ((options & DMGL_JAVA(1 << 2)) == 0)
d_append_buffer (dpi, dc->u.s_builtin.type->name,
	 dc->u.s_builtin.type->len);
    else
d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
	 dc->u.s_builtin.type->java_len);
    return;

  case DEMANGLE_COMPONENT_EXTENDED_BUILTIN_TYPE:
    d_append_buffer (dpi, dc->u.s_extended_builtin.type->name,
       dc->u.s_extended_builtin.type->len);
    d_append_num (dpi, dc->u.s_extended_builtin.arg);
    if (dc->u.s_extended_builtin.suffix)
d_append_buffer (dpi, &dc->u.s_extended_builtin.suffix, 1);
    return;

  case DEMANGLE_COMPONENT_VENDOR_TYPE:
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_FUNCTION_TYPE:
    {
if ((options & DMGL_RET_POSTFIX(1 << 5)) != 0)
 d_print_function_type (dpi,
		 options & ~(DMGL_RET_POSTFIX(1 << 5) | DMGL_RET_DROP(1 << 6)),
		 dc, dpi->modifiers);

/* Print return type if present */
if (d_left (dc)((dc)->u.s_binary.left) != NULL((void*)0) && (options & DMGL_RET_POSTFIX(1 << 5)) != 0)
 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX(1 << 5) | DMGL_RET_DROP(1 << 6)),
	d_left (dc)((dc)->u.s_binary.left));
else if (d_left (dc)((dc)->u.s_binary.left) != NULL((void*)0) && (options & DMGL_RET_DROP(1 << 6)) == 0)
 {
   struct d_print_mod dpm;

   /* We must pass this type down as a modifier in order to
      print it in the right location.  */
   dpm.next = dpi->modifiers;
   dpi->modifiers = &dpm;
   dpm.mod = dc;
   dpm.printed = 0;
   dpm.templates = dpi->templates;

   d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX(1 << 5) | DMGL_RET_DROP(1 << 6)),
	  d_left (dc)((dc)->u.s_binary.left));

   dpi->modifiers = dpm.next;

   if (dpm.printed)
     return;

   /* In standard prefix notation, there is a space between the
      return type and the function signature.  */
   if ((options & DMGL_RET_POSTFIX(1 << 5)) == 0)
     d_append_char (dpi, ' ');
 }

if ((options & DMGL_RET_POSTFIX(1 << 5)) == 0)
 d_print_function_type (dpi,
		 options & ~(DMGL_RET_POSTFIX(1 << 5) | DMGL_RET_DROP(1 << 6)),
		 dc, dpi->modifiers);

return;
    }

  case DEMANGLE_COMPONENT_ARRAY_TYPE:
    {
struct d_print_mod *hold_modifiers;
struct d_print_mod adpm[4];
unsigned int i;
struct d_print_mod *pdpm;

/* We must pass this type down as a modifier in order to print
  multi-dimensional arrays correctly.  If the array itself is
  CV-qualified, we act as though the element type were
  CV-qualified.  We do this by copying the modifiers down
  rather than fiddling pointers, so that we don't wind up
  with a d_print_mod higher on the stack pointing into our
  stack frame after we return.  */

hold_modifiers = dpi->modifiers;

adpm[0].next = hold_modifiers;
dpi->modifiers = &adpm[0];
adpm[0].mod = dc;
adpm[0].printed = 0;
adpm[0].templates = dpi->templates;

i = 1;
pdpm = hold_modifiers;
while (pdpm != NULL((void*)0)
      && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
   || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
   || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
 {
   if (! pdpm->printed)
     {
if (i >= sizeof adpm / sizeof adpm[0])
  {
    d_print_error (dpi);
    return;
  }

adpm[i] = *pdpm;
adpm[i].next = dpi->modifiers;
dpi->modifiers = &adpm[i];
pdpm->printed = 1;
++i;
     }

   pdpm = pdpm->next;
 }

d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));

dpi->modifiers = hold_modifiers;

if (adpm[0].printed)
 return;

while (i > 1)
 {
   --i;
   d_print_mod (dpi, options, adpm[i].mod);
 }

d_print_array_type (dpi, options, dc, dpi->modifiers);

return;
    }

  case DEMANGLE_COMPONENT_PTRMEM_TYPE:
  case DEMANGLE_COMPONENT_VECTOR_TYPE:
    {
struct d_print_mod dpm;

dpm.next = dpi->modifiers;
dpi->modifiers = &dpm;
dpm.mod = dc;
dpm.printed = 0;
dpm.templates = dpi->templates;

d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));

/* If the modifier didn't get printed by the type, print it
  now.  */
if (! dpm.printed)
 d_print_mod (dpi, options, dc);

dpi->modifiers = dpm.next;

return;
    }

  case DEMANGLE_COMPONENT_ARGLIST:
  case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
    if (d_left (dc)((dc)->u.s_binary.left) != NULL((void*)0))
d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    if (d_right (dc)((dc)->u.s_binary.right) != NULL((void*)0))
{
 size_t len;
 unsigned long int flush_count;
 /* Make sure ", " isn't flushed by d_append_string, otherwise
    dpi->len -= 2 wouldn't work.  */
 if (dpi->len >= sizeof (dpi->buf) - 2)
   d_print_flush (dpi);
 d_append_string (dpi, ", ");
 len = dpi->len;
 flush_count = dpi->flush_count;
 d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
 /* If that didn't print anything (which can happen with empty
    template argument packs), remove the comma and space.  */
 if (dpi->flush_count == flush_count && dpi->len == len)
   dpi->len -= 2;
}
    return;

  case DEMANGLE_COMPONENT_INITIALIZER_LIST:
    {
struct demangle_component *type = d_left (dc)((dc)->u.s_binary.left);
struct demangle_component *list = d_right (dc)((dc)->u.s_binary.right);

if (type)
 d_print_comp (dpi, options, type);
d_append_char (dpi, '{');
d_print_comp (dpi, options, list);
d_append_char (dpi, '}');
    }
    return;

  case DEMANGLE_COMPONENT_OPERATOR:
    {
const struct demangle_operator_info *op = dc->u.s_operator.op;
int len = op->len;

d_append_string (dpi, "operator");
/* Add a space before new/delete.  */
if (IS_LOWER (op->name[0])((op->name[0]) >= 'a' && (op->name[0]) <=
 'z'))
 d_append_char (dpi, ' ');
/* Omit a trailing space.  */
if (op->name[len-1] == ' ')
 --len;
d_append_buffer (dpi, op->name, len);
return;
    }

  case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
    d_append_string (dpi, "operator ");
    d_print_comp (dpi, options, dc->u.s_extended_operator.name);
    return;

  case DEMANGLE_COMPONENT_CONVERSION:
    d_append_string (dpi, "operator ");
    d_print_conversion (dpi, options, dc);
    return;

  case DEMANGLE_COMPONENT_NULLARY:
    d_print_expr_op (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    return;

  case DEMANGLE_COMPONENT_UNARY:
    {
struct demangle_component *op = d_left (dc)((dc)->u.s_binary.left);
struct demangle_component *operand = d_right (dc)((dc)->u.s_binary.right);
const char *code = NULL((void*)0);

if (op->type == DEMANGLE_COMPONENT_OPERATOR)
 {
   code = op->u.s_operator.op->code;
   if (!strcmp (code, "ad"))
     {
/* Don't print the argument list for the address of a
   function.  */
if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
    && d_left (operand)((operand)->u.s_binary.left)->type == DEMANGLE_COMPONENT_QUAL_NAME
    && d_right (operand)((operand)->u.s_binary.right)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
  operand = d_left (operand)((operand)->u.s_binary.left);
     }
   if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
     {
/* This indicates a suffix operator.  */
operand = d_left (operand)((operand)->u.s_binary.left);
d_print_subexpr (dpi, options, operand);
d_print_expr_op (dpi, options, op);
return;
     }
 }

/* For sizeof..., just print the pack length.  */
if (code && !strcmp (code, "sZ"))
 {
   struct demangle_component *a = d_find_pack (dpi, operand);
   int len = d_pack_length (a);
   d_append_num (dpi, len);
   return;
 }
else if (code && !strcmp (code, "sP"))
 {
   int len = d_args_length (dpi, operand);
   d_append_num (dpi, len);
   return;
 }

if (op->type != DEMANGLE_COMPONENT_CAST)
 d_print_expr_op (dpi, options, op);
else
 {
   d_append_char (dpi, '(');
   d_print_cast (dpi, options, op);
   d_append_char (dpi, ')');
 }
if (code && !strcmp (code, "gs"))
 /* Avoid parens after '::'.  */
 d_print_comp (dpi, options, operand);
else if (code && !strcmp (code, "st"))
 /* Always print parens for sizeof (type).  */
 {
   d_append_char (dpi, '(');
   d_print_comp (dpi, options, operand);
   d_append_char (dpi, ')');
 }
else
 d_print_subexpr (dpi, options, operand);
    }
    return;

  case DEMANGLE_COMPONENT_BINARY:
    if (d_right (dc)((dc)->u.s_binary.right)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
{
 d_print_error (dpi);
 return;
}

    if (op_is_new_cast (d_left (dc)((dc)->u.s_binary.left)))
{
 d_print_expr_op (dpi, options, d_left (dc)((dc)->u.s_binary.left));
 d_append_char (dpi, '<');
 d_print_comp (dpi, options, d_left (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.left));
 d_append_string (dpi, ">(");
 d_print_comp (dpi, options, d_right (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.right));
 d_append_char (dpi, ')');
 return;
}

    if (d_maybe_print_fold_expression (dpi, options, dc))
return;

    if (d_maybe_print_designated_init (dpi, options, dc))
return;

    /* We wrap an expression which uses the greater-than operator in
an extra layer of parens so that it does not get confused
with the '>' which ends the template parameters.  */
    if (d_left (dc)((dc)->u.s_binary.left)->type == DEMANGLE_COMPONENT_OPERATOR
 && d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->len == 1
 && d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->name[0] == '>')
d_append_char (dpi, '(');

    if (strcmp (d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->code, "cl") == 0
        && d_left (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.left)->type == DEMANGLE_COMPONENT_TYPED_NAME)
{
 /* Function call used in an expression should not have printed types
    of the function arguments.  Values of the function arguments still
    get printed below.  */

 const struct demangle_component *func = d_left (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.left);

 if (d_right (func)((func)->u.s_binary.right)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
   d_print_error (dpi);
 d_print_subexpr (dpi, options, d_left (func)((func)->u.s_binary.left));
}
    else
d_print_subexpr (dpi, options, d_left (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.left));
    if (strcmp (d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->code, "ix") == 0)
{
 d_append_char (dpi, '[');
 d_print_comp (dpi, options, d_right (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.right));
 d_append_char (dpi, ']');
}
    else
{
 if (strcmp (d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->code, "cl") != 0)
   d_print_expr_op (dpi, options, d_left (dc)((dc)->u.s_binary.left));
 d_print_subexpr (dpi, options, d_right (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.right));
}

    if (d_left (dc)((dc)->u.s_binary.left)->type == DEMANGLE_COMPONENT_OPERATOR
 && d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->len == 1
 && d_left (dc)((dc)->u.s_binary.left)->u.s_operator.op->name[0] == '>')
d_append_char (dpi, ')');

    return;

  case DEMANGLE_COMPONENT_BINARY_ARGS:
    /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
    d_print_error (dpi);
    return;

  case DEMANGLE_COMPONENT_TRINARY:
    if (d_right (dc)((dc)->u.s_binary.right)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
 || d_right (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.right)->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
{
 d_print_error (dpi);
 return;
}
    if (d_maybe_print_fold_expression (dpi, options, dc))
return;
    if (d_maybe_print_designated_init (dpi, options, dc))
return;
    {
struct demangle_component *op = d_left (dc)((dc)->u.s_binary.left);
struct demangle_component *first = d_left (d_right (dc))((((dc)->u.s_binary.right))->u.s_binary.left);
struct demangle_component *second = d_left (d_right (d_right (dc)))((((((dc)->u.s_binary.right))->u.s_binary.right))->u
.s_binary.left);
struct demangle_component *third = d_right (d_right (d_right (dc)))((((((dc)->u.s_binary.right))->u.s_binary.right))->u
.s_binary.right);

if (!strcmp (op->u.s_operator.op->code, "qu"))
 {
   d_print_subexpr (dpi, options, first);
   d_print_expr_op (dpi, options, op);
   d_print_subexpr (dpi, options, second);
   d_append_string (dpi, " : ");
   d_print_subexpr (dpi, options, third);
 }
else
 {
   d_append_string (dpi, "new ");
   if (d_left (first)((first)->u.s_binary.left) != NULL((void*)0))
     {
d_print_subexpr (dpi, options, first);
d_append_char (dpi, ' ');
     }
   d_print_comp (dpi, options, second);
   if (third)
     d_print_subexpr (dpi, options, third);
 }
    }
    return;

  case DEMANGLE_COMPONENT_TRINARY_ARG1:
  case DEMANGLE_COMPONENT_TRINARY_ARG2:
    /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
    d_print_error (dpi);
    return;

  case DEMANGLE_COMPONENT_LITERAL:
  case DEMANGLE_COMPONENT_LITERAL_NEG:
    {
enum d_builtin_type_print tp;

/* For some builtin types, produce simpler output.  */
tp = D_PRINT_DEFAULT;
if (d_left (dc)((dc)->u.s_binary.left)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
 {
   tp = d_left (dc)((dc)->u.s_binary.left)->u.s_builtin.type->print;
   switch (tp)
     {
     case D_PRINT_INT:
     case D_PRINT_UNSIGNED:
     case D_PRINT_LONG:
     case D_PRINT_UNSIGNED_LONG:
     case D_PRINT_LONG_LONG:
     case D_PRINT_UNSIGNED_LONG_LONG:
if (d_right (dc)((dc)->u.s_binary.right)->type == DEMANGLE_COMPONENT_NAME)
  {
    if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
      d_append_char (dpi, '-');
    d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
    switch (tp)
      {
      default:
	break;
      case D_PRINT_UNSIGNED:
	d_append_char (dpi, 'u');
	break;
      case D_PRINT_LONG:
	d_append_char (dpi, 'l');
	break;
      case D_PRINT_UNSIGNED_LONG:
	d_append_string (dpi, "ul");
	break;
      case D_PRINT_LONG_LONG:
	d_append_string (dpi, "ll");
	break;
      case D_PRINT_UNSIGNED_LONG_LONG:
	d_append_string (dpi, "ull");
	break;
      }
    return;
  }
break;

     case D_PRINT_BOOL:
if (d_right (dc)((dc)->u.s_binary.right)->type == DEMANGLE_COMPONENT_NAME
    && d_right (dc)((dc)->u.s_binary.right)->u.s_name.len == 1
    && dc->type == DEMANGLE_COMPONENT_LITERAL)
  {
    <