bundle libcxxabi

1 files changed, 10798 insertions, 0 deletions

diff --git a/system/lib/libcxxabi/src/cxa_demangle.cpp b/system/lib/libcxxabi/src/cxa_demangle.cpp
new file mode 100644
index 00000000..1135c99b
--- /dev/null
+++ b/system/lib/libcxxabi/src/cxa_demangle.cpp
@@ -0,0 +1,10798 @@
+//===-------------------------- cxa_demangle.cpp --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "cxa_demangle.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <new>
+#include <algorithm>
+#include <assert.h>
+
+
+#ifdef DEBUGGING
+
+#include <string>
+#include <typeinfo>
+
+#endif
+
+namespace __cxxabiv1
+{
+
+namespace __libcxxabi
+{
+
+#pragma GCC visibility push(hidden)
+
+class __node
+{
+    __node(const __node&);
+    __node& operator=(const __node&);
+public:
+    const char* __name_;
+    size_t __size_;
+    __node* __left_;
+    __node* __right_;
+    long double __value_;
+    long __cached_size_;
+public:
+    __node()
+        : __name_(0), __size_(0), __left_(0), __right_(0), __cached_size_(-1)
+        {}
+    virtual ~__node() {};
+
+    void reset_cached_size()
+    {
+        __cached_size_ = -1;
+        if (__left_)
+            __left_->reset_cached_size();
+        if (__right_)
+            __right_->reset_cached_size();
+    }
+
+    virtual size_t first_size() const  {return 0;}
+    virtual size_t second_size() const {return 0;}
+    virtual size_t size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = first_size() + second_size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const {return buf;}
+    virtual char* second_demangled_name(char* buf) const {return buf;}
+    virtual char* get_demangled_name(char* buf) const
+    {
+        return second_demangled_name(first_demangled_name(buf));
+    }
+    virtual size_t base_size() const {return size();}
+    virtual char* get_base_name(char* buf) const
+    {
+        return get_demangled_name(buf);
+    }
+
+    virtual bool ends_with_template(bool parsing = false) const
+    {
+        return false;
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return false;
+    }
+    virtual __node* base_name() const
+    {
+        return const_cast<__node*>(this);
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return false;
+    }
+    virtual bool is_function() const
+    {
+        return false;
+    }
+    virtual bool is_cv_qualifer() const
+    {
+        return false;
+    }
+    virtual bool is_array() const
+    {
+        return false;
+    }
+
+    virtual bool fix_forward_references(__node**, __node**)
+    {
+        return true;
+    }
+    virtual __node* extract_cv(__node*&) const
+    {
+        return 0;
+    }
+    virtual size_t list_len() const
+    {
+        return 0;
+    }
+    virtual bool is_sub() const
+    {
+        return false;
+    }
+};
+
+#ifdef DEBUGGING
+
+void display(__node* x, int indent = 0)
+{
+    if (x)
+    {
+        for (int i = 0; i < 2*indent; ++i)
+            printf(" ");
+        std::string buf(x->size(), '\0');
+        x->get_demangled_name(&buf.front());
+        printf("%s %s, %p\n", typeid(*x).name(), buf.c_str(), x);
+        display(x->__left_, indent+1);
+        display(x->__right_, indent+1);
+    }
+}
+
+#endif
+
+class __vtable
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("vtable for ") - 1;
+public:
+    __vtable(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "vtable for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __VTT
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("VTT for ") - 1;
+public:
+    __VTT(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "VTT for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __construction_vtable
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("construction vtable for ") - 1 + 4;
+public:
+    __construction_vtable(__node* left, __node* right)
+    {
+        __left_ = left;
+        __right_ = right;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __left_->size()
+                                                  + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "construction vtable for ", n-4);
+        buf =  __left_->get_demangled_name(buf+n-4);
+        *buf++ = '-';
+        *buf++ = 'i';
+        *buf++ = 'n';
+        *buf++ = '-';
+        return __right_->get_demangled_name(buf);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = __left_->fix_forward_references(t_begin, t_end);
+        return r && __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __typeinfo
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("typeinfo for ") - 1;
+public:
+    __typeinfo(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "typeinfo for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __typeinfo_name
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("typeinfo name for ") - 1;
+public:
+    __typeinfo_name(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "typeinfo name for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __covariant_return_thunk
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("covariant return thunk to ") - 1;
+public:
+    __covariant_return_thunk(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "covariant return thunk to ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __virtual_thunk
+    : public __node
+{
+    static const size_t n = sizeof("virtual thunk to ") - 1;
+public:
+    __virtual_thunk(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "virtual thunk to ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __non_virtual_thunk
+    : public __node
+{
+    static const size_t n = sizeof("non-virtual thunk to ") - 1;
+public:
+    __non_virtual_thunk(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "non-virtual thunk to ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __guard_variable
+    : public __node
+{
+    static const size_t n = sizeof("guard variable for ") - 1;
+public:
+    __guard_variable(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "guard variable for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __reference_temporary
+    : public __node
+{
+    static const size_t n = sizeof("reference temporary for ") - 1;
+public:
+    __reference_temporary(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "reference temporary for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __source_name
+    : public __node
+{
+public:
+    __source_name(const char* __name, unsigned __size)
+    {
+        __name_ = __name;
+        __size_ = __size;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0)
+                const_cast<long&>(__cached_size_) = 21;
+            else
+                const_cast<long&>(__cached_size_) = __size_;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0)
+            return strncpy(buf, "(anonymous namespace)", 21) + 21;
+        return strncpy(buf, __name_, __size_) + __size_;
+    }
+};
+
+class __operator_new
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator new") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator new", sizeof("operator new") - 1) +
+                                            sizeof("operator new") - 1;
+    }
+};
+
+class __operator_new_array
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator new[]") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator new[]", sizeof("operator new[]") - 1) +
+                                              sizeof("operator new[]") - 1;
+    }
+};
+
+class __operator_delete
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator delete") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator delete", sizeof("operator delete") - 1) +
+                                               sizeof("operator delete") - 1;
+    }
+};
+
+class __operator_delete_array
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator delete[]") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator delete[]", sizeof("operator delete[]") - 1) +
+                                                 sizeof("operator delete[]") - 1;
+    }
+};
+
+class __operator_logical_and
+    : public __node
+{
+public:
+
+    __operator_logical_and() {}
+    __operator_logical_and(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&&") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") && (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&&", sizeof("operator&&") - 1);
+            buf += sizeof("operator&&") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_addressof
+    : public __node
+{
+public:
+
+    __operator_addressof() {}
+    explicit __operator_addressof(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '&';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&", sizeof("operator&") - 1);
+            buf += sizeof("operator&") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_bit_and
+    : public __node
+{
+public:
+
+    __operator_bit_and() {}
+    __operator_bit_and(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") & (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&", sizeof("operator&") - 1);
+            buf += sizeof("operator&") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_and_equal
+    : public __node
+{
+public:
+
+    __operator_and_equal() {}
+    __operator_and_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") &= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&=", sizeof("operator&=") - 1);
+            buf += sizeof("operator&=") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_equal
+    : public __node
+{
+public:
+
+    __operator_equal() {}
+    __operator_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") = (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator=", sizeof("operator=") - 1);
+            buf += sizeof("operator=") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_alignof_type
+    : public __node
+{
+public:
+
+    __operator_alignof_type() {}
+    __operator_alignof_type(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__right_)
+                const_cast<long&>(__cached_size_) = __right_->size() + 10;
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__right_)
+        {
+            strncpy(buf, "alignof (", 9);
+            buf += 9;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator alignof", sizeof("operator alignof") - 1);
+            buf += sizeof("operator alignof") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__right_)
+            return __right_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_alignof_expression
+    : public __node
+{
+public:
+
+    __operator_alignof_expression() {}
+    __operator_alignof_expression(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__right_)
+                const_cast<long&>(__cached_size_) = __right_->size() + 10;
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__right_)
+        {
+            strncpy(buf, "alignof (", 9);
+            buf += 9;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator alignof", sizeof("operator alignof") - 1);
+            buf += sizeof("operator alignof") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__right_)
+            return __right_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_paren
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator()") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "operator()", sizeof("operator()") - 1);
+        return buf + sizeof("operator()") - 1;
+    }
+};
+
+class __operator_comma
+    : public __node
+{
+public:
+
+    __operator_comma() {}
+    __operator_comma(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator,") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") , (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator,", sizeof("operator,") - 1);
+            buf += sizeof("operator,") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_tilda
+    : public __node
+{
+public:
+
+    __operator_tilda() {}
+    explicit __operator_tilda(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator~") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '~';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator~", sizeof("operator~") - 1);
+            buf += sizeof("operator~") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_cast
+    : public __node
+{
+    static const size_t n = sizeof("operator ") - 1;
+public:
+
+    explicit __operator_cast(__node* type)
+    {
+        __right_ = type;
+    }
+    __operator_cast(__node* type, __node* arg)
+    {
+        __size_ = 1;
+        __right_ = type;
+        __left_ = arg;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            size_t off;
+            if (__size_)
+            {
+                off = 4;
+                off += __right_->size();
+                if (__left_)
+                    off += __left_->size();
+            }
+            else
+                off = n +  __right_->size();;
+            const_cast<long&>(__cached_size_) = off;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_)
+        {
+            *buf++ = '(';
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+            *buf++ = '(';
+            if (__left_)
+                buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator ", n);
+            buf = __right_->get_demangled_name(buf+n);
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return true;
+    }
+};
+
+class __cast_literal
+    : public __node
+{
+public:
+
+    __cast_literal(__node* type, const char* f, const char* l)
+    {
+        __left_ = type;
+        __name_ = f;
+        __size_ = l - f;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = 2 + __left_->size() + __size_;
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        *buf++ = '(';
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = ')';
+        strncpy(buf, __name_, __size_);
+        return buf + __size_;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __operator_dereference
+    : public __node
+{
+public:
+
+    __operator_dereference() {}
+    explicit __operator_dereference(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator*") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '*';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator*", sizeof("operator*") - 1);
+            buf += sizeof("operator*") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_divide
+    : public __node
+{
+public:
+
+    __operator_divide() {}
+    __operator_divide(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator/") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") / (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator/", sizeof("operator/") - 1);
+            buf += sizeof("operator/") - 1;
+        }
+        return buf;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r &&