Lines Matching defs:ddata
410 static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
462 struct cpp_demangle_data ddata;
481 if (!cpp_demangle_data_init(&ddata, org))
483 if (!cpp_demangle_read_type(&ddata, 0))
485 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
490 if (!cpp_demangle_data_init(&ddata, org + 2))
495 if (!cpp_demangle_read_encoding(&ddata))
499 while (*ddata.cur != '\0') {
503 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
505 if (!cpp_demangle_read_type(&ddata, 1))
511 if (ddata.output.size == 0)
513 if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
515 if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
517 if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
519 if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9))
522 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
525 cpp_demangle_data_dest(&ddata);
598 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
606 if (ddata == NULL || decoder == NULL)
609 fp = ddata->cur;
610 while (*ddata->cur != 'E')
611 ++ddata->cur;
613 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
618 rtn = cpp_demangle_push_str(ddata, f, len);
622 ++ddata->cur;
628 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
632 if (ddata == NULL || str == NULL || len == 0)
635 if (ddata->push_head > 0)
636 return (vector_str_push(&ddata->output_tmp, str, len));
638 return (vector_str_push(&ddata->output, str, len));
642 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
646 if (ddata == NULL || str == NULL || len == 0)
649 if (!vector_str_find(&ddata->subst, str, len))
650 return (vector_str_push(&ddata->subst, str, len));
656 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
662 if (ddata == NULL || v == NULL)
668 rtn = cpp_demangle_push_subst(ddata, str, str_len);
676 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
684 if (ddata == NULL || v == NULL)
702 if (!cpp_demangle_push_str(ddata, "*", 1))
707 if (!cpp_demangle_push_subst_v(ddata,
714 if (!cpp_demangle_push_str(ddata, "&", 1))
719 if (!cpp_demangle_push_subst_v(ddata,
726 if (!cpp_demangle_push_str(ddata, " complex", 8))
731 if (!cpp_demangle_push_subst_v(ddata,
738 if (!cpp_demangle_push_str(ddata, " imaginary", 10))
744 if (!cpp_demangle_push_subst_v(ddata,
762 if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) {
773 if (!cpp_demangle_push_subst_v(ddata,
784 if (!cpp_demangle_push_str(ddata, " restrict", 9))
789 if (!cpp_demangle_push_subst_v(ddata,
796 if (!cpp_demangle_push_str(ddata, " volatile", 9))
801 if (!cpp_demangle_push_subst_v(ddata,
808 if (!cpp_demangle_push_str(ddata, " const", 6))
813 if (!cpp_demangle_push_subst_v(ddata,
830 if (!cpp_demangle_push_str(ddata, buf, e_len + 11)) {
840 if (!cpp_demangle_push_subst_v(ddata,
862 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
866 if (ddata == NULL || ddata->subst.size <= idx)
868 if ((len = strlen(ddata->subst.container[idx])) == 0)
870 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
874 ++ddata->cur;
880 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
884 if (ddata == NULL || ddata->tmpl.size <= idx)
886 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
888 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
891 ++ddata->cur;
897 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
903 if (ddata == NULL || *(++ddata->cur) == '\0')
906 if (*ddata->cur == '_') {
907 if (*(++ddata->cur) == '\0')
910 if (!cpp_demangle_read_type(ddata, 0))
913 if (!cpp_demangle_push_str(ddata, "[]", 2))
916 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
917 num = ddata->cur;
918 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
919 ++ddata->cur;
920 if (*ddata->cur != '_')
922 num_len = ddata->cur - num;
924 if (*(++ddata->cur) == '\0')
926 if (!cpp_demangle_read_type(ddata, 0))
928 if (!cpp_demangle_push_str(ddata, "[", 1))
930 if (!cpp_demangle_push_str(ddata, num, num_len))
932 if (!cpp_demangle_push_str(ddata, "]", 1))
935 p_idx = ddata->output.size;
936 if (!cpp_demangle_read_expression(ddata))
938 if ((exp = vector_str_substr(&ddata->output, p_idx,
939 ddata->output.size - 1, &exp_len)) == NULL)
941 idx = ddata->output.size;
943 if (!vector_str_pop(&ddata->output)) {
947 if (*ddata->cur != '_') {
951 ++ddata->cur;
952 if (*ddata->cur == '\0') {
956 if (!cpp_demangle_read_type(ddata, 0)) {
960 if (!cpp_demangle_push_str(ddata, "[", 1)) {
964 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
968 if (!cpp_demangle_push_str(ddata, "]", 1)) {
980 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
984 if (ddata == NULL || *(++ddata->cur) == '\0')
987 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
988 ddata->cur += 2;
989 if (*ddata->cur == '\0')
991 if (!cpp_demangle_read_encoding(ddata))
993 ++ddata->cur;
997 switch (*ddata->cur) {
999 if (*(ddata->cur + 2) != 'E')
1001 switch (*(++ddata->cur)) {
1003 ddata->cur += 2;
1004 return (cpp_demangle_push_str(ddata, "false", 5));
1006 ddata->cur += 2;
1007 return (cpp_demangle_push_str(ddata, "true", 4));
1013 ++ddata->cur;
1014 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
1017 ++ddata->cur;
1019 return (cpp_demangle_push_fp(ddata,
1021 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
1024 ++ddata->cur;
1025 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
1028 ++ddata->cur;
1030 return (cpp_demangle_push_fp(ddata,
1032 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
1043 if (*(++ddata->cur) == 'n') {
1044 if (!cpp_demangle_push_str(ddata, "-", 1))
1046 ++ddata->cur;
1048 num = ddata->cur;
1049 while (*ddata->cur != 'E') {
1050 if (!ELFTC_ISDIGIT(*ddata->cur))
1052 ++ddata->cur;
1054 ++ddata->cur;
1055 return (cpp_demangle_push_str(ddata, num,
1056 ddata->cur - num - 1));
1064 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
1067 if (ddata == NULL || *ddata->cur == '\0')
1070 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1072 ddata->cur += 2;
1073 return (cpp_demangle_read_type(ddata, 0));
1076 ddata->cur += 2;
1077 if (!cpp_demangle_read_type(ddata, 0))
1079 if (!cpp_demangle_read_uqname(ddata))
1081 if (*ddata->cur == 'I')
1082 return (cpp_demangle_read_tmpl_args(ddata));
1087 ddata->cur += 2;
1088 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
1092 ddata->cur += 2;
1093 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
1097 ddata->cur += 2;
1098 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
1102 ddata->cur += 2;
1103 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
1107 ddata->cur += 2;
1108 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
1112 ddata->cur += 2;
1113 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
1117 ddata->cur += 2;
1118 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
1122 ddata->cur += 2;
1123 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
1127 ddata->cur += 2;
1128 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
1132 ddata->cur += 2;
1133 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
1137 ddata->cur += 2;
1138 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
1142 ddata->cur += 2;
1143 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
1147 ddata->cur += 2;
1148 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
1152 ddata->cur += 2;
1153 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
1157 ddata->cur += 2;
1158 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
1162 ddata->cur += 2;
1163 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
1167 ddata->cur += 2;
1168 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
1172 ddata->cur += 2;
1173 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
1177 ddata->cur += 2;
1178 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
1182 ddata->cur += 2;
1183 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
1187 ddata->cur += 2;
1188 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
1192 ddata->cur += 2;
1193 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
1197 ddata->cur += 2;
1198 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
1202 ddata->cur += 2;
1203 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
1207 ddata->cur += 2;
1208 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
1212 ddata->cur += 2;
1213 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
1217 ddata->cur += 2;
1218 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
1222 ddata->cur += 2;
1223 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
1227 ddata->cur += 2;
1228 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
1232 ddata->cur += 2;
1233 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
1237 ddata->cur += 2;
1238 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
1242 ddata->cur += 2;
1243 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
1247 ddata->cur += 2;
1248 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
1252 ddata->cur += 2;
1253 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
1257 ddata->cur += 2;
1258 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
1262 ddata->cur += 2;
1263 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
1267 ddata->cur += 2;
1268 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
1272 ddata->cur += 2;
1273 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
1277 ddata->cur += 2;
1278 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
1282 ddata->cur += 2;
1283 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
1287 ddata->cur += 2;
1288 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
1292 ddata->cur += 2;
1293 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1297 ddata->cur += 2;
1298 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1302 ddata->cur += 2;
1303 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1308 ddata->cur += 2;
1309 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1313 ddata->cur += 2;
1314 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1318 ddata->cur += 2;
1319 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1323 ddata->cur += 2;
1324 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1328 ddata->cur += 2;
1329 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1333 ddata->cur += 2;
1334 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1337 switch (*ddata->cur) {
1339 return (cpp_demangle_read_expr_primary(ddata));
1341 return (cpp_demangle_read_tmpl_param(ddata));
1348 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1354 output = ddata->push_head > 0 ? &ddata->output_tmp :
1355 &ddata->output;
1359 if (!cpp_demangle_read_expression(ddata))
1380 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1384 if (ddata == NULL || name == NULL || len == 0)
1386 if (!cpp_demangle_read_expression(ddata))
1388 if (!cpp_demangle_push_str(ddata, name, len))
1391 return (cpp_demangle_read_expression(ddata));
1395 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1399 if (ddata == NULL || name == NULL || len == 0)
1401 if (!cpp_demangle_read_expression(ddata))
1404 return (cpp_demangle_push_str(ddata, name, len));
1408 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1412 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1416 if (!cpp_demangle_read_expression(ddata))
1418 if (!cpp_demangle_push_str(ddata, name1, len1))
1420 if (!cpp_demangle_read_expression(ddata))
1422 if (!cpp_demangle_push_str(ddata, name2, len2))
1425 return (cpp_demangle_read_expression(ddata));
1429 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1435 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1438 ++ddata->cur;
1439 if (*ddata->cur == 'Y') {
1442 ++ddata->cur;
1444 if (!cpp_demangle_read_type(ddata, 0))
1446 if (*ddata->cur != 'E') {
1447 if (!cpp_demangle_push_str(ddata, "(", 1))
1449 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) {
1450 if ((class_type_size = ddata->class_type.size) == 0)
1453 ddata->class_type.container[class_type_size - 1];
1458 if (!cpp_demangle_push_str(ddata, class_type,
1461 if (!cpp_demangle_push_str(ddata, "::*", 3))
1463 ++ddata->func_type;
1465 if (!cpp_demangle_push_type_qualifier(ddata, v,
1473 if (!cpp_demangle_push_str(ddata, ")(", 2))
1478 if (!cpp_demangle_read_type(ddata, 0))
1480 if (*ddata->cur == 'E')
1486 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) {
1487 if (!cpp_demangle_push_type_qualifier(ddata, v,
1495 if (!cpp_demangle_push_str(ddata, ")", 1))
1499 ++ddata->cur;
1506 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1512 if (ddata == NULL || *ddata->cur == '\0')
1516 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1518 if (!cpp_demangle_push_str(ddata, "hidden alias for ", 17))
1520 ddata->cur += 2;
1521 if (*ddata->cur == '\0')
1523 return (cpp_demangle_read_encoding(ddata));
1526 if (!cpp_demangle_push_str(ddata, "reference temporary #", 21))
1528 ddata->cur += 2;
1529 if (*ddata->cur == '\0')
1531 if (!cpp_demangle_read_name_flat(ddata, &name))
1534 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1536 if (!cpp_demangle_push_str(ddata, num_str, strlen(num_str)))
1538 if (!cpp_demangle_push_str(ddata, " for ", 5))
1540 if (!cpp_demangle_push_str(ddata, name, strlen(name)))
1550 ddata->cur += 2;
1551 if (*ddata->cur == '\0')
1553 switch (*ddata->cur) {
1555 if (!cpp_demangle_push_str(ddata,
1560 if (!cpp_demangle_push_str(ddata,
1564 ++ddata->cur;
1565 return (cpp_demangle_read_encoding(ddata));
1569 if (!cpp_demangle_push_str(ddata, "guard variable for ", 20))
1571 ddata->cur += 2;
1576 if (!cpp_demangle_push_str(ddata,
1579 ddata->cur += 2;
1580 if (*ddata->cur == '\0')
1582 if (!cpp_demangle_read_offset(ddata))
1584 if (!cpp_demangle_read_offset(ddata))
1586 return (cpp_demangle_read_encoding(ddata));
1590 if (!cpp_demangle_push_str(ddata, "construction vtable for ",
1593 ddata->cur += 2;
1594 if (*ddata->cur == '\0')
1596 if (!cpp_demangle_read_type_flat(ddata, &type))
1599 if (!cpp_demangle_read_number(ddata, &offset))
1601 if (*ddata->cur++ != '_')
1603 if (!cpp_demangle_read_type(ddata, 0))
1605 if (!cpp_demangle_push_str(ddata, "-in-", 4))
1607 if (!cpp_demangle_push_str(ddata, type, strlen(type)))
1620 if (!cpp_demangle_push_str(ddata, "typeinfo fn for ", 16))
1622 ddata->cur += 2;
1623 if (*ddata->cur == '\0')
1625 return (cpp_demangle_read_type(ddata, 0));
1629 if (!cpp_demangle_push_str(ddata,
1632 ddata->cur += 2;
1633 if (*ddata->cur == '\0')
1635 if (!cpp_demangle_read_nv_offset(ddata))
1637 return (cpp_demangle_read_encoding(ddata));
1641 if (!cpp_demangle_push_str(ddata, "TLS init function for ",
1644 ddata->cur += 2;
1645 if (*ddata->cur == '\0')
1651 if (!cpp_demangle_push_str(ddata, "typeinfo for ", 13))
1653 ddata->cur += 2;
1654 if (*ddata->cur == '\0')
1656 return (cpp_demangle_read_type(ddata, 0));
1660 if (!cpp_demangle_push_str(ddata, "java Class for ", 15))
1662 ddata->cur += 2;
1663 if (*ddata->cur == '\0')
1665 return (cpp_demangle_read_type(ddata, 0));
1669 if (!cpp_demangle_push_str(ddata, "typeinfo name for ", 18))
1671 ddata->cur += 2;
1672 if (*ddata->cur == '\0')
1674 return (cpp_demangle_read_type(ddata, 0));
1678 if (!cpp_demangle_push_str(ddata, "VTT for ", 8))
1680 ddata->cur += 2;
1681 if (*ddata->cur == '\0')
1683 return (cpp_demangle_read_type(ddata, 0));
1687 if (!cpp_demangle_push_str(ddata,
1690 ddata->cur += 2;
1691 if (*ddata->cur == '\0')
1693 if (!cpp_demangle_read_v_offset(ddata))
1695 return (cpp_demangle_read_encoding(ddata));
1699 if (!cpp_demangle_push_str(ddata, "vtable for ", 12))
1701 ddata->cur += 2;
1702 if (*ddata->cur == '\0')
1704 return (cpp_demangle_read_type(ddata, 0));
1708 if (!cpp_demangle_push_str(ddata, "TLS wrapper function for ",
1711 ddata->cur += 2;
1712 if (*ddata->cur == '\0')
1717 return (cpp_demangle_read_name(ddata));
1721 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1725 if (ddata == NULL)
1727 if (*(++ddata->cur) == '\0')
1729 if (!cpp_demangle_read_encoding(ddata))
1734 if (!cpp_demangle_read_type(ddata, 1))
1736 if (*ddata->cur == 'E')
1741 if (*(++ddata->cur) == '\0')
1743 if (ddata->paren == true) {
1744 if (!cpp_demangle_push_str(ddata, ")", 1))
1746 ddata->paren = false;
1748 if (*ddata->cur == 's')
1749 ++ddata->cur;
1751 if (!cpp_demangle_push_str(ddata, "::", 2))
1753 if (!cpp_demangle_read_name(ddata))
1756 if (*ddata->cur == '_') {
1757 ++ddata->cur;
1758 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1759 ++ddata->cur;
1766 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1773 if (ddata == NULL || *ddata->cur == '\0')
1776 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1780 switch (*ddata->cur) {
1782 return (cpp_demangle_read_subst(ddata));
1784 return (cpp_demangle_read_nested_name(ddata));
1786 return (cpp_demangle_read_local_name(ddata));
1794 if (!cpp_demangle_read_uqname(ddata))
1805 if (!cpp_demangle_push_subst_v(ddata, &v))
1808 if (*ddata->cur == 'I') {
1810 if (!cpp_demangle_read_tmpl_args(ddata))
1818 if (!cpp_demangle_push_subst_v(ddata, &v))
1832 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
1838 output = ddata->push_head > 0 ? &ddata->output_tmp :
1839 &ddata->output;
1843 if (!cpp_demangle_read_name(ddata))
1864 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1871 if (ddata == NULL || *ddata->cur != 'N')
1873 if (*(++ddata->cur) == '\0')
1876 while (*ddata->cur == 'r' || *ddata->cur == 'V' ||
1877 *ddata->cur == 'K') {
1878 switch (*ddata->cur) {
1880 ddata->mem_rst = true;
1883 ddata->mem_vat = true;
1886 ddata->mem_cst = true;
1889 ++ddata->cur;
1892 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1900 switch (*ddata->cur) {
1902 if (!cpp_demangle_read_tmpl_args(ddata))
1906 if (!cpp_demangle_read_subst(ddata))
1910 if (!cpp_demangle_read_tmpl_param(ddata))
1914 if (!cpp_demangle_read_uqname(ddata))
1927 if (!cpp_demangle_push_subst_v(ddata, &v))
1929 if (*ddata->cur == 'E')
1931 else if (*ddata->cur != 'I' &&
1932 *ddata->cur != 'C' && *ddata->cur != 'D') {
1933 if (!cpp_demangle_push_str(ddata, "::", 2))
1942 ++ddata->cur;
1956 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1960 if (ddata == NULL || rtn == NULL)
1964 if (*ddata->cur == 'n') {
1967 ++ddata->cur;
1969 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1973 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1977 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1978 ++ddata->cur;
1989 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
1993 if (!cpp_demangle_read_number(ddata, &n)) {
2007 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
2010 if (ddata == NULL)
2013 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
2016 return (cpp_demangle_read_offset_number(ddata));
2021 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
2024 if (ddata == NULL)
2027 if (*ddata->cur == 'h') {
2028 ++ddata->cur;
2029 return (cpp_demangle_read_nv_offset(ddata));
2030 } else if (*ddata->cur == 'v') {
2031 ++ddata->cur;
2032 return (cpp_demangle_read_v_offset(ddata));
2039 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
2044 if (ddata == NULL || *ddata->cur == '\0')
2048 if (*ddata->cur == 'n') {
2050 start = ddata->cur + 1;
2053 start = ddata->cur;
2056 while (*ddata->cur != '_')
2057 ++ddata->cur;
2059 if (negative && !cpp_demangle_push_str(ddata, "-", 1))
2064 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
2066 if (!cpp_demangle_push_str(ddata, " ", 1))
2069 ++ddata->cur;
2075 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata)
2081 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
2084 p_idx = ddata->output.size;
2085 if (!cpp_demangle_read_type(ddata, 0))
2088 if ((class_type = vector_str_substr(&ddata->output, p_idx,
2089 ddata->output.size - 1, &class_type_len)) == NULL)
2093 idx = ddata->output.size;
2095 if (!vector_str_pop(&ddata->output))
2098 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM))
2101 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
2104 p_func_type = ddata->func_type;
2105 if (!cpp_demangle_read_type(ddata, 0))
2108 if (p_func_type == ddata->func_type) {
2109 if (!cpp_demangle_push_str(ddata, " ", 1))
2111 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
2113 if (!cpp_demangle_push_str(ddata, "::*", 3))
2119 if (!vector_str_pop(&ddata->class_type))
2122 if (!vector_read_cmd_pop(&ddata->cmd))
2132 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
2137 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
2141 if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
2142 err = cpp_demangle_push_str(ddata, "(anonymous namespace)", 21);
2144 err = cpp_demangle_push_str(ddata, ddata->cur, len);
2149 assert(ddata->output.size > 0);
2150 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0)
2151 ddata->last_sname =
2152 ddata->output.container[ddata->output.size - 1];
2154 ddata->cur += len;
2160 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
2164 if (ddata == NULL || *ddata->cur == '\0')
2168 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2171 if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0)
2173 ddata->cur += 2;
2174 if (*ddata->cur == 'I')
2175 return (cpp_demangle_read_subst_stdtmpl(ddata,
2181 if (!cpp_demangle_push_str(ddata, "std::basic_string", 17))
2183 ddata->cur += 2;
2184 if (*ddata->cur == 'I')
2185 return (cpp_demangle_read_subst_stdtmpl(ddata,
2191 if (!cpp_demangle_push_str(ddata, "std::iostream", 19))
2193 ddata->last_sname = "iostream";
2194 ddata->cur += 2;
2195 if (*ddata->cur == 'I')
2196 return (cpp_demangle_read_subst_stdtmpl(ddata,
2202 if (!cpp_demangle_push_str(ddata, "std::istream", 18))
2204 ddata->last_sname = "istream";
2205 ddata->cur += 2;
2206 if (*ddata->cur == 'I')
2207 return (cpp_demangle_read_subst_stdtmpl(ddata,
2213 if (!cpp_demangle_push_str(ddata, "std::ostream", 18))
2215 ddata->last_sname = "istream";
2216 ddata->cur += 2;
2217 if (*ddata->cur == 'I')
2218 return (cpp_demangle_read_subst_stdtmpl(ddata,
2229 if (!cpp_demangle_push_str(ddata, "std::string", 11))
2231 ddata->last_sname = "string";
2232 ddata->cur += 2;
2233 if (*ddata->cur == 'I')
2234 return (cpp_demangle_read_subst_stdtmpl(ddata,
2240 return (cpp_demangle_read_subst_std(ddata));
2243 if (*(++ddata->cur) == '\0')
2247 if (*ddata->cur == '_')
2248 return (cpp_demangle_get_subst(ddata, 0));
2252 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2259 while (*ddata->cur != '_')
2260 ++ddata->cur;
2264 return (cpp_demangle_get_subst(ddata, nth));
2272 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
2279 if (ddata == NULL)
2287 if (!cpp_demangle_push_str(ddata, "std::", 5))
2293 ddata->cur += 2;
2295 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2298 if (!cpp_demangle_read_uqname(ddata))
2308 if (!cpp_demangle_push_subst_v(ddata, &v))
2311 if (*ddata->cur == 'I') {
2313 if (!cpp_demangle_read_tmpl_args(ddata))
2321 if (!cpp_demangle_push_subst_v(ddata, &v))
2334 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2342 if (ddata == NULL || str == NULL || len == 0)
2345 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2351 if (!cpp_demangle_read_tmpl_args(ddata))
2366 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2378 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2381 if (ddata == NULL || *ddata->cur == '\0')
2384 switch (*ddata->cur) {
2386 return (cpp_demangle_read_expr_primary(ddata));
2388 return (cpp_demangle_read_expression(ddata));
2391 return (cpp_demangle_read_type(ddata, 0));
2395 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2401 if (ddata == NULL || *ddata->cur == '\0')
2404 ++ddata->cur;
2406 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL))
2409 if (!cpp_demangle_push_str(ddata, "<", 1))
2413 v = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2416 if (!cpp_demangle_read_tmpl_arg(ddata))
2421 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2422 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2429 if (*ddata->cur == 'E') {
2430 ++ddata->cur;
2434 if (!cpp_demangle_push_str(ddata, " >", 2))
2436 } else if (!cpp_demangle_push_str(ddata, ">", 1))
2439 } else if (*ddata->cur != 'I' &&
2440 !cpp_demangle_push_str(ddata, ", ", 2))
2447 return (vector_read_cmd_pop(&ddata->cmd));
2455 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2459 if (ddata == NULL || *ddata->cur != 'T')
2462 ++ddata->cur;
2464 if (*ddata->cur == '_')
2465 return (cpp_demangle_get_tmpl_param(ddata, 0));
2469 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2476 while (*ddata->cur != '_')
2477 ++ddata->cur;
2481 return (cpp_demangle_get_tmpl_param(ddata, nth));
2489 cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit)
2498 if (ddata == NULL)
2501 output = &ddata->output;
2502 if (ddata->output.size > 0 && !strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) {
2503 ddata->push_head++;
2504 output = &ddata->output_tmp;
2506 if (ddata->paren == false) {
2507 if (!cpp_demangle_push_str(ddata, "(", 1))
2509 if (ddata->output.size < 2)
2511 ddata->paren = true;
2512 ddata->pfirst = true;
2514 if (ddata->subst.size == 1 &&
2515 !vector_str_pop(&ddata->subst))
2519 if (ddata->pfirst)
2520 ddata->pfirst = false;
2521 else if (*ddata->cur != 'I' &&
2522 !cpp_demangle_push_str(ddata, ", ", 2))
2541 switch (*ddata->cur) {
2544 if (!cpp_demangle_push_str(ddata, "signed char", 11))
2546 ++ddata->cur;
2551 if (!cpp_demangle_read_array(ddata))
2558 if (!cpp_demangle_push_str(ddata, "bool", 4))
2560 ++ddata->cur;
2567 ++ddata->cur;
2572 if (!cpp_demangle_push_str(ddata, "char", 4))
2574 ++ddata->cur;
2579 if (!cpp_demangle_push_str(ddata, "double", 6))
2581 ++ddata->cur;
2585 ++ddata->cur;
2586 switch (*ddata->cur) {
2589 if (!cpp_demangle_push_str(ddata, "decimal64", 9))
2591 ++ddata->cur;
2595 if (!cpp_demangle_push_str(ddata, "decimal128", 10))
2597 ++ddata->cur;
2601 if (!cpp_demangle_push_str(ddata, "decimal32", 9))
2603 ++ddata->cur;
2607 if (!cpp_demangle_push_str(ddata, "half", 4))
2609 ++ddata->cur;
2613 if (!cpp_demangle_push_str(ddata, "char32_t", 8))
2615 ++ddata->cur;
2619 if (!cpp_demangle_push_str(ddata, "decltype(nullptr)",
2622 ++ddata->cur;
2626 if (!cpp_demangle_push_str(ddata, "char16_t", 8))
2628 ++ddata->cur;
2632 ++ddata->cur;
2633 if (*ddata->cur == '_') {
2634 ++ddata->cur;
2635 if (!cpp_demangle_read_expression_flat(ddata,
2642 if (!cpp_demangle_read_number_as_string(ddata,
2649 if (*ddata->cur != '_')
2651 ++ddata->cur;
2662 if (!cpp_demangle_push_str(ddata, "long double", 11))
2664 ++ddata->cur;
2669 if (!cpp_demangle_push_str(ddata, "float", 5))
2671 ++ddata->cur;
2676 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2683 if (!cpp_demangle_push_str(ddata, "__float128", 10))
2685 ++ddata->cur;
2692 ++ddata->cur;
2697 if (!cpp_demangle_push_str(ddata, "unsigned char", 13))
2699 ++ddata->cur;
2704 if (!cpp_demangle_push_str(ddata, "int", 3))
2706 ++ddata->cur;
2711 if (!cpp_demangle_push_str(ddata, "unsigned int", 12))
2713 ++ddata->cur;
2720 ++ddata->cur;
2725 if (!cpp_demangle_push_str(ddata, "long", 4))
2727 ++ddata->cur;
2732 if (!cpp_demangle_push_str(ddata, "unsigned long", 13))
2735 ++ddata->cur;
2740 if (!cpp_demangle_read_pointer_to_member(ddata))
2747 if (!cpp_demangle_push_str(ddata, "__int128", 8))
2749 ++ddata->cur;
2754 if (!cpp_demangle_push_str(ddata, "unsigned __int128", 17))
2756 ++ddata->cur;
2763 ++ddata->cur;
2770 ++ddata->cur;
2777 ++ddata->cur;
2782 if (!cpp_demangle_push_str(ddata, "short", 5))
2784 ++ddata->cur;
2789 if (!cpp_demangle_read_subst(ddata))
2796 if (!cpp_demangle_push_str(ddata, "unsigned short", 14))
2798 ++ddata->cur;
2803 if (!cpp_demangle_read_tmpl_param(ddata))
2810 ++ddata->cur;
2811 if (!cpp_demangle_read_sname(ddata))
2818 if (!cpp_demangle_read_number(ddata, &len))
2822 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2824 ddata->cur += len;
2831 if (!cpp_demangle_push_str(ddata, "void", 4))
2833 ++ddata->cur;
2840 ++ddata->cur;
2845 if (!cpp_demangle_push_str(ddata, "wchar_t", 7))
2847 ++ddata->cur;
2852 if (!cpp_demangle_push_str(ddata, "long long", 9))
2854 ++ddata->cur;
2859 if (!cpp_demangle_push_str(ddata, "unsigned long long", 18))
2861 ++ddata->cur;
2866 if (!cpp_demangle_push_str(ddata, "ellipsis", 8))
2868 ++ddata->cur;
2872 if (!cpp_demangle_read_name(ddata))
2882 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2883 !vector_str_push(&ddata->subst, type_str, type_str_len))
2887 if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str))
2895 if (ddata->push_head > 0) {
2896 if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata)
2900 if (--ddata->push_head > 0)
2903 if (!vector_str_push(&ddata->output_tmp, " ", 1))
2906 if (!vector_str_push_vector_head(&ddata->output,
2907 &ddata->output_tmp))
2910 vector_str_dest(&ddata->output_tmp);
2911 if (!vector_str_init(&ddata->output_tmp))
2914 if (!cpp_demangle_push_str(ddata, "(", 1))
2917 ddata->paren = true;
2918 ddata->pfirst = true;
2932 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
2938 output = ddata->push_head > 0 ? &ddata->output_tmp :
2939 &ddata->output;
2943 if (!cpp_demangle_read_type(ddata, 0))
2968 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
2972 if (ddata == NULL || *ddata->cur == '\0')
2976 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2979 if (!cpp_demangle_push_str(ddata, "operator&&", 10))
2981 ddata->cur += 2;
2986 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2988 ddata->cur += 2;
2993 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2995 ddata->cur += 2;
3000 if (!cpp_demangle_push_str(ddata, "operator&=", 10))
3002 ddata->cur += 2;
3007 if (!cpp_demangle_push_str(ddata, "operator=", 9))
3009 ddata->cur += 2;
3014 if (!cpp_demangle_push_str(ddata, "operator()", 10))
3016 ddata->cur += 2;
3021 if (!cpp_demangle_push_str(ddata, "operator,", 9))
3023 ddata->cur += 2;
3028 if (!cpp_demangle_push_str(ddata, "operator~", 9))
3030 ddata->cur += 2;
3035 if (!cpp_demangle_push_str(ddata, "operator(cast)", 14))
3037 ddata->cur += 2;
3038 return (cpp_demangle_read_type(ddata, 1));
3042 if (!cpp_demangle_push_str(ddata, "operator delete []", 18))
3044 ddata->cur += 2;
3049 if (!cpp_demangle_push_str(ddata, "operator*", 9))
3051 ddata->cur += 2;
3056 if (!cpp_demangle_push_str(ddata, "operator delete", 15))
3058 ddata->cur += 2;
3063 if (!cpp_demangle_push_str(ddata, "operator/", 9))
3065 ddata->cur += 2;
3070 if (!cpp_demangle_push_str(ddata, "operator/=", 10))
3072 ddata->cur += 2;
3077 if (!cpp_demangle_push_str(ddata, "operator^", 9))
3079 ddata->cur += 2;
3084 if (!cpp_demangle_push_str(ddata, "operator^=", 10))
3086 ddata->cur += 2;
3091 if (!cpp_demangle_push_str(ddata, "operator==", 10))
3093 ddata->cur += 2;
3098 if (!cpp_demangle_push_str(ddata, "operator>=", 10))
3100 ddata->cur += 2;
3105 if (!cpp_demangle_push_str(ddata, "operator>", 9))
3107 ddata->cur += 2;
3112 if (!cpp_demangle_push_str(ddata, "operator[]", 10))
3114 ddata->cur += 2;
3119 if (!cpp_demangle_push_str(ddata, "operator<=", 10))
3121 ddata->cur += 2;
3126 if (!cpp_demangle_push_str(ddata, "operator<<", 10))
3128 ddata->cur += 2;
3133 if (!cpp_demangle_push_str(ddata, "operator<<=", 11))
3135 ddata->cur += 2;
3140 if (!cpp_demangle_push_str(ddata, "operator<", 9))
3142 ddata->cur += 2;
3147 if (!cpp_demangle_push_str(ddata, "operator-", 9))
3149 ddata->cur += 2;
3154 if (!cpp_demangle_push_str(ddata, "operator-=", 10))
3156 ddata->cur += 2;
3161 if (!cpp_demangle_push_str(ddata, "operator*", 9))
3163 ddata->cur += 2;
3168 if (!cpp_demangle_push_str(ddata, "operator*=", 10))
3170 ddata->cur += 2;
3175 if (!cpp_demangle_push_str(ddata, "operator--", 10))
3177 ddata->cur += 2;
3182 if (!cpp_demangle_push_str(ddata, "operator new []", 15))
3184 ddata->cur += 2;
3189 if (!cpp_demangle_push_str(ddata, "operator!=", 10))
3191 ddata->cur += 2;
3196 if (!cpp_demangle_push_str(ddata, "operator-", 9))
3198 ddata->cur += 2;
3203 if (!cpp_demangle_push_str(ddata, "operator!", 9))
3205 ddata->cur += 2;
3210 if (!cpp_demangle_push_str(ddata, "operator new", 12))
3212 ddata->cur += 2;
3217 if (!cpp_demangle_push_str(ddata, "operator||", 10))
3219 ddata->cur += 2;
3224 if (!cpp_demangle_push_str(ddata, "operator|", 9))
3226 ddata->cur += 2;
3231 if (!cpp_demangle_push_str(ddata, "operator|=", 10))
3233 ddata->cur += 2;
3238 if (!cpp_demangle_push_str(ddata, "operator+", 9))
3240 ddata->cur += 2;
3245 if (!cpp_demangle_push_str(ddata, "operator+=", 10))
3247 ddata->cur += 2;
3252 if (!cpp_demangle_push_str(ddata, "operator->*", 11))
3254 ddata->cur += 2;
3259 if (!cpp_demangle_push_str(ddata, "operator++", 10))
3261 ddata->cur += 2;
3266 if (!cpp_demangle_push_str(ddata, "operator+", 9))
3268 ddata->cur += 2;
3273 if (!cpp_demangle_push_str(ddata, "operator->", 10))
3275 ddata->cur += 2;
3280 if (!cpp_demangle_push_str(ddata, "operator?", 9))
3282 ddata->cur += 2;
3287 if (!cpp_demangle_push_str(ddata, "operator%", 9))
3289 ddata->cur += 2;
3294 if (!cpp_demangle_push_str(ddata, "operator%=", 10))
3296 ddata->cur += 2;
3301 if (!cpp_demangle_push_str(ddata, "operator>>", 10))
3303 ddata->cur += 2;
3308 if (!cpp_demangle_push_str(ddata, "operator>>=", 11))
3310 ddata->cur += 2;
3315 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3317 ddata->cur += 2;
3322 if (!cpp_demangle_push_str(ddata, "scope resolution operator ",
3325 ddata->cur += 2;
3330 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3332 ddata->cur += 2;
3337 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3338 if (!cpp_demangle_push_str(ddata, "vendor extened operator ",
3341 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3343 ddata->cur += 2;
3344 return (cpp_demangle_read_sname(ddata));
3348 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3354 if (ddata->last_sname == NULL)
3356 if ((len = strlen(ddata->last_sname)) == 0)
3358 if (!cpp_demangle_push_str(ddata, "::", 2))
3360 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3362 ddata->cur +=2;
3370 if (ddata->last_sname == NULL)
3372 if ((len = strlen(ddata->last_sname)) == 0)
3374 if (!cpp_demangle_push_str(ddata, "::~", 3))
3376 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3378 ddata->cur +=2;
3383 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3384 return (cpp_demangle_read_sname(ddata));
3387 if (*ddata->cur == 'L')
3388 return (cpp_demangle_local_source_name(ddata));
3401 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3404 if (ddata == NULL || *ddata->cur != 'L')
3406 ++ddata->cur;
3409 if (!cpp_demangle_read_sname(ddata))
3413 if (*ddata->cur == '_') {
3414 ++ddata->cur;
3415 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3416 ++ddata->cur;
3423 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3426 if (ddata == NULL)
3429 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
3432 if (!cpp_demangle_read_offset_number(ddata))
3435 if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17))
3438 return (!cpp_demangle_read_offset_number(ddata));