contrib/libcxxrt/libelftc_dem_gnu3.c

   1 /*-
   2  * Copyright (c) 2007 Hyogeol Lee <hyogeollee@gmail.com>
   3  * Copyright (c) 2015-2017 Kai Wang <kaiwang27@gmail.com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer
  11  *    in this position and unchanged.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #include <sys/types.h>
  28 #include <assert.h>
  29 #include <ctype.h>
  30 #include <errno.h>
  31 #include <limits.h>
  32 #include <stdbool.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 /**
  38  * @file cpp_demangle.c
  39  * @brief Decode IA-64 C++ ABI style implementation.
  40  *
  41  * IA-64 standard ABI(Itanium C++ ABI) references.
  42  *
  43  * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
  44  * http://www.codesourcery.com/cxx-abi/abi-mangling.html
  45  */
  46
  47 /** @brief Dynamic vector data for string. */
  48 struct vector_str {
  49         /** Current size */
  50         size_t          size;
  51         /** Total capacity */
  52         size_t          capacity;
  53         /** String array */
  54         char            **container;
  55 };
  56
  57 #define BUFFER_GROWFACTOR       1.618
  58 #define BUFFER_GROW(x)          (((x)+0.5)*BUFFER_GROWFACTOR)
  59
  60 #define ELFTC_FAILURE           0
  61 #define ELFTC_ISDIGIT(C)        (isdigit((C) & 0xFF))
  62 #define ELFTC_SUCCESS           1
  63
  64 #define VECTOR_DEF_CAPACITY     8
  65
  66 enum type_qualifier {
  67         TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
  68         TYPE_CST, TYPE_VEC, TYPE_RREF
  69 };
  70
  71 struct vector_type_qualifier {
  72         size_t size, capacity;
  73         enum type_qualifier *q_container;
  74         struct vector_str ext_name;
  75 };
  76
  77 enum read_cmd {
  78         READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
  79         READ_TYPE, READ_FUNC, READ_PTRMEM
  80 };
  81
  82 struct read_cmd_item {
  83         enum read_cmd cmd;
  84         void *data;
  85 };
  86
  87 struct vector_read_cmd {
  88         size_t size, capacity;
  89         struct read_cmd_item *r_container;
  90 };
  91
  92 enum push_qualifier {
  93         PUSH_ALL_QUALIFIER,
  94         PUSH_CV_QUALIFIER,
  95         PUSH_NON_CV_QUALIFIER,
  96 };
  97
  98 struct cpp_demangle_data {
  99         struct vector_str        output;        /* output string vector */
 100         struct vector_str        subst;         /* substitution string vector */
 101         struct vector_str        tmpl;
 102         struct vector_str        class_type;
 103         struct vector_str       *cur_output;    /* ptr to current output vec */
 104         struct vector_read_cmd   cmd;
 105         bool                     mem_rst;       /* restrict member function */
 106         bool                     mem_vat;       /* volatile member function */
 107         bool                     mem_cst;       /* const member function */
 108         bool                     mem_ref;       /* lvalue-ref member func */
 109         bool                     mem_rref;      /* rvalue-ref member func */
 110         bool                     is_tmpl;       /* template args */
 111         bool                     is_functype;   /* function type */
 112         bool                     ref_qualifier; /* ref qualifier */
 113         enum type_qualifier      ref_qualifier_type; /* ref qualifier type */
 114         enum push_qualifier      push_qualifier; /* which qualifiers to push */
 115         int                      func_type;
 116         const char              *cur;           /* current mangled name ptr */
 117         const char              *last_sname;    /* last source name */
 118 };
 119
 120 struct type_delimit {
 121         bool paren;
 122         bool firstp;
 123 };
 124
 125 #define CPP_DEMANGLE_TRY_LIMIT  128
 126 #define FLOAT_SPRINTF_TRY_LIMIT 5
 127 #define FLOAT_QUADRUPLE_BYTES   16
 128 #define FLOAT_EXTENED_BYTES     10
 129
 130 #define SIMPLE_HASH(x,y)        (64 * x + y)
 131 #define DEM_PUSH_STR(d,s)       cpp_demangle_push_str((d), (s), strlen((s)))
 132 #define VEC_PUSH_STR(d,s)       vector_str_push((d), (s), strlen((s)))
 133
 134 static size_t   get_strlen_sum(const struct vector_str *v);
 135 static bool     vector_str_grow(struct vector_str *v);
 136
 137 static size_t
 138 get_strlen_sum(const struct vector_str *v)
 139 {
 140         size_t i, len = 0;
 141
 142         if (v == NULL)
 143                 return (0);
 144
 145         assert(v->size > 0);
 146
 147         for (i = 0; i < v->size; ++i)
 148                 len += strlen(v->container[i]);
 149
 150         return (len);
 151 }
 152
 153 /**
 154  * @brief Deallocate resource in vector_str.
 155  */
 156 static void
 157 vector_str_dest(struct vector_str *v)
 158 {
 159         size_t i;
 160
 161         if (v == NULL)
 162                 return;
 163
 164         for (i = 0; i < v->size; ++i)
 165                 free(v->container[i]);
 166
 167         free(v->container);
 168 }
 169
 170 /**
 171  * @brief Find string in vector_str.
 172  * @param v Destination vector.
 173  * @param o String to find.
 174  * @param l Length of the string.
 175  * @return -1 at failed, 0 at not found, 1 at found.
 176  */
 177 static int
 178 vector_str_find(const struct vector_str *v, const char *o, size_t l)
 179 {
 180         size_t i;
 181
 182         if (v == NULL || o == NULL)
 183                 return (-1);
 184
 185         for (i = 0; i < v->size; ++i)
 186                 if (strncmp(v->container[i], o, l) == 0)
 187                         return (1);
 188
 189         return (0);
 190 }
 191
 192 /**
 193  * @brief Get new allocated flat string from vector.
 194  *
 195  * If l is not NULL, return length of the string.
 196  * @param v Destination vector.
 197  * @param l Length of the string.
 198  * @return NULL at failed or NUL terminated new allocated string.
 199  */
 200 static char *
 201 vector_str_get_flat(const struct vector_str *v, size_t *l)
 202 {
 203         ssize_t elem_pos, elem_size, rtn_size;
 204         size_t i;
 205         char *rtn;
 206
 207         if (v == NULL || v->size == 0)
 208                 return (NULL);
 209
 210         if ((rtn_size = get_strlen_sum(v)) == 0)
 211                 return (NULL);
 212
 213         if ((rtn = malloc(sizeof(char) * (rtn_size + 1))) == NULL)
 214                 return (NULL);
 215
 216         elem_pos = 0;
 217         for (i = 0; i < v->size; ++i) {
 218                 elem_size = strlen(v->container[i]);
 219
 220                 memcpy(rtn + elem_pos, v->container[i], elem_size);
 221
 222                 elem_pos += elem_size;
 223         }
 224
 225         rtn[rtn_size] = '\0';
 226
 227         if (l != NULL)
 228                 *l = rtn_size;
 229
 230         return (rtn);
 231 }
 232
 233 static bool
 234 vector_str_grow(struct vector_str *v)
 235 {
 236         size_t i, tmp_cap;
 237         char **tmp_ctn;
 238
 239         if (v == NULL)
 240                 return (false);
 241
 242         assert(v->capacity > 0);
 243
 244         tmp_cap = BUFFER_GROW(v->capacity);
 245
 246         assert(tmp_cap > v->capacity);
 247
 248         if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
 249                 return (false);
 250
 251         for (i = 0; i < v->size; ++i)
 252                 tmp_ctn[i] = v->container[i];
 253
 254         free(v->container);
 255
 256         v->container = tmp_ctn;
 257         v->capacity = tmp_cap;
 258
 259         return (true);
 260 }
 261
 262 /**
 263  * @brief Initialize vector_str.
 264  * @return false at failed, true at success.
 265  */
 266 static bool
 267 vector_str_init(struct vector_str *v)
 268 {
 269
 270         if (v == NULL)
 271                 return (false);
 272
 273         v->size = 0;
 274         v->capacity = VECTOR_DEF_CAPACITY;
 275
 276         assert(v->capacity > 0);
 277
 278         if ((v->container = malloc(sizeof(char *) * v->capacity)) == NULL)
 279                 return (false);
 280
 281         assert(v->container != NULL);
 282
 283         return (true);
 284 }
 285
 286 /**
 287  * @brief Remove last element in vector_str.
 288  * @return false at failed, true at success.
 289  */
 290 static bool
 291 vector_str_pop(struct vector_str *v)
 292 {
 293
 294         if (v == NULL)
 295                 return (false);
 296
 297         if (v->size == 0)
 298                 return (true);
 299
 300         --v->size;
 301
 302         free(v->container[v->size]);
 303         v->container[v->size] = NULL;
 304
 305         return (true);
 306 }
 307
 308 /**
 309  * @brief Push back string to vector.
 310  * @return false at failed, true at success.
 311  */
 312 static bool
 313 vector_str_push(struct vector_str *v, const char *str, size_t len)
 314 {
 315
 316         if (v == NULL || str == NULL)
 317                 return (false);
 318
 319         if (v->size == v->capacity && vector_str_grow(v) == false)
 320                 return (false);
 321
 322         if ((v->container[v->size] = malloc(sizeof(char) * (len + 1))) == NULL)
 323                 return (false);
 324
 325         snprintf(v->container[v->size], len + 1, "%s", str);
 326
 327         ++v->size;
 328
 329         return (true);
 330 }
 331
 332 /**
 333  * @brief Push front org vector to det vector.
 334  * @return false at failed, true at success.
 335  */
 336 static bool
 337 vector_str_push_vector_head(struct vector_str *dst, struct vector_str *org)
 338 {
 339         size_t i, j, tmp_cap;
 340         char **tmp_ctn;
 341
 342         if (dst == NULL || org == NULL)
 343                 return (false);
 344
 345         tmp_cap = BUFFER_GROW(dst->size + org->size);
 346
 347         if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
 348                 return (false);
 349
 350         for (i = 0; i < org->size; ++i)
 351                 if ((tmp_ctn[i] = strdup(org->container[i])) == NULL) {
 352                         for (j = 0; j < i; ++j)
 353                                 free(tmp_ctn[j]);
 354
 355                         free(tmp_ctn);
 356
 357                         return (false);
 358                 }
 359
 360         for (i = 0; i < dst->size; ++i)
 361                 tmp_ctn[i + org->size] = dst->container[i];
 362
 363         free(dst->container);
 364
 365         dst->container = tmp_ctn;
 366         dst->capacity = tmp_cap;
 367         dst->size += org->size;
 368
 369         return (true);
 370 }
 371
 372 /**
 373  * @brief Push org vector to the tail of det vector.
 374  * @return false at failed, true at success.
 375  */
 376 static bool
 377 vector_str_push_vector(struct vector_str *dst, struct vector_str *org)
 378 {
 379         size_t i, j, tmp_cap;
 380         char **tmp_ctn;
 381
 382         if (dst == NULL || org == NULL)
 383                 return (false);
 384
 385         tmp_cap = BUFFER_GROW(dst->size + org->size);
 386
 387         if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
 388                 return (false);
 389
 390         for (i = 0; i < dst->size; ++i)
 391                 tmp_ctn[i] = dst->container[i];
 392
 393         for (i = 0; i < org->size; ++i)
 394                 if ((tmp_ctn[i + dst->size] = strdup(org->container[i])) ==
 395                     NULL) {
 396                         for (j = 0; j < i + dst->size; ++j)
 397                                 free(tmp_ctn[j]);
 398
 399                         free(tmp_ctn);
 400
 401                         return (false);
 402                 }
 403
 404         free(dst->container);
 405
 406         dst->container = tmp_ctn;
 407         dst->capacity = tmp_cap;
 408         dst->size += org->size;
 409
 410         return (true);
 411 }
 412
 413 /**
 414  * @brief Get new allocated flat string from vector between begin and end.
 415  *
 416  * If r_len is not NULL, string length will be returned.
 417  * @return NULL at failed or NUL terminated new allocated string.
 418  */
 419 static char *
 420 vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
 421     size_t *r_len)
 422 {
 423         size_t cur, i, len;
 424         char *rtn;
 425
 426         if (v == NULL || begin > end)
 427                 return (NULL);
 428
 429         len = 0;
 430         for (i = begin; i < end + 1; ++i)
 431                 len += strlen(v->container[i]);
 432
 433         if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
 434                 return (NULL);
 435
 436         if (r_len != NULL)
 437                 *r_len = len;
 438
 439         cur = 0;
 440         for (i = begin; i < end + 1; ++i) {
 441                 len = strlen(v->container[i]);
 442                 memcpy(rtn + cur, v->container[i], len);
 443                 cur += len;
 444         }
 445         rtn[cur] = '\0';
 446
 447         return (rtn);
 448 }
 449
 450 static void     cpp_demangle_data_dest(struct cpp_demangle_data *);
 451 static int      cpp_demangle_data_init(struct cpp_demangle_data *,
 452                     const char *);
 453 static int      cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
 454 static int      cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
 455 static int      cpp_demangle_push_fp(struct cpp_demangle_data *,
 456                     char *(*)(const char *, size_t));
 457 static int      cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
 458                     size_t);
 459 static int      cpp_demangle_pop_str(struct cpp_demangle_data *);
 460 static int      cpp_demangle_push_subst(struct cpp_demangle_data *,
 461                     const char *, size_t);
 462 static int      cpp_demangle_push_subst_v(struct cpp_demangle_data *,
 463                     struct vector_str *);
 464 static int      cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
 465                     struct vector_type_qualifier *, const char *);
 466 static int      cpp_demangle_read_array(struct cpp_demangle_data *);
 467 static int      cpp_demangle_read_encoding(struct cpp_demangle_data *);
 468 static int      cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
 469 static int      cpp_demangle_read_expression(struct cpp_demangle_data *);
 470 static int      cpp_demangle_read_expression_flat(struct cpp_demangle_data *,
 471                     char **);
 472 static int      cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
 473                     const char *, size_t);
 474 static int      cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
 475                     const char *, size_t);
 476 static int      cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
 477                     const char *, size_t, const char *, size_t);
 478 static int      cpp_demangle_read_function(struct cpp_demangle_data *, int *,
 479                     struct vector_type_qualifier *);
 480 static int      cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
 481 static int      cpp_demangle_read_local_name(struct cpp_demangle_data *);
 482 static int      cpp_demangle_read_name(struct cpp_demangle_data *);
 483 static int      cpp_demangle_read_name_flat(struct cpp_demangle_data *,
 484                     char**);
 485 static int      cpp_demangle_read_nested_name(struct cpp_demangle_data *);
 486 static int      cpp_demangle_read_number(struct cpp_demangle_data *, long *);
 487 static int      cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
 488                     char **);
 489 static int      cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
 490 static int      cpp_demangle_read_offset(struct cpp_demangle_data *);
 491 static int      cpp_demangle_read_offset_number(struct cpp_demangle_data *);
 492 static int      cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *,
 493                     struct vector_type_qualifier *);
 494 static int      cpp_demangle_read_sname(struct cpp_demangle_data *);
 495 static int      cpp_demangle_read_subst(struct cpp_demangle_data *);
 496 static int      cpp_demangle_read_subst_std(struct cpp_demangle_data *);
 497 static int      cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
 498                     const char *);
 499 static int      cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
 500 static int      cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
 501 static int      cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
 502 static int      cpp_demangle_read_type(struct cpp_demangle_data *,
 503                     struct type_delimit *);
 504 static int      cpp_demangle_read_type_flat(struct cpp_demangle_data *,
 505                     char **);
 506 static int      cpp_demangle_read_uqname(struct cpp_demangle_data *);
 507 static int      cpp_demangle_read_v_offset(struct cpp_demangle_data *);
 508 static char     *decode_fp_to_double(const char *, size_t);
 509 static char     *decode_fp_to_float(const char *, size_t);
 510 static char     *decode_fp_to_float128(const char *, size_t);
 511 static char     *decode_fp_to_float80(const char *, size_t);
 512 static char     *decode_fp_to_long_double(const char *, size_t);
 513 static int      hex_to_dec(char);
 514 static void     vector_read_cmd_dest(struct vector_read_cmd *);
 515 static struct read_cmd_item *vector_read_cmd_find(struct vector_read_cmd *,
 516                     enum read_cmd);
 517 static int      vector_read_cmd_init(struct vector_read_cmd *);
 518 static int      vector_read_cmd_pop(struct vector_read_cmd *);
 519 static int      vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd,
 520                     void *);
 521 static void     vector_type_qualifier_dest(struct vector_type_qualifier *);
 522 static int      vector_type_qualifier_init(struct vector_type_qualifier *);
 523 static int      vector_type_qualifier_push(struct vector_type_qualifier *,
 524                     enum type_qualifier);
 525
 526 /**
 527  * @brief Decode the input string by IA-64 C++ ABI style.
 528  *
 529  * GNU GCC v3 use IA-64 standard ABI.
 530  * @return New allocated demangled string or NULL if failed.
 531  * @todo 1. Testing and more test case. 2. Code cleaning.
 532  */
 533 char *
 534 __cxa_demangle_gnu3(const char *org)
 535 {
 536         struct cpp_demangle_data ddata;
 537         struct vector_str ret_type;
 538         struct type_delimit td;
 539         ssize_t org_len;
 540         unsigned int limit;
 541         char *rtn = NULL;
 542         bool has_ret = false, more_type = false;
 543
 544         if (org == NULL)
 545                 return (NULL);
 546
 547         org_len = strlen(org);
 548         // Try demangling as a type for short encodings
 549         if ((org_len < 2) || (org[0] != '_' || org[1] != 'Z' )) {
 550                 if (!cpp_demangle_data_init(&ddata, org))
 551                         return (NULL);
 552                 if (!cpp_demangle_read_type(&ddata, 0))
 553                         goto clean;
 554                 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
 555                 goto clean;
 556         }
 557         if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
 558                 if ((rtn = malloc(org_len + 19)) == NULL)
 559                         return (NULL);
 560                 snprintf(rtn, org_len + 19,
 561                     "global constructors keyed to %s", org + 11);
 562                 return (rtn);
 563         }
 564
 565         if (!cpp_demangle_data_init(&ddata, org + 2))
 566                 return (NULL);
 567
 568         if (!cpp_demangle_read_encoding(&ddata))
 569                 goto clean;
 570
 571         /*
 572          * Pop function name from substitution candidate list.
 573          */
 574         if (*ddata.cur != 0 && ddata.subst.size >= 1) {
 575                 if (!vector_str_pop(&ddata.subst))
 576                         goto clean;
 577         }
 578
 579         td.paren = false;
 580         td.firstp = true;
 581         limit = 0;
 582
 583         /*
 584          * The first type is a return type if we just demangled template
 585          * args. (the template args is right next to the function name,
 586          * which means it's a template function)
 587          */
 588         if (ddata.is_tmpl) {
 589                 ddata.is_tmpl = false;
 590                 if (!vector_str_init(&ret_type))
 591                         goto clean;
 592                 ddata.cur_output = &ret_type;
 593                 has_ret = true;
 594         }
 595
 596         while (*ddata.cur != '\0') {
 597                 /*
 598                  * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
 599                  */
 600                 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
 601                         break;
 602
 603                 if (has_ret) {
 604                         /* Read return type */
 605                         if (!cpp_demangle_read_type(&ddata, NULL))
 606                                 goto clean;
 607                 } else {
 608                         /* Read function arg type */
 609                         if (!cpp_demangle_read_type(&ddata, &td))
 610                                 goto clean;
 611                 }
 612
 613                 if (has_ret) {
 614                         /* Push return type to the beginning */
 615                         if (!VEC_PUSH_STR(&ret_type, " "))
 616                                 goto clean;
 617                         if (!vector_str_push_vector_head(&ddata.output,
 618                             &ret_type))
 619                                 goto clean;
 620                         ddata.cur_output = &ddata.output;
 621                         vector_str_dest(&ret_type);
 622                         has_ret = false;
 623                         more_type = true;
 624                 } else if (more_type)
 625                         more_type = false;
 626                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
 627                         goto clean;
 628         }
 629         if (more_type)
 630                 goto clean;
 631
 632         if (ddata.output.size == 0)
 633                 goto clean;
 634         if (td.paren && !VEC_PUSH_STR(&ddata.output, ")"))
 635                 goto clean;
 636         if (ddata.mem_vat && !VEC_PUSH_STR(&ddata.output, " volatile"))
 637                 goto clean;
 638         if (ddata.mem_cst && !VEC_PUSH_STR(&ddata.output, " const"))
 639                 goto clean;
 640         if (ddata.mem_rst && !VEC_PUSH_STR(&ddata.output, " restrict"))
 641                 goto clean;
 642         if (ddata.mem_ref && !VEC_PUSH_STR(&ddata.output, " &"))
 643                 goto clean;
 644         if (ddata.mem_rref && !VEC_PUSH_STR(&ddata.output, " &&"))
 645                 goto clean;
 646
 647         rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
 648
 649 clean:
 650         if (has_ret)
 651                 vector_str_dest(&ret_type);
 652
 653         cpp_demangle_data_dest(&ddata);
 654
 655         return (rtn);
 656 }
 657
 658 static void
 659 cpp_demangle_data_dest(struct cpp_demangle_data *d)
 660 {
 661
 662         if (d == NULL)
 663                 return;
 664
 665         vector_read_cmd_dest(&d->cmd);
 666         vector_str_dest(&d->class_type);
 667         vector_str_dest(&d->tmpl);
 668         vector_str_dest(&d->subst);
 669         vector_str_dest(&d->output);
 670 }
 671
 672 static int
 673 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
 674 {
 675
 676         if (d == NULL || cur == NULL)
 677                 return (0);
 678
 679         if (!vector_str_init(&d->output))
 680                 return (0);
 681         if (!vector_str_init(&d->subst))
 682                 goto clean1;
 683         if (!vector_str_init(&d->tmpl))
 684                 goto clean2;
 685         if (!vector_str_init(&d->class_type))
 686                 goto clean3;
 687         if (!vector_read_cmd_init(&d->cmd))
 688                 goto clean4;
 689
 690         assert(d->output.container != NULL);
 691         assert(d->subst.container != NULL);
 692         assert(d->tmpl.container != NULL);
 693         assert(d->class_type.container != NULL);
 694
 695         d->mem_rst = false;
 696         d->mem_vat = false;
 697         d->mem_cst = false;
 698         d->mem_ref = false;
 699         d->mem_rref = false;
 700         d->is_tmpl = false;
 701         d->is_functype = false;
 702         d->ref_qualifier = false;
 703         d->push_qualifier = PUSH_ALL_QUALIFIER;
 704         d->func_type = 0;
 705         d->cur = cur;
 706         d->cur_output = &d->output;
 707         d->last_sname = NULL;
 708
 709         return (1);
 710
 711 clean4:
 712         vector_str_dest(&d->class_type);
 713 clean3:
 714         vector_str_dest(&d->tmpl);
 715 clean2:
 716         vector_str_dest(&d->subst);
 717 clean1:
 718         vector_str_dest(&d->output);
 719
 720         return (0);
 721 }
 722
 723 static int
 724 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
 725     char *(*decoder)(const char *, size_t))
 726 {
 727         size_t len;
 728         int rtn;
 729         const char *fp;
 730         char *f;
 731
 732         if (ddata == NULL || decoder == NULL)
 733                 return (0);
 734
 735         fp = ddata->cur;
 736         while (*ddata->cur != 'E')
 737                 ++ddata->cur;
 738
 739         if ((f = decoder(fp, ddata->cur - fp)) == NULL)
 740                 return (0);
 741
 742         rtn = 0;
 743         if ((len = strlen(f)) > 0)
 744                 rtn = cpp_demangle_push_str(ddata, f, len);
 745
 746         free(f);
 747
 748         ++ddata->cur;
 749
 750         return (rtn);
 751 }
 752
 753 static int
 754 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
 755     size_t len)
 756 {
 757
 758         if (ddata == NULL || str == NULL || len == 0)
 759                 return (0);
 760
 761         /*
 762          * is_tmpl is used to check if the type (function arg) is right next
 763          * to template args, and should always be cleared whenever new string
 764          * pushed.
 765          */
 766         ddata->is_tmpl = false;
 767
 768         return (vector_str_push(ddata->cur_output, str, len));
 769 }
 770
 771 static int
 772 cpp_demangle_pop_str(struct cpp_demangle_data *ddata)
 773 {
 774
 775         if (ddata == NULL)
 776                 return (0);
 777
 778         return (vector_str_pop(ddata->cur_output));
 779 }
 780
 781 static int
 782 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
 783     size_t len)
 784 {
 785
 786         if (ddata == NULL || str == NULL || len == 0)
 787                 return (0);
 788
 789         if (!vector_str_find(&ddata->subst, str, len))
 790                 return (vector_str_push(&ddata->subst, str, len));
 791
 792         return (1);
 793 }
 794
 795 static int
 796 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
 797 {
 798         size_t str_len;
 799         int rtn;
 800         char *str;
 801
 802         if (ddata == NULL || v == NULL)
 803                 return (0);
 804
 805         if ((str = vector_str_get_flat(v, &str_len)) == NULL)
 806                 return (0);
 807
 808         rtn = cpp_demangle_push_subst(ddata, str, str_len);
 809
 810         free(str);
 811
 812         return (rtn);
 813 }
 814
 815 static int
 816 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
 817     struct vector_type_qualifier *v, const char *type_str)
 818 {
 819         struct vector_str subst_v;
 820         enum type_qualifier t;
 821         size_t idx, e_idx, e_len;
 822         char *buf;
 823         int rtn;
 824         bool cv;
 825
 826         if (ddata == NULL || v == NULL)
 827                 return (0);
 828
 829         if ((idx = v->size) == 0)
 830                 return (1);
 831
 832         rtn = 0;
 833         if (type_str != NULL) {
 834                 if (!vector_str_init(&subst_v))
 835                         return (0);
 836                 if (!VEC_PUSH_STR(&subst_v, type_str))
 837                         goto clean;
 838         }
 839
 840         cv = true;
 841         e_idx = 0;
 842         while (idx > 0) {
 843                 switch (v->q_container[idx - 1]) {
 844                 case TYPE_PTR:
 845                         cv = false;
 846                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
 847                                 break;
 848                         if (!DEM_PUSH_STR(ddata, "*"))
 849                                 goto clean;
 850                         if (type_str != NULL) {
 851                                 if (!VEC_PUSH_STR(&subst_v, "*"))
 852                                         goto clean;
 853                                 if (!cpp_demangle_push_subst_v(ddata,
 854                                     &subst_v))
 855                                         goto clean;
 856                         }
 857                         break;
 858
 859                 case TYPE_REF:
 860                         cv = false;
 861                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
 862                                 break;
 863                         if (!DEM_PUSH_STR(ddata, "&"))
 864                                 goto clean;
 865                         if (type_str != NULL) {
 866                                 if (!VEC_PUSH_STR(&subst_v, "&"))
 867                                         goto clean;
 868                                 if (!cpp_demangle_push_subst_v(ddata,
 869                                     &subst_v))
 870                                         goto clean;
 871                         }
 872                         break;
 873
 874                 case TYPE_RREF:
 875                         cv = false;
 876                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
 877                                 break;
 878                         if (!DEM_PUSH_STR(ddata, "&&"))
 879                                 goto clean;
 880                         if (type_str != NULL) {
 881                                 if (!VEC_PUSH_STR(&subst_v, "&&"))
 882                                         goto clean;
 883                                 if (!cpp_demangle_push_subst_v(ddata,
 884                                     &subst_v))
 885                                         goto clean;
 886                         }
 887                         break;
 888
 889                 case TYPE_CMX:
 890                         cv = false;
 891                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
 892                                 break;
 893                         if (!DEM_PUSH_STR(ddata, " complex"))
 894                                 goto clean;
 895                         if (type_str != NULL) {
 896                                 if (!VEC_PUSH_STR(&subst_v, " complex"))
 897                                         goto clean;
 898                                 if (!cpp_demangle_push_subst_v(ddata,
 899                                     &subst_v))
 900                                         goto clean;
 901                         }
 902                         break;
 903
 904                 case TYPE_IMG:
 905                         cv = false;
 906                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
 907                                 break;
 908                         if (!DEM_PUSH_STR(ddata, " imaginary"))
 909                                 goto clean;
 910                         if (type_str != NULL) {
 911                                 if (!VEC_PUSH_STR(&subst_v, " imaginary"))
 912                                         goto clean;
 913                                 if (!cpp_demangle_push_subst_v(ddata,
 914                                     &subst_v))
 915                                         goto clean;
 916                         }
 917                         break;
 918
 919                 case TYPE_EXT:
 920                         cv = false;
 921                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
 922                                 break;
 923                         if (v->ext_name.size == 0 ||
 924                             e_idx > v->ext_name.size - 1)
 925                                 goto clean;
 926                         if ((e_len = strlen(v->ext_name.container[e_idx])) ==
 927                             0)
 928                                 goto clean;
 929                         if ((buf = malloc(e_len + 2)) == NULL)
 930                                 goto clean;
 931                         snprintf(buf, e_len + 2, " %s",
 932                             v->ext_name.container[e_idx]);
 933
 934                         if (!DEM_PUSH_STR(ddata, buf)) {
 935                                 free(buf);
 936                                 goto clean;
 937                         }
 938
 939                         if (type_str != NULL) {
 940                                 if (!VEC_PUSH_STR(&subst_v, buf)) {
 941                                         free(buf);
 942                                         goto clean;
 943                                 }
 944                                 if (!cpp_demangle_push_subst_v(ddata,
 945                                     &subst_v)) {
 946                                         free(buf);
 947                                         goto clean;
 948                                 }
 949                         }
 950                         free(buf);
 951                         ++e_idx;
 952                         break;
 953
 954                 case TYPE_RST:
 955                         if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
 956                             cv)
 957                                 break;
 958                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
 959                                 break;
 960                         if (!DEM_PUSH_STR(ddata, " restrict"))
 961                                 goto clean;
 962                         if (type_str != NULL) {
 963                                 if (!VEC_PUSH_STR(&subst_v, " restrict"))
 964                                         goto clean;
 965                                 if (idx - 1 > 0) {
 966                                         t = v->q_container[idx - 2];
 967                                         if (t == TYPE_RST || t == TYPE_VAT ||
 968                                             t == TYPE_CST)
 969                                                 break;
 970                                 }
 971                                 if (!cpp_demangle_push_subst_v(ddata,
 972                                     &subst_v))
 973                                         goto clean;
 974                         }
 975                         break;
 976
 977                 case TYPE_VAT:
 978                         if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
 979                             cv)
 980                                 break;
 981                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
 982                                 break;
 983                         if (!DEM_PUSH_STR(ddata, " volatile"))
 984                                 goto clean;
 985                         if (type_str != NULL) {
 986                                 if (!VEC_PUSH_STR(&subst_v, " volatile"))
 987                                         goto clean;
 988                                 if (idx - 1 > 0) {
 989                                         t = v->q_container[idx - 2];
 990                                         if (t == TYPE_RST || t == TYPE_VAT ||
 991                                             t == TYPE_CST)
 992                                                 break;
 993                                 }
 994                                 if (!cpp_demangle_push_subst_v(ddata,
 995                                     &subst_v))
 996                                         goto clean;
 997                         }
 998                         break;
 999
1000                 case TYPE_CST:
1001                         if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
1002                             cv)
1003                                 break;
1004                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
1005                                 break;
1006                         if (!DEM_PUSH_STR(ddata, " const"))
1007                                 goto clean;
1008                         if (type_str != NULL) {
1009                                 if (!VEC_PUSH_STR(&subst_v, " const"))
1010                                         goto clean;
1011                                 if (idx - 1 > 0) {
1012                                         t = v->q_container[idx - 2];
1013                                         if (t == TYPE_RST || t == TYPE_VAT ||
1014                                             t == TYPE_CST)
1015                                                 break;
1016                                 }
1017                                 if (!cpp_demangle_push_subst_v(ddata,
1018                                     &subst_v))
1019                                         goto clean;
1020                         }
1021                         break;
1022
1023                 case TYPE_VEC:
1024                         cv = false;
1025                         if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
1026                                 break;
1027                         if (v->ext_name.size == 0 ||
1028                             e_idx > v->ext_name.size - 1)
1029                                 goto clean;
1030                         if ((e_len = strlen(v->ext_name.container[e_idx])) ==
1031                             0)
1032                                 goto clean;
1033                         if ((buf = malloc(e_len + 12)) == NULL)
1034                                 goto clean;
1035                         snprintf(buf, e_len + 12, " __vector(%s)",
1036                             v->ext_name.container[e_idx]);
1037                         if (!DEM_PUSH_STR(ddata, buf)) {
1038                                 free(buf);
1039                                 goto clean;
1040                         }
1041                         if (type_str != NULL) {
1042                                 if (!VEC_PUSH_STR(&subst_v, buf)) {
1043                                         free(buf);
1044                                         goto clean;
1045                                 }
1046                                 if (!cpp_demangle_push_subst_v(ddata,
1047                                     &subst_v)) {
1048                                         free(buf);
1049                                         goto clean;
1050                                 }
1051                         }
1052                         free(buf);
1053                         ++e_idx;
1054                         break;
1055                 }
1056                 --idx;
1057         }
1058
1059         rtn = 1;
1060 clean:
1061         if (type_str != NULL)
1062                 vector_str_dest(&subst_v);
1063
1064         return (rtn);
1065 }
1066
1067 static int
1068 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
1069 {
1070         size_t len;
1071
1072         if (ddata == NULL || ddata->subst.size <= idx)
1073                 return (0);
1074         if ((len = strlen(ddata->subst.container[idx])) == 0)
1075                 return (0);
1076         if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
1077                 return (0);
1078
1079         /* skip '_' */
1080         ++ddata->cur;
1081
1082         return (1);
1083 }
1084
1085 static int
1086 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
1087 {
1088         size_t len;
1089
1090         if (ddata == NULL || ddata->tmpl.size <= idx)
1091                 return (0);
1092         if ((len = strlen(ddata->tmpl.container[idx])) == 0)
1093                 return (0);
1094         if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
1095                 return (0);
1096
1097         ++ddata->cur;
1098
1099         return (1);
1100 }
1101
1102 static int
1103 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
1104 {
1105         size_t i, num_len, exp_len, p_idx, idx;
1106         const char *num;
1107         char *exp;
1108
1109         if (ddata == NULL || *(++ddata->cur) == '\0')
1110                 return (0);
1111
1112         if (*ddata->cur == '_') {
1113                 if (*(++ddata->cur) == '\0')
1114                         return (0);
1115
1116                 if (!cpp_demangle_read_type(ddata, NULL))
1117                         return (0);
1118
1119                 if (!DEM_PUSH_STR(ddata, " []"))
1120                         return (0);
1121         } else {
1122                 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
1123                         num = ddata->cur;
1124                         while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1125                                 ++ddata->cur;
1126                         if (*ddata->cur != '_')
1127                                 return (0);
1128                         num_len = ddata->cur - num;
1129                         assert(num_len > 0);
1130                         if (*(++ddata->cur) == '\0')
1131                                 return (0);
1132                         if (!cpp_demangle_read_type(ddata, NULL))
1133                                 return (0);
1134                         if (!DEM_PUSH_STR(ddata, " ["))
1135                                 return (0);
1136                         if (!cpp_demangle_push_str(ddata, num, num_len))
1137                                 return (0);
1138                         if (!DEM_PUSH_STR(ddata, "]"))
1139                                 return (0);
1140                 } else {
1141                         p_idx = ddata->output.size;
1142                         if (!cpp_demangle_read_expression(ddata))
1143                                 return (0);
1144                         if ((exp = vector_str_substr(&ddata->output, p_idx,
1145                                  ddata->output.size - 1, &exp_len)) == NULL)
1146                                 return (0);
1147                         idx = ddata->output.size;
1148                         for (i = p_idx; i < idx; ++i)
1149                                 if (!vector_str_pop(&ddata->output)) {
1150                                         free(exp);
1151                                         return (0);
1152                                 }
1153                         if (*ddata->cur != '_') {
1154                                 free(exp);
1155                                 return (0);
1156                         }
1157                         ++ddata->cur;
1158                         if (*ddata->cur == '\0') {
1159                                 free(exp);
1160                                 return (0);
1161                         }
1162                         if (!cpp_demangle_read_type(ddata, NULL)) {
1163                                 free(exp);
1164                                 return (0);
1165                         }
1166                         if (!DEM_PUSH_STR(ddata, " [")) {
1167                                 free(exp);
1168                                 return (0);
1169                         }
1170                         if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
1171                                 free(exp);
1172                                 return (0);
1173                         }
1174                         if (!DEM_PUSH_STR(ddata, "]")) {
1175                                 free(exp);
1176                                 return (0);
1177                         }
1178                         free(exp);
1179                 }
1180         }
1181
1182         return (1);
1183 }
1184
1185 static int
1186 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
1187 {
1188         const char *num;
1189
1190         if (ddata == NULL || *(++ddata->cur) == '\0')
1191                 return (0);
1192
1193         if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
1194                 ddata->cur += 2;
1195                 if (*ddata->cur == '\0')
1196                         return (0);
1197                 if (!cpp_demangle_read_encoding(ddata))
1198                         return (0);
1199                 ++ddata->cur;
1200                 return (1);
1201         }
1202
1203         switch (*ddata->cur) {
1204         case 'b':
1205                 if (*(ddata->cur + 2) != 'E')
1206                         return (0);
1207                 switch (*(++ddata->cur)) {
1208                 case '0':
1209                         ddata->cur += 2;
1210                         return (DEM_PUSH_STR(ddata, "false"));
1211                 case '1':
1212                         ddata->cur += 2;
1213                         return (DEM_PUSH_STR(ddata, "true"));
1214                 default:
1215                         return (0);
1216                 }
1217
1218         case 'd':
1219                 ++ddata->cur;
1220                 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
1221
1222         case 'e':
1223                 ++ddata->cur;
1224                 if (sizeof(long double) == 10)
1225                         return (cpp_demangle_push_fp(ddata,
1226                             decode_fp_to_double));
1227                 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
1228
1229         case 'f':
1230                 ++ddata->cur;
1231                 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
1232
1233         case 'g':
1234                 ++ddata->cur;
1235                 if (sizeof(long double) == 16)
1236                         return (cpp_demangle_push_fp(ddata,
1237                             decode_fp_to_double));
1238                 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
1239
1240         case 'i':
1241         case 'j':
1242         case 'l':
1243         case 'm':
1244         case 'n':
1245         case 's':
1246         case 't':
1247         case 'x':
1248         case 'y':
1249                 if (*(++ddata->cur) == 'n') {
1250                         if (!DEM_PUSH_STR(ddata, "-"))
1251                                 return (0);
1252                         ++ddata->cur;
1253                 }
1254                 num = ddata->cur;
1255                 while (*ddata->cur != 'E') {
1256                         if (!ELFTC_ISDIGIT(*ddata->cur))
1257                                 return (0);
1258                         ++ddata->cur;
1259                 }
1260                 ++ddata->cur;
1261                 return (cpp_demangle_push_str(ddata, num,
1262                     ddata->cur - num - 1));
1263
1264         default:
1265                 return (0);
1266         }
1267 }
1268
1269 static int
1270 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
1271 {
1272
1273         if (ddata == NULL || *ddata->cur == '\0')
1274                 return (0);
1275
1276         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1277         case SIMPLE_HASH('s', 't'):
1278                 ddata->cur += 2;
1279                 return (cpp_demangle_read_type(ddata, NULL));
1280
1281         case SIMPLE_HASH('s', 'r'):
1282                 ddata->cur += 2;
1283                 if (!cpp_demangle_read_type(ddata, NULL))
1284                         return (0);
1285                 if (!cpp_demangle_read_uqname(ddata))
1286                         return (0);
1287                 if (*ddata->cur == 'I')
1288                         return (cpp_demangle_read_tmpl_args(ddata));
1289                 return (1);
1290
1291         case SIMPLE_HASH('a', 'a'):
1292                 /* operator && */
1293                 ddata->cur += 2;
1294                 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
1295
1296         case SIMPLE_HASH('a', 'd'):
1297                 /* operator & (unary) */
1298                 ddata->cur += 2;
1299                 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
1300
1301         case SIMPLE_HASH('a', 'n'):
1302                 /* operator & */
1303                 ddata->cur += 2;
1304                 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
1305
1306         case SIMPLE_HASH('a', 'N'):
1307                 /* operator &= */
1308                 ddata->cur += 2;
1309                 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
1310
1311         case SIMPLE_HASH('a', 'S'):
1312                 /* operator = */
1313                 ddata->cur += 2;
1314                 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
1315
1316         case SIMPLE_HASH('c', 'l'):
1317                 /* operator () */
1318                 ddata->cur += 2;
1319                 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
1320
1321         case SIMPLE_HASH('c', 'm'):
1322                 /* operator , */
1323                 ddata->cur += 2;
1324                 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
1325
1326         case SIMPLE_HASH('c', 'o'):
1327                 /* operator ~ */
1328                 ddata->cur += 2;
1329                 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
1330
1331         case SIMPLE_HASH('c', 'v'):
1332                 /* operator (cast) */
1333                 ddata->cur += 2;
1334                 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
1335
1336         case SIMPLE_HASH('d', 'a'):
1337                 /* operator delete [] */
1338                 ddata->cur += 2;
1339                 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
1340
1341         case SIMPLE_HASH('d', 'e'):
1342                 /* operator * (unary) */
1343                 ddata->cur += 2;
1344                 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
1345
1346         case SIMPLE_HASH('d', 'l'):
1347                 /* operator delete */
1348                 ddata->cur += 2;
1349                 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
1350
1351         case SIMPLE_HASH('d', 'v'):
1352                 /* operator / */
1353                 ddata->cur += 2;
1354                 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
1355
1356         case SIMPLE_HASH('d', 'V'):
1357                 /* operator /= */
1358                 ddata->cur += 2;
1359                 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
1360
1361         case SIMPLE_HASH('e', 'o'):
1362                 /* operator ^ */
1363                 ddata->cur += 2;
1364                 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
1365
1366         case SIMPLE_HASH('e', 'O'):
1367                 /* operator ^= */
1368                 ddata->cur += 2;
1369                 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
1370
1371         case SIMPLE_HASH('e', 'q'):
1372                 /* operator == */
1373                 ddata->cur += 2;
1374                 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
1375
1376         case SIMPLE_HASH('g', 'e'):
1377                 /* operator >= */
1378                 ddata->cur += 2;
1379                 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
1380
1381         case SIMPLE_HASH('g', 't'):
1382                 /* operator > */
1383                 ddata->cur += 2;
1384                 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
1385
1386         case SIMPLE_HASH('i', 'x'):
1387                 /* operator [] */
1388                 ddata->cur += 2;
1389                 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
1390
1391         case SIMPLE_HASH('l', 'e'):
1392                 /* operator <= */
1393                 ddata->cur += 2;
1394                 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
1395
1396         case SIMPLE_HASH('l', 's'):
1397                 /* operator << */
1398                 ddata->cur += 2;
1399                 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
1400
1401         case SIMPLE_HASH('l', 'S'):
1402                 /* operator <<= */
1403                 ddata->cur += 2;
1404                 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
1405
1406         case SIMPLE_HASH('l', 't'):
1407                 /* operator < */
1408                 ddata->cur += 2;
1409                 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
1410
1411         case SIMPLE_HASH('m', 'i'):
1412                 /* operator - */
1413                 ddata->cur += 2;
1414                 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
1415
1416         case SIMPLE_HASH('m', 'I'):
1417                 /* operator -= */
1418                 ddata->cur += 2;
1419                 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
1420
1421         case SIMPLE_HASH('m', 'l'):
1422                 /* operator * */
1423                 ddata->cur += 2;
1424                 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
1425
1426         case SIMPLE_HASH('m', 'L'):
1427                 /* operator *= */
1428                 ddata->cur += 2;
1429                 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
1430
1431         case SIMPLE_HASH('m', 'm'):
1432                 /* operator -- */
1433                 ddata->cur += 2;
1434                 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
1435
1436         case SIMPLE_HASH('n', 'a'):
1437                 /* operator new[] */
1438                 ddata->cur += 2;
1439                 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
1440
1441         case SIMPLE_HASH('n', 'e'):
1442                 /* operator != */
1443                 ddata->cur += 2;
1444                 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
1445
1446         case SIMPLE_HASH('n', 'g'):
1447                 /* operator - (unary) */
1448                 ddata->cur += 2;
1449                 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
1450
1451         case SIMPLE_HASH('n', 't'):
1452                 /* operator ! */
1453                 ddata->cur += 2;
1454                 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
1455
1456         case SIMPLE_HASH('n', 'w'):
1457                 /* operator new */
1458                 ddata->cur += 2;
1459                 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
1460
1461         case SIMPLE_HASH('o', 'o'):
1462                 /* operator || */
1463                 ddata->cur += 2;
1464                 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
1465
1466         case SIMPLE_HASH('o', 'r'):
1467                 /* operator | */
1468                 ddata->cur += 2;
1469                 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
1470
1471         case SIMPLE_HASH('o', 'R'):
1472                 /* operator |= */
1473                 ddata->cur += 2;
1474                 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
1475
1476         case SIMPLE_HASH('p', 'l'):
1477                 /* operator + */
1478                 ddata->cur += 2;
1479                 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
1480
1481         case SIMPLE_HASH('p', 'L'):
1482                 /* operator += */
1483                 ddata->cur += 2;
1484                 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
1485
1486         case SIMPLE_HASH('p', 'm'):
1487                 /* operator ->* */
1488                 ddata->cur += 2;
1489                 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
1490
1491         case SIMPLE_HASH('p', 'p'):
1492                 /* operator ++ */
1493                 ddata->cur += 2;
1494                 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
1495
1496         case SIMPLE_HASH('p', 's'):
1497                 /* operator + (unary) */
1498                 ddata->cur += 2;
1499                 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1500
1501         case SIMPLE_HASH('p', 't'):
1502                 /* operator -> */
1503                 ddata->cur += 2;
1504                 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1505
1506         case SIMPLE_HASH('q', 'u'):
1507                 /* operator ? */
1508                 ddata->cur += 2;
1509                 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1510                     ":", 1));
1511
1512         case SIMPLE_HASH('r', 'm'):
1513                 /* operator % */
1514                 ddata->cur += 2;
1515                 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1516
1517         case SIMPLE_HASH('r', 'M'):
1518                 /* operator %= */
1519                 ddata->cur += 2;
1520                 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1521
1522         case SIMPLE_HASH('r', 's'):
1523                 /* operator >> */
1524                 ddata->cur += 2;
1525                 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1526
1527         case SIMPLE_HASH('r', 'S'):
1528                 /* operator >>= */
1529                 ddata->cur += 2;
1530                 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1531
1532         case SIMPLE_HASH('r', 'z'):
1533                 /* operator sizeof */
1534                 ddata->cur += 2;
1535                 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1536
1537         case SIMPLE_HASH('s', 'v'):
1538                 /* operator sizeof */
1539                 ddata->cur += 2;
1540                 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1541         }
1542
1543         switch (*ddata->cur) {
1544         case 'L':
1545                 return (cpp_demangle_read_expr_primary(ddata));
1546         case 'T':
1547                 return (cpp_demangle_read_tmpl_param(ddata));
1548         }
1549
1550         return (0);
1551 }
1552
1553 static int
1554 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1555 {
1556         struct vector_str *output;
1557         size_t i, p_idx, idx, exp_len;
1558         char *exp;
1559
1560         output = &ddata->output;
1561
1562         p_idx = output->size;
1563
1564         if (!cpp_demangle_read_expression(ddata))
1565                 return (0);
1566
1567         if ((exp = vector_str_substr(output, p_idx, output->size - 1,
1568             &exp_len)) == NULL)
1569                 return (0);
1570
1571         idx = output->size;
1572         for (i = p_idx; i < idx; ++i) {
1573                 if (!vector_str_pop(output)) {
1574                         free(exp);
1575                         return (0);
1576                 }
1577         }
1578
1579         *str = exp;
1580
1581         return (1);
1582 }
1583
1584 static int
1585 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1586     const char *name, size_t len)
1587 {
1588
1589         if (ddata == NULL || name == NULL || len == 0)
1590                 return (0);
1591         if (!cpp_demangle_read_expression(ddata))
1592                 return (0);
1593         if (!cpp_demangle_push_str(ddata, name, len))
1594                 return (0);
1595
1596         return (cpp_demangle_read_expression(ddata));
1597 }
1598
1599 static int
1600 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1601     const char *name, size_t len)
1602 {
1603
1604         if (ddata == NULL || name == NULL || len == 0)
1605                 return (0);
1606         if (!cpp_demangle_read_expression(ddata))
1607                 return (0);
1608
1609         return (cpp_demangle_push_str(ddata, name, len));
1610 }
1611
1612 static int
1613 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1614     const char *name1, size_t len1, const char *name2, size_t len2)
1615 {
1616
1617         if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1618             len2 == 0)
1619                 return (0);
1620
1621         if (!cpp_demangle_read_expression(ddata))
1622                 return (0);
1623         if (!cpp_demangle_push_str(ddata, name1, len1))
1624                 return (0);
1625         if (!cpp_demangle_read_expression(ddata))
1626                 return (0);
1627         if (!cpp_demangle_push_str(ddata, name2, len2))
1628                 return (0);
1629
1630         return (cpp_demangle_read_expression(ddata));
1631 }
1632
1633 static int
1634 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1635     struct vector_type_qualifier *v)
1636 {
1637         struct type_delimit td;
1638         struct read_cmd_item *rc;
1639         size_t class_type_size, class_type_len, limit;
1640         const char *class_type;
1641         int i;
1642         bool paren, non_cv_qualifier;
1643
1644         if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1645                 return (0);
1646
1647         ++ddata->cur;
1648         if (*ddata->cur == 'Y') {
1649                 if (ext_c != NULL)
1650                         *ext_c = 1;
1651                 ++ddata->cur;
1652         }
1653
1654         /* Return type */
1655         if (!cpp_demangle_read_type(ddata, NULL))
1656                 return (0);
1657
1658         if (*ddata->cur != 'E') {
1659                 if (!DEM_PUSH_STR(ddata, " "))
1660                         return (0);
1661
1662                 non_cv_qualifier = false;
1663                 if (v->size > 0) {
1664                         for (i = 0; (size_t) i < v->size; i++) {
1665                                 if (v->q_container[i] != TYPE_RST &&
1666                                     v->q_container[i] != TYPE_VAT &&
1667                                     v->q_container[i] != TYPE_CST) {
1668                                         non_cv_qualifier = true;
1669                                         break;
1670                                 }
1671                         }
1672                 }
1673
1674                 paren = false;
1675                 rc = vector_read_cmd_find(&ddata->cmd, READ_PTRMEM);
1676                 if (non_cv_qualifier || rc != NULL) {
1677                         if (!DEM_PUSH_STR(ddata, "("))
1678                                 return (0);
1679                         paren = true;
1680                 }
1681
1682                 /* Push non-cv qualifiers. */
1683                 ddata->push_qualifier = PUSH_NON_CV_QUALIFIER;
1684                 if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
1685                         return (0);
1686
1687                 if (rc) {
1688                         if (non_cv_qualifier && !DEM_PUSH_STR(ddata, " "))
1689                                 return (0);
1690                         if ((class_type_size = ddata->class_type.size) == 0)
1691                                 return (0);
1692                         class_type =
1693                             ddata->class_type.container[class_type_size - 1];
1694                         if (class_type == NULL)
1695                                 return (0);
1696                         if ((class_type_len = strlen(class_type)) == 0)
1697                                 return (0);
1698                         if (!cpp_demangle_push_str(ddata, class_type,
1699                             class_type_len))
1700                                 return (0);
1701                         if (!DEM_PUSH_STR(ddata, "::*"))
1702                                 return (0);
1703                         /* Push pointer-to-member qualifiers. */
1704                         ddata->push_qualifier = PUSH_ALL_QUALIFIER;
1705                         if (!cpp_demangle_push_type_qualifier(ddata, rc->data,
1706                             NULL))
1707                                 return (0);
1708                         ++ddata->func_type;
1709                 }
1710
1711                 if (paren) {
1712                         if (!DEM_PUSH_STR(ddata, ")"))
1713                                 return (0);
1714                         paren = false;
1715                 }
1716
1717                 td.paren = false;
1718                 td.firstp = true;
1719                 limit = 0;
1720                 ddata->is_functype = true;
1721                 for (;;) {
1722                         if (!cpp_demangle_read_type(ddata, &td))
1723                                 return (0);
1724                         if (*ddata->cur == 'E')
1725                                 break;
1726                         if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1727                                 return (0);
1728                 }
1729                 ddata->is_functype = false;
1730                 if (td.paren) {
1731                         if (!DEM_PUSH_STR(ddata, ")"))
1732                                 return (0);
1733                         td.paren = false;
1734                 }
1735
1736                 /* Push CV qualifiers. */
1737                 ddata->push_qualifier = PUSH_CV_QUALIFIER;
1738                 if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
1739                         return (0);
1740
1741                 ddata->push_qualifier = PUSH_ALL_QUALIFIER;
1742
1743                 /* Release type qualifier vector. */
1744                 vector_type_qualifier_dest(v);
1745                 if (!vector_type_qualifier_init(v))
1746                         return (0);
1747
1748                 /* Push ref-qualifiers. */
1749                 if (ddata->ref_qualifier) {
1750                         switch (ddata->ref_qualifier_type) {
1751                         case TYPE_REF:
1752                                 if (!DEM_PUSH_STR(ddata, " &"))
1753                                         return (0);
1754                                 break;
1755                         case TYPE_RREF:
1756                                 if (!DEM_PUSH_STR(ddata, " &&"))
1757                                         return (0);
1758                                 break;
1759                         default:
1760                                 return (0);
1761                         }
1762                         ddata->ref_qualifier = false;
1763                 }
1764         }
1765
1766         ++ddata->cur;
1767
1768         return (1);
1769 }
1770
1771 /* read encoding, encoding are function name, data name, special-name */
1772 static int
1773 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1774 {
1775         char *name, *type, *num_str;
1776         long offset;
1777         int rtn;
1778
1779         if (ddata == NULL || *ddata->cur == '\0')
1780                 return (0);
1781
1782         /* special name */
1783         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1784         case SIMPLE_HASH('G', 'A'):
1785                 if (!DEM_PUSH_STR(ddata, "hidden alias for "))
1786                         return (0);
1787                 ddata->cur += 2;
1788                 if (*ddata->cur == '\0')
1789                         return (0);
1790                 return (cpp_demangle_read_encoding(ddata));
1791
1792         case SIMPLE_HASH('G', 'R'):
1793                 if (!DEM_PUSH_STR(ddata, "reference temporary #"))
1794                         return (0);
1795                 ddata->cur += 2;
1796                 if (*ddata->cur == '\0')
1797                         return (0);
1798                 if (!cpp_demangle_read_name_flat(ddata, &name))
1799                         return (0);
1800                 rtn = 0;
1801                 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1802                         goto clean1;
1803                 if (!DEM_PUSH_STR(ddata, num_str))
1804                         goto clean2;
1805                 if (!DEM_PUSH_STR(ddata, " for "))
1806                         goto clean2;
1807                 if (!DEM_PUSH_STR(ddata, name))
1808                         goto clean2;
1809                 rtn = 1;
1810         clean2:
1811                 free(num_str);
1812         clean1:
1813                 free(name);
1814                 return (rtn);
1815
1816         case SIMPLE_HASH('G', 'T'):
1817                 ddata->cur += 2;
1818                 if (*ddata->cur == '\0')
1819                         return (0);
1820                 switch (*ddata->cur) {
1821                 case 'n':
1822                         if (!DEM_PUSH_STR(ddata, "non-transaction clone for "))
1823                                 return (0);
1824                         break;
1825                 case 't':
1826                 default:
1827                         if (!DEM_PUSH_STR(ddata, "transaction clone for "))
1828                                 return (0);
1829                         break;
1830                 }
1831                 ++ddata->cur;
1832                 return (cpp_demangle_read_encoding(ddata));
1833
1834         case SIMPLE_HASH('G', 'V'):
1835                 /* sentry object for 1 time init */
1836                 if (!DEM_PUSH_STR(ddata, "guard variable for "))
1837                         return (0);
1838                 ddata->cur += 2;
1839                 break;
1840
1841         case SIMPLE_HASH('T', 'c'):
1842                 /* virtual function covariant override thunk */
1843                 if (!DEM_PUSH_STR(ddata,
1844                     "virtual function covariant override "))
1845                         return (0);
1846                 ddata->cur += 2;
1847                 if (*ddata->cur == '\0')
1848                         return (0);
1849                 if (!cpp_demangle_read_offset(ddata))
1850                         return (0);
1851                 if (!cpp_demangle_read_offset(ddata))
1852                         return (0);
1853                 return (cpp_demangle_read_encoding(ddata));
1854
1855         case SIMPLE_HASH('T', 'C'):
1856                 /* construction vtable */
1857                 if (!DEM_PUSH_STR(ddata, "construction vtable for "))
1858                         return (0);
1859                 ddata->cur += 2;
1860                 if (*ddata->cur == '\0')
1861                         return (0);
1862                 if (!cpp_demangle_read_type_flat(ddata, &type))
1863                         return (0);
1864                 rtn = 0;
1865                 if (!cpp_demangle_read_number(ddata, &offset))
1866                         goto clean3;
1867                 if (*ddata->cur++ != '_')
1868                         goto clean3;
1869                 if (!cpp_demangle_read_type(ddata, NULL))
1870                         goto clean3;
1871                 if (!DEM_PUSH_STR(ddata, "-in-"))
1872                         goto clean3;
1873                 if (!DEM_PUSH_STR(ddata, type))
1874                         goto clean3;
1875                 rtn = 1;
1876         clean3:
1877                 free(type);
1878                 return (rtn);
1879
1880         case SIMPLE_HASH('T', 'D'):
1881                 /* typeinfo common proxy */
1882                 break;
1883
1884         case SIMPLE_HASH('T', 'F'):
1885                 /* typeinfo fn */
1886                 if (!DEM_PUSH_STR(ddata, "typeinfo fn for "))
1887                         return (0);
1888                 ddata->cur += 2;
1889                 if (*ddata->cur == '\0')
1890                         return (0);
1891                 return (cpp_demangle_read_type(ddata, NULL));
1892
1893         case SIMPLE_HASH('T', 'h'):
1894                 /* virtual function non-virtual override thunk */
1895                 if (!DEM_PUSH_STR(ddata,
1896                     "virtual function non-virtual override "))
1897                         return (0);
1898                 ddata->cur += 2;
1899                 if (*ddata->cur == '\0')
1900                         return (0);
1901                 if (!cpp_demangle_read_nv_offset(ddata))
1902                         return (0);
1903                 return (cpp_demangle_read_encoding(ddata));
1904
1905         case SIMPLE_HASH('T', 'H'):
1906                 /* TLS init function */
1907                 if (!DEM_PUSH_STR(ddata, "TLS init function for "))
1908                         return (0);
1909                 ddata->cur += 2;
1910                 if (*ddata->cur == '\0')
1911                         return (0);
1912                 break;
1913
1914         case SIMPLE_HASH('T', 'I'):
1915                 /* typeinfo structure */
1916                 if (!DEM_PUSH_STR(ddata, "typeinfo for "))
1917                         return (0);
1918                 ddata->cur += 2;
1919                 if (*ddata->cur == '\0')
1920                         return (0);
1921                 return (cpp_demangle_read_type(ddata, NULL));
1922
1923         case SIMPLE_HASH('T', 'J'):
1924                 /* java class */
1925                 if (!DEM_PUSH_STR(ddata, "java Class for "))
1926                         return (0);
1927                 ddata->cur += 2;
1928                 if (*ddata->cur == '\0')
1929                         return (0);
1930                 return (cpp_demangle_read_type(ddata, NULL));
1931
1932         case SIMPLE_HASH('T', 'S'):
1933                 /* RTTI name (NTBS) */
1934                 if (!DEM_PUSH_STR(ddata, "typeinfo name for "))
1935                         return (0);
1936                 ddata->cur += 2;
1937                 if (*ddata->cur == '\0')
1938                         return (0);
1939                 return (cpp_demangle_read_type(ddata, NULL));
1940
1941         case SIMPLE_HASH('T', 'T'):
1942                 /* VTT table */
1943                 if (!DEM_PUSH_STR(ddata, "VTT for "))
1944                         return (0);
1945                 ddata->cur += 2;
1946                 if (*ddata->cur == '\0')
1947                         return (0);
1948                 return (cpp_demangle_read_type(ddata, NULL));
1949
1950         case SIMPLE_HASH('T', 'v'):
1951                 /* virtual function virtual override thunk */
1952                 if (!DEM_PUSH_STR(ddata, "virtual function virtual override "))
1953                         return (0);
1954                 ddata->cur += 2;
1955                 if (*ddata->cur == '\0')
1956                         return (0);
1957                 if (!cpp_demangle_read_v_offset(ddata))
1958                         return (0);
1959                 return (cpp_demangle_read_encoding(ddata));
1960
1961         case SIMPLE_HASH('T', 'V'):
1962                 /* virtual table */
1963                 if (!DEM_PUSH_STR(ddata, "vtable for "))
1964                         return (0);
1965                 ddata->cur += 2;
1966                 if (*ddata->cur == '\0')
1967                         return (0);
1968                 return (cpp_demangle_read_type(ddata, NULL));
1969
1970         case SIMPLE_HASH('T', 'W'):
1971                 /* TLS wrapper function */
1972                 if (!DEM_PUSH_STR(ddata, "TLS wrapper function for "))
1973                         return (0);
1974                 ddata->cur += 2;
1975                 if (*ddata->cur == '\0')
1976                         return (0);
1977                 break;
1978         }
1979
1980         return (cpp_demangle_read_name(ddata));
1981 }
1982
1983 static int
1984 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1985 {
1986         struct vector_str local_name;
1987         struct type_delimit td;
1988         size_t limit;
1989         bool  more_type;
1990
1991         if (ddata == NULL)
1992                 return (0);
1993         if (*(++ddata->cur) == '\0')
1994                 return (0);
1995
1996         if (!vector_str_init(&local_name))
1997                 return (0);
1998         ddata->cur_output = &local_name;
1999
2000         if (!cpp_demangle_read_encoding(ddata)) {
2001                 vector_str_dest(&local_name);
2002                 return (0);
2003         }
2004
2005         ddata->cur_output = &ddata->output;
2006
2007         td.paren = false;
2008         td.firstp = true;
2009         more_type = false;
2010         limit = 0;
2011
2012         /*
2013          * The first type is a return type if we just demangled template
2014          * args. (the template args is right next to the function name,
2015          * which means it's a template function)
2016          */
2017         if (ddata->is_tmpl) {
2018                 ddata->is_tmpl = false;
2019
2020                 /* Read return type */
2021                 if (!cpp_demangle_read_type(ddata, NULL)) {
2022                         vector_str_dest(&local_name);
2023                         return (0);
2024                 }
2025
2026                 more_type = true;
2027         }
2028
2029         /* Now we can push the name after possible return type is handled. */
2030         if (!vector_str_push_vector(&ddata->output, &local_name)) {
2031                 vector_str_dest(&local_name);
2032                 return (0);
2033         }
2034         vector_str_dest(&local_name);
2035
2036         while (*ddata->cur != '\0') {
2037                 if (!cpp_demangle_read_type(ddata, &td))
2038                         return (0);
2039                 if (more_type)
2040                         more_type = false;
2041                 if (*ddata->cur == 'E')
2042                         break;
2043                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2044                         return (0);
2045         }
2046         if (more_type)
2047                 return (0);
2048
2049         if (*(++ddata->cur) == '\0')
2050                 return (0);
2051         if (td.paren == true) {
2052                 if (!DEM_PUSH_STR(ddata, ")"))
2053                         return (0);
2054                 td.paren = false;
2055         }
2056         if (*ddata->cur == 's')
2057                 ++ddata->cur;
2058         else {
2059                 if (!DEM_PUSH_STR(ddata, "::"))
2060                         return (0);
2061                 if (!cpp_demangle_read_name(ddata))
2062                         return (0);
2063         }
2064         if (*ddata->cur == '_') {
2065                 ++ddata->cur;
2066                 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
2067                         ++ddata->cur;
2068         }
2069
2070         return (1);
2071 }
2072
2073 static int
2074 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
2075 {
2076         struct vector_str *output, v;
2077         size_t p_idx, subst_str_len;
2078         int rtn;
2079         char *subst_str;
2080
2081         if (ddata == NULL || *ddata->cur == '\0')
2082                 return (0);
2083
2084         output = ddata->cur_output;
2085
2086         subst_str = NULL;
2087
2088         switch (*ddata->cur) {
2089         case 'S':
2090                 return (cpp_demangle_read_subst(ddata));
2091         case 'N':
2092                 return (cpp_demangle_read_nested_name(ddata));
2093         case 'Z':
2094                 return (cpp_demangle_read_local_name(ddata));
2095         }
2096
2097         if (!vector_str_init(&v))
2098                 return (0);
2099
2100         p_idx = output->size;
2101         rtn = 0;
2102         if (!cpp_demangle_read_uqname(ddata))
2103                 goto clean;
2104         if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2105             &subst_str_len)) == NULL)
2106                 goto clean;
2107         if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
2108                 rtn = 1;
2109                 goto clean;
2110         }
2111         if (!vector_str_push(&v, subst_str, subst_str_len))
2112                 goto clean;
2113         if (!cpp_demangle_push_subst_v(ddata, &v))
2114                 goto clean;
2115
2116         if (*ddata->cur == 'I') {
2117                 p_idx = output->size;
2118                 if (!cpp_demangle_read_tmpl_args(ddata))
2119                         goto clean;
2120                 free(subst_str);
2121                 if ((subst_str = vector_str_substr(output, p_idx,
2122                     output->size - 1, &subst_str_len)) == NULL)
2123                         goto clean;
2124                 if (!vector_str_push(&v, subst_str, subst_str_len))
2125                         goto clean;
2126                 if (!cpp_demangle_push_subst_v(ddata, &v))
2127                         goto clean;
2128         }
2129
2130         rtn = 1;
2131
2132 clean:
2133         free(subst_str);
2134         vector_str_dest(&v);
2135
2136         return (rtn);
2137 }
2138
2139 static int
2140 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
2141 {
2142         struct vector_str *output;
2143         size_t i, p_idx, idx, name_len;
2144         char *name;
2145
2146         output = ddata->cur_output;
2147
2148         p_idx = output->size;
2149
2150         if (!cpp_demangle_read_name(ddata))
2151                 return (0);
2152
2153         if ((name = vector_str_substr(output, p_idx, output->size - 1,
2154             &name_len)) == NULL)
2155                 return (0);
2156
2157         idx = output->size;
2158         for (i = p_idx; i < idx; ++i) {
2159                 if (!vector_str_pop(output)) {
2160                         free(name);
2161                         return (0);
2162                 }
2163         }
2164
2165         *str = name;
2166
2167         return (1);
2168 }
2169
2170 static int
2171 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
2172 {
2173         struct vector_str *output, v;
2174         size_t limit, p_idx, subst_str_len;
2175         int rtn;
2176         char *subst_str;
2177
2178         if (ddata == NULL || *ddata->cur != 'N')
2179                 return (0);
2180         if (*(++ddata->cur) == '\0')
2181                 return (0);
2182
2183         do {
2184                 switch (*ddata->cur) {
2185                 case 'r':
2186                         ddata->mem_rst = true;
2187                         break;
2188                 case 'V':
2189                         ddata->mem_vat = true;
2190                         break;
2191                 case 'K':
2192                         ddata->mem_cst = true;
2193                         break;
2194                 case 'R':
2195                         ddata->mem_ref = true;
2196                         break;
2197                 case 'O':
2198                         ddata->mem_rref = true;
2199                         break;
2200                 default:
2201                         goto next;
2202                 }
2203         } while (*(++ddata->cur));
2204
2205 next:
2206         output = ddata->cur_output;
2207         if (!vector_str_init(&v))
2208                 return (0);
2209
2210         rtn = 0;
2211         limit = 0;
2212         for (;;) {
2213                 p_idx = output->size;
2214                 switch (*ddata->cur) {
2215                 case 'I':
2216                         if (!cpp_demangle_read_tmpl_args(ddata))
2217                                 goto clean;
2218                         break;
2219                 case 'S':
2220                         if (!cpp_demangle_read_subst(ddata))
2221                                 goto clean;
2222                         break;
2223                 case 'T':
2224                         if (!cpp_demangle_read_tmpl_param(ddata))
2225                                 goto clean;
2226                         break;
2227                 default:
2228                         if (!cpp_demangle_read_uqname(ddata))
2229                                 goto clean;
2230                 }
2231
2232                 if (p_idx == output->size)
2233                         goto next_comp;
2234                 if ((subst_str = vector_str_substr(output, p_idx,
2235                     output->size - 1, &subst_str_len)) == NULL)
2236                         goto clean;
2237                 if (!vector_str_push(&v, subst_str, subst_str_len)) {
2238                         free(subst_str);
2239                         goto clean;
2240                 }
2241                 free(subst_str);
2242
2243                 if (!cpp_demangle_push_subst_v(ddata, &v))
2244                         goto clean;
2245
2246         next_comp:
2247                 if (*ddata->cur == 'E')
2248                         break;
2249                 else if (*ddata->cur != 'I' && *ddata->cur != 'C' &&
2250                     *ddata->cur != 'D' && p_idx != output->size) {
2251                         if (!DEM_PUSH_STR(ddata, "::"))
2252                                 goto clean;
2253                         if (!VEC_PUSH_STR(&v, "::"))
2254                                 goto clean;
2255                 }
2256                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2257                         goto clean;
2258         }
2259
2260         ++ddata->cur;
2261         rtn = 1;
2262
2263 clean:
2264         vector_str_dest(&v);
2265
2266         return (rtn);
2267 }
2268
2269 /*
2270  * read number
2271  * number ::= [n] <decimal>
2272  */
2273 static int
2274 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
2275 {
2276         long len, negative_factor;
2277
2278         if (ddata == NULL || rtn == NULL)
2279                 return (0);
2280
2281         negative_factor = 1;
2282         if (*ddata->cur == 'n') {
2283                 negative_factor = -1;
2284
2285                 ++ddata->cur;
2286         }
2287         if (ELFTC_ISDIGIT(*ddata->cur) == 0)
2288                 return (0);
2289
2290         errno = 0;
2291         if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
2292             errno != 0)
2293                 return (0);
2294
2295         while (ELFTC_ISDIGIT(*ddata->cur) != 0)
2296                 ++ddata->cur;
2297
2298         assert(len >= 0);
2299         assert(negative_factor == 1 || negative_factor == -1);
2300
2301         *rtn = len * negative_factor;
2302
2303         return (1);
2304 }
2305
2306 static int
2307 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
2308 {
2309         long n;
2310
2311         if (!cpp_demangle_read_number(ddata, &n)) {
2312                 *str = NULL;
2313                 return (0);
2314         }
2315
2316         if (asprintf(str, "%ld", n) < 0) {
2317                 *str = NULL;
2318                 return (0);
2319         }
2320
2321         return (1);
2322 }
2323
2324 static int
2325 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
2326 {
2327
2328         if (ddata == NULL)
2329                 return (0);
2330
2331         if (!DEM_PUSH_STR(ddata, "offset : "))
2332                 return (0);
2333
2334         return (cpp_demangle_read_offset_number(ddata));
2335 }
2336
2337 /* read offset, offset are nv-offset, v-offset */
2338 static int
2339 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
2340 {
2341
2342         if (ddata == NULL)
2343                 return (0);
2344
2345         if (*ddata->cur == 'h') {
2346                 ++ddata->cur;
2347                 return (cpp_demangle_read_nv_offset(ddata));
2348         } else if (*ddata->cur == 'v') {
2349                 ++ddata->cur;
2350                 return (cpp_demangle_read_v_offset(ddata));
2351         }
2352
2353         return (0);
2354 }
2355
2356 static int
2357 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
2358 {
2359         bool negative;
2360         const char *start;
2361
2362         if (ddata == NULL || *ddata->cur == '\0')
2363                 return (0);
2364
2365         /* offset could be negative */
2366         if (*ddata->cur == 'n') {
2367                 negative = true;
2368                 start = ddata->cur + 1;
2369         } else {
2370                 negative = false;
2371                 start = ddata->cur;
2372         }
2373
2374         while (*ddata->cur != '_')
2375                 ++ddata->cur;
2376
2377         if (negative && !DEM_PUSH_STR(ddata, "-"))
2378                 return (0);
2379
2380         assert(start != NULL);
2381
2382         if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
2383                 return (0);
2384         if (!DEM_PUSH_STR(ddata, " "))
2385                 return (0);
2386
2387         ++ddata->cur;
2388
2389         return (1);
2390 }
2391
2392 static int
2393 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata,
2394     struct vector_type_qualifier *v)
2395 {
2396         size_t class_type_len, i, idx, p_idx;
2397         int p_func_type, rtn;
2398         char *class_type;
2399
2400         if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
2401                 return (0);
2402
2403         p_idx = ddata->output.size;
2404         if (!cpp_demangle_read_type(ddata, NULL))
2405                 return (0);
2406
2407         if ((class_type = vector_str_substr(&ddata->output, p_idx,
2408             ddata->output.size - 1, &class_type_len)) == NULL)
2409                 return (0);
2410
2411         rtn = 0;
2412         idx = ddata->output.size;
2413         for (i = p_idx; i < idx; ++i)
2414                 if (!vector_str_pop(&ddata->output))
2415                         goto clean1;
2416
2417         if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM, v))
2418                 goto clean1;
2419
2420         if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
2421                 goto clean2;
2422
2423         p_func_type = ddata->func_type;
2424         if (!cpp_demangle_read_type(ddata, NULL))
2425                 goto clean3;
2426
2427         if (p_func_type == ddata->func_type) {
2428                 if (!DEM_PUSH_STR(ddata, " "))
2429                         goto clean3;
2430                 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
2431                         goto clean3;
2432                 if (!DEM_PUSH_STR(ddata, "::*"))
2433                         goto clean3;
2434         }
2435
2436         rtn = 1;
2437 clean3:
2438         if (!vector_str_pop(&ddata->class_type))
2439                 rtn = 0;
2440 clean2:
2441         if (!vector_read_cmd_pop(&ddata->cmd))
2442                 rtn = 0;
2443 clean1:
2444         free(class_type);
2445
2446         vector_type_qualifier_dest(v);
2447         if (!vector_type_qualifier_init(v))
2448                 return (0);
2449
2450         return (rtn);
2451 }
2452
2453 /* read source-name, source-name is <len> <ID> */
2454 static int
2455 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
2456 {
2457         long len;
2458         int err;
2459
2460         if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
2461             len <= 0)
2462                 return (0);
2463
2464         if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
2465                 err = DEM_PUSH_STR(ddata, "(anonymous namespace)");
2466         else
2467                 err = cpp_demangle_push_str(ddata, ddata->cur, len);
2468
2469         if (err == 0)
2470                 return (0);
2471
2472         assert(ddata->cur_output->size > 0);
2473         if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == NULL)
2474                 ddata->last_sname =
2475                     ddata->cur_output->container[ddata->output.size - 1];
2476
2477         ddata->cur += len;
2478
2479         return (1);
2480 }
2481
2482 static int
2483 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
2484 {
2485         long nth;
2486
2487         if (ddata == NULL || *ddata->cur == '\0')
2488                 return (0);
2489
2490         /* abbreviations of the form Sx */
2491         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2492         case SIMPLE_HASH('S', 'a'):
2493                 /* std::allocator */
2494                 if (!DEM_PUSH_STR(ddata, "std::allocator"))
2495                         return (0);
2496                 ddata->cur += 2;
2497                 if (*ddata->cur == 'I')
2498                         return (cpp_demangle_read_subst_stdtmpl(ddata,
2499                             "std::allocator"));
2500                 return (1);
2501
2502         case SIMPLE_HASH('S', 'b'):
2503                 /* std::basic_string */
2504                 if (!DEM_PUSH_STR(ddata, "std::basic_string"))
2505                         return (0);
2506                 ddata->cur += 2;
2507                 if (*ddata->cur == 'I')
2508                         return (cpp_demangle_read_subst_stdtmpl(ddata,
2509                             "std::basic_string"));
2510                 return (1);
2511
2512         case SIMPLE_HASH('S', 'd'):
2513                 /* std::basic_iostream<char, std::char_traits<char> > */
2514                 if (!DEM_PUSH_STR(ddata, "std::basic_iostream<char, "
2515                     "std::char_traits<char> >"))
2516                         return (0);
2517                 ddata->last_sname = "basic_iostream";
2518                 ddata->cur += 2;
2519                 if (*ddata->cur == 'I')
2520                         return (cpp_demangle_read_subst_stdtmpl(ddata,
2521                             "std::basic_iostream<char, std::char_traits"
2522                                 "<char> >"));
2523                 return (1);
2524
2525         case SIMPLE_HASH('S', 'i'):
2526                 /* std::basic_istream<char, std::char_traits<char> > */
2527                 if (!DEM_PUSH_STR(ddata, "std::basic_istream<char, "
2528                     "std::char_traits<char> >"))
2529                         return (0);
2530                 ddata->last_sname = "basic_istream";
2531                 ddata->cur += 2;
2532                 if (*ddata->cur == 'I')
2533                         return (cpp_demangle_read_subst_stdtmpl(ddata,
2534                             "std::basic_istream<char, std::char_traits"
2535                                 "<char> >"));
2536                 return (1);
2537
2538         case SIMPLE_HASH('S', 'o'):
2539                 /* std::basic_ostream<char, std::char_traits<char> > */
2540                 if (!DEM_PUSH_STR(ddata, "std::basic_ostream<char, "
2541                     "std::char_traits<char> >"))
2542                         return (0);
2543                 ddata->last_sname = "basic_ostream";
2544                 ddata->cur += 2;
2545                 if (*ddata->cur == 'I')
2546                         return (cpp_demangle_read_subst_stdtmpl(ddata,
2547                             "std::basic_ostream<char, std::char_traits"
2548                                 "<char> >"));
2549                 return (1);
2550
2551         case SIMPLE_HASH('S', 's'):
2552                 /*
2553                  * std::basic_string<char, std::char_traits<char>,
2554                  * std::allocator<char> >
2555                  *
2556                  * a.k.a std::string
2557                  */
2558                 if (!DEM_PUSH_STR(ddata, "std::basic_string<char, "
2559                     "std::char_traits<char>, std::allocator<char> >"))
2560                         return (0);
2561                 ddata->last_sname = "string";
2562                 ddata->cur += 2;
2563                 if (*ddata->cur == 'I')
2564                         return (cpp_demangle_read_subst_stdtmpl(ddata,
2565                             "std::basic_string<char, std::char_traits<char>,"
2566                                 " std::allocator<char> >"));
2567                 return (1);
2568
2569         case SIMPLE_HASH('S', 't'):
2570                 /* std:: */
2571                 return (cpp_demangle_read_subst_std(ddata));
2572         }
2573
2574         if (*(++ddata->cur) == '\0')
2575                 return (0);
2576
2577         /* Skip unknown substitution abbreviations. */
2578         if (!(*ddata->cur >= '0' && *ddata->cur <= '9') &&
2579             !(*ddata->cur >= 'A' && *ddata->cur <= 'Z') &&
2580             *ddata->cur != '_') {
2581                 ++ddata->cur;
2582                 return (1);
2583         }
2584
2585         /* substitution */
2586         if (*ddata->cur == '_')
2587                 return (cpp_demangle_get_subst(ddata, 0));
2588         else {
2589                 errno = 0;
2590                 /* substitution number is base 36 */
2591                 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2592                     errno != 0)
2593                         return (0);
2594
2595                 /* first was '_', so increase one */
2596                 ++nth;
2597
2598                 while (*ddata->cur != '_')
2599                         ++ddata->cur;
2600
2601                 assert(nth > 0);
2602
2603                 return (cpp_demangle_get_subst(ddata, nth));
2604         }
2605
2606         /* NOTREACHED */
2607         return (0);
2608 }
2609
2610 static int
2611 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
2612 {
2613         struct vector_str *output, v;
2614         size_t p_idx, subst_str_len;
2615         int rtn;
2616         char *subst_str;
2617
2618         if (ddata == NULL)
2619                 return (0);
2620
2621         if (!vector_str_init(&v))
2622                 return (0);
2623
2624         subst_str = NULL;
2625         rtn = 0;
2626         if (!DEM_PUSH_STR(ddata, "std::"))
2627                 goto clean;
2628
2629         if (!VEC_PUSH_STR(&v, "std::"))
2630                 goto clean;
2631
2632         ddata->cur += 2;
2633
2634         output = ddata->cur_output;
2635
2636         p_idx = output->size;
2637         if (!cpp_demangle_read_uqname(ddata))
2638                 goto clean;
2639
2640         if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2641             &subst_str_len)) == NULL)
2642                 goto clean;
2643
2644         if (!vector_str_push(&v, subst_str, subst_str_len))
2645                 goto clean;
2646
2647         if (!cpp_demangle_push_subst_v(ddata, &v))
2648                 goto clean;
2649
2650         if (*ddata->cur == 'I') {
2651                 p_idx = output->size;
2652                 if (!cpp_demangle_read_tmpl_args(ddata))
2653                         goto clean;
2654                 free(subst_str);
2655                 if ((subst_str = vector_str_substr(output, p_idx,
2656                     output->size - 1, &subst_str_len)) == NULL)
2657                         goto clean;
2658                 if (!vector_str_push(&v, subst_str, subst_str_len))
2659                         goto clean;
2660                 if (!cpp_demangle_push_subst_v(ddata, &v))
2661                         goto clean;
2662         }
2663
2664         rtn = 1;
2665 clean:
2666         free(subst_str);
2667         vector_str_dest(&v);
2668
2669         return (rtn);
2670 }
2671
2672 static int
2673 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2674     const char *str)
2675 {
2676         struct vector_str *output;
2677         size_t p_idx, substr_len, len;
2678         int rtn;
2679         char *subst_str, *substr;
2680
2681         if (ddata == NULL || str == NULL)
2682                 return (0);
2683
2684         if ((len = strlen(str)) == 0)
2685                 return (0);
2686
2687         output = ddata->cur_output;
2688
2689         p_idx = output->size;
2690         substr = NULL;
2691         subst_str = NULL;
2692
2693         if (!cpp_demangle_read_tmpl_args(ddata))
2694                 return (0);
2695         if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2696             &substr_len)) == NULL)
2697                 return (0);
2698
2699         rtn = 0;
2700         if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2701             NULL)
2702                 goto clean;
2703
2704         memcpy(subst_str, str, len);
2705         memcpy(subst_str + len, substr, substr_len);
2706         subst_str[substr_len + len] = '\0';
2707
2708         if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2709                 goto clean;
2710
2711         rtn = 1;
2712 clean:
2713         free(subst_str);
2714         free(substr);
2715
2716         return (rtn);
2717 }
2718
2719 static int
2720 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2721 {
2722
2723         if (ddata == NULL || *ddata->cur == '\0')
2724                 return (0);
2725
2726         switch (*ddata->cur) {
2727         case 'L':
2728                 return (cpp_demangle_read_expr_primary(ddata));
2729         case 'X':
2730                 ++ddata->cur;
2731                 if (!cpp_demangle_read_expression(ddata))
2732                         return (0);
2733                 return (*ddata->cur++ == 'E');
2734         }
2735
2736         return (cpp_demangle_read_type(ddata, NULL));
2737 }
2738
2739 static int
2740 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2741 {
2742         struct vector_str *v;
2743         size_t arg_len, idx, limit, size;
2744         char *arg;
2745
2746         if (ddata == NULL || *ddata->cur == '\0')
2747                 return (0);
2748
2749         ++ddata->cur;
2750
2751         if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL, NULL))
2752                 return (0);
2753
2754         if (!DEM_PUSH_STR(ddata, "<"))
2755                 return (0);
2756
2757         limit = 0;
2758         v = ddata->cur_output;
2759         for (;;) {
2760                 idx = v->size;
2761                 if (!cpp_demangle_read_tmpl_arg(ddata))
2762                         return (0);
2763                 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2764                     NULL)
2765                         return (0);
2766                 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2767                     !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2768                         free(arg);
2769                         return (0);
2770                 }
2771
2772                 free(arg);
2773
2774                 if (*ddata->cur == 'E') {
2775                         ++ddata->cur;
2776                         size = v->size;
2777                         assert(size > 0);
2778                         if (!strncmp(v->container[size - 1], ">", 1)) {
2779                                 if (!DEM_PUSH_STR(ddata, " >"))
2780                                         return (0);
2781                         } else if (!DEM_PUSH_STR(ddata, ">"))
2782                                 return (0);
2783                         ddata->is_tmpl = true;
2784                         break;
2785                 } else if (*ddata->cur != 'I' &&
2786                     !DEM_PUSH_STR(ddata, ", "))
2787                         return (0);
2788
2789                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2790                         return (0);
2791         }
2792
2793         return (vector_read_cmd_pop(&ddata->cmd));
2794 }
2795
2796 /*
2797  * Read template parameter that forms in 'T[number]_'.
2798  * This function much like to read_subst but only for types.
2799  */
2800 static int
2801 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2802 {
2803         long nth;
2804
2805         if (ddata == NULL || *ddata->cur != 'T')
2806                 return (0);
2807
2808         ++ddata->cur;
2809
2810         if (*ddata->cur == '_')
2811                 return (cpp_demangle_get_tmpl_param(ddata, 0));
2812         else {
2813
2814                 errno = 0;
2815                 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2816                     errno != 0)
2817                         return (0);
2818
2819                 /* T_ is first */
2820                 ++nth;
2821
2822                 while (*ddata->cur != '_')
2823                         ++ddata->cur;
2824
2825                 assert(nth > 0);
2826
2827                 return (cpp_demangle_get_tmpl_param(ddata, nth));
2828         }
2829
2830         /* NOTREACHED */
2831         return (0);
2832 }
2833
2834 static int
2835 cpp_demangle_read_type(struct cpp_demangle_data *ddata,
2836     struct type_delimit *td)
2837 {
2838         struct vector_type_qualifier v;
2839         struct vector_str *output, sv;
2840         size_t p_idx, type_str_len, subst_str_len;
2841         int extern_c, is_builtin;
2842         long len;
2843         const char *p;
2844         char *type_str, *exp_str, *num_str, *subst_str;
2845         bool skip_ref_qualifier, omit_void;
2846
2847         if (ddata == NULL)
2848                 return (0);
2849
2850         output = ddata->cur_output;
2851         if (td) {
2852                 if (td->paren == false) {
2853                         if (!DEM_PUSH_STR(ddata, "("))
2854                                 return (0);
2855                         if (ddata->output.size < 2)
2856                                 return (0);
2857                         td->paren = true;
2858                 }
2859
2860                 if (!td->firstp) {
2861                         if (*ddata->cur != 'I') {
2862                                 if (!DEM_PUSH_STR(ddata, ", "))
2863                                         return (0);
2864                         }
2865                 }
2866         }
2867
2868         assert(output != NULL);
2869         /*
2870          * [r, V, K] [P, R, O, C, G, U] builtin, function, class-enum, array
2871          * pointer-to-member, template-param, template-template-param, subst
2872          */
2873
2874         if (!vector_type_qualifier_init(&v))
2875                 return (0);
2876
2877         extern_c = 0;
2878         is_builtin = 1;
2879         p_idx = output->size;
2880         type_str = exp_str = num_str = NULL;
2881         skip_ref_qualifier = false;
2882
2883 again:
2884
2885         /* Clear ref-qualifier flag */
2886         if (*ddata->cur != 'R' && *ddata->cur != 'O' && *ddata->cur != 'E')
2887                 ddata->ref_qualifier = false;
2888
2889         /* builtin type */
2890         switch (*ddata->cur) {
2891         case 'a':
2892                 /* signed char */
2893                 if (!DEM_PUSH_STR(ddata, "signed char"))
2894                         goto clean;
2895                 ++ddata->cur;
2896                 goto rtn;
2897
2898         case 'A':
2899                 /* array type */
2900                 if (!cpp_demangle_read_array(ddata))
2901                         goto clean;
2902                 is_builtin = 0;
2903                 goto rtn;
2904
2905         case 'b':
2906                 /* bool */
2907                 if (!DEM_PUSH_STR(ddata, "bool"))
2908                         goto clean;
2909                 ++ddata->cur;
2910                 goto rtn;
2911
2912         case 'C':
2913                 /* complex pair */
2914                 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2915                         goto clean;
2916                 ++ddata->cur;
2917                 if (td)
2918                         td->firstp = false;
2919                 goto again;
2920
2921         case 'c':
2922                 /* char */
2923                 if (!DEM_PUSH_STR(ddata, "char"))
2924                         goto clean;
2925                 ++ddata->cur;
2926                 goto rtn;
2927
2928         case 'd':
2929                 /* double */
2930                 if (!DEM_PUSH_STR(ddata, "double"))
2931                         goto clean;
2932                 ++ddata->cur;
2933                 goto rtn;
2934
2935         case 'D':
2936                 ++ddata->cur;
2937                 switch (*ddata->cur) {
2938                 case 'a':
2939                         /* auto */
2940                         if (!DEM_PUSH_STR(ddata, "auto"))
2941                                 goto clean;
2942                         ++ddata->cur;
2943                         break;
2944                 case 'c':
2945                         /* decltype(auto) */
2946                         if (!DEM_PUSH_STR(ddata, "decltype(auto)"))
2947                                 goto clean;
2948                         ++ddata->cur;
2949                         break;
2950                 case 'd':
2951                         /* IEEE 754r decimal floating point (64 bits) */
2952                         if (!DEM_PUSH_STR(ddata, "decimal64"))
2953                                 goto clean;
2954                         ++ddata->cur;
2955                         break;
2956                 case 'e':
2957                         /* IEEE 754r decimal floating point (128 bits) */
2958                         if (!DEM_PUSH_STR(ddata, "decimal128"))
2959                                 goto clean;
2960                         ++ddata->cur;
2961                         break;
2962                 case 'f':
2963                         /* IEEE 754r decimal floating point (32 bits) */
2964                         if (!DEM_PUSH_STR(ddata, "decimal32"))
2965                                 goto clean;
2966                         ++ddata->cur;
2967                         break;
2968                 case 'h':
2969                         /* IEEE 754r half-precision floating point (16 bits) */
2970                         if (!DEM_PUSH_STR(ddata, "half"))
2971                                 goto clean;
2972                         ++ddata->cur;
2973                         break;
2974                 case 'i':
2975                         /* char32_t */
2976                         if (!DEM_PUSH_STR(ddata, "char32_t"))
2977                                 goto clean;
2978                         ++ddata->cur;
2979                         break;
2980                 case 'n':
2981                         /* std::nullptr_t (i.e., decltype(nullptr)) */
2982                         if (!DEM_PUSH_STR(ddata, "decltype(nullptr)"))
2983                                 goto clean;
2984                         ++ddata->cur;
2985                         break;
2986                 case 's':
2987                         /* char16_t */
2988                         if (!DEM_PUSH_STR(ddata, "char16_t"))
2989                                 goto clean;
2990                         ++ddata->cur;
2991                         break;
2992                 case 'v':
2993                         /* gcc vector_size extension. */
2994                         ++ddata->cur;
2995                         if (*ddata->cur == '_') {
2996                                 ++ddata->cur;
2997                                 if (!cpp_demangle_read_expression_flat(ddata,
2998                                     &exp_str))
2999                                         goto clean;
3000                                 if (!VEC_PUSH_STR(&v.ext_name, exp_str))
3001                                         goto clean;
3002                         } else {
3003                                 if (!cpp_demangle_read_number_as_string(ddata,
3004                                     &num_str))
3005                                         goto clean;
3006                                 if (!VEC_PUSH_STR(&v.ext_name, num_str))
3007                                         goto clean;
3008                         }
3009                         if (*ddata->cur != '_')
3010                                 goto clean;
3011                         ++ddata->cur;
3012                         if (!vector_type_qualifier_push(&v, TYPE_VEC))
3013                                 goto clean;
3014                         if (td)
3015                                 td->firstp = false;
3016                         goto again;
3017                 default:
3018                         goto clean;
3019                 }
3020                 goto rtn;
3021
3022         case 'e':
3023                 /* long double */
3024                 if (!DEM_PUSH_STR(ddata, "long double"))
3025                         goto clean;
3026                 ++ddata->cur;
3027                 goto rtn;
3028
3029         case 'E':
3030                 /* unexpected end except ref-qualifiers */
3031                 if (ddata->ref_qualifier && ddata->is_functype) {
3032                         skip_ref_qualifier = true;
3033                         /* Pop the delimiter. */
3034                         cpp_demangle_pop_str(ddata);
3035                         goto rtn;
3036                 }
3037                 goto clean;
3038
3039         case 'f':
3040                 /* float */
3041                 if (!DEM_PUSH_STR(ddata, "float"))
3042                         goto clean;
3043                 ++ddata->cur;
3044                 goto rtn;
3045
3046         case 'F':
3047                 /* function */
3048                 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
3049                         goto clean;
3050                 is_builtin = 0;
3051                 goto rtn;
3052
3053         case 'g':
3054                 /* __float128 */
3055                 if (!DEM_PUSH_STR(ddata, "__float128"))
3056                         goto clean;
3057                 ++ddata->cur;
3058                 goto rtn;
3059
3060         case 'G':
3061                 /* imaginary */
3062                 if (!vector_type_qualifier_push(&v, TYPE_IMG))
3063                         goto clean;
3064                 ++ddata->cur;
3065                 if (td)
3066                         td->firstp = false;
3067                 goto again;
3068
3069         case 'h':
3070                 /* unsigned char */
3071                 if (!DEM_PUSH_STR(ddata, "unsigned char"))
3072                         goto clean;
3073                 ++ddata->cur;
3074                 goto rtn;
3075
3076         case 'i':
3077                 /* int */
3078                 if (!DEM_PUSH_STR(ddata, "int"))
3079                         goto clean;
3080                 ++ddata->cur;
3081                 goto rtn;
3082
3083         case 'I':
3084                 /* template args. */
3085                 /* handles <substitute><template-args> */
3086                 p_idx = output->size;
3087                 if (!cpp_demangle_read_tmpl_args(ddata))
3088                         goto clean;
3089                 if ((subst_str = vector_str_substr(output, p_idx,
3090                     output->size - 1, &subst_str_len)) == NULL)
3091                         goto clean;
3092                 if (!vector_str_init(&sv)) {
3093                         free(subst_str);
3094                         goto clean;
3095                 }
3096                 if (!vector_str_push(&sv, subst_str, subst_str_len)) {
3097                         free(subst_str);
3098                         vector_str_dest(&sv);
3099                         goto clean;
3100                 }
3101                 free(subst_str);
3102                 if (!cpp_demangle_push_subst_v(ddata, &sv)) {
3103                         vector_str_dest(&sv);
3104                         goto clean;
3105                 }
3106                 vector_str_dest(&sv);
3107                 goto rtn;
3108
3109         case 'j':
3110                 /* unsigned int */
3111                 if (!DEM_PUSH_STR(ddata, "unsigned int"))
3112                         goto clean;
3113                 ++ddata->cur;
3114                 goto rtn;
3115
3116         case 'K':
3117                 /* const */
3118                 if (!vector_type_qualifier_push(&v, TYPE_CST))
3119                         goto clean;
3120                 ++ddata->cur;
3121                 if (td)
3122                         td->firstp = false;
3123                 goto again;
3124
3125         case 'l':
3126                 /* long */
3127                 if (!DEM_PUSH_STR(ddata, "long"))
3128                         goto clean;
3129                 ++ddata->cur;
3130                 goto rtn;
3131
3132         case 'm':
3133                 /* unsigned long */
3134                 if (!DEM_PUSH_STR(ddata, "unsigned long"))
3135                         goto clean;
3136
3137                 ++ddata->cur;
3138
3139                 goto rtn;
3140         case 'M':
3141                 /* pointer to member */
3142                 if (!cpp_demangle_read_pointer_to_member(ddata, &v))
3143                         goto clean;
3144                 is_builtin = 0;
3145                 goto rtn;
3146
3147         case 'n':
3148                 /* __int128 */
3149                 if (!DEM_PUSH_STR(ddata, "__int128"))
3150                         goto clean;
3151                 ++ddata->cur;
3152                 goto rtn;
3153
3154         case 'o':
3155                 /* unsigned __int128 */
3156                 if (!DEM_PUSH_STR(ddata, "unsigned __int128"))
3157                         goto clean;
3158                 ++ddata->cur;
3159                 goto rtn;
3160
3161         case 'O':
3162                 /* rvalue reference */
3163                 if (ddata->ref_qualifier)
3164                         goto clean;
3165                 if (!vector_type_qualifier_push(&v, TYPE_RREF))
3166                         goto clean;
3167                 ddata->ref_qualifier = true;
3168                 ddata->ref_qualifier_type = TYPE_RREF;
3169                 ++ddata->cur;
3170                 if (td)
3171                         td->firstp = false;
3172                 goto again;
3173
3174         case 'P':
3175                 /* pointer */
3176                 if (!vector_type_qualifier_push(&v, TYPE_PTR))
3177                         goto clean;
3178                 ++ddata->cur;
3179                 if (td)
3180                         td->firstp = false;
3181                 goto again;
3182
3183         case 'r':
3184                 /* restrict */
3185                 if (!vector_type_qualifier_push(&v, TYPE_RST))
3186                         goto clean;
3187                 ++ddata->cur;
3188                 if (td)
3189                         td->firstp = false;
3190                 goto again;
3191
3192         case 'R':
3193                 /* reference */
3194                 if (ddata->ref_qualifier)
3195                         goto clean;
3196                 if (!vector_type_qualifier_push(&v, TYPE_REF))
3197                         goto clean;
3198                 ddata->ref_qualifier = true;
3199                 ddata->ref_qualifier_type = TYPE_REF;
3200                 ++ddata->cur;
3201                 if (td)
3202                         td->firstp = false;
3203                 goto again;
3204
3205         case 's':
3206                 /* short, local string */
3207                 if (!DEM_PUSH_STR(ddata, "short"))
3208                         goto clean;
3209                 ++ddata->cur;
3210                 goto rtn;
3211
3212         case 'S':
3213                 /* substitution */
3214                 if (!cpp_demangle_read_subst(ddata))
3215                         goto clean;
3216                 is_builtin = 0;
3217                 goto rtn;
3218
3219         case 't':
3220                 /* unsigned short */
3221                 if (!DEM_PUSH_STR(ddata, "unsigned short"))
3222                         goto clean;
3223                 ++ddata->cur;
3224                 goto rtn;
3225
3226         case 'T':
3227                 /* template parameter */
3228                 if (!cpp_demangle_read_tmpl_param(ddata))
3229                         goto clean;
3230                 is_builtin = 0;
3231                 goto rtn;
3232
3233         case 'u':
3234                 /* vendor extended builtin */
3235                 ++ddata->cur;
3236                 if (!cpp_demangle_read_sname(ddata))
3237                         goto clean;
3238                 is_builtin = 0;
3239                 goto rtn;
3240
3241         case 'U':
3242                 /* vendor extended type qualifier */
3243                 ++ddata->cur;
3244                 if (!cpp_demangle_read_number(ddata, &len))
3245                         goto clean;
3246                 if (len <= 0)
3247                         goto clean;
3248                 if (!vector_str_push(&v.ext_name, ddata->cur, len))
3249                         goto clean;
3250                 ddata->cur += len;
3251                 if (!vector_type_qualifier_push(&v, TYPE_EXT))
3252                         goto clean;
3253                 if (td)
3254                         td->firstp = false;
3255                 goto again;
3256
3257         case 'v':
3258                 /* void */
3259                 omit_void = false;
3260                 if (td && td->firstp) {
3261                         /*
3262                          * peek into next bytes and see if we should omit
3263                          * the "void".
3264                          */
3265                         omit_void = true;
3266                         for (p = ddata->cur + 1; *p != '\0'; p++) {
3267                                 if (*p == 'E')
3268                                         break;
3269                                 if (*p != 'R' && *p != 'O') {
3270                                         omit_void = false;
3271                                         break;
3272                                 }
3273                         }
3274                 }
3275                 if (!omit_void && !DEM_PUSH_STR(ddata, "void"))
3276                         goto clean;
3277                 ++ddata->cur;
3278                 goto rtn;
3279
3280         case 'V':
3281                 /* volatile */
3282                 if (!vector_type_qualifier_push(&v, TYPE_VAT))
3283                         goto clean;
3284                 ++ddata->cur;
3285                 if (td)
3286                         td->firstp = false;
3287                 goto again;
3288
3289         case 'w':
3290                 /* wchar_t */
3291                 if (!DEM_PUSH_STR(ddata, "wchar_t"))
3292                         goto clean;
3293                 ++ddata->cur;
3294                 goto rtn;
3295
3296         case 'x':
3297                 /* long long */
3298                 if (!DEM_PUSH_STR(ddata, "long long"))
3299                         goto clean;
3300                 ++ddata->cur;
3301                 goto rtn;
3302
3303         case 'y':
3304                 /* unsigned long long */
3305                 if (!DEM_PUSH_STR(ddata, "unsigned long long"))
3306                         goto clean;
3307                 ++ddata->cur;
3308                 goto rtn;
3309
3310         case 'z':
3311                 /* ellipsis */
3312                 if (!DEM_PUSH_STR(ddata, "..."))
3313                         goto clean;
3314                 ++ddata->cur;
3315                 goto rtn;
3316         }
3317
3318         if (!cpp_demangle_read_name(ddata))
3319                 goto clean;
3320
3321         is_builtin = 0;
3322 rtn:
3323
3324         type_str = vector_str_substr(output, p_idx, output->size - 1,
3325             &type_str_len);
3326
3327         if (is_builtin == 0) {
3328                 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
3329                     !vector_str_push(&ddata->subst, type_str, type_str_len))
3330                         goto clean;
3331         }
3332
3333         if (!skip_ref_qualifier &&
3334             !cpp_demangle_push_type_qualifier(ddata, &v, type_str))
3335                 goto clean;
3336
3337         if (td)
3338                 td->firstp = false;
3339
3340         free(type_str);
3341         free(exp_str);
3342         free(num_str);
3343         vector_type_qualifier_dest(&v);
3344
3345         return (1);
3346 clean:
3347         free(type_str);
3348         free(exp_str);
3349         free(num_str);
3350         vector_type_qualifier_dest(&v);
3351
3352         return (0);
3353 }
3354
3355 static int
3356 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
3357 {
3358         struct vector_str *output;
3359         size_t i, p_idx, idx, type_len;
3360         char *type;
3361
3362         output = ddata->cur_output;
3363
3364         p_idx = output->size;
3365
3366         if (!cpp_demangle_read_type(ddata, NULL))
3367                 return (0);
3368
3369         if ((type = vector_str_substr(output, p_idx, output->size - 1,
3370             &type_len)) == NULL)
3371                 return (0);
3372
3373         idx = output->size;
3374         for (i = p_idx; i < idx; ++i) {
3375                 if (!vector_str_pop(output)) {
3376                         free(type);
3377                         return (0);
3378                 }
3379         }
3380
3381         *str = type;
3382
3383         return (1);
3384 }
3385
3386 /*
3387  * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
3388  * source-name
3389  */
3390 static int
3391 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
3392 {
3393         size_t len;
3394
3395         if (ddata == NULL || *ddata->cur == '\0')
3396                 return (0);
3397
3398         /* operator name */
3399         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3400         case SIMPLE_HASH('a', 'a'):
3401                 /* operator && */
3402                 if (!DEM_PUSH_STR(ddata, "operator&&"))
3403                         return (0);
3404                 ddata->cur += 2;
3405                 return (1);
3406
3407         case SIMPLE_HASH('a', 'd'):
3408                 /* operator & (unary) */
3409                 if (!DEM_PUSH_STR(ddata, "operator&"))
3410                         return (0);
3411                 ddata->cur += 2;
3412                 return (1);
3413
3414         case SIMPLE_HASH('a', 'n'):
3415                 /* operator & */
3416                 if (!DEM_PUSH_STR(ddata, "operator&"))
3417                         return (0);
3418                 ddata->cur += 2;
3419                 return (1);
3420
3421         case SIMPLE_HASH('a', 'N'):
3422                 /* operator &= */
3423                 if (!DEM_PUSH_STR(ddata, "operator&="))
3424                         return (0);
3425                 ddata->cur += 2;
3426                 return (1);
3427
3428         case SIMPLE_HASH('a', 'S'):
3429                 /* operator = */
3430                 if (!DEM_PUSH_STR(ddata, "operator="))
3431                         return (0);
3432                 ddata->cur += 2;
3433                 return (1);
3434
3435         case SIMPLE_HASH('c', 'l'):
3436                 /* operator () */
3437                 if (!DEM_PUSH_STR(ddata, "operator()"))
3438                         return (0);
3439                 ddata->cur += 2;
3440                 return (1);
3441
3442         case SIMPLE_HASH('c', 'm'):
3443                 /* operator , */
3444                 if (!DEM_PUSH_STR(ddata, "operator,"))
3445                         return (0);
3446                 ddata->cur += 2;
3447                 return (1);
3448
3449         case SIMPLE_HASH('c', 'o'):
3450                 /* operator ~ */
3451                 if (!DEM_PUSH_STR(ddata, "operator~"))
3452                         return (0);
3453                 ddata->cur += 2;
3454                 return (1);
3455
3456         case SIMPLE_HASH('c', 'v'):
3457                 /* operator (cast) */
3458                 if (!DEM_PUSH_STR(ddata, "operator(cast)"))
3459                         return (0);
3460                 ddata->cur += 2;
3461                 return (cpp_demangle_read_type(ddata, NULL));
3462
3463         case SIMPLE_HASH('d', 'a'):
3464                 /* operator delete [] */
3465                 if (!DEM_PUSH_STR(ddata, "operator delete []"))
3466                         return (0);
3467                 ddata->cur += 2;
3468                 return (1);
3469
3470         case SIMPLE_HASH('d', 'e'):
3471                 /* operator * (unary) */
3472                 if (!DEM_PUSH_STR(ddata, "operator*"))
3473                         return (0);
3474                 ddata->cur += 2;
3475                 return (1);
3476
3477         case SIMPLE_HASH('d', 'l'):
3478                 /* operator delete */
3479                 if (!DEM_PUSH_STR(ddata, "operator delete"))
3480                         return (0);
3481                 ddata->cur += 2;
3482                 return (1);
3483
3484         case SIMPLE_HASH('d', 'v'):
3485                 /* operator / */
3486                 if (!DEM_PUSH_STR(ddata, "operator/"))
3487                         return (0);
3488                 ddata->cur += 2;
3489                 return (1);
3490
3491         case SIMPLE_HASH('d', 'V'):
3492                 /* operator /= */
3493                 if (!DEM_PUSH_STR(ddata, "operator/="))
3494                         return (0);
3495                 ddata->cur += 2;
3496                 return (1);
3497
3498         case SIMPLE_HASH('e', 'o'):
3499                 /* operator ^ */
3500                 if (!DEM_PUSH_STR(ddata, "operator^"))
3501                         return (0);
3502                 ddata->cur += 2;
3503                 return (1);
3504
3505         case SIMPLE_HASH('e', 'O'):
3506                 /* operator ^= */
3507                 if (!DEM_PUSH_STR(ddata, "operator^="))
3508                         return (0);
3509                 ddata->cur += 2;
3510                 return (1);
3511
3512         case SIMPLE_HASH('e', 'q'):
3513                 /* operator == */
3514                 if (!DEM_PUSH_STR(ddata, "operator=="))
3515                         return (0);
3516                 ddata->cur += 2;
3517                 return (1);
3518
3519         case SIMPLE_HASH('g', 'e'):
3520                 /* operator >= */
3521                 if (!DEM_PUSH_STR(ddata, "operator>="))
3522                         return (0);
3523                 ddata->cur += 2;
3524                 return (1);
3525
3526         case SIMPLE_HASH('g', 't'):
3527                 /* operator > */
3528                 if (!DEM_PUSH_STR(ddata, "operator>"))
3529                         return (0);
3530                 ddata->cur += 2;
3531                 return (1);
3532
3533         case SIMPLE_HASH('i', 'x'):
3534                 /* operator [] */
3535                 if (!DEM_PUSH_STR(ddata, "operator[]"))
3536                         return (0);
3537                 ddata->cur += 2;
3538                 return (1);
3539
3540         case SIMPLE_HASH('l', 'e'):
3541                 /* operator <= */
3542                 if (!DEM_PUSH_STR(ddata, "operator<="))
3543                         return (0);
3544                 ddata->cur += 2;
3545                 return (1);
3546
3547         case SIMPLE_HASH('l', 's'):
3548                 /* operator << */
3549                 if (!DEM_PUSH_STR(ddata, "operator<<"))
3550                         return (0);
3551                 ddata->cur += 2;
3552                 return (1);
3553
3554         case SIMPLE_HASH('l', 'S'):
3555                 /* operator <<= */
3556                 if (!DEM_PUSH_STR(ddata, "operator<<="))
3557                         return (0);
3558                 ddata->cur += 2;
3559                 return (1);
3560
3561         case SIMPLE_HASH('l', 't'):
3562                 /* operator < */
3563                 if (!DEM_PUSH_STR(ddata, "operator<"))
3564                         return (0);
3565                 ddata->cur += 2;
3566                 return (1);
3567
3568         case SIMPLE_HASH('m', 'i'):
3569                 /* operator - */
3570                 if (!DEM_PUSH_STR(ddata, "operator-"))
3571                         return (0);
3572                 ddata->cur += 2;
3573                 return (1);
3574
3575         case SIMPLE_HASH('m', 'I'):
3576                 /* operator -= */
3577                 if (!DEM_PUSH_STR(ddata, "operator-="))
3578                         return (0);
3579                 ddata->cur += 2;
3580                 return (1);
3581
3582         case SIMPLE_HASH('m', 'l'):
3583                 /* operator * */
3584                 if (!DEM_PUSH_STR(ddata, "operator*"))
3585                         return (0);
3586                 ddata->cur += 2;
3587                 return (1);
3588
3589         case SIMPLE_HASH('m', 'L'):
3590                 /* operator *= */
3591                 if (!DEM_PUSH_STR(ddata, "operator*="))
3592                         return (0);
3593                 ddata->cur += 2;
3594                 return (1);
3595
3596         case SIMPLE_HASH('m', 'm'):
3597                 /* operator -- */
3598                 if (!DEM_PUSH_STR(ddata, "operator--"))
3599                         return (0);
3600                 ddata->cur += 2;
3601                 return (1);
3602
3603         case SIMPLE_HASH('n', 'a'):
3604                 /* operator new[] */
3605                 if (!DEM_PUSH_STR(ddata, "operator new []"))
3606                         return (0);
3607                 ddata->cur += 2;
3608                 return (1);
3609
3610         case SIMPLE_HASH('n', 'e'):
3611                 /* operator != */
3612                 if (!DEM_PUSH_STR(ddata, "operator!="))
3613                         return (0);
3614                 ddata->cur += 2;
3615                 return (1);
3616
3617         case SIMPLE_HASH('n', 'g'):
3618                 /* operator - (unary) */
3619                 if (!DEM_PUSH_STR(ddata, "operator-"))
3620                         return (0);
3621                 ddata->cur += 2;
3622                 return (1);
3623
3624         case SIMPLE_HASH('n', 't'):
3625                 /* operator ! */
3626                 if (!DEM_PUSH_STR(ddata, "operator!"))
3627                         return (0);
3628                 ddata->cur += 2;
3629                 return (1);
3630
3631         case SIMPLE_HASH('n', 'w'):
3632                 /* operator new */
3633                 if (!DEM_PUSH_STR(ddata, "operator new"))
3634                         return (0);
3635                 ddata->cur += 2;
3636                 return (1);
3637
3638         case SIMPLE_HASH('o', 'o'):
3639                 /* operator || */
3640                 if (!DEM_PUSH_STR(ddata, "operator||"))
3641                         return (0);
3642                 ddata->cur += 2;
3643                 return (1);
3644
3645         case SIMPLE_HASH('o', 'r'):
3646                 /* operator | */
3647                 if (!DEM_PUSH_STR(ddata, "operator|"))
3648                         return (0);
3649                 ddata->cur += 2;
3650                 return (1);
3651
3652         case SIMPLE_HASH('o', 'R'):
3653                 /* operator |= */
3654                 if (!DEM_PUSH_STR(ddata, "operator|="))
3655                         return (0);
3656                 ddata->cur += 2;
3657                 return (1);
3658
3659         case SIMPLE_HASH('p', 'l'):
3660                 /* operator + */
3661                 if (!DEM_PUSH_STR(ddata, "operator+"))
3662                         return (0);
3663                 ddata->cur += 2;
3664                 return (1);
3665
3666         case SIMPLE_HASH('p', 'L'):
3667                 /* operator += */
3668                 if (!DEM_PUSH_STR(ddata, "operator+="))
3669                         return (0);
3670                 ddata->cur += 2;
3671                 return (1);
3672
3673         case SIMPLE_HASH('p', 'm'):
3674                 /* operator ->* */
3675                 if (!DEM_PUSH_STR(ddata, "operator->*"))
3676                         return (0);
3677                 ddata->cur += 2;
3678                 return (1);
3679
3680         case SIMPLE_HASH('p', 'p'):
3681                 /* operator ++ */
3682                 if (!DEM_PUSH_STR(ddata, "operator++"))
3683                         return (0);
3684                 ddata->cur += 2;
3685                 return (1);
3686
3687         case SIMPLE_HASH('p', 's'):
3688                 /* operator + (unary) */
3689                 if (!DEM_PUSH_STR(ddata, "operator+"))
3690                         return (0);
3691                 ddata->cur += 2;
3692                 return (1);
3693
3694         case SIMPLE_HASH('p', 't'):
3695                 /* operator -> */
3696                 if (!DEM_PUSH_STR(ddata, "operator->"))
3697                         return (0);
3698                 ddata->cur += 2;
3699                 return (1);
3700
3701         case SIMPLE_HASH('q', 'u'):
3702                 /* operator ? */
3703                 if (!DEM_PUSH_STR(ddata, "operator?"))
3704                         return (0);
3705                 ddata->cur += 2;
3706                 return (1);
3707
3708         case SIMPLE_HASH('r', 'm'):
3709                 /* operator % */
3710                 if (!DEM_PUSH_STR(ddata, "operator%"))
3711                         return (0);
3712                 ddata->cur += 2;
3713                 return (1);
3714
3715         case SIMPLE_HASH('r', 'M'):
3716                 /* operator %= */
3717                 if (!DEM_PUSH_STR(ddata, "operator%="))
3718                         return (0);
3719                 ddata->cur += 2;
3720                 return (1);
3721
3722         case SIMPLE_HASH('r', 's'):
3723                 /* operator >> */
3724                 if (!DEM_PUSH_STR(ddata, "operator>>"))
3725                         return (0);
3726                 ddata->cur += 2;
3727                 return (1);
3728
3729         case SIMPLE_HASH('r', 'S'):
3730                 /* operator >>= */
3731                 if (!DEM_PUSH_STR(ddata, "operator>>="))
3732                         return (0);
3733                 ddata->cur += 2;
3734                 return (1);
3735
3736         case SIMPLE_HASH('r', 'z'):
3737                 /* operator sizeof */
3738                 if (!DEM_PUSH_STR(ddata, "operator sizeof "))
3739                         return (0);
3740                 ddata->cur += 2;
3741                 return (1);
3742
3743         case SIMPLE_HASH('s', 'r'):
3744                 /* scope resolution operator */
3745                 if (!DEM_PUSH_STR(ddata, "scope resolution operator "))
3746                         return (0);
3747                 ddata->cur += 2;
3748                 return (1);
3749
3750         case SIMPLE_HASH('s', 'v'):
3751                 /* operator sizeof */
3752                 if (!DEM_PUSH_STR(ddata, "operator sizeof "))
3753                         return (0);
3754                 ddata->cur += 2;
3755                 return (1);
3756         }
3757
3758         /* vendor extened operator */
3759         if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3760                 if (!DEM_PUSH_STR(ddata, "vendor extened operator "))
3761                         return (0);
3762                 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3763                         return (0);
3764                 ddata->cur += 2;
3765                 return (cpp_demangle_read_sname(ddata));
3766         }
3767
3768         /* ctor-dtor-name */
3769         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3770         case SIMPLE_HASH('C', '1'):
3771         case SIMPLE_HASH('C', '2'):
3772         case SIMPLE_HASH('C', '3'):
3773                 if (ddata->last_sname == NULL)
3774                         return (0);
3775                 if ((len = strlen(ddata->last_sname)) == 0)
3776                         return (0);
3777                 if (!DEM_PUSH_STR(ddata, "::"))
3778                         return (0);
3779                 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3780                         return (0);
3781                 ddata->cur +=2;
3782                 return (1);
3783
3784         case SIMPLE_HASH('D', '0'):
3785         case SIMPLE_HASH('D', '1'):
3786         case SIMPLE_HASH('D', '2'):
3787                 if (ddata->last_sname == NULL)
3788                         return (0);
3789                 if ((len = strlen(ddata->last_sname)) == 0)
3790                         return (0);
3791                 if (!DEM_PUSH_STR(ddata, "::~"))
3792                         return (0);
3793                 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3794                         return (0);
3795                 ddata->cur +=2;
3796                 return (1);
3797         }
3798
3799         /* source name */
3800         if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3801                 return (cpp_demangle_read_sname(ddata));
3802
3803         /* local source name */
3804         if (*ddata->cur == 'L')
3805                 return (cpp_demangle_local_source_name(ddata));
3806
3807         return (1);
3808 }
3809
3810 /*
3811  * Read local source name.
3812  *
3813  * References:
3814  *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3815  *   http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3816  */
3817 static int
3818 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3819 {
3820         /* L */
3821         if (ddata == NULL || *ddata->cur != 'L')
3822                 return (0);
3823         ++ddata->cur;
3824
3825         /* source name */
3826         if (!cpp_demangle_read_sname(ddata))
3827                 return (0);
3828
3829         /* discriminator */
3830         if (*ddata->cur == '_') {
3831                 ++ddata->cur;
3832                 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3833                         ++ddata->cur;
3834         }
3835
3836         return (1);
3837 }
3838
3839 static int
3840 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3841 {
3842
3843         if (ddata == NULL)
3844                 return (0);
3845
3846         if (!DEM_PUSH_STR(ddata, "offset : "))
3847                 return (0);
3848
3849         if (!cpp_demangle_read_offset_number(ddata))
3850                 return (0);
3851
3852         if (!DEM_PUSH_STR(ddata, "virtual offset : "))
3853                 return (0);
3854
3855         return (!cpp_demangle_read_offset_number(ddata));
3856 }
3857
3858 /*
3859  * Decode floating point representation to string
3860  * Return new allocated string or NULL
3861  *
3862  * Todo
3863  * Replace these functions to macro.
3864  */
3865 static char *
3866 decode_fp_to_double(const char *p, size_t len)
3867 {
3868         double f;
3869         size_t rtn_len, limit, i;
3870         int byte;
3871         char *rtn;
3872
3873         if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3874                 return (NULL);
3875
3876         memset(&f, 0, sizeof(double));
3877
3878         for (i = 0; i < len / 2; ++i) {
3879                 byte = hex_to_dec(p[len - i * 2 - 1]) +
3880                     hex_to_dec(p[len - i * 2 - 2]) * 16;
3881
3882                 if (byte < 0 || byte > 255)
3883                         return (NULL);
3884
3885 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3886                 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3887 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3888                 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3889                     (unsigned char)(byte);
3890 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3891         }
3892
3893         rtn_len = 64;
3894         limit = 0;
3895 again:
3896         if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3897                 return (NULL);
3898
3899         if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3900                 free(rtn);
3901                 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3902                         return (NULL);
3903                 rtn_len *= BUFFER_GROWFACTOR;
3904                 goto again;
3905         }
3906
3907         return rtn;
3908 }
3909
3910 static char *
3911 decode_fp_to_float(const char *p, size_t len)
3912 {
3913         size_t i, rtn_len, limit;
3914         float f;
3915         int byte;
3916         char *rtn;
3917
3918         if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3919                 return (NULL);
3920
3921         memset(&f, 0, sizeof(float));
3922
3923         for (i = 0; i < len / 2; ++i) {
3924                 byte = hex_to_dec(p[len - i * 2 - 1]) +
3925                     hex_to_dec(p[len - i * 2 - 2]) * 16;
3926                 if (byte < 0 || byte > 255)
3927                         return (NULL);
3928 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3929                 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3930 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3931                 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3932                     (unsigned char)(byte);
3933 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3934         }
3935
3936         rtn_len = 64;
3937         limit = 0;
3938 again:
3939         if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3940                 return (NULL);
3941
3942         if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3943                 free(rtn);
3944                 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3945                         return (NULL);
3946                 rtn_len *= BUFFER_GROWFACTOR;
3947                 goto again;
3948         }
3949
3950         return rtn;
3951 }
3952
3953 static char *
3954 decode_fp_to_float128(const char *p, size_t len)
3955 {
3956         long double f;
3957         size_t rtn_len, limit, i;
3958         int byte;
3959         unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3960         char *rtn;
3961
3962         switch(sizeof(long double)) {
3963         case FLOAT_QUADRUPLE_BYTES:
3964                 return (decode_fp_to_long_double(p, len));
3965         case FLOAT_EXTENED_BYTES:
3966                 if (p == NULL || len == 0 || len % 2 != 0 ||
3967                     len / 2 > FLOAT_QUADRUPLE_BYTES)
3968                         return (NULL);
3969
3970                 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3971
3972                 for (i = 0; i < len / 2; ++i) {
3973                         byte = hex_to_dec(p[len - i * 2 - 1]) +
3974                             hex_to_dec(p[len - i * 2 - 2]) * 16;
3975                         if (byte < 0 || byte > 255)
3976                                 return (NULL);
3977 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3978                         buf[i] = (unsigned char)(byte);
3979 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3980                         buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3981                             (unsigned char)(byte);
3982 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3983                 }
3984                 memset(&f, 0, FLOAT_EXTENED_BYTES);
3985
3986 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3987                 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3988 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3989                 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3990 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3991
3992                 rtn_len = 256;
3993                 limit = 0;
3994 again:
3995                 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3996                         return (NULL);
3997
3998                 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3999                         free(rtn);
4000                         if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
4001                                 return (NULL);
4002                         rtn_len *= BUFFER_GROWFACTOR;
4003                         goto again;
4004                 }
4005
4006                 return (rtn);
4007         default:
4008                 return (NULL);
4009         }
4010 }
4011
4012 static char *
4013 decode_fp_to_float80(const char *p, size_t len)
4014 {
4015         long double f;
4016         size_t rtn_len, limit, i;
4017         int byte;
4018         unsigned char buf[FLOAT_EXTENED_BYTES];
4019         char *rtn;
4020
4021         switch(sizeof(long double)) {
4022         case FLOAT_QUADRUPLE_BYTES:
4023                 if (p == NULL || len == 0 || len % 2 != 0 ||
4024                     len / 2 > FLOAT_EXTENED_BYTES)
4025                         return (NULL);
4026
4027                 memset(buf, 0, FLOAT_EXTENED_BYTES);
4028
4029                 for (i = 0; i < len / 2; ++i) {
4030                         byte = hex_to_dec(p[len - i * 2 - 1]) +
4031                             hex_to_dec(p[len - i * 2 - 2]) * 16;
4032
4033                         if (byte < 0 || byte > 255)
4034                                 return (NULL);
4035
4036 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
4037                         buf[i] = (unsigned char)(byte);
4038 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4039                         buf[FLOAT_EXTENED_BYTES - i -1] =
4040                             (unsigned char)(byte);
4041 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4042                 }
4043
4044                 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
4045
4046 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
4047                 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
4048 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4049                 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
4050 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4051
4052                 rtn_len = 256;
4053                 limit = 0;
4054 again:
4055                 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
4056                         return (NULL);
4057
4058                 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
4059                         free(rtn);
4060                         if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
4061                                 return (NULL);
4062                         rtn_len *= BUFFER_GROWFACTOR;
4063                         goto again;
4064                 }
4065
4066                 return (rtn);
4067         case FLOAT_EXTENED_BYTES:
4068                 return (decode_fp_to_long_double(p, len));
4069         default:
4070                 return (NULL);
4071         }
4072 }
4073
4074 static char *
4075 decode_fp_to_long_double(const char *p, size_t len)
4076 {
4077         long double f;
4078         size_t rtn_len, limit, i;
4079         int byte;
4080         char *rtn;
4081
4082         if (p == NULL || len == 0 || len % 2 != 0 ||
4083             len / 2 > sizeof(long double))
4084                 return (NULL);
4085
4086         memset(&f, 0, sizeof(long double));
4087
4088         for (i = 0; i < len / 2; ++i) {
4089                 byte = hex_to_dec(p[len - i * 2 - 1]) +
4090                     hex_to_dec(p[len - i * 2 - 2]) * 16;
4091
4092                 if (byte < 0 || byte > 255)
4093                         return (NULL);
4094
4095 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
4096                 ((unsigned char *)&f)[i] = (unsigned char)(byte);
4097 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4098                 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
4099                     (unsigned char)(byte);
4100 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4101         }
4102
4103         rtn_len = 256;
4104         limit = 0;
4105 again:
4106         if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
4107                 return (NULL);
4108
4109         if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
4110                 free(rtn);
4111                 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
4112                         return (NULL);
4113                 rtn_len *= BUFFER_GROWFACTOR;
4114                 goto again;
4115         }
4116
4117         return (rtn);
4118 }
4119
4120 /* Simple hex to integer function used by decode_to_* function. */
4121 static int
4122 hex_to_dec(char c)
4123 {
4124
4125         switch (c) {
4126         case '0':
4127                 return (0);
4128         case '1':
4129                 return (1);
4130         case '2':
4131                 return (2);
4132         case '3':
4133                 return (3);
4134         case '4':
4135                 return (4);
4136         case '5':
4137                 return (5);
4138         case '6':
4139                 return (6);
4140         case '7':
4141                 return (7);
4142         case '8':
4143                 return (8);
4144         case '9':
4145                 return (9);
4146         case 'a':
4147                 return (10);
4148         case 'b':
4149                 return (11);
4150         case 'c':
4151                 return (12);
4152         case 'd':
4153                 return (13);
4154         case 'e':
4155                 return (14);
4156         case 'f':
4157                 return (15);
4158         default:
4159                 return (-1);
4160         }
4161 }
4162
4163 /**
4164  * @brief Test input string is mangled by IA-64 C++ ABI style.
4165  *
4166  * Test string heads with "_Z" or "_GLOBAL__I_".
4167  * @return Return 0 at false.
4168  */
4169 bool
4170 is_cpp_mangled_gnu3(const char *org)
4171 {
4172         size_t len;
4173
4174         len = strlen(org);
4175         return ((len > 2 && *org == '_' && *(org + 1) == 'Z') ||
4176             (len > 11 && !strncmp(org, "_GLOBAL__I_", 11)));
4177 }
4178
4179 static void
4180 vector_read_cmd_dest(struct vector_read_cmd *v)
4181 {
4182
4183         if (v == NULL)
4184                 return;
4185
4186         free(v->r_container);
4187 }
4188
4189 static struct read_cmd_item *
4190 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
4191 {
4192         int i;
4193
4194         if (v == NULL || dst == READ_FAIL)
4195                 return (NULL);
4196
4197         for (i = (int) v->size - 1; i >= 0; i--)
4198                 if (v->r_container[i].cmd == dst)
4199                         return (&v->r_container[i]);
4200
4201         return (NULL);
4202 }
4203
4204 static int
4205 vector_read_cmd_init(struct vector_read_cmd *v)
4206 {
4207
4208         if (v == NULL)
4209                 return (0);
4210
4211         v->size = 0;
4212         v->capacity = VECTOR_DEF_CAPACITY;
4213
4214         if ((v->r_container = malloc(sizeof(*v->r_container) * v->capacity))
4215             == NULL)
4216                 return (0);
4217
4218         return (1);
4219 }
4220
4221 static int
4222 vector_read_cmd_pop(struct vector_read_cmd *v)
4223 {
4224
4225         if (v == NULL || v->size == 0)
4226                 return (0);
4227
4228         --v->size;
4229         v->r_container[v->size].cmd = READ_FAIL;
4230         v->r_container[v->size].data = NULL;
4231
4232         return (1);
4233 }
4234
4235 static int
4236 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd, void *data)
4237 {
4238         struct read_cmd_item *tmp_r_ctn;
4239         size_t tmp_cap;
4240         size_t i;
4241
4242         if (v == NULL)
4243                 return (0);
4244
4245         if (v->size == v->capacity) {
4246                 tmp_cap = BUFFER_GROW(v->capacity);
4247                 if ((tmp_r_ctn = malloc(sizeof(*tmp_r_ctn) * tmp_cap)) == NULL)
4248                         return (0);
4249                 for (i = 0; i < v->size; ++i)
4250                         tmp_r_ctn[i] = v->r_container[i];
4251                 free(v->r_container);
4252                 v->r_container = tmp_r_ctn;
4253                 v->capacity = tmp_cap;
4254         }
4255
4256         v->r_container[v->size].cmd = cmd;
4257         v->r_container[v->size].data = data;
4258         ++v->size;
4259
4260         return (1);
4261 }
4262
4263 static void
4264 vector_type_qualifier_dest(struct vector_type_qualifier *v)
4265 {
4266
4267         if (v == NULL)
4268                 return;
4269
4270         free(v->q_container);
4271         vector_str_dest(&v->ext_name);
4272 }
4273
4274 /* size, capacity, ext_name */
4275 static int
4276 vector_type_qualifier_init(struct vector_type_qualifier *v)
4277 {
4278
4279         if (v == NULL)
4280                 return (0);
4281
4282         v->size = 0;
4283         v->capacity = VECTOR_DEF_CAPACITY;
4284
4285         if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
4286             == NULL)
4287                 return (0);
4288
4289         assert(v->q_container != NULL);
4290
4291         if (!vector_str_init(&v->ext_name)) {
4292                 free(v->q_container);
4293                 return (0);
4294         }
4295
4296         return (1);
4297 }
4298
4299 static int
4300 vector_type_qualifier_push(struct vector_type_qualifier *v,
4301     enum type_qualifier t)
4302 {
4303         enum type_qualifier *tmp_ctn;
4304         size_t tmp_cap;
4305         size_t i;
4306
4307         if (v == NULL)
4308                 return (0);
4309
4310         if (v->size == v->capacity) {
4311                 tmp_cap = BUFFER_GROW(v->capacity);
4312                 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
4313                     == NULL)
4314                         return (0);
4315                 for (i = 0; i < v->size; ++i)
4316                         tmp_ctn[i] = v->q_container[i];
4317                 free(v->q_container);
4318                 v->q_container = tmp_ctn;
4319                 v->capacity = tmp_cap;
4320         }
4321
4322         v->q_container[v->size] = t;
4323         ++v->size;
4324
4325         return (1);
4326 }