Let cxa_demangle.cpp compile with gcc/libstdc++ 4.8 and clang-cl/MSVC2013's STL.

[thakis]

Summary

I wanted a demangler that can demangle both Itanium-style and Microsoft-style mangled symbols, and that runs on all of Windows, Linux, and Mac OS X. I used libcxxabi's cxa_demangle for the Itanium demangling, but that required to get it to build with gcc on Linux and with clang-cl/MSVC on Windows. It required only small changes, and imho they look reasonable enough to send them upstream.

libstdc++ needs a few typedefs in malloc_alloc. MSVC's STL needs rebind(), construct(), destroy().

MSVC2013 also has no snprintf, but it allegedly exists in 2015. (I haven't tried building with 2015, though.)

[mclow.lists]

This looks good to me.

[thakis]

r248129, thanks!

src/cxa_demangle.cpp

 #include <vector>
 #include <algorithm>
 #include <string>
 #include <numeric>
 #include <cstdlib>
 #include <cstring>
 #include <cctype>
 
+#ifdef _MSC_VER
+// snprintf is implemented in VS 2015
+#if _MSC_VER < 1900
+#define snprintf _snprintf_s
+#endif
+#endif
+
 namespace __cxxabiv1
 {
 
 namespace
 {
 
 enum
 {
operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
     return !(x == y);
 }
 
 template <class T>
 class malloc_alloc
 {
 public:
     typedef T value_type;
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
 
     malloc_alloc() = default;
     template <class U> malloc_alloc(const malloc_alloc<U>&) noexcept {}
 
     T* allocate(std::size_t n)
     {
         return static_cast<T*>(std::malloc(n*sizeof(T)));
     }
     void deallocate(T* p, std::size_t) noexcept
     {
         std::free(p);
     }
+
+    template <class U> struct rebind { using other = malloc_alloc<U>; };
+    template <class U, class... Args>
+    void construct(U* p, Args&&... args)
+    {
+        ::new ((void*)p) U(std::forward<Args>(args)...);
+    }
+    void destroy(T* p)
+    {
+        p->~T();
+    }
 };
 
 template <class T, class U>
 inline
 bool
 operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept
 {
     return true;