Lines Matching refs:mangled
544 consume_count_with_underscores (const char **mangled)
548 if (**mangled == '_')
550 (*mangled)++;
551 if (!ISDIGIT ((unsigned char)**mangled))
554 idx = consume_count (mangled);
555 if (**mangled != '_')
559 (*mangled)++;
563 if (**mangled < '0' || **mangled > '9')
566 idx = **mangled - '0';
567 (*mangled)++;
775 /* Takes operator name as e.g. "++" and returns mangled
830 /* char *cplus_demangle (const char *mangled, int options)
832 If MANGLED is a mangled function name produced by GNU C++, then
859 ML_(cplus_demangle) (const char *mangled, int options)
865 return xstrdup (mangled);
875 ret = cplus_demangle_v3 (mangled, work->options);
882 ret = java_demangle_v3 (mangled);
888 return ada_demangle (mangled, options);
890 ret = internal_cplus_demangle (work, mangled);
898 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
906 if (strncmp (mangled, "_ada_", 5) == 0)
907 mangled += 5;
910 if (!ISLOWER (mangled[0]))
918 len0 = strlen (mangled) + 7 + 1;
922 p = mangled;
1138 /* End of mangled name. */
1148 len0 = strlen (mangled);
1151 if (mangled[0] == '<')
1152 strcpy (demangled, mangled);
1154 sprintf (demangled, "<%s>", mangled);
1166 internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1181 if ((mangled != NULL) && (*mangled != '\0'))
1189 is a "__" string in the mangled string. Consider "_$_5__foo" for
1194 success = gnu_special (work, &mangled, &decl);
1203 success = demangle_prefix (work, &mangled, &decl);
1205 if (success && (*mangled != '\0'))
1207 success = demangle_signature (work, &mangled, &decl);
1361 /* Clear out any mangled storage */
1389 demangle_signature -- demangle the signature part of a mangled name
1394 demangle_signature (struct work_stuff *work, const char **mangled,
1399 Consume and demangle the signature portion of the mangled name.
1402 entry it contains the demangled root name from the mangled name
1406 *MANGLED points to the current unconsumed location in the mangled
1411 Demangling GNU style mangled names is nasty because there is no
1417 const char **mangled, string *declp)
1427 while (success && (**mangled != '\0'))
1429 switch (**mangled)
1432 oldmangled = *mangled;
1433 success = demangle_qualified (work, mangled, declp, 1, 0);
1435 remember_type (work, oldmangled, *mangled - oldmangled);
1442 //oldmangled = *mangled;
1443 success = demangle_qualified (work, mangled, declp, 1, 0);
1455 oldmangled = *mangled;
1457 (*mangled)++;
1464 work->type_quals |= code_for_qualifier (**mangled);
1468 oldmangled = *mangled;
1469 (*mangled)++;
1476 while (**mangled && (**mangled != '_'))
1477 (*mangled)++;
1478 if (!**mangled)
1481 (*mangled)++;
1491 oldmangled = *mangled;
1494 success = demangle_class (work, mangled, declp);
1497 remember_type (work, oldmangled, *mangled - oldmangled);
1503 if (**mangled != 'F')
1512 success = do_type (work, mangled, &s);
1533 (*mangled)++;
1544 success = demangle_args (work, mangled, declp);
1548 if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1550 ++(*mangled);
1552 success = do_type (work, mangled, &tname);
1564 oldmangled = *mangled;
1566 success = demangle_template (work, mangled, &tname,
1570 remember_type (work, oldmangled, *mangled - oldmangled);
1598 (*mangled)++;
1599 success = do_type (work, mangled, &return_type);
1609 a mangled name that is either bogus, or has been mangled by
1617 (*mangled)++;
1618 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1619 (*mangled)++;
1629 success = demangle_template (work, mangled, declp, 0, 0,
1633 (*mangled)++;
1646 success = demangle_args (work, mangled, declp);
1669 success = demangle_args (work, mangled, declp);
1687 success = demangle_args (work, mangled, declp);
1707 demangle_method_args (struct work_stuff *work, const char **mangled,
1714 string_append (declp, *mangled + 1);
1715 *mangled += strlen (*mangled);
1720 success = demangle_args (work, mangled, declp);
1729 const char **mangled, string *tname)
1739 if (get_count (mangled, &r))
1749 if (**mangled == 'Z')
1751 (*mangled)++;
1755 else if (**mangled == 'z')
1757 (*mangled)++;
1759 demangle_template_template_parm (work, mangled, tname);
1768 success = do_type (work, mangled, &temp);
1790 demangle_expression (struct work_stuff *work, const char **mangled,
1798 (*mangled)++;
1799 while (success && **mangled != 'W' && **mangled != '\0')
1808 len = strlen (*mangled);
1815 && memcmp (optable[i].in, *mangled, l) == 0)
1821 (*mangled) += l;
1832 success = demangle_template_value_parm (work, mangled, s, tk);
1835 if (**mangled != 'W')
1840 (*mangled)++;
1848 const char **mangled, string *s)
1852 if (**mangled == 'E')
1853 success = demangle_expression (work, mangled, s, tk_integral);
1854 else if (**mangled == 'Q' || **mangled == 'K')
1855 success = demangle_qualified (work, mangled, s, 0, 1);
1867 if (**mangled == '_')
1869 if (mangled[0][1] == 'm')
1877 (*mangled) += 2;
1890 if (**mangled == 'm')
1893 (*mangled)++;
1910 value = consume_count (mangled);
1912 value = consume_count_with_underscores (mangled);
1929 && **mangled == '_')
1930 (*mangled)++;
1944 const char **mangled, string *s)
1946 if (**mangled == 'E')
1947 return demangle_expression (work, mangled, s, tk_real);
1949 if (**mangled == 'm')
1952 (*mangled)++;
1954 while (ISDIGIT ((unsigned char)**mangled))
1956 string_appendn (s, *mangled, 1);
1957 (*mangled)++;
1959 if (**mangled == '.') /* fraction */
1962 (*mangled)++;
1963 while (ISDIGIT ((unsigned char)**mangled))
1965 string_appendn (s, *mangled, 1);
1966 (*mangled)++;
1969 if (**mangled == 'e') /* exponent */
1972 (*mangled)++;
1973 while (ISDIGIT ((unsigned char)**mangled))
1975 string_appendn (s, *mangled, 1);
1976 (*mangled)++;
1984 demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1989 if (**mangled == 'Y')
1994 (*mangled)++;
1995 idx = consume_count_with_underscores (mangled);
1998 || consume_count_with_underscores (mangled) == -1)
2006 success = demangle_integral_value (work, mangled, s);
2011 if (**mangled == 'm')
2014 (*mangled)++;
2017 val = consume_count(mangled);
2030 int val = consume_count (mangled);
2039 success = demangle_real_value (work, mangled, s);
2042 if (**mangled == 'Q')
2043 success = demangle_qualified (work, mangled, s,
2048 int symbol_len = consume_count (mangled);
2056 strncpy (p, *mangled, symbol_len);
2060 mangled here does not make use of any of the squangling
2062 mangled independently. */
2077 *mangled += symbol_len;
2093 demangle_template (struct work_stuff *work, const char **mangled,
2104 (*mangled)++;
2108 if (**mangled == 'z')
2111 (*mangled)++;
2112 (*mangled)++;
2114 idx = consume_count_with_underscores (mangled);
2117 || consume_count_with_underscores (mangled) == -1)
2135 if ((r = consume_count (mangled)) <= 0
2136 || (int) strlen (*mangled) < r)
2141 && strncmp (*mangled, "JArray1Z", 8) == 0;
2144 string_appendn (tname, *mangled, r);
2147 string_appendn (trawname, *mangled, r);
2148 *mangled += r;
2154 if (!get_count (mangled, &r))
2173 if (**mangled == 'Z')
2175 (*mangled)++;
2177 success = do_type (work, mangled, &temp);
2198 else if (**mangled == 'z')
2201 (*mangled)++;
2202 success = demangle_template_template_parm (work, mangled, tname);
2205 && (r2 = consume_count (mangled)) > 0
2206 && (int) strlen (*mangled) >= r2)
2209 string_appendn (tname, *mangled, r2);
2215 memcpy (work->tmpl_argvec[i], *mangled, len);
2218 *mangled += r2;
2233 success = do_type (work, mangled, &temp);
2246 success = demangle_template_value_parm (work, mangled, s,
2290 string_append (declp, *mangled + 1);
2291 *mangled += strlen (*mangled);
2296 success = demangle_args (work, mangled, declp);
2304 arm_pt (const char *mangled,
2309 if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2316 if (*args + len == mangled + n && **args == '_')
2324 if ((*anchor = strstr (mangled, "__tm__"))
2325 || (*anchor = strstr (mangled, "__ps__"))
2326 || (*anchor = strstr (mangled, "__pt__")))
2333 if (*args + len == mangled + n && **args == '_')
2339 else if ((*anchor = strstr (mangled, "__S")))
2346 if (*args + len == mangled + n && **args == '_')
2358 demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2363 const char *e = *mangled + n;
2368 if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2375 start_spec_args = strchr (*mangled, '<');
2376 if (start_spec_args && (start_spec_args - *mangled < n))
2377 string_appendn (declp, *mangled, start_spec_args - *mangled);
2379 string_appendn (declp, *mangled, n);
2380 (*mangled) += n + 1;
2394 switch (**mangled)
2398 (*mangled)++;
2399 if (!do_type (work, mangled, &arg))
2406 if (!do_hpacc_template_const_value (work, mangled, &arg))
2412 if (!do_hpacc_template_literal (work, mangled, &arg))
2426 if ((**mangled == '\000') || (**mangled == '_'))
2434 if (**mangled == '_')
2435 (*mangled)++;
2440 else if (arm_pt (*mangled, n, &p, &args))
2446 string_appendn (declp, *mangled, p - *mangled);
2514 else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2515 && (*mangled)[9] == 'N'
2516 && (*mangled)[8] == (*mangled)[10]
2517 && strchr (cplus_markers, (*mangled)[8]))
2526 string_appendn (declp, *mangled, n);
2528 *mangled += n;
2532 mangled string; qualifiers, local class indicators, etc. have
2536 demangle_class_name (struct work_stuff *work, const char **mangled,
2542 n = consume_count (mangled);
2545 if ((int) strlen (*mangled) >= n)
2547 demangle_arm_hp_template (work, mangled, n, declp);
2558 demangle_class -- demangle a mangled class sequence
2563 demangle_class (struct work_stuff *work, const char **mangled,
2571 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2572 On exit, it points to the next token after the mangled class on
2590 demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2599 if (demangle_class_name (work, mangled, &class_name))
2632 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2638 one; *mangled will be consumed so caller will not make further calls to
2642 iterate_demangle_function (struct work_stuff *work, const char **mangled,
2645 const char *mangle_init = *mangled;
2657 return demangle_function_name (work, mangled, declp, scan);
2668 occurrence, since "__" most often occur between independent mangled
2674 if (demangle_function_name (work, mangled, declp, scan))
2676 success = demangle_signature (work, mangled, declp);
2682 *mangled = mangle_init;
2711 demangle_prefix -- consume the mangled name prefix and find signature
2716 demangle_prefix (struct work_stuff *work, const char **mangled,
2721 Consume and demangle the prefix of the mangled name.
2730 MANGLED points to the current pointer into the mangled name. As each
2731 token of the mangled name is consumed, it is updated. Upon entry
2732 the current mangled name pointer points to the first character of
2733 the mangled name. Upon exit, it should point to the first character
2741 demangle_prefix (struct work_stuff *work, const char **mangled,
2748 if (strlen(*mangled) > 6
2749 && (strncmp(*mangled, "_imp__", 6) == 0
2750 || strncmp(*mangled, "__imp_", 6) == 0))
2755 (*mangled) += 6;
2758 else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2760 char *marker = strchr (cplus_markers, (*mangled)[8]);
2761 if (marker != NULL && *marker == (*mangled)[10])
2763 if ((*mangled)[9] == 'D')
2766 (*mangled) += 11;
2768 if (gnu_special (work, mangled, declp))
2771 else if ((*mangled)[9] == 'I')
2774 (*mangled) += 11;
2776 if (gnu_special (work, mangled, declp))
2781 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2784 (*mangled) += 7;
2787 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2790 (*mangled) += 7;
2796 scan = strstr (*mangled, "__"); */
2799 scan = *mangled;
2830 else if ((scan == *mangled)
2840 *mangled = scan + 2;
2841 consume_count (mangled);
2842 string_append (declp, *mangled);
2843 *mangled += strlen (*mangled);
2854 *mangled = scan + 2;
2863 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2873 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2875 else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2882 || (arm_special (mangled, declp) == 0))
2895 return iterate_demangle_function (work, mangled, declp, scan);
2904 return iterate_demangle_function (work, mangled, declp, scan);
2908 /* Doesn't look like a mangled name */
2914 string_append (declp, *mangled);
2915 *mangled += strlen (*mangled);
2925 gnu_special -- special handling of gnu mangled strings
2930 gnu_special (struct work_stuff *work, const char **mangled,
2950 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2956 if ((*mangled)[0] == '_'
2957 && strchr (cplus_markers, (*mangled)[1]) != NULL
2958 && (*mangled)[2] == '_')
2961 (*mangled) += 3;
2964 else if ((*mangled)[0] == '_'
2965 && (((*mangled)[1] == '_'
2966 && (*mangled)[2] == 'v'
2967 && (*mangled)[3] == 't'
2968 && (*mangled)[4] == '_')
2969 || ((*mangled)[1] == 'v'
2970 && (*mangled)[2] == 't'
2971 && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2974 and create the decl. Note that we consume the entire mangled
2977 if ((*mangled)[2] == 'v')
2978 (*mangled) += 5; /* New style, with thunks: "__vt_" */
2980 (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2981 while (**mangled != '\0')
2983 switch (**mangled)
2987 success = demangle_qualified (work, mangled, declp, 0, 1);
2990 success = demangle_template (work, mangled, declp, 0, 1,
2994 if (ISDIGIT((unsigned char)*mangled[0]))
2996 n = consume_count(mangled);
3001 if (n > (int) strlen (*mangled))
3009 n = strcspn (*mangled, cplus_markers);
3011 string_appendn (declp, *mangled, n);
3012 (*mangled) += n;
3015 p = strpbrk (*mangled, cplus_markers);
3016 if (success && ((p == NULL) || (p == *mangled)))
3021 (*mangled)++;
3033 else if ((*mangled)[0] == '_'
3034 && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
3035 && (p = strpbrk (*mangled, cplus_markers)) != NULL)
3038 (*mangled)++;
3039 switch (**mangled)
3043 success = demangle_qualified (work, mangled, declp, 0, 1);
3046 success = demangle_template (work, mangled, declp, 0, 1, 1);
3049 n = consume_count (mangled);
3050 if (n < 0 || n > (long) strlen (*mangled))
3056 if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
3057 && (*mangled)[9] == 'N'
3058 && (*mangled)[8] == (*mangled)[10]
3059 && strchr (cplus_markers, (*mangled)[8]))
3063 it's just there to make the mangled name unique; we just
3066 (*mangled) += n;
3070 p = strpbrk (*mangled, cplus_markers);
3074 string_appendn (declp, *mangled, n);
3075 (*mangled) += n;
3077 if (success && (p == *mangled))
3081 (*mangled)++;
3083 n = strlen (*mangled);
3084 string_appendn (declp, *mangled, n);
3085 (*mangled) += n;
3092 else if (strncmp (*mangled, "__thunk_", 8) == 0)
3096 (*mangled) += 8;
3097 delta = consume_count (mangled);
3102 char *method = internal_cplus_demangle (work, ++*mangled);
3111 n = strlen (*mangled);
3112 (*mangled) += n;
3120 else if (strncmp (*mangled, "__t", 3) == 0
3121 && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
3123 p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
3124 (*mangled) += 4;
3125 switch (**mangled)
3129 success = demangle_qualified (work, mangled, declp, 0, 1);
3132 success = demangle_template (work, mangled, declp, 0, 1, 1);
3135 success = do_type (work, mangled, declp);
3138 if (success && **mangled != '\0')
3151 recursively_demangle(struct work_stuff *work, const char **mangled,
3158 memcpy (recurse, *mangled, namelength);
3170 string_appendn (result, *mangled, namelength);
3173 *mangled += namelength;
3180 arm_special -- special handling of ARM/lucid mangled strings
3185 arm_special (const char **mangled,
3200 arm_special (const char **mangled, string *declp)
3206 if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3209 and create the decl. Note that we consume the entire mangled
3212 scan = *mangled + ARM_VTABLE_STRLEN;
3226 (*mangled) += ARM_VTABLE_STRLEN;
3227 while (**mangled != '\0')
3229 n = consume_count (mangled);
3231 || n > (long) strlen (*mangled))
3233 string_prependn (declp, *mangled, n);
3234 (*mangled) += n;
3235 if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3238 (*mangled) += 2;
3259 demangle_qualified (struct work_stuff *, const char *mangled,
3265 the mangled form of "Outer::Inner". The demangled output is
3283 demangle_qualified (struct work_stuff *work, const char **mangled,
3301 if ((*mangled)[0] == 'K')
3305 (*mangled)++;
3306 idx = consume_count_with_underscores (mangled);
3313 switch ((*mangled)[1])
3316 /* GNU mangled name with more than 9 classes. The count is preceded
3319 (*mangled)++;
3320 qualifiers = consume_count_with_underscores (mangled);
3335 num[0] = (*mangled)[1];
3342 if ((*mangled)[2] == '_')
3344 (*mangled)++;
3346 (*mangled) += 2;
3365 if (*mangled[0] == '_')
3366 (*mangled)++;
3368 if (*mangled[0] == 't')
3376 success = demangle_template(work, mangled, &temp,
3381 else if (*mangled[0] == 'K')
3384 (*mangled)++;
3385 idx = consume_count_with_underscores (mangled);
3402 namelength = consume_count (mangled);
3408 recursively_demangle(work, mangled, &temp, namelength);
3413 success = do_type (work, mangled, &last_name);
3472 Assume that *type points at a count in a mangled name; set
3542 do_type (struct work_stuff *work, const char **mangled, string *result)
3560 switch (**mangled)
3566 (*mangled)++;
3575 (*mangled)++;
3584 ++(*mangled);
3592 if (**mangled != '_')
3593 success = demangle_template_value_parm (work, mangled, &decl,
3595 if (**mangled == '_')
3596 ++(*mangled);
3603 (*mangled)++;
3604 if (!get_count (mangled, &n) || n >= work -> ntypes)
3611 mangled = &remembered_type;
3617 (*mangled)++;
3627 if (!demangle_nested_args (work, mangled, &decl)
3628 || (**mangled != '_' && **mangled != '\0'))
3633 if (success && (**mangled == '_'))
3634 (*mangled)++;
3642 member = **mangled == 'M';
3643 (*mangled)++;
3649 if (**mangled != 'Q')
3652 if (ISDIGIT ((unsigned char)**mangled))
3654 n = consume_count (mangled);
3656 || (int) strlen (*mangled) < n)
3661 string_prependn (&decl, *mangled, n);
3662 *mangled += n;
3664 else if (**mangled == 'X' || **mangled == 'Y')
3667 do_type (work, mangled, &temp);
3671 else if (**mangled == 't')
3675 success = demangle_template (work, mangled, &temp,
3688 else if (**mangled == 'Q')
3690 success = demangle_qualified (work, mangled, &decl,
3705 switch (**mangled)
3710 type_quals |= code_for_qualifier (**mangled);
3711 (*mangled)++;
3718 if (*(*mangled)++ != 'F')
3724 if ((member && !demangle_nested_args (work, mangled, &decl))
3725 || **mangled != '_')
3730 (*mangled)++;
3743 (*mangled)++;
3754 string_prepend (&decl, demangle_qualifier (**mangled));
3756 (*mangled)++;
3769 if (success) switch (**mangled)
3775 success = demangle_qualified (work, mangled, result, 0, 1);
3781 (*mangled)++;
3782 if (!get_count (mangled, &n) || n >= work -> numb)
3794 (*mangled)++;
3795 idx = consume_count_with_underscores (mangled);
3799 || consume_count_with_underscores (mangled) == -1)
3815 success = demangle_fund_type (work, mangled, result);
3855 const char **mangled, string *result)
3867 switch (**mangled)
3876 string_prepend (result, demangle_qualifier (**mangled));
3878 (*mangled)++;
3881 (*mangled)++;
3886 (*mangled)++;
3891 (*mangled)++;
3903 switch (**mangled)
3909 (*mangled)++;
3914 (*mangled)++;
3919 (*mangled)++;
3924 (*mangled)++;
3929 (*mangled)++;
3934 (*mangled)++;
3940 (*mangled)++;
3946 (*mangled)++;
3952 (*mangled)++;
3958 (*mangled)++;
3964 (*mangled)++;
3970 (*mangled)++;
3971 if (!ISDIGIT ((unsigned char)**mangled))
3977 (*mangled)++;
3978 if (**mangled == '_')
3981 (*mangled)++;
3983 i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3984 (*mangled)++, i++)
3985 buf[i] = **mangled;
3986 if (**mangled != '_')
3992 (*mangled)++;
3996 strncpy (buf, *mangled, 2);
3998 *mangled += min (strlen (*mangled), 2);
4029 if (demangle_class_name (work, mangled, &btype)) {
4043 success = demangle_template (work, mangled, &btype, 0, 1, 1);
4058 **mangled points to 'S' or 'U' */
4062 const char **mangled, string *result)
4066 if (**mangled != 'U' && **mangled != 'S')
4069 unsigned_const = (**mangled == 'U');
4071 (*mangled)++;
4073 switch (**mangled)
4079 (*mangled)++;
4084 (*mangled)++;
4091 if (!(ISDIGIT ((unsigned char)**mangled)))
4096 while (ISDIGIT ((unsigned char)**mangled))
4098 char_str[0] = **mangled;
4100 (*mangled)++;
4113 **mangled is pointing to the 'A' */
4116 do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
4123 if (**mangled != 'A')
4126 (*mangled)++;
4128 literal_len = consume_count (mangled);
4139 memcpy (recurse, *mangled, literal_len);
4151 string_appendn (result, *mangled, literal_len);
4153 (*mangled) += literal_len;
4189 do_arg (struct work_stuff *work, const char **mangled, string *result)
4193 const char *start = *mangled;
4209 if (**mangled == 'n')
4212 (*mangled)++;
4213 work->nrepeats = consume_count(mangled);
4221 if (**mangled != '_')
4226 (*mangled)++;
4230 return do_arg (work, mangled, result);
4242 if (!do_type (work, mangled, work->previous_argument))
4247 remember_type (work, start, *mangled - start);
4435 demangle_args (struct work_stuff *work, const char **mangled,
4448 if (**mangled == '\0')
4454 while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4457 if ((**mangled == 'N') || (**mangled == 'T'))
4459 temptype = *(*mangled)++;
4463 if (!get_count (mangled, &r))
4480 if ((t = consume_count(mangled)) <= 0)
4487 if (!get_count (mangled, &t))
4525 if (!do_arg (work, mangled, &arg))
4534 if (**mangled == 'e')
4536 (*mangled)++;
4558 demangle_nested_args (struct work_stuff *work, const char **mangled,
4579 result = demangle_args (work, mangled, declp);
4597 demangle_function_name (struct work_stuff *work, const char **mangled,
4604 string_appendn (declp, (*mangled), scan - (*mangled));
4612 (*mangled) = scan + 2;
4618 if (HP_DEMANGLING && (**mangled == 'X'))
4620 demangle_arm_hp_template (work, mangled, 0, declp);