contrib/libcxxrt/libelftc_dem_gnu3.c

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