Lines Matching refs:mangled
212 /* Extract the number from MANGLED, and assign the result to RET.
216 dlang_number (const char *mangled, unsigned long *ret)
219 if (mangled == NULL || !ISDIGIT (*mangled))
224 while (ISDIGIT (*mangled))
226 unsigned long digit = mangled[0] - '0';
233 mangled++;
236 if (*mangled == '\0')
240 return mangled;
243 /* Extract the hex-digit from MANGLED, and assign the result to RET.
246 dlang_hexdigit (const char *mangled, char *ret)
251 if (mangled == NULL || !ISXDIGIT (mangled[0]) || !ISXDIGIT (mangled[1]))
254 c = mangled[0];
260 c = mangled[1];
266 mangled += 2;
268 return mangled;
271 /* Extract the function calling convention from MANGLED and
274 dlang_call_convention_p (const char *mangled)
276 switch (*mangled)
287 /* Extract the back reference position from MANGLED, and assign the result
291 dlang_decode_backref (const char *mangled, long *ret)
294 if (mangled == NULL || !ISALPHA (*mangled))
297 /* Any identifier or non-basic type that has been emitted to the mangled
300 mangled symbol name.
312 while (ISALPHA (*mangled))
320 if (mangled[0] >= 'a' && mangled[0] <= 'z')
322 val += mangled[0] - 'a';
326 return mangled + 1;
329 val += mangled[0] - 'A';
330 mangled++;
339 dlang_backref (const char *mangled, const char **ret, struct dlang_info *info)
343 if (mangled == NULL || *mangled != 'Q')
347 const char *qpos = mangled;
349 mangled++;
351 mangled = dlang_decode_backref (mangled, &refpos);
352 if (mangled == NULL)
361 return mangled;
364 /* Demangle a back referenced symbol from MANGLED and append it to DECL.
367 dlang_symbol_backref (string *decl, const char *mangled,
380 mangled = dlang_backref (mangled, &backref, info);
391 return mangled;
394 /* Demangle a back referenced type from MANGLED and append it to DECL.
398 dlang_type_backref (string *decl, const char *mangled, struct dlang_info *info,
411 if (mangled - info->s >= info->last_backref)
415 info->last_backref = mangled - info->s;
418 mangled = dlang_backref (mangled, &backref, info);
431 return mangled;
434 /* Extract the beginning of a symbol name from MANGLED and
437 dlang_symbol_name_p (const char *mangled, struct dlang_info *info)
440 const char *qref = mangled;
442 if (ISDIGIT (*mangled))
445 if (mangled[0] == '_' && mangled[1] == '_'
446 && (mangled[2] == 'T' || mangled[2] == 'U'))
449 if (*mangled != 'Q')
452 mangled = dlang_decode_backref (mangled + 1, &ret);
453 if (mangled == NULL || ret > qref - info->s)
459 /* Demangle the calling convention from MANGLED and append it to DECL.
462 dlang_call_convention (string *decl, const char *mangled)
464 if (mangled == NULL || *mangled == '\0')
467 switch (*mangled)
470 mangled++;
473 mangled++;
477 mangled++;
481 mangled++;
485 mangled++;
489 mangled++;
496 return mangled;
499 /* Extract the type modifiers from MANGLED and append them to DECL.
502 dlang_type_modifiers (string *decl, const char *mangled)
504 if (mangled == NULL || *mangled == '\0')
507 switch (*mangled)
510 mangled++;
512 return mangled;
514 mangled++;
516 return mangled;
518 mangled++;
520 return dlang_type_modifiers (decl, mangled);
522 mangled++;
523 if (*mangled == 'g') /* wild */
525 mangled++;
527 return dlang_type_modifiers (decl, mangled);
533 return mangled;
537 /* Demangle the D function attributes from MANGLED and append it to DECL.
540 dlang_attributes (string *decl, const char *mangled)
542 if (mangled == NULL || *mangled == '\0')
545 while (*mangled == 'N')
547 mangled++;
548 switch (*mangled)
551 mangled++;
555 mangled++;
559 mangled++;
563 mangled++;
567 mangled++;
571 mangled++;
584 mangled--;
587 mangled++;
591 mangled++;
595 mangled++;
599 mangled++;
609 return mangled;
612 /* Demangle the function type from MANGLED without the return type.
619 const char *mangled, struct dlang_info *info)
625 mangled = dlang_call_convention (call ? call : &dump, mangled);
626 mangled = dlang_attributes (attr ? attr : &dump, mangled);
631 mangled = dlang_function_args (args ? args : &dump, mangled, info);
636 return mangled;
639 /* Demangle the function type from MANGLED and append it to DECL.
642 dlang_function_type (string *decl, const char *mangled, struct dlang_info *info)
646 if (mangled == NULL || *mangled == '\0')
649 /* The order of the mangled string is:
659 mangled = dlang_function_type_noreturn (&args, decl, &attr, mangled, info);
662 mangled = dlang_type (&type, mangled, info);
673 return mangled;
676 MANGLED and append it to DECL.
679 dlang_function_args (string *decl, const char *mangled, struct dlang_info *info)
683 while (mangled && *mangled != '\0')
685 switch (*mangled)
688 mangled++;
690 return mangled;
692 mangled++;
696 return mangled;
698 mangled++;
699 return mangled;
705 if (*mangled == 'M') /* scope(T) */
707 mangled++;
711 if (mangled[0] == 'N' && mangled[1] == 'k') /* return(T) */
713 mangled += 2;
717 switch (*mangled)
720 mangled++;
722 if (*mangled == 'K') /* in ref(T) */
724 mangled++;
729 mangled++;
733 mangled++;
737 mangled++;
741 mangled = dlang_type (decl, mangled, info);
744 return mangled;
747 /* Demangle the type from MANGLED and append it to DECL.
750 dlang_type (string *decl, const char *mangled, struct dlang_info *info)
752 if (mangled == NULL || *mangled == '\0')
755 switch (*mangled)
758 mangled++;
760 mangled = dlang_type (decl, mangled, info);
762 return mangled;
764 mangled++;
766 mangled = dlang_type (decl, mangled, info);
768 return mangled;
770 mangled++;
772 mangled = dlang_type (decl, mangled, info);
774 return mangled;
776 mangled++;
777 if (*mangled == 'g') /* wild(T) */
779 mangled++;
781 mangled = dlang_type (decl, mangled, info);
783 return mangled;
785 else if (*mangled == 'h') /* vector(T) */
787 mangled++;
789 mangled = dlang_type (decl, mangled, info);
791 return mangled;
793 else if (*mangled == 'n') /* typeof(*null) */
795 mangled++;
797 return mangled;
802 mangled++;
803 mangled = dlang_type (decl, mangled, info);
805 return mangled;
810 mangled++;
812 numptr = mangled;
813 while (ISDIGIT (*mangled))
816 mangled++;
818 mangled = dlang_type (decl, mangled, info);
822 return mangled;
828 mangled++;
831 mangled = dlang_type (&type, mangled, info);
834 mangled = dlang_type (decl, mangled, info);
840 return mangled;
843 mangled++;
844 if (!dlang_call_convention_p (mangled))
846 mangled = dlang_type (decl, mangled, info);
848 return mangled;
858 mangled = dlang_function_type (decl, mangled, info);
860 return mangled;
865 mangled++;
866 return dlang_parse_qualified (decl, mangled, info, 0);
871 mangled++;
874 mangled = dlang_type_modifiers (&mods, mangled);
878 if (mangled && *mangled == 'Q')
879 mangled = dlang_type_backref (decl, mangled, info, 1);
881 mangled = dlang_function_type (decl, mangled, info);
887 return mangled;
890 mangled++;
891 return dlang_parse_tuple (decl, mangled, info);
895 mangled++;
897 return mangled;
899 mangled++;
901 return mangled;
903 mangled++;
905 return mangled;
907 mangled++;
909 return mangled;
911 mangled++;
913 return mangled;
915 mangled++;
917 return mangled;
919 mangled++;
921 return mangled;
923 mangled++;
925 return mangled;
927 mangled++;
929 return mangled;
931 mangled++;
933 return mangled;
935 mangled++;
937 return mangled;
939 mangled++;
941 return mangled;
943 mangled++;
945 return mangled;
949 mangled++;
951 return mangled;
953 mangled++;
955 return mangled;
957 mangled++;
959 return mangled;
961 mangled++;
963 return mangled;
965 mangled++;
967 return mangled;
969 mangled++;
971 return mangled;
975 mangled++;
977 return mangled;
979 mangled++;
981 return mangled;
983 mangled++;
985 return mangled;
987 mangled++;
989 return mangled;
991 mangled++;
992 switch (*mangled)
995 mangled++;
997 return mangled;
999 mangled++;
1001 return mangled;
1007 return dlang_type_backref (decl, mangled, info, 0);
1014 /* Extract the identifier from MANGLED and append it to DECL.
1017 dlang_identifier (string *decl, const char *mangled, struct dlang_info *info)
1021 if (mangled == NULL || *mangled == '\0')
1024 if (*mangled == 'Q')
1025 return dlang_symbol_backref (decl, mangled, info);
1028 if (mangled[0] == '_' && mangled[1] == '_'
1029 && (mangled[2] == 'T' || mangled[2] == 'U'))
1030 return dlang_parse_template (decl, mangled, info, TEMPLATE_LENGTH_UNKNOWN);
1032 const char *endptr = dlang_number (mangled, &len);
1040 mangled = endptr;
1043 if (len >= 5 && mangled[0] == '_' && mangled[1] == '_'
1044 && (mangled[2] == 'T' || mangled[2] == 'U'))
1045 return dlang_parse_template (decl, mangled, info, len);
1048 the same mangled name. To make the mangled names unique, a fake parent in
1050 if (len >= 4 && mangled[0] == '_' && mangled[1] == '_' && mangled[2] == 'S')
1052 const char *numptr = mangled + 3;
1053 while (numptr < (mangled + len) && ISDIGIT (*numptr))
1056 if (mangled + len == numptr)
1059 mangled += len;
1060 return dlang_identifier (decl, mangled, info);
1066 return dlang_lname (decl, mangled, len);
1069 /* Extract the plain identifier from MANGLED and prepend/append it to DECL
1073 dlang_lname (string *decl, const char *mangled, unsigned long len)
1078 if (strncmp (mangled, "__ctor", len) == 0)
1082 mangled += len;
1083 return mangled;
1085 else if (strncmp (mangled, "__dtor", len) == 0)
1089 mangled += len;
1090 return mangled;
1092 else if (strncmp (mangled, "__initZ", len + 1) == 0)
1097 mangled += len;
1098 return mangled;
1100 else if (strncmp (mangled, "__vtblZ", len + 1) == 0)
1105 mangled += len;
1106 return mangled;
1111 if (strncmp (mangled, "__ClassZ", len + 1) == 0)
1116 mangled += len;
1117 return mangled;
1122 if (strncmp (mangled, "__postblitMFZ", len + 3) == 0)
1126 mangled += len + 3;
1127 return mangled;
1132 if (strncmp (mangled, "__InterfaceZ", len + 1) == 0)
1137 mangled += len;
1138 return mangled;
1143 if (strncmp (mangled, "__ModuleInfoZ", len + 1) == 0)
1148 mangled += len;
1149 return mangled;
1154 string_appendn (decl, mangled, len);
1155 mangled += len;
1157 return mangled;
1160 /* Extract the integer value from MANGLED and append it to DECL,
1164 dlang_parse_integer (string *decl, const char *mangled, char type)
1174 mangled = dlang_number (mangled, &val);
1175 if (mangled == NULL)
1230 mangled = dlang_number (mangled, &val);
1231 if (mangled == NULL)
1239 const char *numptr = mangled;
1242 if (! ISDIGIT (*mangled))
1245 while (ISDIGIT (*mangled))
1248 mangled++;
1269 return mangled;
1272 /* Extract the floating-point value from MANGLED and append it to DECL.
1275 dlang_parse_real (string *decl, const char *mangled)
1278 if (strncmp (mangled, "NAN", 3) == 0)
1281 mangled += 3;
1282 return mangled;
1284 else if (strncmp (mangled, "INF", 3) == 0)
1287 mangled += 3;
1288 return mangled;
1290 else if (strncmp (mangled, "NINF", 4) == 0)
1293 mangled += 4;
1294 return mangled;
1298 if (*mangled == 'N')
1301 mangled++;
1304 if (!ISXDIGIT (*mangled))
1308 string_appendn (decl, mangled, 1);
1310 mangled++;
1313 while (ISXDIGIT (*mangled))
1315 string_appendn (decl, mangled, 1);
1316 mangled++;
1320 if (*mangled != 'P')
1324 mangled++;
1326 if (*mangled == 'N')
1329 mangled++;
1332 while (ISDIGIT (*mangled))
1334 string_appendn (decl, mangled, 1);
1335 mangled++;
1338 return mangled;
1341 /* Extract the string value from MANGLED and append it to DECL.
1344 dlang_parse_string (string *decl, const char *mangled)
1346 char type = *mangled;
1349 mangled++;
1350 mangled = dlang_number (mangled, &len);
1351 if (mangled == NULL || *mangled != '_')
1354 mangled++;
1359 const char *endptr = dlang_hexdigit (mangled, &val);
1392 string_appendn (decl, mangled, 2);
1396 mangled = endptr;
1403 return mangled;
1406 /* Extract the static array value from MANGLED and append it to DECL.
1409 dlang_parse_arrayliteral (string *decl, const char *mangled,
1414 mangled = dlang_number (mangled, &elements);
1415 if (mangled == NULL)
1421 mangled = dlang_value (decl, mangled, NULL, '\0', info);
1422 if (mangled == NULL)
1430 return mangled;
1433 /* Extract the associative array value from MANGLED and append it to DECL.
1436 dlang_parse_assocarray (string *decl, const char *mangled,
1441 mangled = dlang_number (mangled, &elements);
1442 if (mangled == NULL)
1448 mangled = dlang_value (decl, mangled, NULL, '\0', info);
1449 if (mangled == NULL)
1453 mangled = dlang_value (decl, mangled, NULL, '\0', info);
1454 if (mangled == NULL)
1462 return mangled;
1465 /* Extract the struct literal value for NAME from MANGLED and append it to DECL.
1468 dlang_parse_structlit (string *decl, const char *mangled, const char *name,
1473 mangled = dlang_number (mangled, &args);
1474 if (mangled == NULL)
1483 mangled = dlang_value (decl, mangled, NULL, '\0', info);
1484 if (mangled == NULL)
1492 return mangled;
1495 /* Extract the value from MANGLED and append it to DECL.
1498 dlang_value (string *decl, const char *mangled, const char *name, char type,
1501 if (mangled == NULL || *mangled == '\0')
1504 switch (*mangled)
1508 mangled++;
1514 mangled++;
1516 mangled = dlang_parse_integer (decl, mangled, type);
1520 mangled++;
1528 mangled = dlang_parse_integer (decl, mangled, type);
1533 mangled++;
1534 mangled = dlang_parse_real (decl, mangled);
1539 mangled++;
1540 mangled = dlang_parse_real (decl, mangled);
1542 if (mangled == NULL || *mangled != 'c')
1544 mangled++;
1545 mangled = dlang_parse_real (decl, mangled);
1553 mangled = dlang_parse_string (decl, mangled);
1558 mangled++;
1560 mangled = dlang_parse_assocarray (decl, mangled, info);
1562 mangled = dlang_parse_arrayliteral (decl, mangled, info);
1567 mangled++;
1568 mangled = dlang_parse_structlit (decl, mangled, name, info);
1573 mangled++;
1574 if (strncmp (mangled, "_D", 2) != 0
1575 || !dlang_symbol_name_p (mangled + 2, info))
1577 mangled = dlang_parse_mangle (decl, mangled, info);
1584 return mangled;
1587 /* Extract and demangle the symbol in MANGLED and append it to DECL.
1590 dlang_parse_mangle (string *decl, const char *mangled, struct dlang_info *info)
1592 /* A D mangled symbol is comprised of both scope and type information.
1603 mangled += 2;
1605 mangled = dlang_parse_qualified (decl, mangled, info, 1);
1607 if (mangled != NULL)
1610 if (*mangled == 'Z')
1611 mangled++;
1618 mangled = dlang_type (&type, mangled, info);
1623 return mangled;
1626 /* Extract and demangle the qualified symbol in MANGLED and append it to DECL.
1630 dlang_parse_qualified (string *decl, const char *mangled,
1654 if (*mangled == '0')
1657 mangled++;
1658 while (*mangled == '0');
1666 mangled = dlang_identifier (decl, mangled, info);
1671 unconsumed position of the mangled decl. */
1672 if (mangled && (*mangled == 'M' || dlang_call_convention_p (mangled)))
1675 const char *start = mangled;
1682 if (*mangled == 'M')
1684 mangled++;
1685 mangled = dlang_type_modifiers (&mods, mangled);
1689 mangled = dlang_function_type_noreturn (decl, NULL, NULL,
1690 mangled, info);
1694 if (mangled == NULL || *mangled == '\0')
1697 mangled = start;
1704 while (mangled && dlang_symbol_name_p (mangled, info));
1706 return mangled;
1709 /* Demangle the tuple from MANGLED and append it to DECL.
1712 dlang_parse_tuple (string *decl, const char *mangled, struct dlang_info *info)
1716 mangled = dlang_number (mangled, &elements);
1717 if (mangled == NULL)
1724 mangled = dlang_type (decl, mangled, info);
1725 if (mangled == NULL)
1733 return mangled;
1736 /* Demangle the template symbol parameter from MANGLED and append it to DECL.
1739 dlang_template_symbol_param (string *decl, const char *mangled,
1742 if (strncmp (mangled, "_D", 2) == 0
1743 && dlang_symbol_name_p (mangled + 2, info))
1744 return dlang_parse_mangle (decl, mangled, info);
1746 if (*mangled == 'Q')
1747 return dlang_parse_qualified (decl, mangled, info, 0);
1750 const char *endptr = dlang_number (mangled, &len);
1756 the symbol length is encoded and the first character of the mangled
1766 mangled = pend;
1779 if (dlang_symbol_name_p (mangled, info))
1780 mangled = dlang_parse_qualified (decl, mangled, info, 0);
1781 else if (strncmp (mangled, "_D", 2) == 0
1782 && dlang_symbol_name_p (mangled + 2, info))
1783 mangled = dlang_parse_mangle (decl, mangled, info);
1786 if (mangled && (endptr == NULL || (mangled - pend) == psize))
1787 return mangled;
1797 /* Demangle the argument list from MANGLED and append it to DECL.
1800 dlang_template_args (string *decl, const char *mangled, struct dlang_info *info)
1804 while (mangled && *mangled != '\0')
1806 switch (*mangled)
1809 mangled++;
1810 return mangled;
1817 if (*mangled == 'H')
1818 mangled++;
1820 switch (*mangled)
1823 mangled++;
1824 mangled = dlang_template_symbol_param (decl, mangled, info);
1827 mangled++;
1828 mangled = dlang_type (decl, mangled, info);
1836 mangled++;
1837 type = *mangled;
1843 if (dlang_backref (mangled, &backref, info) == NULL)
1852 mangled = dlang_type (&name, mangled, info);
1856 mangled = dlang_value (decl, mangled, name.b, type, info);
1860 case 'X': /* Externally mangled parameter. */
1865 mangled++;
1866 endptr = dlang_number (mangled, &len);
1871 mangled = endptr + len;
1879 return mangled;
1882 /* Extract and demangle the template symbol in MANGLED, expected to
1886 dlang_parse_template (string *decl, const char *mangled,
1889 const char *start = mangled;
1904 if (!dlang_symbol_name_p (mangled + 3, info) || mangled[3] == '0')
1907 mangled += 3;
1910 mangled = dlang_identifier (decl, mangled, info);
1914 mangled = dlang_template_args (&args, mangled, info);
1924 && mangled
1925 && (unsigned long) (mangled - start) != len)
1928 return mangled;
1933 dlang_demangle_init_info (const char *mangled, int last_backref,
1936 info->s = mangled;
1940 /* Extract and demangle the symbol in MANGLED. Returns the demangled
1944 dlang_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
1949 if (mangled == NULL || *mangled == '\0')
1952 if (strncmp (mangled, "_D", 2) != 0)
1957 if (strcmp (mangled, "_Dmain") == 0)
1965 dlang_demangle_init_info (mangled, strlen (mangled), &info);
1966 mangled = dlang_parse_mangle (&decl, mangled, &info);
1969 if (mangled == NULL || *mangled != '\0')
Indexes created Sun Mar 01 05:31:48 UTC 2026