Move D demangling routines out of d-lang.c and into d-support.c, which

is intended to house other D language support functions.

gdb/ChangeLog:
2014-01-17  Iain Buclaw  <ibuclaw@gdcproject.org>

    * Makefile.in (SFILES): Add d-support.c.
    (COMMON_OBS): Add d-support.o.
    * d-lang.h (d_parse_symbol): Add comment, now defined in
    d-support.c.
    * d-lang.c (parse_call_convention)
    (parse_attributes, parse_function_types)
    (parse_function_args, parse_type, parse_identifier)
    (call_convention_p, d_parse_symbol): Move functions to ...
    * d-support.c: ... New file.

1 files changed, 621 insertions, 0 deletions

diff --git a/gdb/d-support.c b/gdb/d-support.c
new file mode 100644
index 0000000..8123981
--- /dev/null
+++ b/gdb/d-support.c
@@ -0,0 +1,621 @@
+/* Helper routines for D support in GDB.
+
+   Copyright (C) 2014 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "defs.h"
+#include "d-lang.h"
+#include "gdb_obstack.h"
+
+#include "safe-ctype.h"
+
+static const char *parse_function_args (struct obstack *, const char *);
+static const char *parse_type (struct obstack *, const char *);
+
+
+/* Demangle the calling convention from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+
+static const char *
+parse_call_convention (struct obstack *tempbuf, const char *mangle)
+{
+  if ((mangle == NULL) || (*mangle == '\0'))
+    return mangle;
+
+  switch (*mangle)
+    {
+    case 'F': /* (D) */
+      mangle++;
+      break;
+    case 'U': /* (C) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(C) ");
+      break;
+    case 'W': /* (Windows) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(Windows) ");
+      break;
+    case 'V': /* (Pascal) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(Pascal) ");
+      break;
+    case 'R': /* (C++) */
+      mangle++;
+      obstack_grow_str (tempbuf, "extern(C++) ");
+      break;
+    default:
+      return NULL;
+    }
+
+  return mangle;
+}
+
+/* Demangle the D function attributes from MANGLE and append it to TEMPBUF.
+   Return the remaining string on success or NULL on failure.  */
+
+static const char *
+parse_attributes (struct obstack *tempbuf, const char *mangle)
+{
+  if ((mangle == NULL) || (*mangle == '\0'))
+    return mangle;
+
+  while (*mangle == 'N')
+    {
+      mangle++;
+      switch (*mangle)
+	{
+	case 'a': /* pure */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "pure ");
+	  continue;
+	case 'b': /* nothrow */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "nothrow ");
+	  continue;
+	case 'c': /* ref */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "ref ");
+	  continue;
+	case 'd': /* @property */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "@property ");
+	  continue;
+	case 'e': /* @trusted */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "@trusted ");
+	  continue;
+	case 'f': /* @safe */
+	  mangle++;
+	  obstack_grow_str (tempbuf, "@safe ");
+	  continue;
+	case 'g':
+	case 'h':
+	  /* inout parameter is represented as 'Ng'.
+	     vector parameter is represented as 'Nh'.
+	     If we see this, then we know we're really in the
+	     parameter list.  Rewind and break.  */
+	  mangle--;
+	}
+      break;
+    }
+  return mangle;
+}
+
+/* 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.  */
+
+static int
+call_convention_p (const char *mangle)
+{
+  size_t i;
+
+  if ((mangle == NULL) || (*mangle == '\0'))
+    return 0;
+
+  switch (*mangle)
+    {
+    case 'F': case 'U': case 'V':
+    case 'W': case 'R':
+      return 1;
+
+    case 'M': /* Prefix for functions needing 'this'.  */
+      i = 1;
+      if (mangle[i] == 'x')
+	i++;
+
+      switch (mangle[i])
+	{
+	case 'F': case 'U': case 'V':
+	case 'W': case 'R':
+	  return 1;
+	}
+
+    default:
+      return 0;
+    }
+}
+
+/* Extract and demangle the symbol in MANGLE and append it to TEMPBUF.
+   Return the remaining signature on success or NULL on failure.  */
+
+const char *
+d_parse_symbol (struct obstack *tempbuf, const char *mangle)
+{
+  size_t n = 0;
+  do
+    {
+      if (n++)
+	obstack_grow_str (tempbuf, ".");
+
+      mangle = parse_identifier (tempbuf, mangle);
+
+      if (call_convention_p (mangle))
+	{
+	  char *saved;
+
+	  /* Skip over 'this' parameter.  */
+	  if (*mangle == 'M')
+	    mangle += (mangle[1] == 'x') ? 2 : 1;
+
+	  /* Skip over calling convention and attributes in qualified name.  */
+	  saved = obstack_next_free (tempbuf);
+	  mangle = parse_call_convention (tempbuf, mangle);
+	  mangle = parse_attributes (tempbuf, mangle);
+	  obstack_next_free (tempbuf) = saved;
+
+	  obstack_grow_str (tempbuf, "(");
+	  mangle = parse_function_args (tempbuf, mangle);
+	  obstack_grow_str (tempbuf, ")");
+
+	  /* Demangle the function return type as a kind of sanity test.  */
+	  if ((mangle != NULL) && !ISDIGIT (*mangle))
+	    {
+	      saved = obstack_next_free (tempbuf);
+	      mangle = parse_type (tempbuf, mangle);
+	      obstack_next_free (tempbuf) = saved;
+	    }
+	}
+    }
+  while ((mangle != NULL) && ISDIGIT (*mangle));
+
+  return mangle;
+}
+