Lines Matching defs:mangled
531 consume_count_with_underscores (const char **mangled)
535 if (**mangled == '_')
537 (*mangled)++;
538 if (!ISDIGIT ((unsigned char)**mangled))
541 idx = consume_count (mangled);
542 if (**mangled != '_')
546 (*mangled)++;
550 if (**mangled < '0' || **mangled > '9')
553 idx = **mangled - '0';
554 (*mangled)++;
762 /* Takes operator name as e.g. "++" and returns mangled
817 /* char *cplus_demangle (const char *mangled, int options)
819 If MANGLED is a mangled function name produced by GNU C++, then
846 cplus_demangle (const char *mangled, int options)
852 return xstrdup (mangled);
862 ret = cplus_demangle_v3 (mangled, work->options);
869 ret = java_demangle_v3 (mangled);
875 return ada_demangle(mangled,options);
877 ret = internal_cplus_demangle (work, mangled);
908 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
919 if (strncmp (mangled, "_ada_", 5) == 0)
921 mangled += 5;
925 if (mangled[0] == '_' || mangled[0] == '<')
928 p = strstr (mangled, "___");
930 len0 = strlen (mangled);
935 len0 = p - mangled;
947 if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
948 for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
950 if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
955 else if (mangled[i] == '$')
962 for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
964 demangled[j] = mangled[i];
968 if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
976 demangled[j] = mangled[i];
993 &demangled_size, strlen (mangled) + 3,
996 if (mangled[0] == '<')
997 strcpy (demangled, mangled);
999 sprintf (demangled, "<%s>", mangled);
1011 internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1026 if ((mangled != NULL) && (*mangled != '\0'))
1034 is a "__" string in the mangled string. Consider "_$_5__foo" for
1039 success = gnu_special (work, &mangled, &decl);
1043 success = demangle_prefix (work, &mangled, &decl);
1045 if (success && (*mangled != '\0'))
1047 success = demangle_signature (work, &mangled, &decl);
1200 /* Clear out any mangled storage */
1228 demangle_signature -- demangle the signature part of a mangled name
1233 demangle_signature (struct work_stuff *work, const char **mangled,
1238 Consume and demangle the signature portion of the mangled name.
1241 entry it contains the demangled root name from the mangled name
1245 *MANGLED points to the current unconsumed location in the mangled
1250 Demangling GNU style mangled names is nasty because there is no
1256 const char **mangled, string *declp)
1266 while (success && (**mangled != '\0'))
1268 switch (**mangled)
1271 oldmangled = *mangled;
1272 success = demangle_qualified (work, mangled, declp, 1, 0);
1274 remember_type (work, oldmangled, *mangled - oldmangled);
1281 oldmangled = *mangled;
1282 success = demangle_qualified (work, mangled, declp, 1, 0);
1294 oldmangled = *mangled;
1296 (*mangled)++;
1303 work->type_quals |= code_for_qualifier (**mangled);
1307 oldmangled = *mangled;
1308 (*mangled)++;
1315 while (**mangled && (**mangled != '_'))
1316 (*mangled)++;
1317 if (!**mangled)
1320 (*mangled)++;
1330 oldmangled = *mangled;
1333 success = demangle_class (work, mangled, declp);
1336 remember_type (work, oldmangled, *mangled - oldmangled);
1342 if (**mangled != 'F')
1351 success = do_type (work, mangled, &s);
1372 (*mangled)++;
1383 success = demangle_args (work, mangled, declp);
1387 if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1389 ++(*mangled);
1391 success = do_type (work, mangled, &tname);
1403 oldmangled = *mangled;
1405 success = demangle_template (work, mangled, &tname,
1409 remember_type (work, oldmangled, *mangled - oldmangled);
1437 (*mangled)++;
1438 success = do_type (work, mangled, &return_type);
1448 a mangled name that is either bogus, or has been mangled by
1456 (*mangled)++;
1457 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1458 (*mangled)++;
1468 success = demangle_template (work, mangled, declp, 0, 0,
1472 (*mangled)++;
1485 success = demangle_args (work, mangled, declp);
1508 success = demangle_args (work, mangled, declp);
1526 success = demangle_args (work, mangled, declp);
1546 demangle_method_args (struct work_stuff *work, const char **mangled,
1553 string_append (declp, *mangled + 1);
1554 *mangled += strlen (*mangled);
1559 success = demangle_args (work, mangled, declp);
1568 const char **mangled, string *tname)
1578 if (get_count (mangled, &r))
1588 if (**mangled == 'Z')
1590 (*mangled)++;
1594 else if (**mangled == 'z')
1596 (*mangled)++;
1598 demangle_template_template_parm (work, mangled, tname);
1607 success = do_type (work, mangled, &temp);
1629 demangle_expression (struct work_stuff *work, const char **mangled,
1637 (*mangled)++;
1638 while (success && **mangled != 'W' && **mangled != '\0')
1647 len = strlen (*mangled);
1654 && memcmp (optable[i].in, *mangled, l) == 0)
1660 (*mangled) += l;
1671 success = demangle_template_value_parm (work, mangled, s, tk);
1674 if (**mangled != 'W')
1679 (*mangled)++;
1687 const char **mangled, string *s)
1691 if (**mangled == 'E')
1692 success = demangle_expression (work, mangled, s, tk_integral);
1693 else if (**mangled == 'Q' || **mangled == 'K')
1694 success = demangle_qualified (work, mangled, s, 0, 1);
1706 if (**mangled == '_')
1708 if (mangled[0][1] == 'm')
1716 (*mangled) += 2;
1729 if (**mangled == 'm')
1732 (*mangled)++;
1749 value = consume_count (mangled);
1751 value = consume_count_with_underscores (mangled);
1768 && **mangled == '_')
1769 (*mangled)++;
1783 const char **mangled, string *s)
1785 if (**mangled == 'E')
1786 return demangle_expression (work, mangled, s, tk_real);
1788 if (**mangled == 'm')
1791 (*mangled)++;
1793 while (ISDIGIT ((unsigned char)**mangled))
1795 string_appendn (s, *mangled, 1);
1796 (*mangled)++;
1798 if (**mangled == '.') /* fraction */
1801 (*mangled)++;
1802 while (ISDIGIT ((unsigned char)**mangled))
1804 string_appendn (s, *mangled, 1);
1805 (*mangled)++;
1808 if (**mangled == 'e') /* exponent */
1811 (*mangled)++;
1812 while (ISDIGIT ((unsigned char)**mangled))
1814 string_appendn (s, *mangled, 1);
1815 (*mangled)++;
1823 demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1828 if (**mangled == 'Y')
1833 (*mangled)++;
1834 idx = consume_count_with_underscores (mangled);
1837 || consume_count_with_underscores (mangled) == -1)
1845 success = demangle_integral_value (work, mangled, s);
1850 if (**mangled == 'm')
1853 (*mangled)++;
1856 val = consume_count(mangled);
1869 int val = consume_count (mangled);
1878 success = demangle_real_value (work, mangled, s);
1881 if (**mangled == 'Q')
1882 success = demangle_qualified (work, mangled, s,
1887 int symbol_len = consume_count (mangled);
1895 strncpy (p, *mangled, symbol_len);
1899 mangled here does not make use of any of the squangling
1901 mangled independently. */
1916 *mangled += symbol_len;
1932 demangle_template (struct work_stuff *work, const char **mangled,
1943 (*mangled)++;
1947 if (**mangled == 'z')
1950 (*mangled)++;
1951 (*mangled)++;
1953 idx = consume_count_with_underscores (mangled);
1956 || consume_count_with_underscores (mangled) == -1)
1974 if ((r = consume_count (mangled)) <= 0
1975 || (int) strlen (*mangled) < r)
1980 && strncmp (*mangled, "JArray1Z", 8) == 0;
1983 string_appendn (tname, *mangled, r);
1986 string_appendn (trawname, *mangled, r);
1987 *mangled += r;
1993 if (!get_count (mangled, &r))
2012 if (**mangled == 'Z')
2014 (*mangled)++;
2016 success = do_type (work, mangled, &temp);
2037 else if (**mangled == 'z')
2040 (*mangled)++;
2041 success = demangle_template_template_parm (work, mangled, tname);
2044 && (r2 = consume_count (mangled)) > 0
2045 && (int) strlen (*mangled) >= r2)
2048 string_appendn (tname, *mangled, r2);
2054 memcpy (work->tmpl_argvec[i], *mangled, len);
2057 *mangled += r2;
2072 success = do_type (work, mangled, &temp);
2085 success = demangle_template_value_parm (work, mangled, s,
2129 string_append (declp, *mangled + 1);
2130 *mangled += strlen (*mangled);
2135 success = demangle_args (work, mangled, declp);
2143 arm_pt (struct work_stuff *work, const char *mangled,
2148 if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2155 if (*args + len == mangled + n && **args == '_')
2163 if ((*anchor = strstr (mangled, "__tm__"))
2164 || (*anchor = strstr (mangled, "__ps__"))
2165 || (*anchor = strstr (mangled, "__pt__")))
2172 if (*args + len == mangled + n && **args == '_')
2178 else if ((*anchor = strstr (mangled, "__S")))
2185 if (*args + len == mangled + n && **args == '_')
2197 demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2202 const char *e = *mangled + n;
2207 if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2214 start_spec_args = strchr (*mangled, '<');
2215 if (start_spec_args && (start_spec_args - *mangled < n))
2216 string_appendn (declp, *mangled, start_spec_args - *mangled);
2218 string_appendn (declp, *mangled, n);
2219 (*mangled) += n + 1;
2233 switch (**mangled)
2237 (*mangled)++;
2238 if (!do_type (work, mangled, &arg))
2245 if (!do_hpacc_template_const_value (work, mangled, &arg))
2251 if (!do_hpacc_template_literal (work, mangled, &arg))
2265 if ((**mangled == '\000') || (**mangled == '_'))
2273 if (**mangled == '_')
2274 (*mangled)++;
2279 else if (arm_pt (work, *mangled, n, &p, &args))
2285 string_appendn (declp, *mangled, p - *mangled);
2353 else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2354 && (*mangled)[9] == 'N'
2355 && (*mangled)[8] == (*mangled)[10]
2356 && strchr (cplus_markers, (*mangled)[8]))
2365 string_appendn (declp, *mangled, n);
2367 *mangled += n;
2371 mangled string; qualifiers, local class indicators, etc. have
2375 demangle_class_name (struct work_stuff *work, const char **mangled,
2381 n = consume_count (mangled);
2384 if ((int) strlen (*mangled) >= n)
2386 demangle_arm_hp_template (work, mangled, n, declp);
2397 demangle_class -- demangle a mangled class sequence
2402 demangle_class (struct work_stuff *work, const char **mangled,
2410 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2411 On exit, it points to the next token after the mangled class on
2429 demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2438 if (demangle_class_name (work, mangled, &class_name))
2471 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2477 one; *mangled will be consumed so caller will not make further calls to
2481 iterate_demangle_function (struct work_stuff *work, const char **mangled,
2484 const char *mangle_init = *mangled;
2497 demangle_function_name (work, mangled, declp, scan);
2510 occurrence, since "__" most often occur between independent mangled
2516 demangle_function_name (work, mangled, declp, scan);
2517 success = demangle_signature (work, mangled, declp);
2522 *mangled = mangle_init;
2551 demangle_prefix -- consume the mangled name prefix and find signature
2556 demangle_prefix (struct work_stuff *work, const char **mangled,
2561 Consume and demangle the prefix of the mangled name.
2570 MANGLED points to the current pointer into the mangled name. As each
2571 token of the mangled name is consumed, it is updated. Upon entry
2572 the current mangled name pointer points to the first character of
2573 the mangled name. Upon exit, it should point to the first character
2581 demangle_prefix (struct work_stuff *work, const char **mangled,
2588 if (strlen(*mangled) > 6
2589 && (strncmp(*mangled, "_imp__", 6) == 0
2590 || strncmp(*mangled, "__imp_", 6) == 0))
2595 (*mangled) += 6;
2598 else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2600 char *marker = strchr (cplus_markers, (*mangled)[8]);
2601 if (marker != NULL && *marker == (*mangled)[10])
2603 if ((*mangled)[9] == 'D')
2606 (*mangled) += 11;
2608 if (gnu_special (work, mangled, declp))
2611 else if ((*mangled)[9] == 'I')
2614 (*mangled) += 11;
2616 if (gnu_special (work, mangled, declp))
2621 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2624 (*mangled) += 7;
2627 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2630 (*mangled) += 7;
2636 scan = strstr (*mangled, "__"); */
2639 scan = *mangled;
2670 else if ((scan == *mangled)
2680 *mangled = scan + 2;
2681 consume_count (mangled);
2682 string_append (declp, *mangled);
2683 *mangled += strlen (*mangled);
2694 *mangled = scan + 2;
2703 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2713 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2715 else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2722 || (arm_special (mangled, declp) == 0))
2735 return iterate_demangle_function (work, mangled, declp, scan);
2744 return iterate_demangle_function (work, mangled, declp, scan);
2748 /* Doesn't look like a mangled name */
2754 string_append (declp, *mangled);
2755 *mangled += strlen (*mangled);
2765 gnu_special -- special handling of gnu mangled strings
2770 gnu_special (struct work_stuff *work, const char **mangled,
2790 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2796 if ((*mangled)[0] == '_'
2797 && strchr (cplus_markers, (*mangled)[1]) != NULL
2798 && (*mangled)[2] == '_')
2801 (*mangled) += 3;
2804 else if ((*mangled)[0] == '_'
2805 && (((*mangled)[1] == '_'
2806 && (*mangled)[2] == 'v'
2807 && (*mangled)[3] == 't'
2808 && (*mangled)[4] == '_')
2809 || ((*mangled)[1] == 'v'
2810 && (*mangled)[2] == 't'
2811 && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2814 and create the decl. Note that we consume the entire mangled
2817 if ((*mangled)[2] == 'v')
2818 (*mangled) += 5; /* New style, with thunks: "__vt_" */
2820 (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2821 while (**mangled != '\0')
2823 switch (**mangled)
2827 success = demangle_qualified (work, mangled, declp, 0, 1);
2830 success = demangle_template (work, mangled, declp, 0, 1,
2834 if (ISDIGIT((unsigned char)*mangled[0]))
2836 n = consume_count(mangled);
2841 if (n > (int) strlen (*mangled))
2849 n = strcspn (*mangled, cplus_markers);
2851 string_appendn (declp, *mangled, n);
2852 (*mangled) += n;
2855 p = strpbrk (*mangled, cplus_markers);
2856 if (success && ((p == NULL) || (p == *mangled)))
2861 (*mangled)++;
2873 else if ((*mangled)[0] == '_'
2874 && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
2875 && (p = strpbrk (*mangled, cplus_markers)) != NULL)
2878 (*mangled)++;
2879 switch (**mangled)
2883 success = demangle_qualified (work, mangled, declp, 0, 1);
2886 success = demangle_template (work, mangled, declp, 0, 1, 1);
2889 n = consume_count (mangled);
2890 if (n < 0 || n > (long) strlen (*mangled))
2896 if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2897 && (*mangled)[9] == 'N'
2898 && (*mangled)[8] == (*mangled)[10]
2899 && strchr (cplus_markers, (*mangled)[8]))
2903 it's just there to make the mangled name unique; we just
2906 (*mangled) += n;
2910 p = strpbrk (*mangled, cplus_markers);
2914 string_appendn (declp, *mangled, n);
2915 (*mangled) += n;
2917 if (success && (p == *mangled))
2921 (*mangled)++;
2923 n = strlen (*mangled);
2924 string_appendn (declp, *mangled, n);
2925 (*mangled) += n;
2932 else if (strncmp (*mangled, "__thunk_", 8) == 0)
2936 (*mangled) += 8;
2937 delta = consume_count (mangled);
2942 char *method = internal_cplus_demangle (work, ++*mangled);
2951 n = strlen (*mangled);
2952 (*mangled) += n;
2960 else if (strncmp (*mangled, "__t", 3) == 0
2961 && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
2963 p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
2964 (*mangled) += 4;
2965 switch (**mangled)
2969 success = demangle_qualified (work, mangled, declp, 0, 1);
2972 success = demangle_template (work, mangled, declp, 0, 1, 1);
2975 success = do_type (work, mangled, declp);
2978 if (success && **mangled != '\0')
2991 recursively_demangle(struct work_stuff *work, const char **mangled,
2998 memcpy (recurse, *mangled, namelength);
3010 string_appendn (result, *mangled, namelength);
3013 *mangled += namelength;
3020 arm_special -- special handling of ARM/lucid mangled strings
3025 arm_special (const char **mangled,
3040 arm_special (const char **mangled, string *declp)
3046 if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3049 and create the decl. Note that we consume the entire mangled
3052 scan = *mangled + ARM_VTABLE_STRLEN;
3066 (*mangled) += ARM_VTABLE_STRLEN;
3067 while (**mangled != '\0')
3069 n = consume_count (mangled);
3071 || n > (long) strlen (*mangled))
3073 string_prependn (declp, *mangled, n);
3074 (*mangled) += n;
3075 if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3078 (*mangled) += 2;
3099 demangle_qualified (struct work_stuff *, const char *mangled,
3105 the mangled form of "Outer::Inner". The demangled output is
3123 demangle_qualified (struct work_stuff *work, const char **mangled,
3141 if ((*mangled)[0] == 'K')
3145 (*mangled)++;
3146 idx = consume_count_with_underscores (mangled);
3153 switch ((*mangled)[1])
3156 /* GNU mangled name with more than 9 classes. The count is preceded
3159 (*mangled)++;
3160 qualifiers = consume_count_with_underscores (mangled);
3175 num[0] = (*mangled)[1];
3182 if ((*mangled)[2] == '_')
3184 (*mangled)++;
3186 (*mangled) += 2;
3205 if (*mangled[0] == '_')
3206 (*mangled)++;
3208 if (*mangled[0] == 't')
3216 success = demangle_template(work, mangled, &temp,
3221 else if (*mangled[0] == 'K')
3224 (*mangled)++;
3225 idx = consume_count_with_underscores (mangled);
3242 namelength = consume_count (mangled);
3248 recursively_demangle(work, mangled, &temp, namelength);
3253 success = do_type (work, mangled, &last_name);
3312 Assume that *type points at a count in a mangled name; set
3382 do_type (struct work_stuff *work, const char **mangled, string *result)
3400 switch (**mangled)
3406 (*mangled)++;
3415 (*mangled)++;
3424 ++(*mangled);
3432 if (**mangled != '_')
3433 success = demangle_template_value_parm (work, mangled, &decl,
3435 if (**mangled == '_')
3436 ++(*mangled);
3443 (*mangled)++;
3444 if (!get_count (mangled, &n) || n >= work -> ntypes)
3451 mangled = &remembered_type;
3457 (*mangled)++;
3467 if (!demangle_nested_args (work, mangled, &decl)
3468 || (**mangled != '_' && **mangled != '\0'))
3473 if (success && (**mangled == '_'))
3474 (*mangled)++;
3482 member = **mangled == 'M';
3483 (*mangled)++;
3489 if (**mangled != 'Q')
3492 if (ISDIGIT ((unsigned char)**mangled))
3494 n = consume_count (mangled);
3496 || (int) strlen (*mangled) < n)
3501 string_prependn (&decl, *mangled, n);
3502 *mangled += n;
3504 else if (**mangled == 'X' || **mangled == 'Y')
3507 do_type (work, mangled, &temp);
3511 else if (**mangled == 't')
3515 success = demangle_template (work, mangled, &temp,
3525 else if (**mangled == 'Q')
3527 success = demangle_qualified (work, mangled, &decl,
3542 switch (**mangled)
3547 type_quals |= code_for_qualifier (**mangled);
3548 (*mangled)++;
3555 if (*(*mangled)++ != 'F')
3561 if ((member && !demangle_nested_args (work, mangled, &decl))
3562 || **mangled != '_')
3567 (*mangled)++;
3580 (*mangled)++;
3591 string_prepend (&decl, demangle_qualifier (**mangled));
3593 (*mangled)++;
3606 if (success) switch (**mangled)
3612 success = demangle_qualified (work, mangled, result, 0, 1);
3618 (*mangled)++;
3619 if (!get_count (mangled, &n) || n >= work -> numb)
3631 (*mangled)++;
3632 idx = consume_count_with_underscores (mangled);
3636 || consume_count_with_underscores (mangled) == -1)
3652 success = demangle_fund_type (work, mangled, result);
3692 const char **mangled, string *result)
3704 switch (**mangled)
3713 string_prepend (result, demangle_qualifier (**mangled));
3715 (*mangled)++;
3718 (*mangled)++;
3723 (*mangled)++;
3728 (*mangled)++;
3740 switch (**mangled)
3746 (*mangled)++;
3751 (*mangled)++;
3756 (*mangled)++;
3761 (*mangled)++;
3766 (*mangled)++;
3771 (*mangled)++;
3777 (*mangled)++;
3783 (*mangled)++;
3789 (*mangled)++;
3795 (*mangled)++;
3801 (*mangled)++;
3807 (*mangled)++;
3808 if (!ISDIGIT ((unsigned char)**mangled))
3814 (*mangled)++;
3815 if (**mangled == '_')
3818 (*mangled)++;
3820 i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3821 (*mangled)++, i++)
3822 buf[i] = **mangled;
3823 if (**mangled != '_')
3829 (*mangled)++;
3833 strncpy (buf, *mangled, 2);
3835 *mangled += min (strlen (*mangled), 2);
3859 if (demangle_class_name (work, mangled, &btype)) {
3873 success = demangle_template (work, mangled, &btype, 0, 1, 1);
3888 **mangled points to 'S' or 'U' */
3892 const char **mangled, string *result)
3896 if (**mangled != 'U' && **mangled != 'S')
3899 unsigned_const = (**mangled == 'U');
3901 (*mangled)++;
3903 switch (**mangled)
3909 (*mangled)++;
3914 (*mangled)++;
3921 if (!(ISDIGIT ((unsigned char)**mangled)))
3926 while (ISDIGIT ((unsigned char)**mangled))
3928 char_str[0] = **mangled;
3930 (*mangled)++;
3943 **mangled is pointing to the 'A' */
3946 do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
3953 if (**mangled != 'A')
3956 (*mangled)++;
3958 literal_len = consume_count (mangled);
3969 memcpy (recurse, *mangled, literal_len);
3981 string_appendn (result, *mangled, literal_len);
3983 (*mangled) += literal_len;
4019 do_arg (struct work_stuff *work, const char **mangled, string *result)
4023 const char *start = *mangled;
4039 if (**mangled == 'n')
4042 (*mangled)++;
4043 work->nrepeats = consume_count(mangled);
4051 if (**mangled != '_')
4056 (*mangled)++;
4060 return do_arg (work, mangled, result);
4072 if (!do_type (work, mangled, work->previous_argument))
4077 remember_type (work, start, *mangled - start);
4265 demangle_args (struct work_stuff *work, const char **mangled,
4278 if (**mangled == '\0')
4284 while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4287 if ((**mangled == 'N') || (**mangled == 'T'))
4289 temptype = *(*mangled)++;
4293 if (!get_count (mangled, &r))
4310 if ((t = consume_count(mangled)) <= 0)
4317 if (!get_count (mangled, &t))
4355 if (!do_arg (work, mangled, &arg))
4364 if (**mangled == 'e')
4366 (*mangled)++;
4388 demangle_nested_args (struct work_stuff *work, const char **mangled,
4409 result = demangle_args (work, mangled, declp);
4425 demangle_function_name (struct work_stuff *work, const char **mangled,
4432 string_appendn (declp, (*mangled), scan - (*mangled));
4440 (*mangled) = scan + 2;
4446 if (HP_DEMANGLING && (**mangled == 'X'))
4448 demangle_arm_hp_template (work, mangled, 0, declp);