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