1 /* Demangler for the D programming language
2    Copyright 2014, 2015, 2016 Free Software Foundation, Inc.
3    Written by Iain Buclaw (ibuclaw@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    This file imports strtol for decoding mangled literals.  */
32 
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36 
37 #include "safe-ctype.h"
38 
39 #include <sys/types.h>
40 #include <string.h>
41 #include <stdio.h>
42 
43 #ifdef HAVE_STDLIB_H
44 #include <stdlib.h>
45 #else
46 extern long strtol (const char *nptr, char **endptr, int base);
47 #endif
48 
49 #include <demangle.h>
50 #include "libiberty.h"
51 
52 /* A mini string-handling package */
53 
54 typedef struct string		/* Beware: these aren't required to be */
55 {				/*  '\0' terminated.  */
56   char *b;			/* pointer to start of string */
57   char *p;			/* pointer after last character */
58   char *e;			/* pointer after end of allocated space */
59 } string;
60 
61 static void
62 string_need (string *s, int n)
63 {
64   int tem;
65 
66   if (s->b == NULL)
67     {
68       if (n < 32)
69 	{
70 	  n = 32;
71 	}
72       s->p = s->b = XNEWVEC (char, n);
73       s->e = s->b + n;
74     }
75   else if (s->e - s->p < n)
76     {
77       tem = s->p - s->b;
78       n += tem;
79       n *= 2;
80       s->b = XRESIZEVEC (char, s->b, n);
81       s->p = s->b + tem;
82       s->e = s->b + n;
83     }
84 }
85 
86 static void
87 string_delete (string *s)
88 {
89   if (s->b != NULL)
90     {
91       XDELETEVEC (s->b);
92       s->b = s->e = s->p = NULL;
93     }
94 }
95 
96 static void
97 string_init (string *s)
98 {
99   s->b = s->p = s->e = NULL;
100 }
101 
102 static int
103 string_length (string *s)
104 {
105   if (s->p == s->b)
106     {
107       return 0;
108     }
109   return s->p - s->b;
110 }
111 
112 static void
113 string_setlength (string *s, int n)
114 {
115   if (n - string_length (s) < 0)
116     {
117       s->p = s->b + n;
118     }
119 }
120 
121 static void
122 string_append (string *p, const char *s)
123 {
124   int n = strlen (s);
125   string_need (p, n);
126   memcpy (p->p, s, n);
127   p->p += n;
128 }
129 
130 static void
131 string_appendn (string *p, const char *s, int n)
132 {
133   if (n != 0)
134     {
135       string_need (p, n);
136       memcpy (p->p, s, n);
137       p->p += n;
138     }
139 }
140 
141 static void
142 string_prependn (string *p, const char *s, int n)
143 {
144   char *q;
145 
146   if (n != 0)
147     {
148       string_need (p, n);
149       for (q = p->p - 1; q >= p->b; q--)
150 	{
151 	  q[n] = q[0];
152 	}
153       memcpy (p->b, s, n);
154       p->p += n;
155     }
156 }
157 
158 static void
159 string_prepend (string *p, const char *s)
160 {
161   if (s != NULL && *s != '\0')
162     {
163       string_prependn (p, s, strlen (s));
164     }
165 }
166 
167 /* What kinds of symbol we could be parsing.  */
168 enum dlang_symbol_kinds
169 {
170   /* Top-level symbol, needs it's type checked.  */
171   dlang_top_level,
172   /* Function symbol, needs it's type checked.   */
173   dlang_function,
174   /* Strongly typed name, such as for classes, structs and enums.  */
175   dlang_type_name,
176   /* Template identifier.  */
177   dlang_template_ident,
178   /* Template symbol parameter.  */
179   dlang_template_param
180 };
181 
182 /* Prototypes for forward referenced functions */
183 static const char *dlang_function_args (string *, const char *);
184 
185 static const char *dlang_type (string *, const char *);
186 
187 static const char *dlang_value (string *, const char *, const char *, char);
188 
189 static const char *dlang_parse_symbol (string *, const char *,
190 				       enum dlang_symbol_kinds);
191 
192 static const char *dlang_parse_tuple (string *, const char *);
193 
194 static const char *dlang_parse_template (string *, const char *, long);
195 
196 
197 /* Demangle the calling convention from MANGLED and append it to DECL.
198    Return the remaining string on success or NULL on failure.  */
199 static const char *
200 dlang_call_convention (string *decl, const char *mangled)
201 {
202   if (mangled == NULL || *mangled == '\0')
203     return NULL;
204 
205   switch (*mangled)
206     {
207     case 'F': /* (D) */
208       mangled++;
209       break;
210     case 'U': /* (C) */
211       mangled++;
212       string_append (decl, "extern(C) ");
213       break;
214     case 'W': /* (Windows) */
215       mangled++;
216       string_append (decl, "extern(Windows) ");
217       break;
218     case 'V': /* (Pascal) */
219       mangled++;
220       string_append (decl, "extern(Pascal) ");
221       break;
222     case 'R': /* (C++) */
223       mangled++;
224       string_append (decl, "extern(C++) ");
225       break;
226     case 'Y': /* (Objective-C) */
227       mangled++;
228       string_append (decl, "extern(Objective-C) ");
229       break;
230     default:
231       return NULL;
232     }
233 
234   return mangled;
235 }
236 
237 /* Extract the type modifiers from MANGLED and append them to DECL.
238    Returns the remaining signature on success or NULL on failure.  */
239 static const char *
240 dlang_type_modifiers (string *decl, const char *mangled)
241 {
242   if (mangled == NULL || *mangled == '\0')
243     return NULL;
244 
245   switch (*mangled)
246     {
247     case 'x': /* const */
248       mangled++;
249       string_append (decl, " const");
250       return mangled;
251     case 'y': /* immutable */
252       mangled++;
253       string_append (decl, " immutable");
254       return mangled;
255     case 'O': /* shared */
256       mangled++;
257       string_append (decl, " shared");
258       return dlang_type_modifiers (decl, mangled);
259     case 'N':
260       mangled++;
261       if (*mangled == 'g') /* wild */
262 	{
263 	  mangled++;
264 	  string_append (decl, " inout");
265 	  return dlang_type_modifiers (decl, mangled);
266 	}
267       else
268 	return NULL;
269 
270     default:
271       return mangled;
272     }
273 }
274 
275 /* Demangle the D function attributes from MANGLED and append it to DECL.
276    Return the remaining string on success or NULL on failure.  */
277 static const char *
278 dlang_attributes (string *decl, const char *mangled)
279 {
280   if (mangled == NULL || *mangled == '\0')
281     return NULL;
282 
283   while (*mangled == 'N')
284     {
285       mangled++;
286       switch (*mangled)
287 	{
288 	case 'a': /* pure */
289 	  mangled++;
290 	  string_append (decl, "pure ");
291 	  continue;
292 	case 'b': /* nothrow */
293 	  mangled++;
294 	  string_append (decl, "nothrow ");
295 	  continue;
296 	case 'c': /* ref */
297 	  mangled++;
298 	  string_append (decl, "ref ");
299 	  continue;
300 	case 'd': /* @property */
301 	  mangled++;
302 	  string_append (decl, "@property ");
303 	  continue;
304 	case 'e': /* @trusted */
305 	  mangled++;
306 	  string_append (decl, "@trusted ");
307 	  continue;
308 	case 'f': /* @safe */
309 	  mangled++;
310 	  string_append (decl, "@safe ");
311 	  continue;
312 	case 'g':
313 	case 'h':
314 	case 'k':
315 	  /* inout parameter is represented as 'Ng'.
316 	     vector parameter is represented as 'Nh'.
317 	     return paramenter is represented as 'Nk'.
318 	     If we see this, then we know we're really in the
319 	     parameter list.  Rewind and break.  */
320 	  mangled--;
321 	  break;
322 	case 'i': /* @nogc */
323 	  mangled++;
324 	  string_append (decl, "@nogc ");
325 	  continue;
326 	case 'j': /* return */
327 	  mangled++;
328 	  string_append (decl, "return ");
329 	  continue;
330 
331 	default: /* unknown attribute */
332 	  return NULL;
333 	}
334       break;
335     }
336 
337   return mangled;
338 }
339 
340 /* Demangle the function type from MANGLED and append it to DECL.
341    Return the remaining string on success or NULL on failure.  */
342 static const char *
343 dlang_function_type (string *decl, const char *mangled)
344 {
345   string attr, args, type;
346   size_t szattr, szargs, sztype;
347 
348   if (mangled == NULL || *mangled == '\0')
349     return NULL;
350 
351   /* The order of the mangled string is:
352 	CallConvention FuncAttrs Arguments ArgClose Type
353 
354      The demangled string is re-ordered as:
355 	CallConvention Type Arguments FuncAttrs
356    */
357   string_init (&attr);
358   string_init (&args);
359   string_init (&type);
360 
361   /* Function call convention.  */
362   mangled = dlang_call_convention (decl, mangled);
363 
364   /* Function attributes.  */
365   mangled = dlang_attributes (&attr, mangled);
366   szattr = string_length (&attr);
367 
368   /* Function arguments.  */
369   mangled = dlang_function_args (&args, mangled);
370   szargs = string_length (&args);
371 
372   /* Function return type.  */
373   mangled = dlang_type (&type, mangled);
374   sztype = string_length (&type);
375 
376   /* Append to decl in order. */
377   string_appendn (decl, type.b, sztype);
378   string_append (decl, "(");
379   string_appendn (decl, args.b, szargs);
380   string_append (decl, ") ");
381   string_appendn (decl, attr.b, szattr);
382 
383   string_delete (&attr);
384   string_delete (&args);
385   string_delete (&type);
386   return mangled;
387 }
388 
389 /* Demangle the argument list from MANGLED and append it to DECL.
390    Return the remaining string on success or NULL on failure.  */
391 static const char *
392 dlang_function_args (string *decl, const char *mangled)
393 {
394   size_t n = 0;
395 
396   while (mangled && *mangled != '\0')
397     {
398       switch (*mangled)
399 	{
400 	case 'X': /* (variadic T t...) style.  */
401 	  mangled++;
402 	  string_append (decl, "...");
403 	  return mangled;
404 	case 'Y': /* (variadic T t, ...) style.  */
405 	  mangled++;
406 	  if (n != 0)
407 	    string_append (decl, ", ");
408 	  string_append (decl, "...");
409 	  return mangled;
410 	case 'Z': /* Normal function.  */
411 	  mangled++;
412 	  return mangled;
413 	}
414 
415       if (n++)
416 	string_append (decl, ", ");
417 
418       if (*mangled == 'M') /* scope(T) */
419 	{
420 	  mangled++;
421 	  string_append (decl, "scope ");
422 	}
423 
424       if (mangled[0] == 'N' && mangled[1] == 'k') /* return(T) */
425 	{
426 	  mangled += 2;
427 	  string_append (decl, "return ");
428 	}
429 
430       switch (*mangled)
431 	{
432 	case 'J': /* out(T) */
433 	  mangled++;
434 	  string_append (decl, "out ");
435 	  break;
436 	case 'K': /* ref(T) */
437 	  mangled++;
438 	  string_append (decl, "ref ");
439 	  break;
440 	case 'L': /* lazy(T) */
441 	  mangled++;
442 	  string_append (decl, "lazy ");
443 	  break;
444 	}
445       mangled = dlang_type (decl, mangled);
446     }
447 
448   return mangled;
449 }
450 
451 /* Demangle the type from MANGLED and append it to DECL.
452    Return the remaining string on success or NULL on failure.  */
453 static const char *
454 dlang_type (string *decl, const char *mangled)
455 {
456   if (mangled == NULL || *mangled == '\0')
457     return NULL;
458 
459   switch (*mangled)
460     {
461     case 'O': /* shared(T) */
462       mangled++;
463       string_append (decl, "shared(");
464       mangled = dlang_type (decl, mangled);
465       string_append (decl, ")");
466       return mangled;
467     case 'x': /* const(T) */
468       mangled++;
469       string_append (decl, "const(");
470       mangled = dlang_type (decl, mangled);
471       string_append (decl, ")");
472       return mangled;
473     case 'y': /* immutable(T) */
474       mangled++;
475       string_append (decl, "immutable(");
476       mangled = dlang_type (decl, mangled);
477       string_append (decl, ")");
478       return mangled;
479     case 'N':
480       mangled++;
481       if (*mangled == 'g') /* wild(T) */
482 	{
483 	  mangled++;
484 	  string_append (decl, "inout(");
485 	  mangled = dlang_type (decl, mangled);
486 	  string_append (decl, ")");
487 	  return mangled;
488 	}
489       else if (*mangled == 'h') /* vector(T) */
490 	{
491 	  mangled++;
492 	  string_append (decl, "__vector(");
493 	  mangled = dlang_type (decl, mangled);
494 	  string_append (decl, ")");
495 	  return mangled;
496 	}
497       else
498 	return NULL;
499     case 'A': /* dynamic array (T[]) */
500       mangled++;
501       mangled = dlang_type (decl, mangled);
502       string_append (decl, "[]");
503       return mangled;
504     case 'G': /* static array (T[N]) */
505     {
506       const char *numptr;
507       size_t num = 0;
508       mangled++;
509 
510       numptr = mangled;
511       while (ISDIGIT (*mangled))
512 	{
513 	  num++;
514 	  mangled++;
515 	}
516       mangled = dlang_type (decl, mangled);
517       string_append (decl, "[");
518       string_appendn (decl, numptr, num);
519       string_append (decl, "]");
520       return mangled;
521     }
522     case 'H': /* associative array (T[T]) */
523     {
524       string type;
525       size_t sztype;
526       mangled++;
527 
528       string_init (&type);
529       mangled = dlang_type (&type, mangled);
530       sztype = string_length (&type);
531 
532       mangled = dlang_type (decl, mangled);
533       string_append (decl, "[");
534       string_appendn (decl, type.b, sztype);
535       string_append (decl, "]");
536 
537       string_delete (&type);
538       return mangled;
539     }
540     case 'P': /* pointer (T*) */
541       mangled++;
542       /* Function pointer types don't include the trailing asterisk.  */
543       switch (*mangled)
544 	{
545 	case 'F': case 'U': case 'W':
546 	case 'V': case 'R': case 'Y':
547 	  mangled = dlang_function_type (decl, mangled);
548 	  string_append (decl, "function");
549 	  return mangled;
550 	}
551       mangled = dlang_type (decl, mangled);
552       string_append (decl, "*");
553       return mangled;
554     case 'I': /* ident T */
555     case 'C': /* class T */
556     case 'S': /* struct T */
557     case 'E': /* enum T */
558     case 'T': /* typedef T */
559       mangled++;
560       return dlang_parse_symbol (decl, mangled, dlang_type_name);
561     case 'D': /* delegate T */
562     {
563       string mods;
564       size_t szmods;
565       mangled++;
566 
567       string_init (&mods);
568       mangled = dlang_type_modifiers (&mods, mangled);
569       szmods = string_length (&mods);
570 
571       mangled = dlang_function_type (decl, mangled);
572       string_append (decl, "delegate");
573       string_appendn (decl, mods.b, szmods);
574 
575       string_delete (&mods);
576       return mangled;
577     }
578     case 'B': /* tuple T */
579       mangled++;
580       return dlang_parse_tuple (decl, mangled);
581 
582     /* Basic types */
583     case 'n':
584       mangled++;
585       string_append (decl, "none");
586       return mangled;
587     case 'v':
588       mangled++;
589       string_append (decl, "void");
590       return mangled;
591     case 'g':
592       mangled++;
593       string_append (decl, "byte");
594       return mangled;
595     case 'h':
596       mangled++;
597       string_append (decl, "ubyte");
598       return mangled;
599     case 's':
600       mangled++;
601       string_append (decl, "short");
602       return mangled;
603     case 't':
604       mangled++;
605       string_append (decl, "ushort");
606       return mangled;
607     case 'i':
608       mangled++;
609       string_append (decl, "int");
610       return mangled;
611     case 'k':
612       mangled++;
613       string_append (decl, "uint");
614       return mangled;
615     case 'l':
616       mangled++;
617       string_append (decl, "long");
618       return mangled;
619     case 'm':
620       mangled++;
621       string_append (decl, "ulong");
622       return mangled;
623     case 'f':
624       mangled++;
625       string_append (decl, "float");
626       return mangled;
627     case 'd':
628       mangled++;
629       string_append (decl, "double");
630       return mangled;
631     case 'e':
632       mangled++;
633       string_append (decl, "real");
634       return mangled;
635 
636     /* Imaginary and Complex types */
637     case 'o':
638       mangled++;
639       string_append (decl, "ifloat");
640       return mangled;
641     case 'p':
642       mangled++;
643       string_append (decl, "idouble");
644       return mangled;
645     case 'j':
646       mangled++;
647       string_append (decl, "ireal");
648       return mangled;
649     case 'q':
650       mangled++;
651       string_append (decl, "cfloat");
652       return mangled;
653     case 'r':
654       mangled++;
655       string_append (decl, "cdouble");
656       return mangled;
657     case 'c':
658       mangled++;
659       string_append (decl, "creal");
660       return mangled;
661 
662     /* Other types */
663     case 'b':
664       mangled++;
665       string_append (decl, "bool");
666       return mangled;
667     case 'a':
668       mangled++;
669       string_append (decl, "char");
670       return mangled;
671     case 'u':
672       mangled++;
673       string_append (decl, "wchar");
674       return mangled;
675     case 'w':
676       mangled++;
677       string_append (decl, "dchar");
678       return mangled;
679     case 'z':
680       mangled++;
681       switch (*mangled)
682 	{
683 	case 'i':
684 	  mangled++;
685 	  string_append (decl, "cent");
686 	  return mangled;
687 	case 'k':
688 	  mangled++;
689 	  string_append (decl, "ucent");
690 	  return mangled;
691 	}
692       return NULL;
693 
694     default: /* unhandled */
695       return NULL;
696     }
697 }
698 
699 /* Extract the identifier from MANGLED and append it to DECL.
700    Return the remaining string on success or NULL on failure.  */
701 static const char *
702 dlang_identifier (string *decl, const char *mangled,
703 		  enum dlang_symbol_kinds kind)
704 {
705   char *endptr;
706   long len;
707 
708   if (mangled == NULL || *mangled == '\0')
709     return NULL;
710 
711   len = strtol (mangled, &endptr, 10);
712 
713   if (endptr == NULL || len <= 0)
714     return NULL;
715 
716   /* In template parameter symbols, the first character of the mangled
717      name can be a digit.  This causes ambiguity issues because the
718      digits of the two numbers are adjacent.  */
719   if (kind == dlang_template_param)
720     {
721       long psize = len;
722       char *pend;
723       int saved = string_length (decl);
724 
725       /* Work backwards until a match is found.  */
726       for (pend = endptr; endptr != NULL; pend--)
727 	{
728 	  mangled = pend;
729 
730 	  /* Reached the beginning of the pointer to the name length,
731 	     try parsing the entire symbol.  */
732 	  if (psize == 0)
733 	    {
734 	      psize = len;
735 	      pend = endptr;
736 	      endptr = NULL;
737 	    }
738 
739 	  /* Check whether template parameter is a function with a valid
740 	     return type or an untyped identifier.  */
741 	  if (ISDIGIT (*mangled))
742 	    mangled = dlang_parse_symbol (decl, mangled, dlang_template_ident);
743 	  else if (strncmp (mangled, "_D", 2) == 0)
744 	    {
745 	      mangled += 2;
746 	      mangled = dlang_parse_symbol (decl, mangled, dlang_function);
747 	    }
748 
749 	  /* Check for name length mismatch.  */
750 	  if (mangled && (mangled - pend) == psize)
751 	    return mangled;
752 
753 	  psize /= 10;
754 	  string_setlength (decl, saved);
755 	}
756 
757       /* No match on any combinations.  */
758       return NULL;
759     }
760   else
761     {
762       if (strlen (endptr) < (size_t) len)
763 	return NULL;
764 
765       mangled = endptr;
766 
767       /* May be a template instance.  */
768       if (len >= 5 && strncmp (mangled, "__T", 3) == 0)
769 	{
770 	  /* Template symbol.  */
771 	  if (ISDIGIT (mangled[3]) && mangled[3] != '0')
772 	    return dlang_parse_template (decl, mangled, len);
773 
774 	  return NULL;
775 	}
776 
777       switch (len)
778 	{
779 	case 6:
780 	  if (strncmp (mangled, "__ctor", len) == 0)
781 	    {
782 	      /* Constructor symbol for a class/struct.  */
783 	      string_append (decl, "this");
784 	      mangled += len;
785 	      return mangled;
786 	    }
787 	  else if (strncmp (mangled, "__dtor", len) == 0)
788 	    {
789 	      /* Destructor symbol for a class/struct.  */
790 	      string_append (decl, "~this");
791 	      mangled += len;
792 	      return mangled;
793 	    }
794 	  else if (strncmp (mangled, "__initZ", len+1) == 0)
795 	    {
796 	      /* The static initialiser for a given symbol.  */
797 	      string_append (decl, "init$");
798 	      mangled += len;
799 	      return mangled;
800 	    }
801 	  else if (strncmp (mangled, "__vtblZ", len+1) == 0)
802 	    {
803 	      /* The vtable symbol for a given class.  */
804 	      string_prepend (decl, "vtable for ");
805 	      string_setlength (decl, string_length (decl) - 1);
806 	      mangled += len;
807 	      return mangled;
808 	    }
809 	  break;
810 
811 	case 7:
812 	  if (strncmp (mangled, "__ClassZ", len+1) == 0)
813 	    {
814 	      /* The classinfo symbol for a given class.  */
815 	      string_prepend (decl, "ClassInfo for ");
816 	      string_setlength (decl, string_length (decl) - 1);
817 	      mangled += len;
818 	      return mangled;
819 	    }
820 	  break;
821 
822 	case 10:
823 	  if (strncmp (mangled, "__postblitMFZ", len+3) == 0)
824 	    {
825 	      /* Postblit symbol for a struct.  */
826 	      string_append (decl, "this(this)");
827 	      mangled += len + 3;
828 	      return mangled;
829 	    }
830 	  break;
831 
832 	case 11:
833 	  if (strncmp (mangled, "__InterfaceZ", len+1) == 0)
834 	    {
835 	      /* The interface symbol for a given class.  */
836 	      string_prepend (decl, "Interface for ");
837 	      string_setlength (decl, string_length (decl) - 1);
838 	      mangled += len;
839 	      return mangled;
840 	    }
841 	  break;
842 
843 	case 12:
844 	  if (strncmp (mangled, "__ModuleInfoZ", len+1) == 0)
845 	    {
846 	      /* The ModuleInfo symbol for a given module.  */
847 	      string_prepend (decl, "ModuleInfo for ");
848 	      string_setlength (decl, string_length (decl) - 1);
849 	      mangled += len;
850 	      return mangled;
851 	    }
852 	  break;
853 	}
854 
855       string_appendn (decl, mangled, len);
856       mangled += len;
857     }
858 
859   return mangled;
860 }
861 
862 /* Extract the integer value from MANGLED and append it to DECL,
863    where TYPE is the type it should be represented as.
864    Return the remaining string on success or NULL on failure.  */
865 static const char *
866 dlang_parse_integer (string *decl, const char *mangled, char type)
867 {
868   if (type == 'a' || type == 'u' || type == 'w')
869     {
870       /* Parse character value.  */
871       char value[10];
872       int pos = 10;
873       int width = 0;
874       char *endptr;
875       long val = strtol (mangled, &endptr, 10);
876 
877       if (endptr == NULL || val < 0)
878 	return NULL;
879 
880       string_append (decl, "'");
881 
882       if (type == 'a' && val >= 0x20 && val < 0x7F)
883 	{
884 	  /* Represent as a character literal.  */
885 	  char c = (char) val;
886 	  string_appendn (decl, &c, 1);
887 	}
888       else
889 	{
890 	  /* Represent as a hexadecimal value.  */
891 	  switch (type)
892 	    {
893 	    case 'a': /* char */
894 	      string_append (decl, "\\x");
895 	      width = 2;
896 	      break;
897 	    case 'u': /* wchar */
898 	      string_append (decl, "\\u");
899 	      width = 4;
900 	      break;
901 	    case 'w': /* dchar */
902 	      string_append (decl, "\\U");
903 	      width = 8;
904 	      break;
905 	    }
906 
907 	  while (val > 0)
908 	    {
909 	      int digit = val % 16;
910 
911 	      if (digit < 10)
912 		value[--pos] = (char)(digit + '0');
913 	      else
914 		value[--pos] = (char)((digit - 10) + 'a');
915 
916 	      val /= 16;
917 	      width--;
918 	    }
919 
920 	  for (; width > 0; width--)
921 	    value[--pos] = '0';
922 
923 	  string_appendn (decl, &(value[pos]), 10 - pos);
924 	}
925       string_append (decl, "'");
926       mangled = endptr;
927     }
928   else if (type == 'b')
929     {
930       /* Parse boolean value.  */
931       char *endptr;
932       long val = strtol (mangled, &endptr, 10);
933 
934       if (endptr == NULL || val < 0)
935 	return NULL;
936 
937       string_append (decl, val ? "true" : "false");
938       mangled = endptr;
939     }
940   else
941     {
942       /* Parse integer value.  */
943       const char *numptr = mangled;
944       size_t num = 0;
945 
946       while (ISDIGIT (*mangled))
947 	{
948 	  num++;
949 	  mangled++;
950 	}
951       string_appendn (decl, numptr, num);
952 
953       /* Append suffix.  */
954       switch (type)
955 	{
956 	case 'h': /* ubyte */
957 	case 't': /* ushort */
958 	case 'k': /* uint */
959 	  string_append (decl, "u");
960 	  break;
961 	case 'l': /* long */
962 	  string_append (decl, "L");
963 	  break;
964 	case 'm': /* ulong */
965 	  string_append (decl, "uL");
966 	  break;
967 	}
968     }
969 
970   return mangled;
971 }
972 
973 /* Extract the floating-point value from MANGLED and append it to DECL.
974    Return the remaining string on success or NULL on failure.  */
975 static const char *
976 dlang_parse_real (string *decl, const char *mangled)
977 {
978   char buffer[64];
979   int len = 0;
980 
981   /* Handle NAN and +-INF.  */
982   if (strncmp (mangled, "NAN", 3) == 0)
983     {
984       string_append (decl, "NaN");
985       mangled += 3;
986       return mangled;
987     }
988   else if (strncmp (mangled, "INF", 3) == 0)
989     {
990       string_append (decl, "Inf");
991       mangled += 3;
992       return mangled;
993     }
994   else if (strncmp (mangled, "NINF", 4) == 0)
995     {
996       string_append (decl, "-Inf");
997       mangled += 4;
998       return mangled;
999     }
1000 
1001   /* Hexadecimal prefix and leading bit.  */
1002   if (*mangled == 'N')
1003     {
1004       buffer[len++] = '-';
1005       mangled++;
1006     }
1007 
1008   if (!ISXDIGIT (*mangled))
1009     return NULL;
1010 
1011   buffer[len++] = '0';
1012   buffer[len++] = 'x';
1013   buffer[len++] = *mangled;
1014   buffer[len++] = '.';
1015   mangled++;
1016 
1017   /* Significand.  */
1018   while (ISXDIGIT (*mangled))
1019     {
1020       buffer[len++] = *mangled;
1021       mangled++;
1022     }
1023 
1024   /* Exponent.  */
1025   if (*mangled != 'P')
1026     return NULL;
1027 
1028   buffer[len++] = 'p';
1029   mangled++;
1030 
1031   if (*mangled == 'N')
1032     {
1033       buffer[len++] = '-';
1034       mangled++;
1035     }
1036 
1037   while (ISDIGIT (*mangled))
1038     {
1039       buffer[len++] = *mangled;
1040       mangled++;
1041     }
1042 
1043   /* Write out the demangled hexadecimal, rather than trying to
1044      convert the buffer into a floating-point value.  */
1045   buffer[len] = '\0';
1046   len = strlen (buffer);
1047   string_appendn (decl, buffer, len);
1048   return mangled;
1049 }
1050 
1051 /* Convert VAL from an ascii hexdigit to value.  */
1052 static char
1053 ascii2hex (char val)
1054 {
1055   if (val >= 'a' && val <= 'f')
1056     return (val - 'a' + 10);
1057 
1058   if (val >= 'A' && val <= 'F')
1059     return (val - 'A' + 10);
1060 
1061   if (val >= '0' && val <= '9')
1062     return (val - '0');
1063 
1064   return 0;
1065 }
1066 
1067 /* Extract the string value from MANGLED and append it to DECL.
1068    Return the remaining string on success or NULL on failure.  */
1069 static const char *
1070 dlang_parse_string (string *decl, const char *mangled)
1071 {
1072   char type = *mangled;
1073   char *endptr;
1074   long len;
1075 
1076   mangled++;
1077   len = strtol (mangled, &endptr, 10);
1078 
1079   if (endptr == NULL || len < 0)
1080     return NULL;
1081 
1082   mangled = endptr;
1083   if (*mangled != '_')
1084     return NULL;
1085 
1086   mangled++;
1087   string_append (decl, "\"");
1088   while (len--)
1089     {
1090       if (ISXDIGIT (mangled[0]) && ISXDIGIT (mangled[1]))
1091 	{
1092 	  char a = ascii2hex (mangled[0]);
1093 	  char b = ascii2hex (mangled[1]);
1094 	  char val = (a << 4) | b;
1095 
1096 	  /* Sanitize white and non-printable characters.  */
1097 	  switch (val)
1098 	    {
1099 	    case ' ':
1100 	      string_append (decl, " ");
1101 	      break;
1102 	    case '\t':
1103 	      string_append (decl, "\\t");
1104 	      break;
1105 	    case '\n':
1106 	      string_append (decl, "\\n");
1107 	      break;
1108 	    case '\r':
1109 	      string_append (decl, "\\r");
1110 	      break;
1111 	    case '\f':
1112 	      string_append (decl, "\\f");
1113 	      break;
1114 	    case '\v':
1115 	      string_append (decl, "\\v");
1116 	      break;
1117 
1118 	    default:
1119 	      if (ISPRINT (val))
1120 		string_appendn (decl, &val, 1);
1121 	      else
1122 		{
1123 		  string_append (decl, "\\x");
1124 		  string_appendn (decl, mangled, 2);
1125 		}
1126 	    }
1127 	}
1128       else
1129 	return NULL;
1130 
1131       mangled += 2;
1132     }
1133   string_append (decl, "\"");
1134 
1135   if (type != 'a')
1136     string_appendn (decl, &type, 1);
1137 
1138   return mangled;
1139 }
1140 
1141 /* Extract the static array value from MANGLED and append it to DECL.
1142    Return the remaining string on success or NULL on failure.  */
1143 static const char *
1144 dlang_parse_arrayliteral (string *decl, const char *mangled)
1145 {
1146   char *endptr;
1147   long elements = strtol (mangled, &endptr, 10);
1148 
1149   if (endptr == NULL || elements < 0)
1150     return NULL;
1151 
1152   mangled = endptr;
1153   string_append (decl, "[");
1154   while (elements--)
1155     {
1156       mangled = dlang_value (decl, mangled, NULL, '\0');
1157       if (elements != 0)
1158 	string_append (decl, ", ");
1159     }
1160 
1161   string_append (decl, "]");
1162   return mangled;
1163 }
1164 
1165 /* Extract the associative array value from MANGLED and append it to DECL.
1166    Return the remaining string on success or NULL on failure.  */
1167 static const char *
1168 dlang_parse_assocarray (string *decl, const char *mangled)
1169 {
1170   char *endptr;
1171   long elements = strtol (mangled, &endptr, 10);
1172 
1173   if (endptr == NULL || elements < 0)
1174     return NULL;
1175 
1176   mangled = endptr;
1177   string_append (decl, "[");
1178   while (elements--)
1179     {
1180       mangled = dlang_value (decl, mangled, NULL, '\0');
1181       string_append (decl, ":");
1182       mangled = dlang_value (decl, mangled, NULL, '\0');
1183 
1184       if (elements != 0)
1185 	string_append (decl, ", ");
1186     }
1187 
1188   string_append (decl, "]");
1189   return mangled;
1190 }
1191 
1192 /* Extract the struct literal value for NAME from MANGLED and append it to DECL.
1193    Return the remaining string on success or NULL on failure.  */
1194 static const char *
1195 dlang_parse_structlit (string *decl, const char *mangled, const char *name)
1196 {
1197   char *endptr;
1198   long args = strtol (mangled, &endptr, 10);
1199 
1200   if (endptr == NULL || args < 0)
1201     return NULL;
1202 
1203   mangled = endptr;
1204   if (name != NULL)
1205     string_append (decl, name);
1206 
1207   string_append (decl, "(");
1208   while (args--)
1209     {
1210       mangled = dlang_value (decl, mangled, NULL, '\0');
1211       if (args != 0)
1212 	string_append (decl, ", ");
1213     }
1214 
1215   string_append (decl, ")");
1216   return mangled;
1217 }
1218 
1219 /* Extract the value from MANGLED and append it to DECL.
1220    Return the remaining string on success or NULL on failure.  */
1221 static const char *
1222 dlang_value (string *decl, const char *mangled, const char *name, char type)
1223 {
1224   if (mangled == NULL || *mangled == '\0')
1225     return NULL;
1226 
1227   switch (*mangled)
1228     {
1229       /* Null value.  */
1230     case 'n':
1231       mangled++;
1232       string_append (decl, "null");
1233       break;
1234 
1235       /* Integral values.  */
1236     case 'N':
1237       mangled++;
1238       string_append (decl, "-");
1239       mangled = dlang_parse_integer (decl, mangled, type);
1240       break;
1241 
1242     case 'i':
1243       mangled++;
1244       if (*mangled < '0' || *mangled > '9')
1245 	return NULL;
1246       /* Fall through */
1247     case '0': case '1': case '2': case '3': case '4':
1248     case '5': case '6': case '7': case '8': case '9':
1249       mangled = dlang_parse_integer (decl, mangled, type);
1250       break;
1251 
1252       /* Real value.  */
1253     case 'e':
1254       mangled++;
1255       mangled = dlang_parse_real (decl, mangled);
1256       break;
1257 
1258       /* Complex value.  */
1259     case 'c':
1260       mangled++;
1261       mangled = dlang_parse_real (decl, mangled);
1262       string_append (decl, "+");
1263       if (mangled == NULL || *mangled != 'c')
1264 	return NULL;
1265       mangled++;
1266       mangled = dlang_parse_real (decl, mangled);
1267       string_append (decl, "i");
1268       break;
1269 
1270       /* String values.  */
1271     case 'a': /* UTF8 */
1272     case 'w': /* UTF16 */
1273     case 'd': /* UTF32 */
1274       mangled = dlang_parse_string (decl, mangled);
1275       break;
1276 
1277       /* Array values.  */
1278     case 'A':
1279       mangled++;
1280       if (type == 'H')
1281 	mangled = dlang_parse_assocarray (decl, mangled);
1282       else
1283 	mangled = dlang_parse_arrayliteral (decl, mangled);
1284       break;
1285 
1286       /* Struct values.  */
1287     case 'S':
1288       mangled++;
1289       mangled = dlang_parse_structlit (decl, mangled, name);
1290       break;
1291 
1292     default:
1293       return NULL;
1294     }
1295 
1296   return mangled;
1297 }
1298 
1299 /* Extract the type modifiers from MANGLED and return the string
1300    length that it consumes in MANGLED on success or 0 on failure.  */
1301 static int
1302 dlang_type_modifier_p (const char *mangled)
1303 {
1304   int i;
1305 
1306   switch (*mangled)
1307     {
1308     case 'x': case 'y':
1309       return 1;
1310 
1311     case 'O':
1312       mangled++;
1313       i = dlang_type_modifier_p (mangled);
1314       return i + 1;
1315 
1316     case 'N':
1317       mangled++;
1318       if (*mangled == 'g')
1319 	{
1320 	  mangled++;
1321 	  i = dlang_type_modifier_p (mangled);
1322 	  return i + 2;
1323 	}
1324     }
1325 
1326   return 0;
1327 }
1328 
1329 /* Extract the function calling convention from MANGLED and
1330    return 1 on success or 0 on failure.  */
1331 static int
1332 dlang_call_convention_p (const char *mangled)
1333 {
1334   /* Prefix for functions needing 'this' */
1335   if (*mangled == 'M')
1336     {
1337       mangled++;
1338       /* Also skip over any type modifiers.  */
1339       mangled += dlang_type_modifier_p (mangled);
1340     }
1341 
1342   switch (*mangled)
1343     {
1344     case 'F': case 'U': case 'V':
1345     case 'W': case 'R': case 'Y':
1346       return 1;
1347 
1348     default:
1349       return 0;
1350     }
1351 }
1352 
1353 /* Extract and demangle the symbol in MANGLED and append it to DECL.
1354    Returns the remaining signature on success or NULL on failure.  */
1355 static const char *
1356 dlang_parse_symbol (string *decl, const char *mangled,
1357 		    enum dlang_symbol_kinds kind)
1358 {
1359   int saved;
1360   size_t n = 0;
1361   do
1362     {
1363       if (n++)
1364 	string_append (decl, ".");
1365 
1366       mangled = dlang_identifier (decl, mangled, kind);
1367 
1368       if (mangled && dlang_call_convention_p (mangled))
1369 	{
1370 	  string mods;
1371 	  const char *start = NULL;
1372 	  int checkpoint = 0;
1373 
1374 	  /* Skip over 'this' parameter.  */
1375 	  if (*mangled == 'M')
1376 	    mangled++;
1377 
1378 	  /* We have reached here because we expect an extern(Pascal) function.
1379 	     However this is so rare, that it is more likely a template value
1380 	     parameter.  Since this can't be assumed, first attempt parsing
1381 	     the symbol as a function, and then back out on failure.  */
1382 	  if (*mangled == 'V')
1383 	    {
1384 	      start = mangled;
1385 	      checkpoint = string_length (decl);
1386 	    }
1387 
1388 	  /* Save the type modifiers for appending at the end.  */
1389 	  string_init (&mods);
1390 	  mangled = dlang_type_modifiers (&mods, mangled);
1391 
1392 	  /* Skip over calling convention and attributes in qualified name.  */
1393 	  saved = string_length (decl);
1394 	  mangled = dlang_call_convention (decl, mangled);
1395 	  mangled = dlang_attributes (decl, mangled);
1396 	  string_setlength (decl, saved);
1397 
1398 	  string_append (decl, "(");
1399 	  mangled = dlang_function_args (decl, mangled);
1400 	  string_append (decl, ")");
1401 
1402 	  /* Add any const/immutable/shared modifier. */
1403 	  string_appendn (decl, mods.b, string_length (&mods));
1404 	  string_delete (&mods);
1405 
1406 	  if (mangled == NULL && checkpoint != 0)
1407 	    {
1408 	      mangled = start;
1409 	      string_setlength (decl, checkpoint);
1410 	    }
1411 	}
1412     }
1413   while (mangled && ISDIGIT (*mangled));
1414 
1415   /* Only top-level symbols or function template parameters have
1416      a type that needs checking.  */
1417   if (kind == dlang_top_level || kind == dlang_function)
1418     {
1419       /* Artificial symbols end with 'Z' and have no type.  */
1420       if (mangled && *mangled == 'Z')
1421 	mangled++;
1422       else
1423 	{
1424 	  saved = string_length (decl);
1425 	  mangled = dlang_type (decl, mangled);
1426 	  string_setlength (decl, saved);
1427 	}
1428 
1429       /* Check that the entire symbol was successfully demangled.  */
1430       if (kind == dlang_top_level)
1431 	{
1432 	  if (mangled == NULL || *mangled != '\0')
1433 	    return NULL;
1434 	}
1435     }
1436 
1437   return mangled;
1438 }
1439 
1440 /* Demangle the tuple from MANGLED and append it to DECL.
1441    Return the remaining string on success or NULL on failure.  */
1442 static const char *
1443 dlang_parse_tuple (string *decl, const char *mangled)
1444 {
1445   char *endptr;
1446   long elements = strtol (mangled, &endptr, 10);
1447 
1448   if (endptr == NULL || elements < 0)
1449     return NULL;
1450 
1451   mangled = endptr;
1452   string_append (decl, "Tuple!(");
1453 
1454   while (elements--)
1455     {
1456       mangled = dlang_type (decl, mangled);
1457       if (elements != 0)
1458 	string_append (decl, ", ");
1459     }
1460 
1461   string_append (decl, ")");
1462   return mangled;
1463 }
1464 
1465 /* Demangle the argument list from MANGLED and append it to DECL.
1466    Return the remaining string on success or NULL on failure.  */
1467 static const char *
1468 dlang_template_args (string *decl, const char *mangled)
1469 {
1470   size_t n = 0;
1471 
1472   while (mangled && *mangled != '\0')
1473     {
1474       switch (*mangled)
1475 	{
1476 	case 'Z': /* End of parameter list.  */
1477 	  mangled++;
1478 	  return mangled;
1479 	}
1480 
1481       if (n++)
1482 	string_append (decl, ", ");
1483 
1484       /* Skip over specialised template prefix.  */
1485       if (*mangled == 'H')
1486 	mangled++;
1487 
1488       switch (*mangled)
1489 	{
1490 	case 'S': /* Symbol parameter.  */
1491 	  mangled++;
1492 	  mangled = dlang_parse_symbol (decl, mangled, dlang_template_param);
1493 	  break;
1494 	case 'T': /* Type parameter.  */
1495 	  mangled++;
1496 	  mangled = dlang_type (decl, mangled);
1497 	  break;
1498 	case 'V': /* Value parameter.  */
1499 	{
1500 	  string name;
1501 	  char type;
1502 
1503 	  /* Peek at the type.  */
1504 	  mangled++;
1505 	  type = *mangled;
1506 
1507 	  /* In the few instances where the type is actually desired in
1508 	     the output, it should precede the value from dlang_value.  */
1509 	  string_init (&name);
1510 	  mangled = dlang_type (&name, mangled);
1511 	  string_need (&name, 1);
1512 	  *(name.p) = '\0';
1513 
1514 	  mangled = dlang_value (decl, mangled, name.b, type);
1515 	  string_delete (&name);
1516 	  break;
1517 	}
1518 
1519 	default:
1520 	  return NULL;
1521 	}
1522     }
1523 
1524   return mangled;
1525 }
1526 
1527 /* Extract and demangle the template symbol in MANGLED, expected to
1528    be made up of LEN characters, and append it to DECL.
1529    Returns the remaining signature on success or NULL on failure.  */
1530 static const char *
1531 dlang_parse_template (string *decl, const char *mangled, long len)
1532 {
1533   const char *start = mangled;
1534 
1535   /* Template instance names have the types and values of its parameters
1536      encoded into it.
1537 
1538 	TemplateInstanceName:
1539 	    Number __T LName TemplateArgs Z
1540 		   ^
1541      The start pointer should be at the above location, and LEN should be
1542      the value of the decoded number.
1543    */
1544   if (strncmp (mangled, "__T", 3) != 0)
1545     return NULL;
1546 
1547   mangled += 3;
1548 
1549   /* Template identifier.  */
1550   mangled = dlang_identifier (decl, mangled, dlang_template_ident);
1551 
1552   /* Template arguments.  */
1553   string_append (decl, "!(");
1554   mangled = dlang_template_args (decl, mangled);
1555   string_append (decl, ")");
1556 
1557   /* Check for template name length mismatch.  */
1558   if (mangled && (mangled - start) != len)
1559     return NULL;
1560 
1561   return mangled;
1562 }
1563 
1564 /* Extract and demangle the symbol in MANGLED.  Returns the demangled
1565    signature on success or NULL on failure.  */
1566 
1567 char *
1568 dlang_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
1569 {
1570   string decl;
1571   char *demangled = NULL;
1572 
1573   if (mangled == NULL || *mangled == '\0')
1574     return NULL;
1575 
1576   if (strncmp (mangled, "_D", 2) != 0)
1577     return NULL;
1578 
1579   string_init (&decl);
1580 
1581   if (strcmp (mangled, "_Dmain") == 0)
1582     {
1583       string_append (&decl, "D main");
1584     }
1585   else
1586     {
1587       mangled += 2;
1588 
1589       if (dlang_parse_symbol (&decl, mangled, dlang_top_level) == NULL)
1590 	string_delete (&decl);
1591     }
1592 
1593   if (string_length (&decl) > 0)
1594     {
1595       string_need (&decl, 1);
1596       *(decl.p) = '\0';
1597       demangled = decl.b;
1598     }
1599 
1600   return demangled;
1601 }
1602 
1603