+/* Demangle the function type from MANGLE and append it to TEMPBUF.
+ Return the remaining string on success or NULL on failure. */
+
+static const char *
+parse_function_type (struct obstack *tempbuf, const char *mangle)
+{
+ struct obstack obattr, obargs, obtype;
+ char *attr, *args, *type;
+ size_t szattr, szargs, sztype;
+
+ if ((mangle == NULL) || (*mangle == '\0'))
+ return mangle;
+
+ /* The order of the mangled string is:
+ TypeFunction ::
+ CallConvention FuncAttrs Arguments ArgClose Type
+
+ The demangled string is re-ordered as:
+ CallConvention Type Arguments FuncAttrs
+ */
+ obstack_init (&obattr);
+ obstack_init (&obargs);
+ obstack_init (&obtype);
+
+ /* Function call convention. */
+ mangle = parse_call_convention (tempbuf, mangle);
+
+ /* Function attributes. */
+ mangle = parse_attributes (&obattr, mangle);
+ szattr = obstack_object_size (&obattr);
+ attr = obstack_finish (&obattr);
+
+ /* Function arguments. */
+ mangle = parse_function_args (&obargs, mangle);
+ szargs = obstack_object_size (&obargs);
+ args = obstack_finish (&obargs);
+
+ /* Function return type. */
+ mangle = parse_type (&obtype, mangle);
+ sztype = obstack_object_size (&obtype);
+ type = obstack_finish (&obtype);
+
+ /* Append to buffer in order. */
+ obstack_grow (tempbuf, type, sztype);
+ obstack_grow_str (tempbuf, "(");
+ obstack_grow (tempbuf, args, szargs);
+ obstack_grow_str (tempbuf, ") ");
+ obstack_grow (tempbuf, attr, szattr);
+
+ obstack_free (&obattr, NULL);
+ obstack_free (&obargs, NULL);
+ obstack_free (&obtype, NULL);
+ return mangle;
+}
+
+/* Demangle the argument list from MANGLE and append it to TEMPBUF.
+ Return the remaining string on success or NULL on failure. */
+
+static const char *
+parse_function_args (struct obstack *tempbuf, const char *mangle)
+{
+ size_t n = 0;
+
+ while ((mangle != NULL) && (*mangle != '\0'))
+ {
+ switch (*mangle)
+ {
+ case 'X': /* (variadic T t...) style. */
+ mangle++;
+ obstack_grow_str (tempbuf, "...");
+ return mangle;
+ case 'Y': /* (variadic T t, ...) style. */
+ mangle++;
+ obstack_grow_str (tempbuf, ", ...");
+ return mangle;
+ case 'Z': /* Normal function. */
+ mangle++;
+ return mangle;
+ }
+
+ if (n++)
+ obstack_grow_str (tempbuf, ", ");
+
+ if (*mangle == 'M') /* scope(T) */
+ {
+ mangle++;
+ obstack_grow_str (tempbuf, "scope ");
+ }
+
+ switch (*mangle)
+ {
+ case 'J': /* out(T) */
+ mangle++;
+ obstack_grow_str (tempbuf, "out ");
+ break;
+ case 'K': /* ref(T) */
+ mangle++;
+ obstack_grow_str (tempbuf, "ref ");
+ break;
+ case 'L': /* lazy(T) */
+ mangle++;
+ obstack_grow_str (tempbuf, "lazy ");
+ break;
+ }
+ mangle = parse_type (tempbuf, mangle);
+ }
+ return mangle;
+}
+
+/* Demangle the type from MANGLE and append it to TEMPBUF.
+ Return the remaining string on success or NULL on failure. */
+
+static const char *
+parse_type (struct obstack *tempbuf, const char *mangle)
+{
+ if ((mangle == NULL) || (*mangle == '\0'))
+ return mangle;
+
+ switch (*mangle)
+ {
+ case 'O': /* shared(T) */
+ mangle++;
+ obstack_grow_str (tempbuf, "shared(");
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, ")");
+ return mangle;
+ case 'x': /* const(T) */
+ mangle++;
+ obstack_grow_str (tempbuf, "const(");
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, ")");
+ return mangle;
+ case 'y': /* immutable(T) */
+ mangle++;
+ obstack_grow_str (tempbuf, "immutable(");
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, ")");
+ return mangle;
+ case 'N':
+ mangle++;
+ if (*mangle == 'g') /* wild(T) */
+ {
+ mangle++;
+ obstack_grow_str (tempbuf, "inout(");
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, ")");
+ return mangle;
+ }
+ else if (*mangle == 'h') /* vector(T) */
+ {
+ mangle++;
+ /* The basetype for vectors are always static arrays. */
+ if (*mangle != 'G')
+ return NULL;
+ obstack_grow_str (tempbuf, "__vector(");
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, ")");
+ return mangle;
+ }
+ else
+ return NULL;
+ case 'A': /* dynamic array (T[]) */
+ mangle++;
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, "[]");
+ return mangle;
+ case 'G': /* static array (T[N]) */
+ {
+ const char *numptr;
+ size_t num = 0;
+ mangle++;
+
+ numptr = mangle;
+ while (ISDIGIT (*mangle))
+ {
+ num++;
+ mangle++;
+ }
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, "[");
+ obstack_grow (tempbuf, numptr, num);
+ obstack_grow_str (tempbuf, "]");
+ return mangle;
+ }
+ case 'H': /* associative array (T[T]) */
+ {
+ struct obstack obtype;
+ char *type;
+ size_t sztype;
+ mangle++;
+
+ obstack_init (&obtype);
+ mangle = parse_type (&obtype, mangle);
+ sztype = obstack_object_size (&obtype);
+ type = obstack_finish (&obtype);
+
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, "[");
+ obstack_grow (tempbuf, type, sztype);
+ obstack_grow_str (tempbuf, "]");
+
+ obstack_free (&obtype, NULL);
+ return mangle;
+ }
+ case 'P': /* pointer (T*) */
+ mangle++;
+ mangle = parse_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, "*");
+ return mangle;
+ case 'I': /* ident T */
+ case 'C': /* class T */
+ case 'S': /* struct T */
+ case 'E': /* enum T */
+ case 'T': /* typedef T */
+ mangle++;
+ return d_parse_symbol (tempbuf, mangle);
+ case 'D': /* delegate T */
+ mangle++;
+ mangle = parse_function_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, "delegate");
+ return mangle;
+ case 'B': /* tuple T */
+ /* TODO: Handle this. */
+ return NULL;
+
+ /* Function types */
+ case 'F': case 'U': case 'W':
+ case 'V': case 'R':
+ mangle = parse_function_type (tempbuf, mangle);
+ obstack_grow_str (tempbuf, "function");
+ return mangle;
+
+ /* Basic types */
+ case 'n':
+ mangle++;
+ obstack_grow_str (tempbuf, "none");
+ return mangle;
+ case 'v':
+ mangle++;
+ obstack_grow_str (tempbuf, "void");
+ return mangle;
+ case 'g':
+ mangle++;
+ obstack_grow_str (tempbuf, "byte");
+ return mangle;
+ case 'h':
+ mangle++;
+ obstack_grow_str (tempbuf, "ubyte");
+ return mangle;
+ case 's':
+ mangle++;
+ obstack_grow_str (tempbuf, "short");
+ return mangle;
+ case 't':
+ mangle++;
+ obstack_grow_str (tempbuf, "ushort");
+ return mangle;
+ case 'i':
+ mangle++;
+ obstack_grow_str (tempbuf, "int");
+ return mangle;
+ case 'k':
+ mangle++;
+ obstack_grow_str (tempbuf, "uint");
+ return mangle;
+ case 'l':
+ mangle++;
+ obstack_grow_str (tempbuf, "long");
+ return mangle;
+ case 'm':
+ mangle++;
+ obstack_grow_str (tempbuf, "ulong");
+ return mangle;
+ case 'f':
+ mangle++;
+ obstack_grow_str (tempbuf, "float");
+ return mangle;
+ case 'd':
+ mangle++;
+ obstack_grow_str (tempbuf, "double");
+ return mangle;
+ case 'e':
+ mangle++;
+ obstack_grow_str (tempbuf, "real");
+ return mangle;
+
+ /* Imaginary and Complex types */
+ case 'o':
+ mangle++;
+ obstack_grow_str (tempbuf, "ifloat");
+ return mangle;
+ case 'p':
+ mangle++;
+ obstack_grow_str (tempbuf, "idouble");
+ return mangle;
+ case 'j':
+ mangle++;
+ obstack_grow_str (tempbuf, "ireal");
+ return mangle;
+ case 'q':
+ mangle++;
+ obstack_grow_str (tempbuf, "cfloat");
+ return mangle;
+ case 'r':
+ mangle++;
+ obstack_grow_str (tempbuf, "cdouble");
+ return mangle;
+ case 'c':
+ mangle++;
+ obstack_grow_str (tempbuf, "creal");
+ return mangle;
+
+ /* Other types */
+ case 'b':
+ mangle++;
+ obstack_grow_str (tempbuf, "bool");
+ return mangle;
+ case 'a':
+ mangle++;
+ obstack_grow_str (tempbuf, "char");
+ return mangle;
+ case 'u':
+ mangle++;
+ obstack_grow_str (tempbuf, "wchar");
+ return mangle;
+ case 'w':
+ mangle++;
+ obstack_grow_str (tempbuf, "dchar");
+ return mangle;
+
+ default: /* unhandled */
+ return NULL;
+ }
+}
+
+/* Extract the identifier from MANGLE and append it to TEMPBUF.
+ Return the remaining string on success or NULL on failure. */
+
+static const char *
+parse_identifier (struct obstack *tempbuf, const char *mangle)
+{
+ if ((mangle == NULL) || (*mangle == '\0'))
+ return mangle;
+
+ if (ISDIGIT (*mangle))
+ {
+ char *endptr;
+ long i = strtol (mangle, &endptr, 10);
+
+ if (i <= 0 || strlen (endptr) < i)
+ return NULL;
+
+ mangle = endptr;
+
+ /* No support for demangling templates. */
+ if (i >= 5 && strncmp (mangle, "__T", 3) == 0)
+ return NULL;
+
+ if (strncmp (mangle, "__ctor", i) == 0)
+ {
+ /* Constructor symbol for a class/struct. */
+ obstack_grow_str (tempbuf, "this");
+ mangle += i;
+ return mangle;
+ }
+ else if (strncmp (mangle, "__dtor", i) == 0)
+ {
+ /* Destructor symbol for a class/struct. */
+ obstack_grow_str (tempbuf, "~this");
+ mangle += i;
+ return mangle;
+ }
+ else if (strncmp (mangle, "__postblit", i) == 0)
+ {
+ /* Postblit symbol for a struct. */
+ obstack_grow_str (tempbuf, "this(this)");
+ mangle += i;
+ return mangle;
+ }
+ else if (strncmp (mangle, "__initZ", i+1) == 0)
+ {
+ /* The static initialiser for a given symbol. */
+ obstack_grow_str (tempbuf, "init$");
+ mangle += i + 1;
+ return mangle;
+ }
+ else if (strncmp (mangle, "__ClassZ", i+1) == 0)
+ {
+ /* The classinfo symbol for a given class. */
+ obstack_grow_str (tempbuf, "classinfo$");
+ mangle += i + 1;
+ return mangle;
+ }
+ else if (strncmp (mangle, "__vtblZ", i+1) == 0)
+ {
+ /* The vtable symbol for a given class. */
+ obstack_grow_str (tempbuf, "vtbl$");
+ mangle += i + 1;
+ return mangle;
+ }
+ else if (strncmp (mangle, "__InterfaceZ", i+1) == 0)
+ {
+ /* The interface symbol for a given class. */
+ obstack_grow_str (tempbuf, "interface$");
+ mangle += i + 1;
+ return mangle;
+ }
+ else if (strncmp (mangle, "__ModuleInfoZ", i+1) == 0)
+ {
+ /* The ModuleInfo symbol for a given module. */
+ obstack_grow_str (tempbuf, "moduleinfo$");
+ mangle += i + 1;
+ return mangle;
+ }
+ obstack_grow (tempbuf, mangle, i);
+ mangle += i;
+ }
+ else
+ return NULL;
+
+ return mangle;
+}
+
+/* Test whether the current position of MANGLE is pointing to the
+ beginning of a mangled function parameter list, which starts with
+ the calling convention. Returns 1 on success or 0 on failure. */
+