/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/cp-demangle.c

Bug Summary

File:	build/libiberty/cp-demangle.c
Warning:	line 4947, 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-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name cp-demangle.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D HAVE_CONFIG_H -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/../include -D _GNU_SOURCE -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wwrite-strings -fconst-strings -fdebug-compilation-dir /home/marxin/BIG/buildbot/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 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-fn7Kdr.plist -x c /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/cp-demangle.c
1/* Demangler for g++ V3 ABI.
 Copyright (C) 2003-2021 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;
/* Non-zero if we're printing a lambda argument.  A template
   parameter reference actually means 'auto'.  */
int is_lambda_arg;
/* 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 *);

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

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

434static struct demangle_component *d_unqualified_name (struct d_info *);

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

438static int d_number (struct d_info *);

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

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

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

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

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

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

452static struct demangle_component **
453d_cv_qualifiers (struct d_info *, struct demangle_component **, int);

455static struct demangle_component *
456d_ref_qualifier (struct d_info *, struct demangle_component *);

458static struct demangle_component *
459d_function_type (struct d_info *);

461static struct demangle_component *
462d_bare_function_type (struct d_info *, int);

464static struct demangle_component *
465d_class_enum_type (struct d_info *);

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

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

471static struct demangle_component *
472d_pointer_to_member_type (struct d_info *);

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

477static struct demangle_component *d_template_args (struct d_info *);
478static struct demangle_component *d_template_args_1 (struct d_info *);

480static struct demangle_component *
481d_template_arg (struct d_info *);

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

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

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

489static int d_discriminator (struct d_info *);

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

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

495static struct demangle_component *
496d_clone_suffix (struct d_info *, struct demangle_component *);

498static int
499d_add_substitution (struct d_info *, struct demangle_component *);

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

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

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

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

509static inline void
510d_growable_string_resize (struct d_growable_string *, size_t);

512static inline void
513d_growable_string_append_buffer (struct d_growable_string *,
                               const char *, size_t);
515static void
516d_growable_string_callback_adapter (const char *, size_t, void *);

518static void
519d_print_init (struct d_print_info *, demangle_callbackref, void *,
     struct demangle_component *);

522static inline void d_print_error (struct d_print_info *);

524static inline int d_print_saw_error (struct d_print_info *);

526static inline void d_print_flush (struct d_print_info *);

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

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

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

535static inline char d_last_char (struct d_print_info *);

537static void
538d_print_comp (struct d_print_info *, int, struct demangle_component *);

540static void
541d_print_java_identifier (struct d_print_info *, const char *, int);

543static void
544d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);

546static void
547d_print_mod (struct d_print_info *, int, struct demangle_component *);

549static void
550d_print_function_type (struct d_print_info *, int,
                     struct demangle_component *,
                     struct d_print_mod *);

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

559static void
560d_print_expr_op (struct d_print_info *, int, struct demangle_component *);

562static void d_print_cast (struct d_print_info *, int,
	  struct demangle_component *);
564static void d_print_conversion (struct d_print_info *, int,
		struct demangle_component *);

567static int d_demangle_callback (const char *, int,
                              demangle_callbackref, void *);
569static char *d_demangle (const char *, int, size_t *);

571#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

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

584static int
585is_fnqual_component_type (enum demangle_component_type type)
586{
switch (type)
13
←
Control jumps to the 'default' case at line 591→
  {
  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;
14
←
 Execution continues on line 594→
  }
return 0;
15
←
Returning zero, which participates in a condition later→
595}


598#ifdef CP_DEMANGLE_DEBUG

600static void
601d_dump (struct demangle_component *dc, int indent)
602{
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_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_FIXED_TYPE:
    printf ("fixed-point type, accum? %d, sat? %d\n",
            dc->u.s_fixed.accum, dc->u.s_fixed.sat);
    d_dump (dc->u.s_fixed.length, indent + 2);
    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_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);
854}

856#endif /* CP_DEMANGLE_DEBUG */

858/* Fill in a DEMANGLE_COMPONENT_NAME.  */

860CP_STATIC_IF_GLIBCPP_V3
861int
862cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
863{
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;
872}

874/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */

876CP_STATIC_IF_GLIBCPP_V3
877int
878cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
                                     struct demangle_component *name)
880{
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;
889}

891/* Fill in a DEMANGLE_COMPONENT_CTOR.  */

893CP_STATIC_IF_GLIBCPP_V3
894int
895cplus_demangle_fill_ctor (struct demangle_component *p,
                        enum gnu_v3_ctor_kinds kind,
                        struct demangle_component *name)
898{
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;
910}

912/* Fill in a DEMANGLE_COMPONENT_DTOR.  */

914CP_STATIC_IF_GLIBCPP_V3
915int
916cplus_demangle_fill_dtor (struct demangle_component *p,
                        enum gnu_v3_dtor_kinds kind,
                        struct demangle_component *name)
919{
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;
931}

933/* Add a new component.  */

935static struct demangle_component *
936d_make_empty (struct d_info *di)
937{
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;
947}

949/* Add a new generic component.  */

951static struct demangle_component *
952d_make_comp (struct d_info *di, enum demangle_component_type type,
           struct demangle_component *left,
           struct demangle_component *right)
955{
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_COMPOUND_NAME:
  case DEMANGLE_COMPONENT_VECTOR_TYPE:
  case DEMANGLE_COMPONENT_CLONE:
    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:
    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:
    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:
  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;
1055}

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

1059static struct demangle_component *
1060d_make_demangle_mangled_name (struct d_info *di, const char *s)
1061{
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);
1066}

1068/* Add a new name component.  */

1070static struct demangle_component *
1071d_make_name (struct d_info *di, const char *s, int len)
1072{
struct demangle_component *p;

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

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

1083static struct demangle_component *
1084d_make_builtin_type (struct d_info *di,
                   const struct demangle_builtin_type_info *type)
1086{
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;
1098}

1100/* Add a new operator component.  */

1102static struct demangle_component *
1103d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
1104{
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;
1114}

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

1118static struct demangle_component *
1119d_make_extended_operator (struct d_info *di, int args,
                        struct demangle_component *name)
1121{
struct demangle_component *p;

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

1130static struct demangle_component *
1131d_make_default_arg (struct d_info *di, int num,
    struct demangle_component *sub)
1133{
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;
1142}

1144/* Add a new constructor component.  */

1146static struct demangle_component *
1147d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
           struct demangle_component *name)
1149{
struct demangle_component *p;

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

1158/* Add a new destructor component.  */

1160static struct demangle_component *
1161d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
           struct demangle_component *name)
1163{
struct demangle_component *p;

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

1172/* Add a new template parameter.  */

1174static struct demangle_component *
1175d_make_template_param (struct d_info *di, int i)
1176{
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;
1186}

1188/* Add a new function parameter.  */

1190static struct demangle_component *
1191d_make_function_param (struct d_info *di, int i)
1192{
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;
1202}

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

1206static struct demangle_component *
1207d_make_sub (struct d_info *di, const char *name, int len)
1208{
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;
1219}

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

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

1225CP_STATIC_IF_GLIBCPP_V3
1226struct demangle_component *
1227cplus_demangle_mangled_name (struct d_info *di, int top_level)
1228{
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;
1251}

1253/* 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.  */

1262static int
1263has_return_type (struct demangle_component *dc)
1264{
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));
  }
1278}

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

1283static int
1284is_ctor_dtor_or_conversion (struct demangle_component *dc)
1285{
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;
  }
1300}

1302/* <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.  */

1311static struct demangle_component *
1312d_encoding (struct d_info *di, int top_level)
1313{
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);

    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;
1375}

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

1379static struct demangle_component *
1380d_abi_tags (struct d_info *di, struct demangle_component *dc)
1381{
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;
1400}

1402/* <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>
1412*/

1414static struct demangle_component *
1415d_name (struct d_info *di)
1416{
char peek = d_peek_char (di)(*((di)->n));
struct demangle_component *dc;

switch (peek)
  {
  case 'N':
    return d_nested_name (di);

  case 'Z':
    return d_local_name (di);

  case 'U':
    return d_unqualified_name (di);

  case 'S':
    {
int subst;

if (d_peek_next_char (di)((di)->n[1]) != 't')
 {
   dc = d_substitution (di, 0);
   subst = 1;
 }
else
 {
   d_advance (di, 2)((di)->n += (2));
   dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
	      d_make_name (di, "std", 3),
	      d_unqualified_name (di));
   di->expansion += 3;
   subst = 0;
 }

if (d_peek_char (di)(*((di)->n)) != 'I')
 {
   /* The grammar does not permit this case to occur if we
      called d_substitution() above (i.e., subst == 1).  We
      don't bother to check.  */
 }
else
 {
   /* This is <template-args>, which means that we just saw
      <unscoped-template-name>, which is a substitution
      candidate if we didn't just get it from a
      substitution.  */
   if (! subst)
     {
if (! d_add_substitution (di, dc))
  return NULL((void*)0);
     }
   dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
	      d_template_args (di));
 }

return dc;
    }

  case 'L':
  default:
    dc = d_unqualified_name (di);
    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 (! d_add_substitution (di, dc))
   return NULL((void*)0);
 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
	    d_template_args (di));
}
    return dc;
  }
1489}

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

1495static struct demangle_component *
1496d_nested_name (struct d_info *di)
1497{
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;
1527}

1529/* <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).  */

1543static struct demangle_component *
1544d_prefix (struct d_info *di, int subst)
1545{
struct demangle_component *ret = NULL((void*)0);

while (1)
  {
    char peek;
    enum demangle_component_type comb_type;
    struct demangle_component *dc;

    peek = d_peek_char (di)(*((di)->n));
    if (peek == '\0')
return NULL((void*)0);

    /* 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.  */

    comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
    if (peek == 'D')
{
 char peek2 = d_peek_next_char (di)((di)->n[1]);
 if (peek2 == 'T' || peek2 == 't')
   /* Decltype.  */
   dc = cplus_demangle_type (di);
 else
   /* Destructor name.  */
   dc = d_unqualified_name (di);
}
    else if (IS_DIGIT (peek)((peek) >= '0' && (peek) <= '9')
 || IS_LOWER (peek)((peek) >= 'a' && (peek) <= 'z')
 || peek == 'C'
 || peek == 'U'
 || peek == 'L')
dc = d_unqualified_name (di);
    else if (peek == 'S')
dc = d_substitution (di, 1);
    else if (peek == 'I')
{
 if (ret == NULL((void*)0))
   return NULL((void*)0);
 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
 dc = d_template_args (di);
}
    else if (peek == 'T')
dc = d_template_param (di);
    else if (peek == 'E')
return ret;
    else if (peek == 'M')
{
 /* Initializer scope for a lambda.  We don't need to represent
    this; the normal code will just treat the variable as a type
    scope, which gives appropriate output.  */
 if (ret == NULL((void*)0))
   return NULL((void*)0);
 d_advance (di, 1)((di)->n += (1));
 continue;
}
    else
return NULL((void*)0);

    if (ret == NULL((void*)0))
ret = dc;
    else
ret = d_make_comp (di, comb_type, ret, dc);

    if (peek != 'S' && d_peek_char (di)(*((di)->n)) != 'E' && subst)
{
 if (! d_add_substitution (di, ret))
   return NULL((void*)0);
}
  }
1616}

1618/* <unqualified-name> ::= <operator-name>
                    ::= <ctor-dtor-name>
                    ::= <source-name>
      ::= <local-source-name> 

  <local-source-name>	::= L <source-name> <discriminator>
1624*/

1626static struct demangle_component *
1627d_unqualified_name (struct d_info *di)
1628{
struct demangle_component *ret;
char peek;

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 == '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 (d_peek_char (di)(*((di)->n)) == 'B')
  ret = d_abi_tags (di, ret);
return ret;
1686}

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

1690static struct demangle_component *
1691d_source_name (struct d_info *di)
1692{
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;
1702}

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

1706static int
1707d_number (struct d_info *di)
1708{
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));
  }
1737}

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

1741static struct demangle_component *
1742d_number_component (struct d_info *di)
1743{
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;
1751}

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

1755static struct demangle_component *
1756d_identifier (struct d_info *di, int len)
1757{
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);
1794}

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

 This list is sorted for binary search.  */

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

1804CP_STATIC_IF_GLIBCPP_V3
1805const struct demangle_operator_info cplus_demangle_operators[] =
1806{
{ "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 }
1880};

1882static struct demangle_component *
1883d_operator_name (struct d_info *di)
1884{
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);
}
  }
1936}

1938static struct demangle_component *
1939d_make_character (struct d_info *di, int c)
1940{
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;
1949}

1951static struct demangle_component *
1952d_java_resource (struct d_info *di)
1953{
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;
2032}

2034/* <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>
2051*/

2053static struct demangle_component *
2054d_special_name (struct d_info *di)
2055{
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), NULL((void*)0));

case 'W':
 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
	      d_name (di), 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), NULL((void*)0));

case 'R':
 {
   struct demangle_component *name = d_name (di);
   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 '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);
2184}

2186/* <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.  */

2199static int
2200d_call_offset (struct d_info *di, int c)
2201{
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;
2221}

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

2231static struct demangle_component *
2232d_ctor_dtor_name (struct d_info *di)
2233{
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);
  }
2315}

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

2320static int
2321next_is_type_qual (struct d_info *di)
2322{
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;
2333}

2335/* <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>
2353*/

2355CP_STATIC_IF_GLIBCPP_V3
2356const struct demangle_builtin_type_info
2357cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT(34)] =
2358{
/* 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 },
2396};

2398CP_STATIC_IF_GLIBCPP_V3
2399struct demangle_component *
2400cplus_demangle_type (struct d_info *di)
2401{
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 '0': case '1': case '2': case '3': case '4':
  case '5': case '6': case '7': case '8': case '9':
  case 'N':
  case 'Z':
    ret = d_class_enum_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 'S':
    /* If this is a special substitution, then it is the start of
<class-enum-type>.  */
    {
char peek_next;

peek_next = d_peek_next_char (di)((di)->n[1]);
if (IS_DIGIT (peek_next)((peek_next) >= '0' && (peek_next) <= '9')
   || peek_next == '_'
   || IS_UPPER (peek_next)((peek_next) >= 'A' && (peek_next) <= 'Z'))
 {
   ret = d_substitution (di, 0);
   /* The substituted name may have been a template name and
      may be followed by tepmlate args.  */
   if (d_peek_char (di)(*((di)->n)) == 'I')
     ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
		 d_template_args (di));
   else
     can_subst = 0;
 }
else
 {
   ret = d_class_enum_type (di);
   /* If the substitution was a complete type, then it is not
      a new substitution candidate.  However, if the
      substitution was followed by template arguments, then
      the whole thing is a substitution candidate.  */
   if (ret != NULL((void*)0) && ret->type == DEMANGLE_COMPONENT_SUB_STD)
     can_subst = 0;
 }
    }
    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':
 /* Fixed point types. DF<int bits><length><fract bits><sat>  */
 ret = d_make_empty (di);
 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))(((*((di)->n))) >= '0' && ((*((di)->n))) <=
 '9')))
   /* For demangling we don't care about the bits.  */
   d_number (di);
 ret->u.s_fixed.length = cplus_demangle_type (di);
 if (ret->u.s_fixed.length == NULL((void*)0))
   return NULL((void*)0);
 d_number (di);
 peek = d_next_char (di)((*((di)->n)) == '\0' ? '\0' : *((di)->n++));
 ret->u.s_fixed.sat = (peek == 's');
 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 NULL((void*)0);
  }

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

return ret;
2740}

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

2744static struct demangle_component **
2745d_cv_qualifiers (struct d_info *di,
               struct demangle_component **pret, int member_fn)
2747{
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;
2847}

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

2852static struct demangle_component *
2853d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2854{
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;
2878}

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

2882static struct demangle_component *
2883d_function_type (struct d_info *di)
2884{
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;
2915}

2917/* <type>+ */

2919static struct demangle_component *
2920d_parmlist (struct d_info *di)
2921{
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;
2963}

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

2967static struct demangle_component *
2968d_bare_function_type (struct d_info *di, int has_return_type)
2969{
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);
2998}

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

3002static struct demangle_component *
3003d_class_enum_type (struct d_info *di)
3004{
return d_name (di);
3006}

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

3012static struct demangle_component *
3013d_array_type (struct d_info *di)
3014{
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));
3051}

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

3056static struct demangle_component *
3057d_vector_type (struct d_info *di)
3058{
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));
3079}

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

3083static struct demangle_component *
3084d_pointer_to_member_type (struct d_info *di)
3085{
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);
3116}

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

3120static int
3121d_compact_number (struct d_info *di)
3122{
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;
3134}

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

3140static struct demangle_component *
3141d_template_param (struct d_info *di)
3142{
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);
3153}

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

3157static struct demangle_component *
3158d_template_args (struct d_info *di)
3159{
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);
3166}

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

3170static struct demangle_component *
3171d_template_args_1 (struct d_info *di)
3172{
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;
3214}

3216/* <template-arg> ::= <type>
                ::= X <expression> E
                ::= <expr-primary>
3219*/

3221static struct demangle_component *
3222d_template_arg (struct d_info *di)
3223{
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);
  }
3246}

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

3251static struct demangle_component *
3252d_exprlist (struct d_info *di, char terminator)
3253{
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;
3282}

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

3287static int
3288op_is_new_cast (struct demangle_component *op)
3289{
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'));
3294}

3296/*   <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.  */

3305static struct demangle_component *
3306d_unresolved_name (struct d_info *di)
3307{
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);
if (d_peek_char (di)(*((di)->n)) == 'I')
  name = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
	d_template_args (di));
return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
3339}

3341/* <expression> ::= <(unary) operator-name> <expression>
              ::= <(binary) operator-name> <expression> <expression>
              ::= <(trinary) operator-name> <expression> <expression> <expression>
::= cl <expression>+ E
              ::= st <type>
              ::= <template-param>
::= <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
3355*/

3357static struct demangle_component *
3358d_expression_1 (struct d_info *di)
3359{
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);
    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
  {
    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);
   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);
    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);
}
  }
3604}

3606static struct demangle_component *
3607d_expression (struct d_info *di)
3608{
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;
3616}

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

3623static struct demangle_component *
3624d_expr_primary (struct d_info *di)
3625{
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;
3690}

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

3697static struct demangle_component *
3698d_local_name (struct d_info *di)
3699{
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);

    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);
3758}

3760/* <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.  */

3769static int
3770d_discriminator (struct d_info *di)
3771{
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;
3795}

3797/* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */

3799static struct demangle_component *
3800d_lambda (struct d_info *di)
3801{
struct demangle_component *tl;
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, 'l')((*((di)->n)) == 'l' ? ((di)->n++, 1) : 0))
  return NULL((void*)0);

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

if (! d_check_char (di, 'E')((*((di)->n)) == 'E' ? ((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_LAMBDA;
    ret->u.s_unary_num.sub = tl;
    ret->u.s_unary_num.num = num;
  }

return ret;
3831}

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

3835static struct demangle_component *
3836d_unnamed_type (struct d_info *di)
3837{
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;
3861}

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

3866static struct demangle_component *
3867d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3868{
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') || pend[1] == '_'))
  {
    pend += 2;
    while (IS_LOWER (*pend)((*pend) >= 'a' && (*pend) <= 'z') || *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);
3888}

3890/* Add a new substitution.  */

3892static int
3893d_add_substitution (struct d_info *di, struct demangle_component *dc)
3894{
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;
3902}

3904/* <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.
3921*/

3923static const struct d_standard_sub_info standard_subs[] =
3924{
{ '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 }
3946};

3948static struct demangle_component *
3949d_substitution (struct d_info *di, int prefix)
3950{
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);
  }
4044}

4046static void
4047d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
4048{
checkpoint->n = di->n;
checkpoint->next_comp = di->next_comp;
checkpoint->next_sub = di->next_sub;
checkpoint->expansion = di->expansion;
4053}

4055static void
4056d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
4057{
di->n = checkpoint->n;
di->next_comp = checkpoint->next_comp;
di->next_sub = checkpoint->next_sub;
di->expansion = checkpoint->expansion;
4062}

4064/* Initialize a growable string.  */

4066static void
4067d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
4068{
dgs->buf = NULL((void*)0);
dgs->len = 0;
dgs->alc = 0;
dgs->allocation_failure = 0;

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

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

4080static inline void
4081d_growable_string_resize (struct d_growable_string *dgs, size_t need)
4082{
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;
4108}

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

4112static inline void
4113d_growable_string_append_buffer (struct d_growable_string *dgs,
                               const char *s, size_t l)
4115{
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;
4128}

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

4132static void
4133d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
4134{
struct d_growable_string *dgs = (struct d_growable_string*) opaque;

d_growable_string_append_buffer (dgs, s, l);
4138}

4140/* 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.  */

4147static void
4148d_count_templates_scopes (struct d_print_info *dpi,
	  struct demangle_component *dc)
4150{
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_OPERATOR:
  case DEMANGLE_COMPONENT_CHARACTER:
  case DEMANGLE_COMPONENT_NUMBER:
  case DEMANGLE_COMPONENT_UNNAMED_TYPE:
    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_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_FIXED_TYPE:
    d_count_templates_scopes (dpi, dc->u.s_fixed.length);
    break;

  case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
  case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
    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;
  }
4279}

4281/* Initialize a print information structure.  */

4283static void
4284d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
     void *opaque, struct demangle_component *dc)
4286{
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->is_lambda_arg = 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);
4320}

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

4324static inline void
4325d_print_error (struct d_print_info *dpi)
4326{
dpi->demangle_failure = 1;
4328}

4330static inline int
4331d_print_saw_error (struct d_print_info *dpi)
4332{
return dpi->demangle_failure != 0;
4
←
Assuming field 'demangle_failure' is equal to 0→
5
←
Returning zero, which participates in a condition later→
4334}

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

4338static inline void
4339d_print_flush (struct d_print_info *dpi)
4340{
dpi->buf[dpi->len] = '\0';
dpi->callback (dpi->buf, dpi->len, dpi->opaque);
dpi->len = 0;
dpi->flush_count++;
4345}

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

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

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

4359static inline void
4360d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4361{
size_t i;

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

4368static inline void
4369d_append_string (struct d_print_info *dpi, const char *s)
4370{
d_append_buffer (dpi, s, strlen (s));
4372}

4374static inline void
4375d_append_num (struct d_print_info *dpi, int l)
4376{
char buf[25];
sprintf (buf,"%d", l);
d_append_string (dpi, buf);
4380}

4382static inline char
4383d_last_char (struct d_print_info *dpi)
4384{
return dpi->last_char;
4386}

4388/* 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.  */

4397CP_STATIC_IF_GLIBCPP_V3
4398int
4399cplus_demangle_print_callback (int options,
                             struct demangle_component *dc,
                             demangle_callbackref callback, void *opaque)
4402{
struct d_print_info dpi;

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

{
4408#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;
4418#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
));
4423#endif

  d_print_comp (&dpi, options, dc);
}

d_print_flush (&dpi);

return ! d_print_saw_error (&dpi);
4431}

4433/* 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.  */

4441CP_STATIC_IF_GLIBCPP_V3
4442char *
4443cplus_demangle_print (int options, struct demangle_component *dc,
                    int estimate, size_t *palc)
4445{
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;
4461}

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

4466static struct demangle_component *
4467d_index_template_argument (struct demangle_component *args, int i)
4468{
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);
4489}

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

4494static struct demangle_component *
4495d_lookup_template_argument (struct d_print_info *dpi,
	    const struct demangle_component *dc)
4497{
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);
4507}

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

4511static struct demangle_component *
4512d_find_pack (struct d_print_info *dpi,
    const struct demangle_component *dc)
4514{
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_SUB_STD:
  case DEMANGLE_COMPONENT_CHARACTER:
  case DEMANGLE_COMPONENT_FUNCTION_PARAM:
  case DEMANGLE_COMPONENT_UNNAMED_TYPE:
  case DEMANGLE_COMPONENT_FIXED_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));
  }
4557}

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

4561static int
4562d_pack_length (const struct demangle_component *dc)
4563{
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;
4572}

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

4577static int
4578d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
4579{
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;
4596}

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

4601static void
4602d_print_subexpr (struct d_print_info *dpi, int options,
 struct demangle_component *dc)
4604{
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, ')');
4616}

4618/* Save the current scope.  */

4620static void
4621d_save_scope (struct d_print_info *dpi,
     const struct demangle_component *container)
4623{
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);
4656}

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

4661static struct d_saved_scope *
4662d_get_saved_scope (struct d_print_info *dpi,
   const struct demangle_component *container)
4664{
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);
4672}

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

4677static int
4678d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
	       struct demangle_component *dc)
4680{
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;
4736}

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

4740static int
4741is_designated_init (struct demangle_component *dc)
4742{
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'));
4751}

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

4756static int
4757d_maybe_print_designated_init (struct d_print_info *dpi, int options,
	       struct demangle_component *dc)
4759{
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;
4794}

4796/* Subroutine to handle components.  */

4798static void
4799d_print_comp_inner (struct d_print_info *dpi, int options,
    struct demangle_component *dc)
4801{
/* 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
←
Calling 'd_print_saw_error'→
6
←
Returning from 'd_print_saw_error'→
7
←
Taking false branch→
  return;

switch (dc->type)
8
←
Control jumps to 'case DEMANGLE_COMPONENT_TYPED_NAME:'  at line 4857→
  {
  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_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))
9
←
Assuming 'typed_name' is not equal to NULL→
10
←
Loop condition is true.  Entering loop body→
 {
   if (i >= sizeof adpm / sizeof adpm[0])
11
←
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))
12
←
Calling 'is_fnqual_component_type'→
16
←
Returning from 'is_fnqual_component_type'→
17
←
Taking true branch→
     break;
18
←
 Execution continues on line 4893→

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

if (typed_name18.1
'typed_name' is not equal to NULL
 == NULL((void*)0))
19
←
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)
20
←
Assuming field 'type' is not equal to DEMANGLE_COMPONENT_LOCAL_NAME→
21
←
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)
22
←
Assuming field 'type' is not equal to DEMANGLE_COMPONENT_TEMPLATE→
23
←
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)
24
←
Assuming field 'type' is equal to DEMANGLE_COMPONENT_TEMPLATE→
25
←
Taking true branch→
 dpi->templates = dpt.next;
26
←
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->is_lambda_arg)
{
 /* 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_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->is_lambda_arg
   && 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_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_FIXED_TYPE:
    if (dc->u.s_fixed.sat)
d_append_string (dpi, "_Sat ");
    /* Don't print "int _Accum".  */
    if (dc->u.s_fixed.length->u.s_builtin.type
 != &cplus_demangle_builtin_types['i'-'a'])
{
 d_print_comp (dpi, options, dc->u.s_fixed.length);
 d_append_char (dpi, ' ');
}
    if (dc->u.s_fixed.accum)
d_append_string (dpi, "_Accum");
    else
d_append_string (dpi, "_Fract");
    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:
    {
struct demangle_component *name = dc->u.s_extended_operator.name;
if (name->type == DEMANGLE_COMPONENT_NAME
   && !strncmp (name->u.s_name.s, "__alignof__", name->u.s_name.len))
 d_print_comp (dpi, options, dc->u.s_extended_operator.name);
else
 {
   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"))
 || (op->type == DEMANGLE_COMPONENT_EXTENDED_OPERATOR
     && (op->u.s_extended_operator.name->type
	 == DEMANGLE_COMPONENT_NAME)
     && !strncmp (op->u.s_extended_operator.name->u.s_name.s,
		  "__alignof__",
		  op->u.s_extended_operator.name->u.s_name.len)))
 /* Always print parens for sizeof (type) and __alignof__.  */
 {
   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)
  {
    switch (d_right (dc)((dc)->u.s_binary.right)->u.s_name.s[0])
      {
      case '0':
	d_append_string (dpi, "false");
	return;
      case '1':
	d_append_string (dpi, "true");
	return;
      default:
	break;
      }
  }
break;

     default:
break;
     }
 }

d_append_char (dpi, '(');
d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
d_append_char (dpi, ')');
if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
 d_append_char (dpi, '-');
if (tp == D_PRINT_FLOAT)
 d_append_char (dpi, '[');
d_print_comp (dpi, options, d_right (dc)((dc)->u.s_binary.right));
if (tp == D_PRINT_FLOAT)
 d_append_char (dpi, ']');
    }
    return;

  case DEMANGLE_COMPONENT_NUMBER:
    d_append_num (dpi, dc->u.s_number.number);
    return;

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

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

  case DEMANGLE_COMPONENT_CHARACTER:
    d_append_char (dpi, dc->u.s_character.character);
    return;

  case DEMANGLE_COMPONENT_DECLTYPE:
    d_append_string (dpi, "decltype (");
    d_print_comp (dpi, options, d_left (dc)((dc)->u.s_binary.left));
    d_append_char (dpi, ')');
    return;

  case DEMANGLE_COMPONENT_PACK_EXPANSION:
    {
int len;
int i;
struct demangle_component *a = d_find_pack (dpi, d_left (dc)((dc)->u.s_binary.left));
if (a == NULL((void*)0))
 {
   /* d_find_pack won't find anything if the only packs involved
      in this expansion are function parameter packs; in that
      case, just print the pattern and "...".  */
   d_print_subexpr (dpi, options, d_left (dc)((dc)->u.s_binary.left));
   d_append_string (dpi, "...");
   return;
 }

len = d_pack_length (a);
dc = d_left (dc)((dc)->u.s_binary.left);
for (i = 0; i < len; ++i)
 {
   dpi->pack_index = i;
   d_print_comp (dpi, options, dc);
   if (i < len-1)
     d_append_string (dpi, ", ");
 }
    }
    return;

  case DEMANGLE_COMPONENT_FUNCTION_PARAM:
    {
long num = dc->u.s_number.number;
if (num == 0)
 d_append_string (dpi, "this");
else
 {
   d_append_string (dpi, "{parm#");
   d_append_num (dpi, num);
   d_append_char (dpi, '}');
 }
    }
    return;

  case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
    d_append_string (dpi, "global constructors keyed to ");
    d_print_comp (dpi, options, dc->u.s_binary.left);
    return;

  case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
    d_append_string (dpi, "global destructors keyed to ");
    d_print_comp (dpi, options, dc->u.s_binary.left);
    return;

  case DEMANGLE_COMPONENT_LAMBDA:
    d_append_string (dpi, "{lambda(");
    /* Generic lambda auto parms are mangled as the template type
parm they are.  */
    dpi->is_lambda_arg++;
    d_print_comp (dpi, options, dc->u.s_unary_num.sub);
    dpi->is_lambda_arg--;
    d_append_string (dpi, ")#");
    d_append_num (dpi, dc->u.s_unary_num.num + 1);
    d_append_char (dpi, '}');
    return;

  case DEMANGLE_COMPONENT_UNNAMED_TYPE:
    d_append_string (dpi, "{unnamed type#");
    d_append_num (dpi, dc->u.s_number.number + 1);
    d_append_char (dpi, '}');
    return;

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

  default:
    d_print_error (dpi);
    return;
  }
5912}

5914static void
5915d_print_comp (struct d_print_info *dpi, int options,
     struct demangle_component *dc)
5917{
struct d_component_stack self;
if (dc == NULL((void*)0) || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT1024)
  {
    d_print_error (dpi);
    return;
  }

dc->d_printing++;
dpi->recursion++;

self.dc = dc;
self.parent = dpi->component_stack;
dpi->component_stack = &self;

d_print_comp_inner (dpi, options, dc);

dpi->component_stack = self.parent;
dc->d_printing--;
dpi->recursion--;
5937}

5939/* Print a Java dentifier.  For Java we try to handle encoded extended
 Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
 so we don't it for C++.  Characters are encoded as
 __U<hex-char>+_.  */

5944static void
5945d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
5946{
const char *p;
const char *end;

end = name + len;
for (p = name; p < end; ++p)
  {
    if (end - p > 3
 && p[0] == '_'
 && p[1] == '_'
 && p[2] == 'U')
{
 unsigned long c;
 const char *q;

 c = 0;
 for (q = p + 3; q < end; ++q)
   {
     int dig;

     if (IS_DIGIT (*q)((*q) >= '0' && (*q) <= '9'))
dig = *q - '0';
     else if (*q >= 'A' && *q <= 'F')
dig = *q - 'A' + 10;
     else if (*q >= 'a' && *q <= 'f')
dig = *q - 'a' + 10;
     else
break;

     c = c * 16 + dig;
   }
 /* If the Unicode character is larger than 256, we don't try
    to deal with it here.  FIXME.  */
 if (q < end && *q == '_' && c < 256)
   {
     d_append_char (dpi, c);
     p = q;
     continue;
   }
}

    d_append_char (dpi, *p);
  }
5989}

5991/* Print a list of modifiers.  SUFFIX is 1 if we are printing
 qualifiers on this after printing a function.  */

5994static void
5995d_print_mod_list (struct d_print_info *dpi, int options,
                struct d_print_mod *mods, int suffix)
5997{
struct d_print_template *hold_dpt;

if (mods == NULL((void*)0) || d_print_saw_error (dpi))
  return;

if (mods->printed
    || (! suffix
 && (is_fnqual_component_type (mods->mod->type))))
  {
    d_print_mod_list (dpi, options, mods->next, suffix);
    return;
  }

mods->printed = 1;

hold_dpt = dpi->templates;
dpi->templates = mods->templates;

if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
  {
    d_print_function_type (dpi, options, mods->mod, mods->next);
    dpi->templates = hold_dpt;
    return;
  }
else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
  {
    d_print_array_type (dpi, options, mods->mod, mods->next);
    dpi->templates = hold_dpt;
    return;
  }
else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
  {
    struct d_print_mod *hold_modifiers;
    struct demangle_component *dc;

    /* When this is on the modifier stack, we have pulled any
qualifiers off the right argument already.  Otherwise, we
print it as usual, but don't let the left argument see any
modifiers.  */

    hold_modifiers = dpi->modifiers;
    dpi->modifiers = NULL((void*)0);
    d_print_comp (dpi, options, d_left (mods->mod)((mods->mod)->u.s_binary.left));
    dpi->modifiers = hold_modifiers;

    if ((options & DMGL_JAVA(1 << 2)) == 0)
d_append_string (dpi, "::");
    else
d_append_char (dpi, '.');

    dc = d_right (mods->mod)((mods->mod)->u.s_binary.right);

    if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
{
 d_append_string (dpi, "{default arg#");
 d_append_num (dpi, dc->u.s_unary_num.num + 1);
 d_append_string (dpi, "}::");
 dc = dc->u.s_unary_num.sub;
}

    while (is_fnqual_component_type (dc->type))
dc = d_left (dc)((dc)->u.s_binary.left);

    d_print_comp (dpi, options, dc);

    dpi->templates = hold_dpt;
    return;
  }

d_print_mod (dpi, options, mods->mod);

dpi->templates = hold_dpt;

d_print_mod_list (dpi, options, mods->next, suffix);
6072}

6074/* Print a modifier.  */

6076static void
6077d_print_mod (struct d_print_info *dpi, int options,
           struct demangle_component *mod)
6079{
switch (mod->type)
  {
  case DEMANGLE_COMPONENT_RESTRICT:
  case DEMANGLE_COMPONENT_RESTRICT_THIS:
    d_append_string (dpi, " restrict");
    return;
  case DEMANGLE_COMPONENT_VOLATILE:
  case DEMANGLE_COMPONENT_VOLATILE_THIS:
    d_append_string (dpi, " volatile");
    return;
  case DEMANGLE_COMPONENT_CONST:
  case DEMANGLE_COMPONENT_CONST_THIS:
    d_append_string (dpi, " const");
    return;
  case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
    d_append_string (dpi, " transaction_safe");
    return;
  case DEMANGLE_COMPONENT_NOEXCEPT:
    d_append_string (dpi, " noexcept");
    if (d_right (mod)((mod)->u.s_binary.right))
{
 d_append_char (dpi, '(');
 d_print_comp (dpi, options, d_right (mod)((mod)->u.s_binary.right));
 d_append_char (dpi, ')');
}
    return;
  case DEMANGLE_COMPONENT_THROW_SPEC:
    d_append_string (dpi, " throw");
    if (d_right (mod)