1 /* Demangler for the D programming language 2 Copyright (C) 2014-2024 Free Software Foundation, Inc. 3 Written by Iain Buclaw (ibuclaw (at) gdcproject.org) 4 5 This file is part of the libiberty library. 6 Libiberty is free software; you can redistribute it and/or 7 modify it under the terms of the GNU Library General Public 8 License as published by the Free Software Foundation; either 9 version 2 of the License, or (at your option) any later version. 10 11 In addition to the permissions in the GNU Library General Public 12 License, the Free Software Foundation gives you unlimited permission 13 to link the compiled version of this file into combinations with other 14 programs, and to distribute those combinations without any restriction 15 coming from the use of this file. (The Library Public License 16 restrictions do apply in other respects; for example, they cover 17 modification of the file, and distribution when not linked into a 18 combined executable.) 19 20 Libiberty is distributed in the hope that it will be useful, 21 but WITHOUT ANY WARRANTY; without even the implied warranty of 22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23 Library General Public License for more details. 24 25 You should have received a copy of the GNU Library General Public 26 License along with libiberty; see the file COPYING.LIB. 27 If not, see <http://www.gnu.org/licenses/>. */ 28 29 /* This file exports one function; dlang_demangle. */ 30 31 #ifdef HAVE_CONFIG_H 32 #include "config.h" 33 #endif 34 #ifdef HAVE_LIMITS_H 35 #include <limits.h> 36 #endif 37 38 #include "safe-ctype.h" 39 40 #include <sys/types.h> 41 #include <string.h> 42 #include <stdio.h> 43 44 #ifdef HAVE_STDLIB_H 45 #include <stdlib.h> 46 #endif 47 48 #include <demangle.h> 49 #include "libiberty.h" 50 51 #ifndef ULONG_MAX 52 #define ULONG_MAX (~0UL) 53 #endif 54 #ifndef UINT_MAX 55 #define UINT_MAX (~0U) 56 #endif 57 58 /* A mini string-handling package */ 59 60 typedef struct string /* Beware: these aren't required to be */ 61 { /* '\0' terminated. */ 62 char *b; /* pointer to start of string */ 63 char *p; /* pointer after last character */ 64 char *e; /* pointer after end of allocated space */ 65 } string; 66 67 static void 68 string_need (string *s, size_t n) 69 { 70 size_t tem; 71 72 if (s->b == NULL) 73 { 74 if (n < 32) 75 { 76 n = 32; 77 } 78 s->p = s->b = XNEWVEC (char, n); 79 s->e = s->b + n; 80 } 81 else if ((size_t) (s->e - s->p) < n) 82 { 83 tem = s->p - s->b; 84 n += tem; 85 n *= 2; 86 s->b = XRESIZEVEC (char, s->b, n); 87 s->p = s->b + tem; 88 s->e = s->b + n; 89 } 90 } 91 92 static void 93 string_delete (string *s) 94 { 95 if (s->b != NULL) 96 { 97 XDELETEVEC (s->b); 98 s->b = s->e = s->p = NULL; 99 } 100 } 101 102 static void 103 string_init (string *s) 104 { 105 s->b = s->p = s->e = NULL; 106 } 107 108 static int 109 string_length (string *s) 110 { 111 if (s->p == s->b) 112 { 113 return 0; 114 } 115 return s->p - s->b; 116 } 117 118 static void 119 string_setlength (string *s, int n) 120 { 121 if (n - string_length (s) < 0) 122 { 123 s->p = s->b + n; 124 } 125 } 126 127 static void 128 string_append (string *p, const char *s) 129 { 130 size_t n = strlen (s); 131 string_need (p, n); 132 memcpy (p->p, s, n); 133 p->p += n; 134 } 135 136 static void 137 string_appendn (string *p, const char *s, size_t n) 138 { 139 if (n != 0) 140 { 141 string_need (p, n); 142 memcpy (p->p, s, n); 143 p->p += n; 144 } 145 } 146 147 static void 148 string_prependn (string *p, const char *s, size_t n) 149 { 150 char *q; 151 152 if (n != 0) 153 { 154 string_need (p, n); 155 for (q = p->p - 1; q >= p->b; q--) 156 { 157 q[n] = q[0]; 158 } 159 memcpy (p->b, s, n); 160 p->p += n; 161 } 162 } 163 164 static void 165 string_prepend (string *p, const char *s) 166 { 167 if (s != NULL && *s != '\0') 168 { 169 string_prependn (p, s, strlen (s)); 170 } 171 } 172 173 /* Demangle information structure we pass around. */ 174 struct dlang_info 175 { 176 /* The string we are demangling. */ 177 const char *s; 178 /* The index of the last back reference. */ 179 int last_backref; 180 }; 181 182 /* Pass as the LEN to dlang_parse_template if symbol length is not known. */ 183 #define TEMPLATE_LENGTH_UNKNOWN (-1UL) 184 185 /* Prototypes for forward referenced functions */ 186 static const char *dlang_function_type (string *, const char *, 187 struct dlang_info *); 188 189 static const char *dlang_function_args (string *, const char *, 190 struct dlang_info *); 191 192 static const char *dlang_type (string *, const char *, struct dlang_info *); 193 194 static const char *dlang_value (string *, const char *, const char *, char, 195 struct dlang_info *); 196 197 static const char *dlang_parse_qualified (string *, const char *, 198 struct dlang_info *, int); 199 200 static const char *dlang_parse_mangle (string *, const char *, 201 struct dlang_info *); 202 203 static const char *dlang_parse_tuple (string *, const char *, 204 struct dlang_info *); 205 206 static const char *dlang_parse_template (string *, const char *, 207 struct dlang_info *, unsigned long); 208 209 static const char *dlang_lname (string *, const char *, unsigned long); 210 211 212 /* Extract the number from MANGLED, and assign the result to RET. 213 Return the remaining string on success or NULL on failure. 214 A result larger than UINT_MAX is considered a failure. */ 215 static const char * 216 dlang_number (const char *mangled, unsigned long *ret) 217 { 218 /* Return NULL if trying to extract something that isn't a digit. */ 219 if (mangled == NULL || !ISDIGIT (*mangled)) 220 return NULL; 221 222 unsigned long val = 0; 223 224 while (ISDIGIT (*mangled)) 225 { 226 unsigned long digit = mangled[0] - '0'; 227 228 /* Check for overflow. */ 229 if (val > (UINT_MAX - digit) / 10) 230 return NULL; 231 232 val = val * 10 + digit; 233 mangled++; 234 } 235 236 if (*mangled == '\0') 237 return NULL; 238 239 *ret = val; 240 return mangled; 241 } 242 243 /* Extract the hex-digit from MANGLED, and assign the result to RET. 244 Return the remaining string on success or NULL on failure. */ 245 static const char * 246 dlang_hexdigit (const char *mangled, char *ret) 247 { 248 char c; 249 250 /* Return NULL if trying to extract something that isn't a hexdigit. */ 251 if (mangled == NULL || !ISXDIGIT (mangled[0]) || !ISXDIGIT (mangled[1])) 252 return NULL; 253 254 c = mangled[0]; 255 if (!ISDIGIT (c)) 256 *ret = c - (ISUPPER (c) ? 'A' : 'a') + 10; 257 else 258 *ret = c - '0'; 259 260 c = mangled[1]; 261 if (!ISDIGIT (c)) 262 *ret = (*ret << 4) | (c - (ISUPPER (c) ? 'A' : 'a') + 10); 263 else 264 *ret = (*ret << 4) | (c - '0'); 265 266 mangled += 2; 267 268 return mangled; 269 } 270 271 /* Extract the function calling convention from MANGLED and 272 return 1 on success or 0 on failure. */ 273 static int 274 dlang_call_convention_p (const char *mangled) 275 { 276 switch (*mangled) 277 { 278 case 'F': case 'U': case 'V': 279 case 'W': case 'R': case 'Y': 280 return 1; 281 282 default: 283 return 0; 284 } 285 } 286 287 /* Extract the back reference position from MANGLED, and assign the result 288 to RET. Return the remaining string on success or NULL on failure. 289 A result <= 0 is a failure. */ 290 static const char * 291 dlang_decode_backref (const char *mangled, long *ret) 292 { 293 /* Return NULL if trying to extract something that isn't a digit. */ 294 if (mangled == NULL || !ISALPHA (*mangled)) 295 return NULL; 296 297 /* Any identifier or non-basic type that has been emitted to the mangled 298 symbol before will not be emitted again, but is referenced by a special 299 sequence encoding the relative position of the original occurrence in the 300 mangled symbol name. 301 302 Numbers in back references are encoded with base 26 by upper case letters 303 A-Z for higher digits but lower case letters a-z for the last digit. 304 305 NumberBackRef: 306 [a-z] 307 [A-Z] NumberBackRef 308 ^ 309 */ 310 unsigned long val = 0; 311 312 while (ISALPHA (*mangled)) 313 { 314 /* Check for overflow. */ 315 if (val > (ULONG_MAX - 25) / 26) 316 break; 317 318 val *= 26; 319 320 if (mangled[0] >= 'a' && mangled[0] <= 'z') 321 { 322 val += mangled[0] - 'a'; 323 if ((long) val <= 0) 324 break; 325 *ret = val; 326 return mangled + 1; 327 } 328 329 val += mangled[0] - 'A'; 330 mangled++; 331 } 332 333 return NULL; 334 } 335 336 /* Extract the symbol pointed at by the back reference and assign the result 337 to RET. Return the remaining string on success or NULL on failure. */ 338 static const char * 339 dlang_backref (const char *mangled, const char **ret, struct dlang_info *info) 340 { 341 *ret = NULL; 342 343 if (mangled == NULL || *mangled != 'Q') 344 return NULL; 345 346 /* Position of 'Q'. */ 347 const char *qpos = mangled; 348 long refpos; 349 mangled++; 350 351 mangled = dlang_decode_backref (mangled, &refpos); 352 if (mangled == NULL) 353 return NULL; 354 355 if (refpos > qpos - info->s) 356 return NULL; 357 358 /* Set the position of the back reference. */ 359 *ret = qpos - refpos; 360 361 return mangled; 362 } 363 364 /* Demangle a back referenced symbol from MANGLED and append it to DECL. 365 Return the remaining string on success or NULL on failure. */ 366 static const char * 367 dlang_symbol_backref (string *decl, const char *mangled, 368 struct dlang_info *info) 369 { 370 /* An identifier back reference always points to a digit 0 to 9. 371 372 IdentifierBackRef: 373 Q NumberBackRef 374 ^ 375 */ 376 const char *backref; 377 unsigned long len; 378 379 /* Get position of the back reference. */ 380 mangled = dlang_backref (mangled, &backref, info); 381 382 /* Must point to a simple identifier. */ 383 backref = dlang_number (backref, &len); 384 if (backref == NULL || strlen(backref) < len) 385 return NULL; 386 387 backref = dlang_lname (decl, backref, len); 388 if (backref == NULL) 389 return NULL; 390 391 return mangled; 392 } 393 394 /* Demangle a back referenced type from MANGLED and append it to DECL. 395 IS_FUNCTION is 1 if the back referenced type is expected to be a function. 396 Return the remaining string on success or NULL on failure. */ 397 static const char * 398 dlang_type_backref (string *decl, const char *mangled, struct dlang_info *info, 399 int is_function) 400 { 401 /* A type back reference always points to a letter. 402 403 TypeBackRef: 404 Q NumberBackRef 405 ^ 406 */ 407 const char *backref; 408 409 /* If we appear to be moving backwards through the mangle string, then 410 bail as this may be a recursive back reference. */ 411 if (mangled - info->s >= info->last_backref) 412 return NULL; 413 414 int save_refpos = info->last_backref; 415 info->last_backref = mangled - info->s; 416 417 /* Get position of the back reference. */ 418 mangled = dlang_backref (mangled, &backref, info); 419 420 /* Must point to a type. */ 421 if (is_function) 422 backref = dlang_function_type (decl, backref, info); 423 else 424 backref = dlang_type (decl, backref, info); 425 426 info->last_backref = save_refpos; 427 428 if (backref == NULL) 429 return NULL; 430 431 return mangled; 432 } 433 434 /* Extract the beginning of a symbol name from MANGLED and 435 return 1 on success or 0 on failure. */ 436 static int 437 dlang_symbol_name_p (const char *mangled, struct dlang_info *info) 438 { 439 long ret; 440 const char *qref = mangled; 441 442 if (ISDIGIT (*mangled)) 443 return 1; 444 445 if (mangled[0] == '_' && mangled[1] == '_' 446 && (mangled[2] == 'T' || mangled[2] == 'U')) 447 return 1; 448 449 if (*mangled != 'Q') 450 return 0; 451 452 mangled = dlang_decode_backref (mangled + 1, &ret); 453 if (mangled == NULL || ret > qref - info->s) 454 return 0; 455 456 return ISDIGIT (qref[-ret]); 457 } 458 459 /* Demangle the calling convention from MANGLED and append it to DECL. 460 Return the remaining string on success or NULL on failure. */ 461 static const char * 462 dlang_call_convention (string *decl, const char *mangled) 463 { 464 if (mangled == NULL || *mangled == '\0') 465 return NULL; 466 467 switch (*mangled) 468 { 469 case 'F': /* (D) */ 470 mangled++; 471 break; 472 case 'U': /* (C) */ 473 mangled++; 474 string_append (decl, "extern(C) "); 475 break; 476 case 'W': /* (Windows) */ 477 mangled++; 478 string_append (decl, "extern(Windows) "); 479 break; 480 case 'V': /* (Pascal) */ 481 mangled++; 482 string_append (decl, "extern(Pascal) "); 483 break; 484 case 'R': /* (C++) */ 485 mangled++; 486 string_append (decl, "extern(C++) "); 487 break; 488 case 'Y': /* (Objective-C) */ 489 mangled++; 490 string_append (decl, "extern(Objective-C) "); 491 break; 492 default: 493 return NULL; 494 } 495 496 return mangled; 497 } 498 499 /* Extract the type modifiers from MANGLED and append them to DECL. 500 Returns the remaining signature on success or NULL on failure. */ 501 static const char * 502 dlang_type_modifiers (string *decl, const char *mangled) 503 { 504 if (mangled == NULL || *mangled == '\0') 505 return NULL; 506 507 switch (*mangled) 508 { 509 case 'x': /* const */ 510 mangled++; 511 string_append (decl, " const"); 512 return mangled; 513 case 'y': /* immutable */ 514 mangled++; 515 string_append (decl, " immutable"); 516 return mangled; 517 case 'O': /* shared */ 518 mangled++; 519 string_append (decl, " shared"); 520 return dlang_type_modifiers (decl, mangled); 521 case 'N': 522 mangled++; 523 if (*mangled == 'g') /* wild */ 524 { 525 mangled++; 526 string_append (decl, " inout"); 527 return dlang_type_modifiers (decl, mangled); 528 } 529 else 530 return NULL; 531 532 default: 533 return mangled; 534 } 535 } 536 537 /* Demangle the D function attributes from MANGLED and append it to DECL. 538 Return the remaining string on success or NULL on failure. */ 539 static const char * 540 dlang_attributes (string *decl, const char *mangled) 541 { 542 if (mangled == NULL || *mangled == '\0') 543 return NULL; 544 545 while (*mangled == 'N') 546 { 547 mangled++; 548 switch (*mangled) 549 { 550 case 'a': /* pure */ 551 mangled++; 552 string_append (decl, "pure "); 553 continue; 554 case 'b': /* nothrow */ 555 mangled++; 556 string_append (decl, "nothrow "); 557 continue; 558 case 'c': /* ref */ 559 mangled++; 560 string_append (decl, "ref "); 561 continue; 562 case 'd': /* @property */ 563 mangled++; 564 string_append (decl, "@property "); 565 continue; 566 case 'e': /* @trusted */ 567 mangled++; 568 string_append (decl, "@trusted "); 569 continue; 570 case 'f': /* @safe */ 571 mangled++; 572 string_append (decl, "@safe "); 573 continue; 574 case 'g': 575 case 'h': 576 case 'k': 577 case 'n': 578 /* inout parameter is represented as 'Ng'. 579 vector parameter is represented as 'Nh'. 580 return parameter is represented as 'Nk'. 581 typeof(*null) parameter is represented as 'Nn'. 582 If we see this, then we know we're really in the 583 parameter list. Rewind and break. */ 584 mangled--; 585 break; 586 case 'i': /* @nogc */ 587 mangled++; 588 string_append (decl, "@nogc "); 589 continue; 590 case 'j': /* return */ 591 mangled++; 592 string_append (decl, "return "); 593 continue; 594 case 'l': /* scope */ 595 mangled++; 596 string_append (decl, "scope "); 597 continue; 598 case 'm': /* @live */ 599 mangled++; 600 string_append (decl, "@live "); 601 continue; 602 603 default: /* unknown attribute */ 604 return NULL; 605 } 606 break; 607 } 608 609 return mangled; 610 } 611 612 /* Demangle the function type from MANGLED without the return type. 613 The arguments are appended to ARGS, the calling convention is appended 614 to CALL and attributes are appended to ATTR. Any of these can be NULL 615 to throw the information away. Return the remaining string on success 616 or NULL on failure. */ 617 static const char * 618 dlang_function_type_noreturn (string *args, string *call, string *attr, 619 const char *mangled, struct dlang_info *info) 620 { 621 string dump; 622 string_init (&dump); 623 624 /* Skip over calling convention and attributes. */ 625 mangled = dlang_call_convention (call ? call : &dump, mangled); 626 mangled = dlang_attributes (attr ? attr : &dump, mangled); 627 628 if (args) 629 string_append (args, "("); 630 631 mangled = dlang_function_args (args ? args : &dump, mangled, info); 632 if (args) 633 string_append (args, ")"); 634 635 string_delete (&dump); 636 return mangled; 637 } 638 639 /* Demangle the function type from MANGLED and append it to DECL. 640 Return the remaining string on success or NULL on failure. */ 641 static const char * 642 dlang_function_type (string *decl, const char *mangled, struct dlang_info *info) 643 { 644 string attr, args, type; 645 646 if (mangled == NULL || *mangled == '\0') 647 return NULL; 648 649 /* The order of the mangled string is: 650 CallConvention FuncAttrs Arguments ArgClose Type 651 652 The demangled string is re-ordered as: 653 CallConvention Type Arguments FuncAttrs 654 */ 655 string_init (&attr); 656 string_init (&args); 657 string_init (&type); 658 659 mangled = dlang_function_type_noreturn (&args, decl, &attr, mangled, info); 660 661 /* Function return type. */ 662 mangled = dlang_type (&type, mangled, info); 663 664 /* Append to decl in order. */ 665 string_appendn (decl, type.b, string_length (&type)); 666 string_appendn (decl, args.b, string_length (&args)); 667 string_append (decl, " "); 668 string_appendn (decl, attr.b, string_length (&attr)); 669 670 string_delete (&attr); 671 string_delete (&args); 672 string_delete (&type); 673 return mangled; 674 } 675 676 /* Demangle the argument list from MANGLED and append it to DECL. 677 Return the remaining string on success or NULL on failure. */ 678 static const char * 679 dlang_function_args (string *decl, const char *mangled, struct dlang_info *info) 680 { 681 size_t n = 0; 682 683 while (mangled && *mangled != '\0') 684 { 685 switch (*mangled) 686 { 687 case 'X': /* (variadic T t...) style. */ 688 mangled++; 689 string_append (decl, "..."); 690 return mangled; 691 case 'Y': /* (variadic T t, ...) style. */ 692 mangled++; 693 if (n != 0) 694 string_append (decl, ", "); 695 string_append (decl, "..."); 696 return mangled; 697 case 'Z': /* Normal function. */ 698 mangled++; 699 return mangled; 700 } 701 702 if (n++) 703 string_append (decl, ", "); 704 705 if (*mangled == 'M') /* scope(T) */ 706 { 707 mangled++; 708 string_append (decl, "scope "); 709 } 710 711 if (mangled[0] == 'N' && mangled[1] == 'k') /* return(T) */ 712 { 713 mangled += 2; 714 string_append (decl, "return "); 715 } 716 717 switch (*mangled) 718 { 719 case 'I': /* in(T) */ 720 mangled++; 721 string_append (decl, "in "); 722 if (*mangled == 'K') /* in ref(T) */ 723 { 724 mangled++; 725 string_append (decl, "ref "); 726 } 727 break; 728 case 'J': /* out(T) */ 729 mangled++; 730 string_append (decl, "out "); 731 break; 732 case 'K': /* ref(T) */ 733 mangled++; 734 string_append (decl, "ref "); 735 break; 736 case 'L': /* lazy(T) */ 737 mangled++; 738 string_append (decl, "lazy "); 739 break; 740 } 741 mangled = dlang_type (decl, mangled, info); 742 } 743 744 return mangled; 745 } 746 747 /* Demangle the type from MANGLED and append it to DECL. 748 Return the remaining string on success or NULL on failure. */ 749 static const char * 750 dlang_type (string *decl, const char *mangled, struct dlang_info *info) 751 { 752 if (mangled == NULL || *mangled == '\0') 753 return NULL; 754 755 switch (*mangled) 756 { 757 case 'O': /* shared(T) */ 758 mangled++; 759 string_append (decl, "shared("); 760 mangled = dlang_type (decl, mangled, info); 761 string_append (decl, ")"); 762 return mangled; 763 case 'x': /* const(T) */ 764 mangled++; 765 string_append (decl, "const("); 766 mangled = dlang_type (decl, mangled, info); 767 string_append (decl, ")"); 768 return mangled; 769 case 'y': /* immutable(T) */ 770 mangled++; 771 string_append (decl, "immutable("); 772 mangled = dlang_type (decl, mangled, info); 773 string_append (decl, ")"); 774 return mangled; 775 case 'N': 776 mangled++; 777 if (*mangled == 'g') /* wild(T) */ 778 { 779 mangled++; 780 string_append (decl, "inout("); 781 mangled = dlang_type (decl, mangled, info); 782 string_append (decl, ")"); 783 return mangled; 784 } 785 else if (*mangled == 'h') /* vector(T) */ 786 { 787 mangled++; 788 string_append (decl, "__vector("); 789 mangled = dlang_type (decl, mangled, info); 790 string_append (decl, ")"); 791 return mangled; 792 } 793 else if (*mangled == 'n') /* typeof(*null) */ 794 { 795 mangled++; 796 string_append (decl, "typeof(*null)"); 797 return mangled; 798 } 799 else 800 return NULL; 801 case 'A': /* dynamic array (T[]) */ 802 mangled++; 803 mangled = dlang_type (decl, mangled, info); 804 string_append (decl, "[]"); 805 return mangled; 806 case 'G': /* static array (T[N]) */ 807 { 808 const char *numptr; 809 size_t num = 0; 810 mangled++; 811 812 numptr = mangled; 813 while (ISDIGIT (*mangled)) 814 { 815 num++; 816 mangled++; 817 } 818 mangled = dlang_type (decl, mangled, info); 819 string_append (decl, "["); 820 string_appendn (decl, numptr, num); 821 string_append (decl, "]"); 822 return mangled; 823 } 824 case 'H': /* associative array (T[T]) */ 825 { 826 string type; 827 size_t sztype; 828 mangled++; 829 830 string_init (&type); 831 mangled = dlang_type (&type, mangled, info); 832 sztype = string_length (&type); 833 834 mangled = dlang_type (decl, mangled, info); 835 string_append (decl, "["); 836 string_appendn (decl, type.b, sztype); 837 string_append (decl, "]"); 838 839 string_delete (&type); 840 return mangled; 841 } 842 case 'P': /* pointer (T*) */ 843 mangled++; 844 if (!dlang_call_convention_p (mangled)) 845 { 846 mangled = dlang_type (decl, mangled, info); 847 string_append (decl, "*"); 848 return mangled; 849 } 850 /* Fall through */ 851 case 'F': /* function T (D) */ 852 case 'U': /* function T (C) */ 853 case 'W': /* function T (Windows) */ 854 case 'V': /* function T (Pascal) */ 855 case 'R': /* function T (C++) */ 856 case 'Y': /* function T (Objective-C) */ 857 /* Function pointer types don't include the trailing asterisk. */ 858 mangled = dlang_function_type (decl, mangled, info); 859 string_append (decl, "function"); 860 return mangled; 861 case 'C': /* class T */ 862 case 'S': /* struct T */ 863 case 'E': /* enum T */ 864 case 'T': /* typedef T */ 865 mangled++; 866 return dlang_parse_qualified (decl, mangled, info, 0); 867 case 'D': /* delegate T */ 868 { 869 string mods; 870 size_t szmods; 871 mangled++; 872 873 string_init (&mods); 874 mangled = dlang_type_modifiers (&mods, mangled); 875 szmods = string_length (&mods); 876 877 /* Back referenced function type. */ 878 if (mangled && *mangled == 'Q') 879 mangled = dlang_type_backref (decl, mangled, info, 1); 880 else 881 mangled = dlang_function_type (decl, mangled, info); 882 883 string_append (decl, "delegate"); 884 string_appendn (decl, mods.b, szmods); 885 886 string_delete (&mods); 887 return mangled; 888 } 889 case 'B': /* tuple T */ 890 mangled++; 891 return dlang_parse_tuple (decl, mangled, info); 892 893 /* Basic types */ 894 case 'n': 895 mangled++; 896 string_append (decl, "typeof(null)"); 897 return mangled; 898 case 'v': 899 mangled++; 900 string_append (decl, "void"); 901 return mangled; 902 case 'g': 903 mangled++; 904 string_append (decl, "byte"); 905 return mangled; 906 case 'h': 907 mangled++; 908 string_append (decl, "ubyte"); 909 return mangled; 910 case 's': 911 mangled++; 912 string_append (decl, "short"); 913 return mangled; 914 case 't': 915 mangled++; 916 string_append (decl, "ushort"); 917 return mangled; 918 case 'i': 919 mangled++; 920 string_append (decl, "int"); 921 return mangled; 922 case 'k': 923 mangled++; 924 string_append (decl, "uint"); 925 return mangled; 926 case 'l': 927 mangled++; 928 string_append (decl, "long"); 929 return mangled; 930 case 'm': 931 mangled++; 932 string_append (decl, "ulong"); 933 return mangled; 934 case 'f': 935 mangled++; 936 string_append (decl, "float"); 937 return mangled; 938 case 'd': 939 mangled++; 940 string_append (decl, "double"); 941 return mangled; 942 case 'e': 943 mangled++; 944 string_append (decl, "real"); 945 return mangled; 946 947 /* Imaginary and Complex types */ 948 case 'o': 949 mangled++; 950 string_append (decl, "ifloat"); 951 return mangled; 952 case 'p': 953 mangled++; 954 string_append (decl, "idouble"); 955 return mangled; 956 case 'j': 957 mangled++; 958 string_append (decl, "ireal"); 959 return mangled; 960 case 'q': 961 mangled++; 962 string_append (decl, "cfloat"); 963 return mangled; 964 case 'r': 965 mangled++; 966 string_append (decl, "cdouble"); 967 return mangled; 968 case 'c': 969 mangled++; 970 string_append (decl, "creal"); 971 return mangled; 972 973 /* Other types */ 974 case 'b': 975 mangled++; 976 string_append (decl, "bool"); 977 return mangled; 978 case 'a': 979 mangled++; 980 string_append (decl, "char"); 981 return mangled; 982 case 'u': 983 mangled++; 984 string_append (decl, "wchar"); 985 return mangled; 986 case 'w': 987 mangled++; 988 string_append (decl, "dchar"); 989 return mangled; 990 case 'z': 991 mangled++; 992 switch (*mangled) 993 { 994 case 'i': 995 mangled++; 996 string_append (decl, "cent"); 997 return mangled; 998 case 'k': 999 mangled++; 1000 string_append (decl, "ucent"); 1001 return mangled; 1002 } 1003 return NULL; 1004 1005 /* Back referenced type. */ 1006 case 'Q': 1007 return dlang_type_backref (decl, mangled, info, 0); 1008 1009 default: /* unhandled */ 1010 return NULL; 1011 } 1012 } 1013 1014 /* Extract the identifier from MANGLED and append it to DECL. 1015 Return the remaining string on success or NULL on failure. */ 1016 static const char * 1017 dlang_identifier (string *decl, const char *mangled, struct dlang_info *info) 1018 { 1019 unsigned long len; 1020 1021 if (mangled == NULL || *mangled == '\0') 1022 return NULL; 1023 1024 if (*mangled == 'Q') 1025 return dlang_symbol_backref (decl, mangled, info); 1026 1027 /* May be a template instance without a length prefix. */ 1028 if (mangled[0] == '_' && mangled[1] == '_' 1029 && (mangled[2] == 'T' || mangled[2] == 'U')) 1030 return dlang_parse_template (decl, mangled, info, TEMPLATE_LENGTH_UNKNOWN); 1031 1032 const char *endptr = dlang_number (mangled, &len); 1033 1034 if (endptr == NULL || len == 0) 1035 return NULL; 1036 1037 if (strlen (endptr) < len) 1038 return NULL; 1039 1040 mangled = endptr; 1041 1042 /* May be a template instance with a length prefix. */ 1043 if (len >= 5 && mangled[0] == '_' && mangled[1] == '_' 1044 && (mangled[2] == 'T' || mangled[2] == 'U')) 1045 return dlang_parse_template (decl, mangled, info, len); 1046 1047 /* There can be multiple different declarations in the same function that have 1048 the same mangled name. To make the mangled names unique, a fake parent in 1049 the form `__Sddd' is added to the symbol. */ 1050 if (len >= 4 && mangled[0] == '_' && mangled[1] == '_' && mangled[2] == 'S') 1051 { 1052 const char *numptr = mangled + 3; 1053 while (numptr < (mangled + len) && ISDIGIT (*numptr)) 1054 numptr++; 1055 1056 if (mangled + len == numptr) 1057 { 1058 /* Skip over the fake parent. */ 1059 mangled += len; 1060 return dlang_identifier (decl, mangled, info); 1061 } 1062 1063 /* else demangle it as a plain identifier. */ 1064 } 1065 1066 return dlang_lname (decl, mangled, len); 1067 } 1068 1069 /* Extract the plain identifier from MANGLED and prepend/append it to DECL 1070 with special treatment for some magic compiler generted symbols. 1071 Return the remaining string on success or NULL on failure. */ 1072 static const char * 1073 dlang_lname (string *decl, const char *mangled, unsigned long len) 1074 { 1075 switch (len) 1076 { 1077 case 6: 1078 if (strncmp (mangled, "__ctor", len) == 0) 1079 { 1080 /* Constructor symbol for a class/struct. */ 1081 string_append (decl, "this"); 1082 mangled += len; 1083 return mangled; 1084 } 1085 else if (strncmp (mangled, "__dtor", len) == 0) 1086 { 1087 /* Destructor symbol for a class/struct. */ 1088 string_append (decl, "~this"); 1089 mangled += len; 1090 return mangled; 1091 } 1092 else if (strncmp (mangled, "__initZ", len + 1) == 0) 1093 { 1094 /* The static initialiser for a given symbol. */ 1095 string_prepend (decl, "initializer for "); 1096 string_setlength (decl, string_length (decl) - 1); 1097 mangled += len; 1098 return mangled; 1099 } 1100 else if (strncmp (mangled, "__vtblZ", len + 1) == 0) 1101 { 1102 /* The vtable symbol for a given class. */ 1103 string_prepend (decl, "vtable for "); 1104 string_setlength (decl, string_length (decl) - 1); 1105 mangled += len; 1106 return mangled; 1107 } 1108 break; 1109 1110 case 7: 1111 if (strncmp (mangled, "__ClassZ", len + 1) == 0) 1112 { 1113 /* The classinfo symbol for a given class. */ 1114 string_prepend (decl, "ClassInfo for "); 1115 string_setlength (decl, string_length (decl) - 1); 1116 mangled += len; 1117 return mangled; 1118 } 1119 break; 1120 1121 case 10: 1122 if (strncmp (mangled, "__postblitMFZ", len + 3) == 0) 1123 { 1124 /* Postblit symbol for a struct. */ 1125 string_append (decl, "this(this)"); 1126 mangled += len + 3; 1127 return mangled; 1128 } 1129 break; 1130 1131 case 11: 1132 if (strncmp (mangled, "__InterfaceZ", len + 1) == 0) 1133 { 1134 /* The interface symbol for a given class. */ 1135 string_prepend (decl, "Interface for "); 1136 string_setlength (decl, string_length (decl) - 1); 1137 mangled += len; 1138 return mangled; 1139 } 1140 break; 1141 1142 case 12: 1143 if (strncmp (mangled, "__ModuleInfoZ", len + 1) == 0) 1144 { 1145 /* The ModuleInfo symbol for a given module. */ 1146 string_prepend (decl, "ModuleInfo for "); 1147 string_setlength (decl, string_length (decl) - 1); 1148 mangled += len; 1149 return mangled; 1150 } 1151 break; 1152 } 1153 1154 string_appendn (decl, mangled, len); 1155 mangled += len; 1156 1157 return mangled; 1158 } 1159 1160 /* Extract the integer value from MANGLED and append it to DECL, 1161 where TYPE is the type it should be represented as. 1162 Return the remaining string on success or NULL on failure. */ 1163 static const char * 1164 dlang_parse_integer (string *decl, const char *mangled, char type) 1165 { 1166 if (type == 'a' || type == 'u' || type == 'w') 1167 { 1168 /* Parse character value. */ 1169 char value[20]; 1170 int pos = sizeof(value); 1171 int width = 0; 1172 unsigned long val; 1173 1174 mangled = dlang_number (mangled, &val); 1175 if (mangled == NULL) 1176 return NULL; 1177 1178 string_append (decl, "'"); 1179 1180 if (type == 'a' && val >= 0x20 && val < 0x7F) 1181 { 1182 /* Represent as a character literal. */ 1183 char c = (char) val; 1184 string_appendn (decl, &c, 1); 1185 } 1186 else 1187 { 1188 /* Represent as a hexadecimal value. */ 1189 switch (type) 1190 { 1191 case 'a': /* char */ 1192 string_append (decl, "\\x"); 1193 width = 2; 1194 break; 1195 case 'u': /* wchar */ 1196 string_append (decl, "\\u"); 1197 width = 4; 1198 break; 1199 case 'w': /* dchar */ 1200 string_append (decl, "\\U"); 1201 width = 8; 1202 break; 1203 } 1204 1205 while (val > 0) 1206 { 1207 int digit = val % 16; 1208 1209 if (digit < 10) 1210 value[--pos] = (char)(digit + '0'); 1211 else 1212 value[--pos] = (char)((digit - 10) + 'a'); 1213 1214 val /= 16; 1215 width--; 1216 } 1217 1218 for (; width > 0; width--) 1219 value[--pos] = '0'; 1220 1221 string_appendn (decl, &(value[pos]), sizeof(value) - pos); 1222 } 1223 string_append (decl, "'"); 1224 } 1225 else if (type == 'b') 1226 { 1227 /* Parse boolean value. */ 1228 unsigned long val; 1229 1230 mangled = dlang_number (mangled, &val); 1231 if (mangled == NULL) 1232 return NULL; 1233 1234 string_append (decl, val ? "true" : "false"); 1235 } 1236 else 1237 { 1238 /* Parse integer value. */ 1239 const char *numptr = mangled; 1240 size_t num = 0; 1241 1242 if (! ISDIGIT (*mangled)) 1243 return NULL; 1244 1245 while (ISDIGIT (*mangled)) 1246 { 1247 num++; 1248 mangled++; 1249 } 1250 string_appendn (decl, numptr, num); 1251 1252 /* Append suffix. */ 1253 switch (type) 1254 { 1255 case 'h': /* ubyte */ 1256 case 't': /* ushort */ 1257 case 'k': /* uint */ 1258 string_append (decl, "u"); 1259 break; 1260 case 'l': /* long */ 1261 string_append (decl, "L"); 1262 break; 1263 case 'm': /* ulong */ 1264 string_append (decl, "uL"); 1265 break; 1266 } 1267 } 1268 1269 return mangled; 1270 } 1271 1272 /* Extract the floating-point value from MANGLED and append it to DECL. 1273 Return the remaining string on success or NULL on failure. */ 1274 static const char * 1275 dlang_parse_real (string *decl, const char *mangled) 1276 { 1277 /* Handle NAN and +-INF. */ 1278 if (strncmp (mangled, "NAN", 3) == 0) 1279 { 1280 string_append (decl, "NaN"); 1281 mangled += 3; 1282 return mangled; 1283 } 1284 else if (strncmp (mangled, "INF", 3) == 0) 1285 { 1286 string_append (decl, "Inf"); 1287 mangled += 3; 1288 return mangled; 1289 } 1290 else if (strncmp (mangled, "NINF", 4) == 0) 1291 { 1292 string_append (decl, "-Inf"); 1293 mangled += 4; 1294 return mangled; 1295 } 1296 1297 /* Hexadecimal prefix and leading bit. */ 1298 if (*mangled == 'N') 1299 { 1300 string_append (decl, "-"); 1301 mangled++; 1302 } 1303 1304 if (!ISXDIGIT (*mangled)) 1305 return NULL; 1306 1307 string_append (decl, "0x"); 1308 string_appendn (decl, mangled, 1); 1309 string_append (decl, "."); 1310 mangled++; 1311 1312 /* Significand. */ 1313 while (ISXDIGIT (*mangled)) 1314 { 1315 string_appendn (decl, mangled, 1); 1316 mangled++; 1317 } 1318 1319 /* Exponent. */ 1320 if (*mangled != 'P') 1321 return NULL; 1322 1323 string_append (decl, "p"); 1324 mangled++; 1325 1326 if (*mangled == 'N') 1327 { 1328 string_append (decl, "-"); 1329 mangled++; 1330 } 1331 1332 while (ISDIGIT (*mangled)) 1333 { 1334 string_appendn (decl, mangled, 1); 1335 mangled++; 1336 } 1337 1338 return mangled; 1339 } 1340 1341 /* Extract the string value from MANGLED and append it to DECL. 1342 Return the remaining string on success or NULL on failure. */ 1343 static const char * 1344 dlang_parse_string (string *decl, const char *mangled) 1345 { 1346 char type = *mangled; 1347 unsigned long len; 1348 1349 mangled++; 1350 mangled = dlang_number (mangled, &len); 1351 if (mangled == NULL || *mangled != '_') 1352 return NULL; 1353 1354 mangled++; 1355 string_append (decl, "\""); 1356 while (len--) 1357 { 1358 char val; 1359 const char *endptr = dlang_hexdigit (mangled, &val); 1360 1361 if (endptr == NULL) 1362 return NULL; 1363 1364 /* Sanitize white and non-printable characters. */ 1365 switch (val) 1366 { 1367 case ' ': 1368 string_append (decl, " "); 1369 break; 1370 case '\t': 1371 string_append (decl, "\\t"); 1372 break; 1373 case '\n': 1374 string_append (decl, "\\n"); 1375 break; 1376 case '\r': 1377 string_append (decl, "\\r"); 1378 break; 1379 case '\f': 1380 string_append (decl, "\\f"); 1381 break; 1382 case '\v': 1383 string_append (decl, "\\v"); 1384 break; 1385 1386 default: 1387 if (ISPRINT (val)) 1388 string_appendn (decl, &val, 1); 1389 else 1390 { 1391 string_append (decl, "\\x"); 1392 string_appendn (decl, mangled, 2); 1393 } 1394 } 1395 1396 mangled = endptr; 1397 } 1398 string_append (decl, "\""); 1399 1400 if (type != 'a') 1401 string_appendn (decl, &type, 1); 1402 1403 return mangled; 1404 } 1405 1406 /* Extract the static array value from MANGLED and append it to DECL. 1407 Return the remaining string on success or NULL on failure. */ 1408 static const char * 1409 dlang_parse_arrayliteral (string *decl, const char *mangled, 1410 struct dlang_info *info) 1411 { 1412 unsigned long elements; 1413 1414 mangled = dlang_number (mangled, &elements); 1415 if (mangled == NULL) 1416 return NULL; 1417 1418 string_append (decl, "["); 1419 while (elements--) 1420 { 1421 mangled = dlang_value (decl, mangled, NULL, '\0', info); 1422 if (mangled == NULL) 1423 return NULL; 1424 1425 if (elements != 0) 1426 string_append (decl, ", "); 1427 } 1428 1429 string_append (decl, "]"); 1430 return mangled; 1431 } 1432 1433 /* Extract the associative array value from MANGLED and append it to DECL. 1434 Return the remaining string on success or NULL on failure. */ 1435 static const char * 1436 dlang_parse_assocarray (string *decl, const char *mangled, 1437 struct dlang_info *info) 1438 { 1439 unsigned long elements; 1440 1441 mangled = dlang_number (mangled, &elements); 1442 if (mangled == NULL) 1443 return NULL; 1444 1445 string_append (decl, "["); 1446 while (elements--) 1447 { 1448 mangled = dlang_value (decl, mangled, NULL, '\0', info); 1449 if (mangled == NULL) 1450 return NULL; 1451 1452 string_append (decl, ":"); 1453 mangled = dlang_value (decl, mangled, NULL, '\0', info); 1454 if (mangled == NULL) 1455 return NULL; 1456 1457 if (elements != 0) 1458 string_append (decl, ", "); 1459 } 1460 1461 string_append (decl, "]"); 1462 return mangled; 1463 } 1464 1465 /* Extract the struct literal value for NAME from MANGLED and append it to DECL. 1466 Return the remaining string on success or NULL on failure. */ 1467 static const char * 1468 dlang_parse_structlit (string *decl, const char *mangled, const char *name, 1469 struct dlang_info *info) 1470 { 1471 unsigned long args; 1472 1473 mangled = dlang_number (mangled, &args); 1474 if (mangled == NULL) 1475 return NULL; 1476 1477 if (name != NULL) 1478 string_append (decl, name); 1479 1480 string_append (decl, "("); 1481 while (args--) 1482 { 1483 mangled = dlang_value (decl, mangled, NULL, '\0', info); 1484 if (mangled == NULL) 1485 return NULL; 1486 1487 if (args != 0) 1488 string_append (decl, ", "); 1489 } 1490 1491 string_append (decl, ")"); 1492 return mangled; 1493 } 1494 1495 /* Extract the value from MANGLED and append it to DECL. 1496 Return the remaining string on success or NULL on failure. */ 1497 static const char * 1498 dlang_value (string *decl, const char *mangled, const char *name, char type, 1499 struct dlang_info *info) 1500 { 1501 if (mangled == NULL || *mangled == '\0') 1502 return NULL; 1503 1504 switch (*mangled) 1505 { 1506 /* Null value. */ 1507 case 'n': 1508 mangled++; 1509 string_append (decl, "null"); 1510 break; 1511 1512 /* Integral values. */ 1513 case 'N': 1514 mangled++; 1515 string_append (decl, "-"); 1516 mangled = dlang_parse_integer (decl, mangled, type); 1517 break; 1518 1519 case 'i': 1520 mangled++; 1521 /* Fall through */ 1522 1523 /* There really should always be an `i' before encoded numbers, but there 1524 wasn't in early versions of D2, so this case range must remain for 1525 backwards compatibility. */ 1526 case '0': case '1': case '2': case '3': case '4': 1527 case '5': case '6': case '7': case '8': case '9': 1528 mangled = dlang_parse_integer (decl, mangled, type); 1529 break; 1530 1531 /* Real value. */ 1532 case 'e': 1533 mangled++; 1534 mangled = dlang_parse_real (decl, mangled); 1535 break; 1536 1537 /* Complex value. */ 1538 case 'c': 1539 mangled++; 1540 mangled = dlang_parse_real (decl, mangled); 1541 string_append (decl, "+"); 1542 if (mangled == NULL || *mangled != 'c') 1543 return NULL; 1544 mangled++; 1545 mangled = dlang_parse_real (decl, mangled); 1546 string_append (decl, "i"); 1547 break; 1548 1549 /* String values. */ 1550 case 'a': /* UTF8 */ 1551 case 'w': /* UTF16 */ 1552 case 'd': /* UTF32 */ 1553 mangled = dlang_parse_string (decl, mangled); 1554 break; 1555 1556 /* Array values. */ 1557 case 'A': 1558 mangled++; 1559 if (type == 'H') 1560 mangled = dlang_parse_assocarray (decl, mangled, info); 1561 else 1562 mangled = dlang_parse_arrayliteral (decl, mangled, info); 1563 break; 1564 1565 /* Struct values. */ 1566 case 'S': 1567 mangled++; 1568 mangled = dlang_parse_structlit (decl, mangled, name, info); 1569 break; 1570 1571 /* Function literal symbol. */ 1572 case 'f': 1573 mangled++; 1574 if (strncmp (mangled, "_D", 2) != 0 1575 || !dlang_symbol_name_p (mangled + 2, info)) 1576 return NULL; 1577 mangled = dlang_parse_mangle (decl, mangled, info); 1578 break; 1579 1580 default: 1581 return NULL; 1582 } 1583 1584 return mangled; 1585 } 1586 1587 /* Extract and demangle the symbol in MANGLED and append it to DECL. 1588 Returns the remaining signature on success or NULL on failure. */ 1589 static const char * 1590 dlang_parse_mangle (string *decl, const char *mangled, struct dlang_info *info) 1591 { 1592 /* A D mangled symbol is comprised of both scope and type information. 1593 1594 MangleName: 1595 _D QualifiedName Type 1596 _D QualifiedName Z 1597 ^ 1598 The caller should have guaranteed that the start pointer is at the 1599 above location. 1600 Note that type is never a function type, but only the return type of 1601 a function or the type of a variable. 1602 */ 1603 mangled += 2; 1604 1605 mangled = dlang_parse_qualified (decl, mangled, info, 1); 1606 1607 if (mangled != NULL) 1608 { 1609 /* Artificial symbols end with 'Z' and have no type. */ 1610 if (*mangled == 'Z') 1611 mangled++; 1612 else 1613 { 1614 /* Discard the declaration or return type. */ 1615 string type; 1616 1617 string_init (&type); 1618 mangled = dlang_type (&type, mangled, info); 1619 string_delete (&type); 1620 } 1621 } 1622 1623 return mangled; 1624 } 1625 1626 /* Extract and demangle the qualified symbol in MANGLED and append it to DECL. 1627 SUFFIX_MODIFIERS is 1 if we are printing modifiers on this after the symbol. 1628 Returns the remaining signature on success or NULL on failure. */ 1629 static const char * 1630 dlang_parse_qualified (string *decl, const char *mangled, 1631 struct dlang_info *info, int suffix_modifiers) 1632 { 1633 /* Qualified names are identifiers separated by their encoded length. 1634 Nested functions also encode their argument types without specifying 1635 what they return. 1636 1637 QualifiedName: 1638 SymbolFunctionName 1639 SymbolFunctionName QualifiedName 1640 ^ 1641 1642 SymbolFunctionName: 1643 SymbolName 1644 SymbolName TypeFunctionNoReturn 1645 SymbolName M TypeFunctionNoReturn 1646 SymbolName M TypeModifiers TypeFunctionNoReturn 1647 1648 The start pointer should be at the above location. 1649 */ 1650 size_t n = 0; 1651 do 1652 { 1653 /* Skip over anonymous symbols. */ 1654 if (*mangled == '0') 1655 { 1656 do 1657 mangled++; 1658 while (*mangled == '0'); 1659 1660 continue; 1661 } 1662 1663 if (n++) 1664 string_append (decl, "."); 1665 1666 mangled = dlang_identifier (decl, mangled, info); 1667 1668 /* Consume the encoded arguments. However if this is not followed by the 1669 next encoded length or mangle type, then this is not a continuation of 1670 a qualified name, in which case we backtrack and return the current 1671 unconsumed position of the mangled decl. */ 1672 if (mangled && (*mangled == 'M' || dlang_call_convention_p (mangled))) 1673 { 1674 string mods; 1675 const char *start = mangled; 1676 int saved = string_length (decl); 1677 1678 /* Save the type modifiers for appending at the end if needed. */ 1679 string_init (&mods); 1680 1681 /* Skip over 'this' parameter and type modifiers. */ 1682 if (*mangled == 'M') 1683 { 1684 mangled++; 1685 mangled = dlang_type_modifiers (&mods, mangled); 1686 string_setlength (decl, saved); 1687 } 1688 1689 mangled = dlang_function_type_noreturn (decl, NULL, NULL, 1690 mangled, info); 1691 if (suffix_modifiers) 1692 string_appendn (decl, mods.b, string_length (&mods)); 1693 1694 if (mangled == NULL || *mangled == '\0') 1695 { 1696 /* Did not match the rule we were looking for. */ 1697 mangled = start; 1698 string_setlength (decl, saved); 1699 } 1700 1701 string_delete (&mods); 1702 } 1703 } 1704 while (mangled && dlang_symbol_name_p (mangled, info)); 1705 1706 return mangled; 1707 } 1708 1709 /* Demangle the tuple from MANGLED and append it to DECL. 1710 Return the remaining string on success or NULL on failure. */ 1711 static const char * 1712 dlang_parse_tuple (string *decl, const char *mangled, struct dlang_info *info) 1713 { 1714 unsigned long elements; 1715 1716 mangled = dlang_number (mangled, &elements); 1717 if (mangled == NULL) 1718 return NULL; 1719 1720 string_append (decl, "Tuple!("); 1721 1722 while (elements--) 1723 { 1724 mangled = dlang_type (decl, mangled, info); 1725 if (mangled == NULL) 1726 return NULL; 1727 1728 if (elements != 0) 1729 string_append (decl, ", "); 1730 } 1731 1732 string_append (decl, ")"); 1733 return mangled; 1734 } 1735 1736 /* Demangle the template symbol parameter from MANGLED and append it to DECL. 1737 Return the remaining string on success or NULL on failure. */ 1738 static const char * 1739 dlang_template_symbol_param (string *decl, const char *mangled, 1740 struct dlang_info *info) 1741 { 1742 if (strncmp (mangled, "_D", 2) == 0 1743 && dlang_symbol_name_p (mangled + 2, info)) 1744 return dlang_parse_mangle (decl, mangled, info); 1745 1746 if (*mangled == 'Q') 1747 return dlang_parse_qualified (decl, mangled, info, 0); 1748 1749 unsigned long len; 1750 const char *endptr = dlang_number (mangled, &len); 1751 1752 if (endptr == NULL || len == 0) 1753 return NULL; 1754 1755 /* In template parameter symbols generated by the frontend up to 2.076, 1756 the symbol length is encoded and the first character of the mangled 1757 name can be a digit. This causes ambiguity issues because the digits 1758 of the two numbers are adjacent. */ 1759 long psize = len; 1760 const char *pend; 1761 int saved = string_length (decl); 1762 1763 /* Work backwards until a match is found. */ 1764 for (pend = endptr; endptr != NULL; pend--) 1765 { 1766 mangled = pend; 1767 1768 /* Reached the beginning of the pointer to the name length, 1769 try parsing the entire symbol. */ 1770 if (psize == 0) 1771 { 1772 psize = len; 1773 pend = endptr; 1774 endptr = NULL; 1775 } 1776 1777 /* Check whether template parameter is a function with a valid 1778 return type or an untyped identifier. */ 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); 1784 1785 /* Check for name length mismatch. */ 1786 if (mangled && (endptr == NULL || (mangled - pend) == psize)) 1787 return mangled; 1788 1789 psize /= 10; 1790 string_setlength (decl, saved); 1791 } 1792 1793 /* No match on any combinations. */ 1794 return NULL; 1795 } 1796 1797 /* Demangle the argument list from MANGLED and append it to DECL. 1798 Return the remaining string on success or NULL on failure. */ 1799 static const char * 1800 dlang_template_args (string *decl, const char *mangled, struct dlang_info *info) 1801 { 1802 size_t n = 0; 1803 1804 while (mangled && *mangled != '\0') 1805 { 1806 switch (*mangled) 1807 { 1808 case 'Z': /* End of parameter list. */ 1809 mangled++; 1810 return mangled; 1811 } 1812 1813 if (n++) 1814 string_append (decl, ", "); 1815 1816 /* Skip over specialised template prefix. */ 1817 if (*mangled == 'H') 1818 mangled++; 1819 1820 switch (*mangled) 1821 { 1822 case 'S': /* Symbol parameter. */ 1823 mangled++; 1824 mangled = dlang_template_symbol_param (decl, mangled, info); 1825 break; 1826 case 'T': /* Type parameter. */ 1827 mangled++; 1828 mangled = dlang_type (decl, mangled, info); 1829 break; 1830 case 'V': /* Value parameter. */ 1831 { 1832 string name; 1833 char type; 1834 1835 /* Peek at the type. */ 1836 mangled++; 1837 type = *mangled; 1838 1839 if (type == 'Q') 1840 { 1841 /* Value type is a back reference, peek at the real type. */ 1842 const char *backref; 1843 if (dlang_backref (mangled, &backref, info) == NULL) 1844 return NULL; 1845 1846 type = *backref; 1847 } 1848 1849 /* In the few instances where the type is actually desired in 1850 the output, it should precede the value from dlang_value. */ 1851 string_init (&name); 1852 mangled = dlang_type (&name, mangled, info); 1853 string_need (&name, 1); 1854 *(name.p) = '\0'; 1855 1856 mangled = dlang_value (decl, mangled, name.b, type, info); 1857 string_delete (&name); 1858 break; 1859 } 1860 case 'X': /* Externally mangled parameter. */ 1861 { 1862 unsigned long len; 1863 const char *endptr; 1864 1865 mangled++; 1866 endptr = dlang_number (mangled, &len); 1867 if (endptr == NULL || strlen (endptr) < len) 1868 return NULL; 1869 1870 string_appendn (decl, endptr, len); 1871 mangled = endptr + len; 1872 break; 1873 } 1874 default: 1875 return NULL; 1876 } 1877 } 1878 1879 return mangled; 1880 } 1881 1882 /* Extract and demangle the template symbol in MANGLED, expected to 1883 be made up of LEN characters (-1 if unknown), and append it to DECL. 1884 Returns the remaining signature on success or NULL on failure. */ 1885 static const char * 1886 dlang_parse_template (string *decl, const char *mangled, 1887 struct dlang_info *info, unsigned long len) 1888 { 1889 const char *start = mangled; 1890 string args; 1891 1892 /* Template instance names have the types and values of its parameters 1893 encoded into it. 1894 1895 TemplateInstanceName: 1896 Number __T LName TemplateArgs Z 1897 Number __U LName TemplateArgs Z 1898 ^ 1899 The start pointer should be at the above location, and LEN should be 1900 the value of the decoded number. 1901 */ 1902 1903 /* Template symbol. */ 1904 if (!dlang_symbol_name_p (mangled + 3, info) || mangled[3] == '0') 1905 return NULL; 1906 1907 mangled += 3; 1908 1909 /* Template identifier. */ 1910 mangled = dlang_identifier (decl, mangled, info); 1911 1912 /* Template arguments. */ 1913 string_init (&args); 1914 mangled = dlang_template_args (&args, mangled, info); 1915 1916 string_append (decl, "!("); 1917 string_appendn (decl, args.b, string_length (&args)); 1918 string_append (decl, ")"); 1919 1920 string_delete (&args); 1921 1922 /* Check for template name length mismatch. */ 1923 if (len != TEMPLATE_LENGTH_UNKNOWN 1924 && mangled 1925 && (unsigned long) (mangled - start) != len) 1926 return NULL; 1927 1928 return mangled; 1929 } 1930 1931 /* Initialize the information structure we use to pass around information. */ 1932 static void 1933 dlang_demangle_init_info (const char *mangled, int last_backref, 1934 struct dlang_info *info) 1935 { 1936 info->s = mangled; 1937 info->last_backref = last_backref; 1938 } 1939 1940 /* Extract and demangle the symbol in MANGLED. Returns the demangled 1941 signature on success or NULL on failure. */ 1942 1943 char * 1944 dlang_demangle (const char *mangled, int option ATTRIBUTE_UNUSED) 1945 { 1946 string decl; 1947 char *demangled = NULL; 1948 1949 if (mangled == NULL || *mangled == '\0') 1950 return NULL; 1951 1952 if (strncmp (mangled, "_D", 2) != 0) 1953 return NULL; 1954 1955 string_init (&decl); 1956 1957 if (strcmp (mangled, "_Dmain") == 0) 1958 { 1959 string_append (&decl, "D main"); 1960 } 1961 else 1962 { 1963 struct dlang_info info; 1964 1965 dlang_demangle_init_info (mangled, strlen (mangled), &info); 1966 mangled = dlang_parse_mangle (&decl, mangled, &info); 1967 1968 /* Check that the entire symbol was successfully demangled. */ 1969 if (mangled == NULL || *mangled != '\0') 1970 string_delete (&decl); 1971 } 1972 1973 if (string_length (&decl) > 0) 1974 { 1975 string_need (&decl, 1); 1976 *(decl.p) = '\0'; 1977 demangled = decl.b; 1978 } 1979 1980 return demangled; 1981 } 1982 1983
Indexes created Sat Feb 28 05:31:39 UTC 2026