/*
 * Copyright 2009-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2021, Jerome Duval, jerome.duval@gmail.com.
 * Distributed under the terms of the MIT License.
 */

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <new>

#include <TypeConstants.h>

#ifdef _KERNEL_MODE
#       include <debug_heap.h>
#endif

#include "demangle.h"


// C++ ABI: https://itanium-cxx-abi.github.io/cxx-abi/abi.html


//#define TRACE_GCC3_DEMANGLER
#ifdef TRACE_GCC3_DEMANGLER
#       define TRACE(x...) PRINT(x)
#       define DEBUG_SCOPE(name)        DebugScope debug(name, fInput.String())
#else
#       define TRACE(x...) ;
#       define DEBUG_SCOPE(name)        do {} while (false)
#endif

#ifdef _KERNEL_MODE
#       define PRINT(format...)         kprintf(format)
#       define VPRINT(format, args)     PRINT("%s", format)
                                                                        // no vkprintf()
#       define NEW(constructor) new(kdebug_alloc) constructor
#       define DELETE(object)   DebugAlloc::destroy(object)
#else
#       define PRINT(format...)         printf(format)
#       define VPRINT(format, args)     vprintf(format, args)
#       define NEW(constructor) new(std::nothrow) constructor
#       define DELETE(object)   delete object
#endif


typedef long number_type;

enum {
        ERROR_OK = 0,
        ERROR_NOT_MANGLED,
        ERROR_UNSUPPORTED,
        ERROR_INVALID,
        ERROR_BUFFER_TOO_SMALL,
        ERROR_NO_MEMORY,
        ERROR_INTERNAL,
        ERROR_INVALID_PARAMETER_INDEX
};

// object classification
enum object_type {
        OBJECT_TYPE_UNKNOWN,
        OBJECT_TYPE_DATA,
        OBJECT_TYPE_FUNCTION,
        OBJECT_TYPE_METHOD_CLASS,
        OBJECT_TYPE_METHOD_OBJECT,
        OBJECT_TYPE_METHOD_UNKNOWN
};

// prefix classification
enum prefix_type {
        PREFIX_NONE,
        PREFIX_NAMESPACE,
        PREFIX_CLASS,
        PREFIX_UNKNOWN
};

// type classification
enum type_type {
        TYPE_ELLIPSIS,
        TYPE_VOID,
        TYPE_WCHAR_T,
        TYPE_BOOL,
        TYPE_CHAR,
        TYPE_SIGNED_CHAR,
        TYPE_UNSIGNED_CHAR,
        TYPE_SHORT,
        TYPE_UNSIGNED_SHORT,
        TYPE_INT,
        TYPE_UNSIGNED_INT,
        TYPE_LONG,
        TYPE_UNSIGNED_LONG,
        TYPE_LONG_LONG,
        TYPE_UNSIGNED_LONG_LONG,
        TYPE_INT128,
        TYPE_UNSIGNED_INT128,
        TYPE_FLOAT,
        TYPE_DOUBLE,
        TYPE_LONG_DOUBLE,
        TYPE_FLOAT128,
        TYPE_DFLOAT16,
        TYPE_DFLOAT32,
        TYPE_DFLOAT64,
        TYPE_DFLOAT128,
        TYPE_CHAR16_T,
        TYPE_CHAR32_T,

        TYPE_UNKNOWN,
        TYPE_CONST_CHAR_POINTER,
        TYPE_POINTER,
        TYPE_REFERENCE
};

const char* const kTypeNames[] = {
        "...",
        "void",
        "wchar_t",
        "bool",
        "char",
        "signed char",
        "unsigned char",
        "short",
        "unsigned short",
        "int",
        "unsigned int",
        "long",
        "unsigned long",
        "long long",
        "unsigned long long",
        "__int128",
        "unsigned __int128",
        "float",
        "double",
        "long double",
        "__float128",
        "__dfloat16",   // TODO: Official names for the __dfloat*!
        "__dfloat32",
        "__dfloat64",
        "__dfloat64",
        "char16_t",
        "char32_t",

        "?",
        "char const*",
        "void*",
        "void&"
};


// CV qualifier flags
enum {
        CV_QUALIFIER_RESTRICT   = 0x1,
        CV_QUALIFIER_VOLATILE   = 0x2,
        CV_QUALIFIER_CONST              = 0x4
};

enum type_modifier {
        TYPE_QUALIFIER_POINTER = 0,
        TYPE_QUALIFIER_REFERENCE,
        TYPE_QUALIFIER_RVALUE_REFERENCE,
        TYPE_QUALIFIER_COMPLEX,
        TYPE_QUALIFIER_IMAGINARY
};

static const char* const kTypeModifierSuffixes[] = {
        "*",
        "&",
        "&&",
        " complex",
        " imaginary"
};

struct operator_info {
        const char*     mangled_name;
        const char*     name;
        int                     argument_count;
        int                     flags;
};

// operator flags
enum {
        OPERATOR_TYPE_PARAM             = 0x01,
        OPERATOR_IS_MEMBER              = 0x02
};


static const operator_info kOperatorInfos[] = {
        { "nw", "new", -1, OPERATOR_IS_MEMBER },
        { "na", "new[]", -1, OPERATOR_IS_MEMBER },
        { "dl", "delete", -1, OPERATOR_IS_MEMBER },
        { "da", "delete[]", -1, OPERATOR_IS_MEMBER },
        { "ps", "+", 1, 0 },            // unary
        { "ng", "-", 1, 0 },            // unary
        { "ad", "&", 1, 0 },            // unary
        { "de", "*", 1, 0 },            // unary
        { "co", "~", 1, 0 },
        { "pl", "+", 2, 0 },
        { "mi", "-", 2, 0 },
        { "ml", "*", 2, 0 },
        { "dv", "/", 2, 0 },
        { "rm", "%", 2, 0 },
        { "an", "&", 2, 0 },
        { "or", "|", 2, 0 },
        { "eo", "^", 2, 0 },
        { "aS", "=", 2, 0 },
        { "pL", "+=", 2, 0 },
        { "mI", "-=", 2, 0 },
        { "mL", "*=", 2, 0 },
        { "dV", "/=", 2, 0 },
        { "rM", "%=", 2, 0 },
        { "aN", "&=", 2, 0 },
        { "oR", "|=", 2, 0 },
        { "eO", "^=", 2, 0 },
        { "ls", "<<", 2, 0 },
        { "rs", ">>", 2, 0 },
        { "lS", "<<=", 2, 0 },
        { "rS", ">>=", 2, 0 },
        { "eq", "==", 2, 0 },
        { "ne", "!=", 2, 0 },
        { "lt", "<", 2, 0 },
        { "gt", ">", 2, 0 },
        { "le", "<=", 2, 0 },
        { "ge", ">=", 2, 0 },
        { "nt", "!", 1, 0 },
        { "aa", "&&", 2, 0 },
        { "oo", "||", 2, 0 },
        { "pp", "++", 1, 0 },
        { "mm", "--", 1, 0 },
        { "cm", ",", -1, 0 },
        { "pm", "->*", 2, 0 },
        { "pt", "->", 2, 0 },
        { "cl", "()", -1, 0 },
        { "ix", "[]", -1, 0 },
        { "qu", "?", 3, 0 },
        { "st", "sizeof", 1, OPERATOR_TYPE_PARAM },             // type
        { "sz", "sizeof", 1, 0 },                                               // expression
        { "at", "alignof", 1, OPERATOR_TYPE_PARAM },    // type
        { "az", "alignof", 1, 0 },                                              // expression
        {}
};


#ifdef TRACE_GCC3_DEMANGLER

struct DebugScope {
        DebugScope(const char* functionName, const char* remainingString = NULL)
                :
                fParent(sGlobalScope),
                fFunctionName(functionName),
                fLevel(fParent != NULL ? fParent->fLevel + 1 : 0)
        {
                sGlobalScope = this;
                if (remainingString != NULL) {
                        PRINT("%*s%s(): \"%s\"\n", fLevel * 2, "", fFunctionName,
                                remainingString);
                } else
                        PRINT("%*s%s()\n", fLevel * 2, "", fFunctionName);
        }

        ~DebugScope()
        {
                sGlobalScope = fParent;
                PRINT("%*s%s() done\n", fLevel * 2, "", fFunctionName);
        }

        static void Print(const char* format,...)
        {
                int level = sGlobalScope != NULL ? sGlobalScope->fLevel : 0;

                va_list args;
                va_start(args, format);
                PRINT("%*s", (level + 1) * 2, "");
                VPRINT(format, args);
                va_end(args);
        }

private:
        DebugScope*     fParent;
        const char*     fFunctionName;
        int                     fLevel;

        static DebugScope* sGlobalScope;
};

DebugScope* DebugScope::sGlobalScope = NULL;

#endif  // TRACE_GCC3_DEMANGLER


class Input {
public:
        Input()
                :
                fString(NULL),
                fLength(0)
        {
        }

        void SetTo(const char* string, size_t length)
        {
                fString = string;
                fLength = length;
        }

        const char* String() const
        {
                return fString;
        }

        int CharsRemaining() const
        {
                return fLength;
        }

        void Skip(size_t count)
        {
                if (count > fLength) {
                        PRINT("Input::Skip(): fOffset > fLength\n");
                        return;
                }

                fString += count;
                fLength -= count;
        }

        bool HasPrefix(char prefix) const
        {
                return fLength > 0 && fString[0] == prefix;
        }

        bool HasPrefix(const char* prefix) const
        {
                size_t prefixLen = strlen(prefix);
                return prefixLen <= fLength
                        && strncmp(fString, prefix, strlen(prefix)) == 0;
        }

        bool SkipPrefix(char prefix)
        {
                if (!HasPrefix(prefix))
                        return false;

                fString++;
                fLength--;
                return true;
        }

        bool SkipPrefix(const char* prefix)
        {
                size_t prefixLen = strlen(prefix);
                if (prefixLen <= fLength && strncmp(fString, prefix, prefixLen) != 0)
                        return false;

                fString += prefixLen;
                fLength -= prefixLen;
                return true;
        }

        char operator[](size_t index) const
        {
                if (index >= fLength) {
                        PRINT("Input::operator[](): fOffset + index >= fLength\n");
                        return '\0';
                }

                return fString[index];
        }

private:
        const char*     fString;
        size_t          fLength;
};


class NameBuffer {
public:
        NameBuffer(char* buffer, size_t size)
                :
                fBuffer(buffer),
                fSize(size),
                fLength(0),
                fOverflow(false)
        {
        }

        bool IsEmpty() const
        {
                return fLength == 0;
        }

        char LastChar() const
        {
                return fLength > 0 ? fBuffer[fLength - 1] : '\0';
        }

        bool HadOverflow() const
        {
                return fOverflow;
        }

        char* Terminate()
        {
                fBuffer[fLength] = '\0';
                return fBuffer;
        }

        bool Append(const char* string, size_t length)
        {
                if (fLength + length >= fSize) {
                        fOverflow = true;
                        return false;
                }

                memcpy(fBuffer + fLength, string, length);
                fLength += length;
                return true;
        }

        bool Append(const char* string)
        {
                return Append(string, strlen(string));
        }

private:
        char*   fBuffer;
        size_t  fSize;
        size_t  fLength;
        bool    fOverflow;
};


struct TypeInfo {
        type_type       type;
        int                     cvQualifiers;

        TypeInfo()
                :
                type(TYPE_UNKNOWN),
                cvQualifiers(0)
        {
        }

        TypeInfo(type_type type)
                :
                type(type),
                cvQualifiers(0)
        {
        }

        TypeInfo(const TypeInfo& other, int cvQualifiers = 0)
                :
                type(other.type),
                cvQualifiers(other.cvQualifiers | cvQualifiers)
        {
        }

        TypeInfo& operator=(const TypeInfo& other)
        {
                type = other.type;
                cvQualifiers = other.cvQualifiers;
                return *this;
        }
};


struct DemanglingParameters {
        bool    objectNameOnly;

        DemanglingParameters(bool objectNameOnly)
                :
                objectNameOnly(objectNameOnly)
        {
        }
};


struct DemanglingInfo : DemanglingParameters {
        object_type     objectType;

        DemanglingInfo(bool objectNameOnly)
                :
                DemanglingParameters(objectNameOnly),
                objectType(OBJECT_TYPE_UNKNOWN)
        {
        }
};


struct ParameterInfo {
        TypeInfo        type;

        ParameterInfo()
        {
        }
};


class Node;

struct NameDecorationInfo {
        const Node*     firstDecorator;
        const Node*     closestCVDecoratorList;

        NameDecorationInfo(const Node* decorator)
                :
                firstDecorator(decorator),
                closestCVDecoratorList(NULL)
        {
        }
};

struct CVQualifierInfo {
        const Node*     firstCVQualifier;
        const Node*     firstNonCVQualifier;

        CVQualifierInfo()
                :
                firstCVQualifier(NULL),
                firstNonCVQualifier(NULL)
        {
        }
};


class Node {
public:
        Node()
                :
                fNextAllocated(NULL),
                fParent(NULL),
                fNext(NULL),
                fNextReferenceable(NULL),
                fReferenceable(true)
        {
        }

        virtual ~Node()
        {
        }

        Node* NextAllocated() const                     { return fNextAllocated; }
        void SetNextAllocated(Node* node)       { fNextAllocated = node; }

        Node* Parent() const                            { return fParent; }
        virtual void SetParent(Node* node)      { fParent = node; }

        Node* Next() const                      { return fNext; }
        void SetNext(Node* node)        { fNext = node; }

        bool IsReferenceable() const            { return fReferenceable; }
        void SetReferenceable(bool flag)        { fReferenceable = flag; }

        Node* NextReferenceable() const                 { return fNextReferenceable; }
        void SetNextReferenceable(Node* node)   { fNextReferenceable = node; }

        virtual bool GetName(NameBuffer& buffer) const = 0;

        virtual bool GetDecoratedName(NameBuffer& buffer,
                NameDecorationInfo& decorationInfo) const
        {
                if (!GetName(buffer))
                        return false;

                return decorationInfo.firstDecorator == NULL
                        || decorationInfo.firstDecorator->AddDecoration(buffer, NULL);
        }

        virtual bool AddDecoration(NameBuffer& buffer,
                const Node* stopDecorator) const
        {
                return true;
        }

        virtual void GetCVQualifierInfo(CVQualifierInfo& info) const
        {
                info.firstNonCVQualifier = this;
        }

        virtual Node* GetUnqualifiedNode(Node* beforeNode)
        {
                return this;
        }

        virtual bool IsTemplatized() const
        {
                return false;
        }

        virtual Node* TemplateParameterAt(int index) const
        {
                return NULL;
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return false;
        }

        virtual bool IsTypeName(const char* name, size_t length) const
        {
                return false;
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_UNKNOWN;
        }

        virtual prefix_type PrefixType() const
        {
                return PREFIX_NONE;
        }

        virtual TypeInfo Type() const
        {
                return TypeInfo();
        }

private:
        Node*   fNextAllocated;
        Node*   fParent;
        Node*   fNext;
        Node*   fNextReferenceable;
        bool    fReferenceable;
};


class NamedTypeNode : public Node {
public:
        NamedTypeNode(Node* name)
                :
                fName(name)
        {
                if (fName != NULL)
                        fName->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                return fName == NULL || fName->GetName(buffer);
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return fName != NULL && fName->IsNoReturnValueFunction();
        }

        virtual TypeInfo Type() const
        {
                return fName != NULL ? fName->Type() : TypeInfo();
        }

protected:
        Node*   fName;
};


class SubstitutionNode : public Node {
public:
        SubstitutionNode(Node* node)
                :
                fNode(node)
        {
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                return fNode->GetName(buffer);
        }

        virtual bool GetDecoratedName(NameBuffer& buffer,
                NameDecorationInfo& decorationInfo) const
        {
                return fNode->GetDecoratedName(buffer, decorationInfo);
        }

        virtual bool AddDecoration(NameBuffer& buffer,
                const Node* stopDecorator) const
        {
                return fNode->AddDecoration(buffer, stopDecorator);
        }

        virtual void GetCVQualifierInfo(CVQualifierInfo& info) const
        {
                fNode->GetCVQualifierInfo(info);
        }

        virtual bool IsTemplatized() const
        {
                return fNode->IsTemplatized();
        }

        virtual Node* TemplateParameterAt(int index) const
        {
                return fNode->TemplateParameterAt(index);
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return fNode->IsNoReturnValueFunction();
        }

        virtual bool IsTypeName(const char* name, size_t length) const
        {
                return fNode->IsTypeName(name, length);
        }

        virtual object_type ObjectType() const
        {
                return fNode->ObjectType();
        }

        virtual prefix_type PrefixType() const
        {
                return fNode->PrefixType();
        }

        virtual TypeInfo Type() const
        {
                return fNode->Type();
        }

private:
        Node*   fNode;
};


class ArrayNode : public NamedTypeNode {
public:
        ArrayNode(Node* type, int dimension)
                :
                NamedTypeNode(type),
                fDimensionExpression(NULL),
                fDimensionNumber(dimension)
        {
        }

        ArrayNode(Node* type, Node* dimension)
                :
                NamedTypeNode(type),
                fDimensionExpression(dimension),
                fDimensionNumber(0)
        {
                fDimensionExpression->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                if (!fName->GetName(buffer))
                        return false;

                buffer.Append("[", 1);

                if (fDimensionExpression != NULL) {
                        if (!fDimensionExpression->GetName(buffer))
                                return false;
                } else {
                        char stringBuffer[16];
                        snprintf(stringBuffer, sizeof(stringBuffer), "%d",
                                fDimensionNumber);
                        buffer.Append(stringBuffer);
                }

                return buffer.Append("]", 1);
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_DATA;
        }

        virtual TypeInfo Type() const
        {
// TODO: Check!
                return TypeInfo(TYPE_POINTER);
        }


private:
        Node*   fDimensionExpression;
        int             fDimensionNumber;
};


class ObjectNode : public NamedTypeNode {
public:
        ObjectNode(Node* name)
                :
                NamedTypeNode(name)
        {
        }

        virtual bool GetObjectName(NameBuffer& buffer,
                const DemanglingParameters& parameters)
        {
                if (parameters.objectNameOnly)
                        return fName != NULL ? fName->GetName(buffer) : true;

                return GetName(buffer);
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_DATA;
        }

        virtual Node* ParameterAt(uint32 index) const
        {
                return NULL;
        }
};


class SimpleNameNode : public Node {
public:
        SimpleNameNode(const char* name)
                :
                fName(name),
                fLength(strlen(name))
        {
        }

        SimpleNameNode(const char* name, size_t length)
                :
                fName(name),
                fLength(length)
        {
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                return buffer.Append(fName, fLength);
        }

protected:
        const char*     fName;
        size_t          fLength;
};


class SimpleTypeNode : public SimpleNameNode {
public:
        SimpleTypeNode(const char* name)
                :
                SimpleNameNode(name),
                fType(TYPE_UNKNOWN)
        {
        }

        SimpleTypeNode(type_type type)
                :
                SimpleNameNode(kTypeNames[type]),
                fType(type)
        {
        }

        virtual bool IsTypeName(const char* name, size_t length) const
        {
                return fLength == length && strcmp(fName, name) == 0;
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_DATA;
        }

        virtual TypeInfo Type() const
        {
                return TypeInfo(fType);
        }

private:
        type_type       fType;
};


class TypedNumberLiteralNode : public Node {
public:
        TypedNumberLiteralNode(Node* type, const char* number, size_t length)
                :
                fType(type),
                fNumber(number),
                fLength(length)
        {
                fType->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                // If the type is bool and the number is 0 or 1, we use "false" or
                // "true" respectively.
                if (fType->IsTypeName("bool", 4) && fLength == 1
                        && (fNumber[0] == '0' || fNumber[0] == '1')) {
                        return buffer.Append(fNumber[0] == '0' ? "false" : "true");
                }

                // Add the type in parentheses. The GNU demangler omits "int", so do we.
                if (!fType->IsTypeName("int", 3)) {
                        buffer.Append("(");
                        if (!fType->GetName(buffer))
                                return false;
                        buffer.Append(")");
                }

                // add the number -- replace a leading 'n' by '-', if necessary
                if (fLength > 0 && fNumber[0] == 'n') {
                        buffer.Append("-");
                        return buffer.Append(fNumber + 1, fLength - 1);
                }

                return buffer.Append(fNumber, fLength);
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_DATA;
        }

private:
        Node*           fType;
        const char*     fNumber;
        size_t          fLength;
};


class XtructorNode : public Node {
public:
        XtructorNode(bool constructor, char type)
                :
                fConstructor(constructor),
                fType(type)
        {
        }

        virtual void SetParent(Node* node)
        {
                fUnqualifiedNode = node->GetUnqualifiedNode(this);
                Node::SetParent(node);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                if (fUnqualifiedNode == NULL)
                        return false;

                if (!fConstructor)
                        buffer.Append("~");

                return fUnqualifiedNode->GetName(buffer);
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return true;
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_METHOD_CLASS;
        }

private:
        bool            fConstructor;
        char            fType;
        Node*           fUnqualifiedNode;
};


class SpecialNameNode : public Node {
public:
        SpecialNameNode(const char* name, Node* child)
                :
                fName(name),
                fChild(child)
        {
                fChild->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                return buffer.Append(fName) && fChild->GetName(buffer);
        }

protected:
        const char*     fName;
        Node*           fChild;
};


class DecoratingNode : public Node {
public:
        DecoratingNode(Node* child)
                :
                fChildNode(child)
        {
                fChildNode->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                NameDecorationInfo decorationInfo(this);
                return fChildNode->GetDecoratedName(buffer, decorationInfo);
        }

        virtual bool GetDecoratedName(NameBuffer& buffer,
                NameDecorationInfo& decorationInfo) const
        {
                decorationInfo.closestCVDecoratorList = NULL;
                return fChildNode->GetDecoratedName(buffer, decorationInfo);
        }

protected:
        Node*   fChildNode;
};


class CVQualifiersNode : public DecoratingNode {
public:
        CVQualifiersNode(int qualifiers, Node* child)
                :
                DecoratingNode(child),
                fCVQualifiers(qualifiers)
        {
        }

        virtual bool GetDecoratedName(NameBuffer& buffer,
                NameDecorationInfo& decorationInfo) const
        {
                if (decorationInfo.closestCVDecoratorList == NULL)
                        decorationInfo.closestCVDecoratorList = this;
                return fChildNode->GetDecoratedName(buffer, decorationInfo);
        }

        virtual bool AddDecoration(NameBuffer& buffer,
                const Node* stopDecorator) const
        {
                if (this == stopDecorator)
                        return true;

                if (!fChildNode->AddDecoration(buffer, stopDecorator))
                        return false;

                if ((fCVQualifiers & CV_QUALIFIER_RESTRICT) != 0)
                        buffer.Append(" restrict");
                if ((fCVQualifiers & CV_QUALIFIER_VOLATILE) != 0)
                        buffer.Append(" volatile");
                if ((fCVQualifiers & CV_QUALIFIER_CONST) != 0)
                        buffer.Append(" const");

                return true;
        }

        virtual void GetCVQualifierInfo(CVQualifierInfo& info) const
        {
                if (info.firstCVQualifier == NULL)
                        info.firstCVQualifier = this;
                fChildNode->GetCVQualifierInfo(info);
        }

        virtual bool IsTemplatized() const
        {
                return fChildNode->IsTemplatized();
        }

        virtual Node* TemplateParameterAt(int index) const
        {
                return fChildNode->TemplateParameterAt(index);
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return fChildNode->IsNoReturnValueFunction();
        }

        virtual object_type ObjectType() const
        {
                return fChildNode->ObjectType();
        }

        virtual prefix_type PrefixType() const
        {
                return fChildNode->PrefixType();
        }

        virtual TypeInfo Type() const
        {
                return TypeInfo(fChildNode->Type(), fCVQualifiers);
        }

private:
        int             fCVQualifiers;
};


class TypeModifierNode : public DecoratingNode {
public:
        TypeModifierNode(type_modifier modifier, Node* child)
                :
                DecoratingNode(child),
                fModifier(modifier)
        {
        }

        virtual bool AddDecoration(NameBuffer& buffer,
                const Node* stopDecorator) const
        {
                if (this == stopDecorator)
                        return true;

                return fChildNode->AddDecoration(buffer, stopDecorator)
                        && buffer.Append(kTypeModifierSuffixes[fModifier]);
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_DATA;
        }

        virtual TypeInfo Type() const
        {
                TypeInfo type = fChildNode->Type();
                if (type.type == TYPE_CHAR
                        && (type.cvQualifiers & CV_QUALIFIER_CONST) != 0) {
                        return TypeInfo(TYPE_CONST_CHAR_POINTER);
                }

                switch (fModifier) {
                        case TYPE_QUALIFIER_POINTER:
                                return TypeInfo(TYPE_POINTER);
                        case TYPE_QUALIFIER_REFERENCE:
                                return TypeInfo(TYPE_REFERENCE);
                        default:
                                return TypeInfo();
                }
        }

private:
        type_modifier   fModifier;
};


class VendorTypeModifierNode : public DecoratingNode {
public:
        VendorTypeModifierNode(Node* name, Node* child)
                :
                DecoratingNode(child),
                fName(name)
        {
                fName->SetParent(this);
        }

        virtual bool AddDecoration(NameBuffer& buffer,
                const Node* stopDecorator) const
        {
                if (this == stopDecorator)
                        return true;

                return fChildNode->AddDecoration(buffer, stopDecorator)
                        && buffer.Append(" ")
                        && fName->GetName(buffer);
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_DATA;
        }

private:
        Node*   fName;
};


class OperatorNode : public Node {
public:
        OperatorNode(const operator_info* info)
                :
                fInfo(info)
        {
                SetReferenceable(false);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                return buffer.Append(
                                isalpha(fInfo->name[0]) ?  "operator " : "operator")
                        && buffer.Append(fInfo->name);
        }

        virtual object_type ObjectType() const
        {
                return (fInfo->flags & OPERATOR_IS_MEMBER) != 0
                        ? OBJECT_TYPE_METHOD_CLASS : OBJECT_TYPE_UNKNOWN;
        }

private:
        const operator_info*    fInfo;
};


class VendorOperatorNode : public Node {
public:
        VendorOperatorNode(Node* name)
                :
                fName(name)
        {
                fName->SetParent(this);
                SetReferenceable(false);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                return buffer.Append("operator ")
                        && fName->GetName(buffer);
        }

private:
        Node*   fName;
};


class CastOperatorNode : public Node {
public:
        CastOperatorNode(Node* child)
                :
                fChildNode(child)
        {
                fChildNode->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                return buffer.Append("operator ") && fChildNode->GetName(buffer);
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return true;
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_METHOD_OBJECT;
        }

private:
        Node*   fChildNode;
};


class PrefixedNode : public Node {
public:
        PrefixedNode(Node* prefix, Node* node)
                :
                fPrefixNode(prefix),
                fNode(node)
        {
                fPrefixNode->SetParent(this);
                fNode->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                if (!fPrefixNode->GetName(buffer))
                        return false;

                buffer.Append("::");
                return fNode->GetName(buffer);
        }

        virtual Node* GetUnqualifiedNode(Node* beforeNode)
        {
                return beforeNode == fNode
                        ? fPrefixNode->GetUnqualifiedNode(beforeNode)
                        : fNode->GetUnqualifiedNode(beforeNode);
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return fNode->IsNoReturnValueFunction();
        }

        virtual object_type ObjectType() const
        {
                return fNode->ObjectType();
        }

        virtual prefix_type PrefixType() const
        {
                return PREFIX_UNKNOWN;
        }

private:
        Node*   fPrefixNode;
        Node*   fNode;
};


class ClonedNode : public ObjectNode {
public:
        ClonedNode(Node* clone, ObjectNode* node)
                :
                ObjectNode(NULL),
                fNode(node),
                fCloneNode(clone)
        {
                fNode->SetParent(this);
                fCloneNode->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                if (!fNode->GetName(buffer))
                        return false;
                buffer.Append(" ", 1);
                return _AppendCloneName(buffer);
        }

        virtual bool GetObjectName(NameBuffer& buffer,
                const DemanglingParameters& parameters)
        {
                if (parameters.objectNameOnly) {
                        if (!fNode->GetObjectName(buffer, parameters))
                                return false;
                        if (!_AppendCloneName(buffer))
                                return false;
                        return buffer.Append(" ", 1);
                }

                return ObjectNode::GetObjectName(buffer, parameters);
        }

        virtual Node* GetUnqualifiedNode(Node* beforeNode)
        {
                return beforeNode == fCloneNode
                        ? fNode->GetUnqualifiedNode(beforeNode)
                        : fCloneNode->GetUnqualifiedNode(beforeNode);
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return fNode->IsNoReturnValueFunction();
        }

        virtual object_type ObjectType() const
        {
                return fNode->ObjectType();
        }

        virtual prefix_type PrefixType() const
        {
                return PREFIX_UNKNOWN;
        }

        virtual Node* ParameterAt(uint32 index) const
        {
                return fNode->ParameterAt(index);
        }

private:
        bool _AppendCloneName(NameBuffer& buffer) const
        {
                buffer.Append("[clone ");
                if (!fCloneNode->GetName(buffer))
                        return false;
                buffer.Append("]");
                return true;
        }

private:
        ObjectNode*     fNode;
        Node*           fCloneNode;
};


typedef PrefixedNode DependentNameNode;


class TemplateNode : public Node {
public:
        TemplateNode(Node* base)
                :
                fBase(base),
                fFirstArgument(NULL),
                fLastArgument(NULL)
        {
                fBase->SetParent(this);
        }

        void AddArgument(Node* child)
        {
                child->SetParent(this);

                if (fLastArgument != NULL) {
                        fLastArgument->SetNext(child);
                        fLastArgument = child;
                } else {
                        fFirstArgument = child;
                        fLastArgument = child;
                }
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                if (!fBase->GetName(buffer))
                        return false;

                buffer.Append("<");

                Node* child = fFirstArgument;
                while (child != NULL) {
                        if (child != fFirstArgument)
                                buffer.Append(", ");

                        if (!child->GetName(buffer))
                                return false;

                        child = child->Next();
                }

                // add a space between consecutive '>'
                if (buffer.LastChar() == '>')
                        buffer.Append(" ");

                return buffer.Append(">");
        }

        virtual Node* GetUnqualifiedNode(Node* beforeNode)
        {
                return fBase != beforeNode
                        ? fBase->GetUnqualifiedNode(beforeNode) : this;
        }

        virtual bool IsTemplatized() const
        {
                return true;
        }

        virtual Node* TemplateParameterAt(int index) const
        {
                Node* child = fFirstArgument;
                while (child != NULL) {
                        if (index == 0)
                                return child;
                        index--;
                        child = child->Next();
                }

                return NULL;
        }

        virtual bool IsNoReturnValueFunction() const
        {
                return fBase->IsNoReturnValueFunction();
        }

        virtual object_type ObjectType() const
        {
                return fBase->ObjectType();
        }

        virtual prefix_type PrefixType() const
        {
                return fBase->PrefixType();
        }

protected:
        Node*   fBase;
        Node*   fFirstArgument;
        Node*   fLastArgument;
};


class MultiSubExpressionsNode : public Node {
public:
        MultiSubExpressionsNode()
                :
                fFirstSubExpression(NULL),
                fLastSubExpression(NULL)
        {
        }

        void AddSubExpression(Node* child)
        {
                child->SetParent(this);

                if (fLastSubExpression != NULL) {
                        fLastSubExpression->SetNext(child);
                        fLastSubExpression = child;
                } else {
                        fFirstSubExpression = child;
                        fLastSubExpression = child;
                }
        }

protected:
        Node*           fFirstSubExpression;
        Node*           fLastSubExpression;
};


class CallNode : public MultiSubExpressionsNode {
public:
        CallNode()
        {
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                // TODO: Use the real syntax!
                buffer.Append("call(");

                Node* child = fFirstSubExpression;
                while (child != NULL) {
                        if (child != fFirstSubExpression)
                                buffer.Append(", ");

                        if (!child->GetName(buffer))
                                return false;

                        child = child->Next();
                }

                buffer.Append(")");

                return true;
        }
};


class OperatorExpressionNode : public MultiSubExpressionsNode {
public:
        OperatorExpressionNode(const operator_info* info)
                :
                fInfo(info)
        {
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                bool isIdentifier = isalpha(fInfo->name[0]) || fInfo->name[0] == '_';

                if (fInfo->argument_count == 1 || isIdentifier
                        || fInfo->argument_count > 3
                        || (fInfo->argument_count == 3 && strcmp(fInfo->name, "?") != 0)) {
                        // prefix operator
                        buffer.Append(fInfo->name);

                        if (isIdentifier)
                                buffer.Append("(");

                        Node* child = fFirstSubExpression;
                        while (child != NULL) {
                                if (child != fFirstSubExpression)
                                        buffer.Append(", ");

                                if (!child->GetName(buffer))
                                        return false;

                                child = child->Next();
                        }

                        if (isIdentifier)
                                buffer.Append(")");

                        return true;
                }

                Node* arg1 = fFirstSubExpression;
                Node* arg2 = arg1->Next();

                buffer.Append("(");

                if (fInfo->argument_count == 2) {
                        // binary infix operator
                        if (!arg1->GetName(buffer))
                                return false;

                        buffer.Append(" ");
                        buffer.Append(fInfo->name);
                        buffer.Append(" ");

                        if (!arg2->GetName(buffer))
                                return false;

                        return buffer.Append(")");
                }

                Node* arg3 = arg2->Next();

                if (fInfo->argument_count == 2) {
                        // trinary operator "... ? ... : ..."
                        if (!arg1->GetName(buffer))
                                return false;

                        buffer.Append(" ? ");

                        if (!arg2->GetName(buffer))
                                return false;

                        buffer.Append(" : ");

                        if (!arg3->GetName(buffer))
                                return false;

                        return buffer.Append(")");
                }

                return false;
        }

private:
        const operator_info*    fInfo;
};


class ConversionExpressionNode : public MultiSubExpressionsNode {
public:
        ConversionExpressionNode(Node* type)
                :
                fType(type)
        {
                fType->SetParent(this);
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                buffer.Append("(");

                if (!fType->GetName(buffer))
                        return false;

                buffer.Append(")(");

                Node* child = fFirstSubExpression;
                while (child != NULL) {
                        if (child != fFirstSubExpression)
                                buffer.Append(", ");

                        if (!child->GetName(buffer))
                                return false;

                        child = child->Next();
                }

                return buffer.Append(")");
        }

private:
        Node*   fType;
};


class PointerToMemberNode : public DecoratingNode {
public:
        PointerToMemberNode(Node* classType, Node* memberType)
                :
                DecoratingNode(memberType),
                fClassType(classType)
        {
                fClassType->SetParent(this);
        }

        virtual bool AddDecoration(NameBuffer& buffer,
                const Node* stopDecorator) const
        {
                if (this == stopDecorator)
                        return true;

                if (!fChildNode->AddDecoration(buffer, stopDecorator))
                        return false;

                // In most cases we need a space before the name. In some it is
                // superfluous, though.
                if (!buffer.IsEmpty() && buffer.LastChar() != '(')
                        buffer.Append(" ");

                if (!fClassType->GetName(buffer))
                        return false;

                return buffer.Append("::*");
        }

        virtual object_type ObjectType() const
        {
                return OBJECT_TYPE_DATA;
        }

        virtual TypeInfo Type() const
        {
                // TODO: Method pointers aren't ordinary pointers. Though we might not
                // be able to determine the difference.
                return TypeInfo(TYPE_POINTER);
        }


private:
        Node*   fClassType;
};


class FunctionNode : public ObjectNode {
public:
        FunctionNode(Node* nameNode, bool hasReturnType, bool isExternC)
                :
                ObjectNode(nameNode),
                fFirstTypeNode(NULL),
                fLastTypeNode(NULL),
                fHasReturnType(hasReturnType),
                fIsExternC(isExternC)
        {
        }

        void AddType(Node* child)
        {
                child->SetParent(this);

                if (fLastTypeNode != NULL) {
                        fLastTypeNode->SetNext(child);
                        fLastTypeNode = child;
                } else {
                        fFirstTypeNode = child;
                        fLastTypeNode = child;
                }
        }

        virtual bool GetName(NameBuffer& buffer) const
        {
                NameDecorationInfo decorationInfo(NULL);
                return GetDecoratedName(buffer, decorationInfo);
        }

        virtual bool GetDecoratedName(NameBuffer& buffer,
                NameDecorationInfo& decorationInfo) const
        {
                // write 'extern "C"'
//              if (fIsExternC)
//                      buffer.Append("extern \"C\"");

                // write the return type
                Node* child = fFirstTypeNode;
                if (_HasReturnType() && child != NULL) {
                        if (!child->GetName(buffer))
                                return false;
                        child = child->Next();

                        buffer.Append(" ", 1);
                }

                // write the function name
                if (fName == NULL)
                        buffer.Append("(", 1);

                CVQualifierInfo info;
                if (fName != NULL) {
                        // skip CV qualifiers on our name -- we'll add them later
                        fName->GetCVQualifierInfo(info);
                        if (info.firstNonCVQualifier != NULL
                                && !info.firstNonCVQualifier->GetName(buffer)) {
                                return false;
                        }
                }

                // add non-CV qualifier decorations
                if (decorationInfo.firstDecorator != NULL) {
                        if (!decorationInfo.firstDecorator->AddDecoration(buffer,
                                decorationInfo.closestCVDecoratorList)) {
                                return false;
                        }
                }

                if (fName == NULL)
                        buffer.Append(")", 1);

                // add the parameter types
                buffer.Append("(");

                // don't add a single "void" parameter
                if (child != NULL && child->Next() == NULL
                        && child->IsTypeName("void", 4)) {
                        child = NULL;
                }

                Node* firstParam = child;
                while (child != NULL) {
                        if (child != firstParam)
                                buffer.Append(", ");

                        if (!child->GetName(buffer))
                                return false;

                        child = child->Next();
                }

                buffer.Append(")");

                // add CV qualifiers on our name
                if (info.firstCVQualifier != NULL) {
                        if (!info.firstCVQualifier->AddDecoration(buffer,
                                        info.firstNonCVQualifier)) {
                                return false;
                        }
                }

                // add CV qualifiers on us
                if (decorationInfo.closestCVDecoratorList != NULL)
                        decorationInfo.closestCVDecoratorList->AddDecoration(buffer, NULL);

                return true;
        }

        virtual object_type ObjectType() const
        {
                // no name, no fun
                if (fName == NULL)
                        return OBJECT_TYPE_FUNCTION;

                // check our name's prefix
                switch (fName->PrefixType()) {
                        case PREFIX_NONE:
                        case PREFIX_NAMESPACE:
                                return OBJECT_TYPE_FUNCTION;
                        case PREFIX_CLASS:
                        case PREFIX_UNKNOWN:
                                break;
                }

                // Our name has a prefix, but we don't know, whether it is a class or
                // namespace. Let's ask our name what it thinks it is.
                object_type type = fName->ObjectType();
                switch (type) {
                        case OBJECT_TYPE_FUNCTION:
                        case OBJECT_TYPE_METHOD_CLASS:
                        case OBJECT_TYPE_METHOD_OBJECT:
                        case OBJECT_TYPE_METHOD_UNKNOWN:
                                // That's as good as it gets.
                                return type;
                        case OBJECT_TYPE_UNKNOWN:
                        case OBJECT_TYPE_DATA:
                        default:
                                // Obviously our name doesn't have a clue.
                                return OBJECT_TYPE_METHOD_UNKNOWN;
                }
        }

        virtual Node* ParameterAt(uint32 index) const
        {
                // skip return type
                Node* child = fFirstTypeNode;
                if (_HasReturnType() && child != NULL)
                        child = child->Next();

                // ignore a single "void" parameter
                if (child != NULL && child->Next() == NULL
                        && child->IsTypeName("void", 4)) {
                        return NULL;
                }

                // get the type at the index
                while (child != NULL && index > 0) {
                        child = child->Next();
                        index--;
                }

                return child;
        }

private:
        bool _HasReturnType() const
        {
                return fHasReturnType
                        || fName == NULL
                        || (fName->IsTemplatized() && !fName->IsNoReturnValueFunction());
        }

private:
        Node*           fFirstTypeNode;
        Node*           fLastTypeNode;
        bool            fHasReturnType;
        bool            fIsExternC;
};


// #pragma mark - Demangler


class Demangler {
public:
                                                                Demangler();

                        int                                     Demangle(const char* mangledName, char* buffer,
                                                                        size_t size,
                                                                        DemanglingInfo& demanglingInfo);
                        int                                     GetParameterInfo(const char* mangledName,
                                                                        uint32 index, char* buffer, size_t size,
                                                                        ParameterInfo& info);

        // actually private, but public to make gcc 2 happy
        inline  bool                            _SetError(int error);
        inline  void                            _AddAllocatedNode(Node* node);

private:
        template<typename NodeType> struct NodeCreator;

        inline  bool                            _SkipExpected(char c);
        inline  bool                            _SkipExpected(const char* string);

                        void                            _Init();
                        void                            _Cleanup();

                        int                                     _Demangle(const char* mangledName, char* buffer,
                                                                        size_t size,
                                                                        DemanglingInfo& demanglingInfo);
                        int                                     _GetParameterInfo(const char* mangledName,
                                                                        uint32 index, char* buffer, size_t size,
                                                                        ParameterInfo& info);

                        int                                     _Parse(const char* mangledName,
                                                                        const char*& versionSuffix,
                                                                        ObjectNode*& _node);

                        bool                            _ParseClone(ObjectNode*& _node);
                        bool                            _ParseEncoding(ObjectNode*& _node);
                        bool                            _ParseSpecialName(Node*& _node);
                        bool                            _ParseCallOffset(bool& nonVirtual,
                                                                        number_type& offset1, number_type& offset2);
                        bool                            _ParseName(Node*& _node);
                        bool                            _ParseNestedName(Node*& _node);
                        bool                            _ParseNestedNameInternal(Node*& _node);
                        bool                            _ParseLocalName(Node*& _node);
                        bool                            _ParseUnqualifiedName(Node*& _node);
                        bool                            _ParseSourceName(Node*& _node);
                        bool                            _ParseOperatorName(Node*& _node);
                        bool                            _ParseType(Node*& _node);
                        bool                            _ParseTypeInternal(Node*& _node);
                        void                            _ParseCVQualifiers(int& qualifiers);
                        bool                            _ParseTypeWithModifier(type_modifier modifier,
                                                                        int toSkip, Node*& _node);
                        bool                            _TryParseBuiltinType(Node*& _node);
                        bool                            _ParseFunctionType(FunctionNode*& _node);;
                        bool                            _ParseArrayType(Node*& _node);
                        bool                            _ParsePointerToMemberType(Node*& _node);
                        bool                            _ParseTemplateParam(Node*& _node);
                        bool                            _ParseSubstitution(Node*& _node);
                        bool                            _ParseSubstitutionInternal(Node*& _node);
                        bool                            _ParseBareFunctionType(FunctionNode* node);
                        bool                            _ParseTemplateArgs(Node* node, Node*& _node);
                        bool                            _ParseTemplateArg(Node*& _node);
                        bool                            _ParseExpression(Node*& _node);
                        bool                            _ParseExpressionPrimary(Node*& _node);
                        bool                            _ParseNumber(number_type& number);

                        bool                            _CreateNodeAndSkip(const char* name,
                                                                        size_t length, int toSkip, Node*& _node);
                        bool                            _CreateNodeAndSkip(const char* name, int toSkip,
                                                                        Node*& _node);
                        bool                            _CreateTypeNodeAndSkip(type_type type,
                                                                        int toSkip, Node*& _node);
                        bool                            _CreateTypeNodeAndSkip(const char* name,
                                                                        const char* prefix,
                                                                        const char* templateArgs, int toSkip,
                                                                        Node*& _node);

                        void                            _RegisterReferenceableNode(Node* node);
                        bool                            _CreateSubstitutionNode(int index,
                                                                        Node*& _node);

private:
                        Input                           fInput;
                        int                                     fError;
                        Node*                           fAllocatedNodes;
                        Node*                           fFirstReferenceableNode;
                        Node*                           fLastReferenceableNode;
                        Node*                           fTemplatizedNode;
};


template<typename NodeType>
struct Demangler::NodeCreator {
        NodeCreator(Demangler* demangler)
                :
                fDemangler(demangler)
        {
        }

        template<typename ReturnType>
        inline bool operator()(ReturnType*& _node) const
        {
                _node = NEW(NodeType);
                if (_node == NULL)
                        return fDemangler->_SetError(ERROR_NO_MEMORY);

                fDemangler->_AddAllocatedNode(_node);
                return true;
        }

        template<typename ParameterType1, typename ReturnType>
        inline bool operator()(ParameterType1 arg1, ReturnType*& _node) const
        {
                _node = NEW(NodeType(arg1));
                if (_node == NULL)
                        return fDemangler->_SetError(ERROR_NO_MEMORY);

                fDemangler->_AddAllocatedNode(_node);
                return true;
        }

        template<typename ParameterType1, typename ParameterType2,
                typename ReturnType>
        inline bool operator()(ParameterType1 arg1, ParameterType2 arg2,
                ReturnType*& _node) const
        {
                _node = NEW(NodeType(arg1, arg2));
                if (_node == NULL)
                        return fDemangler->_SetError(ERROR_NO_MEMORY);

                fDemangler->_AddAllocatedNode(_node);
                return true;
        }

        template<typename ParameterType1, typename ParameterType2,
                typename ParameterType3, typename ReturnType>
        inline bool operator()(ParameterType1 arg1, ParameterType2 arg2,
                ParameterType3 arg3, ReturnType*& _node) const
        {
                _node = NEW(NodeType(arg1, arg2, arg3));
                if (_node == NULL)
                        return fDemangler->_SetError(ERROR_NO_MEMORY);

                fDemangler->_AddAllocatedNode(_node);
                return true;
        }

private:
                Demangler*      fDemangler;
};


inline bool
Demangler::_SetError(int error)
{
        if (fError == ERROR_OK) {
                fError = error;
#ifdef TRACE_GCC3_DEMANGLER
                DebugScope::Print("_SetError(): %d, remaining input: \"%s\"\n",
                        error, fInput.String());
#endif
        }
        return false;
}


inline void
Demangler::_AddAllocatedNode(Node* node)
{
        node->SetNextAllocated(fAllocatedNodes);
        fAllocatedNodes = node;
}


inline bool
Demangler::_SkipExpected(char c)
{
        return fInput.SkipPrefix(c) || _SetError(ERROR_INVALID);
}


inline bool
Demangler::_SkipExpected(const char* string)
{
        return fInput.SkipPrefix(string) || _SetError(ERROR_INVALID);
}


Demangler::Demangler()
        :
        fInput(),
        fAllocatedNodes(NULL)
{
}


int
Demangler::Demangle(const char* mangledName, char* buffer, size_t size,
        DemanglingInfo& demanglingInfo)
{
        DEBUG_SCOPE("Demangle");

        _Init();

        int result = _Demangle(mangledName, buffer, size, demanglingInfo);

        _Cleanup();

        return result;
}


int
Demangler::GetParameterInfo(const char* mangledName, uint32 index, char* buffer,
        size_t size, ParameterInfo& info)
{
        DEBUG_SCOPE("GetParameterInfo");

        _Init();

        int result = _GetParameterInfo(mangledName, index, buffer, size, info);

        _Cleanup();

        return result;
}


void
Demangler::_Init()
{
        fError = ERROR_OK;

        fFirstReferenceableNode = NULL;
        fLastReferenceableNode = NULL;
        fAllocatedNodes = NULL;
        fTemplatizedNode = NULL;
}


void
Demangler::_Cleanup()
{
        while (fAllocatedNodes != NULL) {
                Node* node = fAllocatedNodes;
                fAllocatedNodes = node->NextAllocated();
                DELETE(node);
        }
}


int
Demangler::_Demangle(const char* mangledName, char* buffer, size_t size,
        DemanglingInfo& demanglingInfo)
{
        // parse the name
        const char* versionSuffix;
        ObjectNode* node;
        int error = _Parse(mangledName, versionSuffix, node);
        if (error != ERROR_OK)
                return error;

        NameBuffer nameBuffer(buffer, size);
        bool success = node->GetObjectName(nameBuffer, demanglingInfo);

        // If versioned, append the unmodified version string
        if (success && versionSuffix != NULL)
                nameBuffer.Append(versionSuffix);

        if (nameBuffer.HadOverflow())
                return ERROR_BUFFER_TOO_SMALL;

        if (!success)
                return ERROR_INTERNAL;

        demanglingInfo.objectType = node->ObjectType();

        nameBuffer.Terminate();
        return ERROR_OK;
}


int
Demangler::_GetParameterInfo(const char* mangledName, uint32 index,
        char* buffer, size_t size, ParameterInfo& info)
{
        // parse the name
        const char* versionSuffix;
        ObjectNode* node;
        int error = _Parse(mangledName, versionSuffix, node);
        if (error != ERROR_OK)
                return error;

        // get the parameter node
        Node* parameter = node->ParameterAt(index);
        if (parameter == NULL)
                return ERROR_INVALID_PARAMETER_INDEX;

        // get the parameter name
        NameBuffer nameBuffer(buffer, size);
        bool success = parameter->GetName(nameBuffer);

        if (nameBuffer.HadOverflow())
                return ERROR_BUFFER_TOO_SMALL;

        if (!success)
                return ERROR_INTERNAL;

        nameBuffer.Terminate();

        // get the type
        info.type = parameter->Type();

        return ERROR_OK;
}


int
Demangler::_Parse(const char* mangledName, const char*& versionSuffix,
        ObjectNode*& _node)
{
        // To support versioned symbols, we ignore the version suffix when
        // demangling.
        versionSuffix = strchr(mangledName, '@');
        fInput.SetTo(mangledName,
                versionSuffix != NULL
                        ? versionSuffix - mangledName : strlen(mangledName));

        // <mangled-name> ::= _Z <encoding> [<clone-suffix>]*

        if (!fInput.SkipPrefix("_Z"))
                return ERROR_NOT_MANGLED;

        if (!_ParseEncoding(_node) || !_ParseClone(_node))
                return fError;

        if (fInput.CharsRemaining() != 0) {
                // bogus at end of input
                return ERROR_INVALID;
        }

        return ERROR_OK;
}


bool
Demangler::_ParseClone(ObjectNode*& _node)
{
        DEBUG_SCOPE("_ParseClone");

        while (fInput.HasPrefix('.')) {
                int count = fInput.CharsRemaining();
                int i = 1;
                while (true) {
                        for (; i < count && fInput[i] != '.'; i++)
                                ;
                        if (i + 1 >= count || fInput[i + 1] < '0' || fInput[i + 1] > '9')
                                break;
                        i++;
                }
                if (i == 1)
                        break;
                Node* clone;
                if (!_CreateNodeAndSkip(fInput.String(), i, i, clone))
                        return false;

                if (!NodeCreator<ClonedNode>(this)(clone, _node, _node))
                        return false;
        }
        return true;
}


bool
Demangler::_ParseEncoding(ObjectNode*& _node)
{
        DEBUG_SCOPE("_ParseEncoding");

        // <encoding> ::= <function name> <bare-function-type>
        //                ::= <data name>
        //                ::= <special-name>

        // NOTE: This is not in the specs: Local entities seem to be prefixed
        // by an 'L'.
        fInput.SkipPrefix('L');

        // parse <special-name>, if it is one
        Node* name;
        if (fInput.HasPrefix('T') || fInput.HasPrefix("GV")) {
                return _ParseSpecialName(name)
                        && NodeCreator<ObjectNode>(this)(name, _node);
        }

        // either <data name> or <function name>
        if (!_ParseName(name))
                return false;

        if (fInput.CharsRemaining() == 0 || fInput.HasPrefix('E')
                || fInput.HasPrefix('.')) {
                // <data name>
                return NodeCreator<ObjectNode>(this)(name, _node);
        }

        // <function name> -- parse remaining <bare-function-type>
        FunctionNode* functionNode;
        if (!NodeCreator<FunctionNode>(this)(name, false, false, functionNode))
                return false;
        _node = functionNode;

        // If our name is templatized, we push it onto the templatized node
        // stack while parsing the function parameters.
        Node* previousTemplatizedNode = fTemplatizedNode;
        if (name->IsTemplatized())
                fTemplatizedNode = name;

        if (!_ParseBareFunctionType(functionNode))
                return false;

        fTemplatizedNode = previousTemplatizedNode;

        return true;
}


bool
Demangler::_ParseSpecialName(Node*& _node)
{
        DEBUG_SCOPE("_ParseSpecialName");

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        // <special-name> ::= GV <object name>  # Guard variable for one-time
        //                                      # initialization
        //                    # No <type>
        if (!fInput.SkipPrefix('T')) {
                Node* name;
                return _SkipExpected("GV")
                        && _ParseName(name)
                        && NodeCreator<SpecialNameNode>(this)("guard variable for ",
                                name, _node);
        }

        // <special-name> ::= TV <type> # virtual table
        //                ::= TT <type> # VTT structure (construction vtable
        //                              # index)
        //                ::= TI <type> # typeinfo structure
        //                ::= TS <type> # typeinfo name (null-terminated byte
        //                              # string)
        const char* prefix = NULL;
        switch (fInput[0]) {
                case 'V':
                        prefix = "vtable for ";
                        break;
                case 'T':
                        prefix = "VTT for ";
                        break;
                case 'I':
                        prefix = "typeinfo for ";
                        break;
                case 'S':
                        prefix = "typeinfo name for ";
                        break;
        }

        if (prefix != NULL) {
                fInput.Skip(1);
                Node* type;
                return _ParseType(type)
                        && NodeCreator<SpecialNameNode>(this)(prefix, type, _node);
        }

        // <special-name> ::= Tc <call-offset> <call-offset> <base encoding>
        //                    # base is the nominal target function of thunk
        //                    # first call-offset is 'this' adjustment
        //                    # second call-offset is result adjustment
        if (fInput.SkipPrefix('c')) {
                bool nonVirtual;
                number_type offset1;
                number_type offset2;
                ObjectNode* name;
                return _ParseCallOffset(nonVirtual, offset1, offset2)
                        && _ParseCallOffset(nonVirtual, offset1, offset2)
                        && _ParseEncoding(name)
                        && NodeCreator<SpecialNameNode>(this)(
                                "covariant return thunk to ", name, _node);
        }

        // <special-name> ::= T <call-offset> <base encoding>
        //                    # base is the nominal target function of thunk
        bool nonVirtual;
        number_type offset1;
        number_type offset2;
        ObjectNode* name;
        return _ParseCallOffset(nonVirtual, offset1, offset2)
                && _ParseEncoding(name)
                && NodeCreator<SpecialNameNode>(this)(
                        nonVirtual ? "non-virtual thunk to " : "virtual thunk to ",
                        name, _node);
}


bool
Demangler::_ParseCallOffset(bool& nonVirtual, number_type& offset1,
        number_type& offset2)
{
        // <call-offset> ::= h <nv-offset> _
        //               ::= v <v-offset> _
        // <nv-offset> ::= <offset number>
        //                 # non-virtual base override
        // <v-offset>  ::= <offset number> _ <virtual offset number>
        //                 # virtual base override, with vcall offset

        // non-virtual
        if (fInput.SkipPrefix('h')) {
                nonVirtual = true;
                return _ParseNumber(offset1) && _SkipExpected('_');
        }

        // virtual
        nonVirtual = false;
        return _SkipExpected('v')
                && _ParseNumber(offset1)
                && _SkipExpected('_')
                && _ParseNumber(offset2)
                && _SkipExpected('_');
}

bool
Demangler::_ParseName(Node*& _node)
{
        DEBUG_SCOPE("_ParseName");

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        // <name> ::= <nested-name>
        //        ::= <unscoped-name>
        //        ::= <unscoped-template-name> <template-args>
        //        ::= <local-name>      # See Scope Encoding below
        //
        // <unscoped-name> ::= <unqualified-name>
        //                 ::= St <unqualified-name>   # ::std::
        //
        // <unscoped-template-name> ::= <unscoped-name>
        //                          ::= <substitution>

        switch (fInput[0]) {
                case 'N':
                        // <nested-name>
                        return _ParseNestedName(_node);
                case 'Z':
                        // <local-name>
                        return _ParseLocalName(_node);
                case 'S':
                {
                        // <substitution>
                        if (!fInput.HasPrefix("St")) {
                                if (!_ParseSubstitution(_node))
                                        return false;
                                break;
                        }

                        // std:: namespace
                        fInput.Skip(2);

                        Node* prefix;
                        if (!NodeCreator<SimpleNameNode>(this)("std", prefix))
                                return false;

                        // <unqualified-name>
                        Node* node;
                        if (!_ParseUnqualifiedName(node)
                                || !NodeCreator<PrefixedNode>(this)(prefix, node, _node)) {
                                return false;
                        }

                        break;
                }
                default:
                        // <unqualified-name>
                        if (!_ParseUnqualifiedName(_node))
                                return false;
                        break;
        }

        // We get here for the names that might be an <unscoped-template-name>.
        // Check whether <template-args> are following.
        if (!fInput.HasPrefix('I'))
                return true;

        // <unscoped-template-name> is referenceable
        _RegisterReferenceableNode(_node);

        return _ParseTemplateArgs(_node, _node);
}


bool
Demangler::_ParseNestedName(Node*& _node)
{
        DEBUG_SCOPE("_ParseNestedName");

        // <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
        //               ::= N [<CV-qualifiers>] <template-prefix>
        //                   <template-args> E
        //
        // <CV-qualifiers> ::= [r] [V] [K]      # restrict (C99), volatile, const
        //
        // <prefix> ::= <prefix> <unqualified-name>
        //          ::= <template-prefix> <template-args>
        //          ::= <template-param>
        //          ::= # empty
        //          ::= <substitution>
        //
        // <template-prefix> ::= <prefix> <template unqualified-name>
        //                   ::= <template-param>
        //                   ::= <substitution>

        if (!_SkipExpected('N'))
                return false;

        // parse CV qualifiers
        int qualifiers;
        _ParseCVQualifiers(qualifiers);

        // parse the main part
        if (!_ParseNestedNameInternal(_node))
                return false;

        // create a CV qualifiers wrapper node, if necessary
        if (qualifiers != 0) {
                return NodeCreator<CVQualifiersNode>(this)(qualifiers, _node,
                        _node);
        }

        return true;
}


bool
Demangler::_ParseNestedNameInternal(Node*& _node)
{
        DEBUG_SCOPE("_ParseNestedNameMain");

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        // the initial prefix might be a template param or a substitution
        Node* initialPrefixNode = NULL;
        Node* prefixNode = NULL;
        switch (fInput[0]) {
                case 'T':       // <template-param>
                        if (!_ParseTemplateParam(initialPrefixNode))
                                return false;

                        // a <prefix> or <template-prefix> and as such referenceable
                        _RegisterReferenceableNode(initialPrefixNode);
                        break;

                case 'S':       // <substitution>
                        if (!_ParseSubstitution(initialPrefixNode))
                                return false;
                        break;
        }

        while (true) {
                bool canTerminate = false;
                Node* node;

                if (initialPrefixNode != NULL) {
                        node = initialPrefixNode;
                        initialPrefixNode = NULL;
                } else {
                        if (!_ParseUnqualifiedName(node))
                                return false;
                        canTerminate = true;
                }

                // join prefix and the new node
                if (prefixNode != NULL) {
                        if (!NodeCreator<PrefixedNode>(this)(prefixNode, node, node))
                                return false;
                }

                // template arguments?
                if (fInput.HasPrefix('I')) {
                        // <template-prefix> is referenceable
                        _RegisterReferenceableNode(node);

                        // parse the template arguments
                        if (!_ParseTemplateArgs(node, node))
                                return false;
                        canTerminate = true;
                }

                if (fInput.CharsRemaining() == 0)
                        return _SetError(ERROR_INVALID);

                // end of nested name?
                if (fInput.SkipPrefix('E')) {
                        // If it doesn't have template args, it must end in an
                        // unqualified name.
                        if (!canTerminate)
                                return _SetError(ERROR_INVALID);

                        _node = node;
                        return true;
                }

                // The fun continues, so this is a <prefix> or <template-prefix>
                // and as such referenceable.
                prefixNode = node;
                _RegisterReferenceableNode(node);
        }
}


bool
Demangler::_ParseLocalName(Node*& _node)
{
        DEBUG_SCOPE("_ParseLocalName");

        // <local-name> := Z <function encoding> E <entity name>
        //                 [<discriminator>]
        //              := Z <function encoding> E s [<discriminator>]
        // <discriminator> := _ <non-negative number>

        // parse the function name
        ObjectNode* functionName;
        if (!_SkipExpected('Z')
                || !_ParseEncoding(functionName)
                || !_SkipExpected('E')) {
                return false;
        }

        Node* entityName;
        if (fInput.SkipPrefix('s')) {
                // string literal
                if (!NodeCreator<SimpleNameNode>(this)("string literal",
                                entityName)) {
                        return false;
                }
        } else {
                // local type or object
                if (!_ParseName(entityName))
                        return false;
        }

        // parse discriminator
        number_type discriminator = 0;
        if (fInput.SkipPrefix('_')) {
                if (!_ParseNumber(discriminator))
                        return false;
                if (discriminator < 0)
                        return _SetError(ERROR_INVALID);
                discriminator++;
        }

        return NodeCreator<PrefixedNode>(this)(functionName, entityName, _node);
}


bool
Demangler::_ParseUnqualifiedName(Node*& _node)
{
        DEBUG_SCOPE("_ParseUnqualifiedName");

        // <unqualified-name> ::= <operator-name>
        //                    ::= <ctor-dtor-name>
        //                    ::= <source-name>
        //
        // <source-name> ::= <positive length number> <identifier>
        // <number> ::= [n] <non-negative decimal integer>
        // <identifier> ::= <unqualified source code identifier>
        //
        // <ctor-dtor-name> ::= C1      # complete object constructor
        //                  ::= C2      # base object constructor
        //                  ::= C3      # complete object allocating constructor
        //                  ::= D0      # deleting destructor
        //                  ::= D1      # complete object destructor
        //                  ::= D2      # base object destructor

        // we need at least 2 chars
        if (fInput.CharsRemaining() < 2)
                return _SetError(ERROR_INVALID);

        if (isdigit(fInput[0]) || (fInput[0] == 'n' && isdigit(fInput[1]))) {
                // <source-name>
                return _ParseSourceName(_node);
        }

        if (fInput[0] == 'C') {
                // <ctor-dtor-name> -- constructors
                switch (fInput[1]) {
                        case '1':
                        case '2':
                        case '3':
                                if (!NodeCreator<XtructorNode>(this)(true, fInput[1] - '1',
                                                _node)) {
                                        return false;
                                }

                                fInput.Skip(2);
                                return true;
                        default:
                                return _SetError(ERROR_INVALID);
                }
        }

        if (fInput[0] == 'D') {
                // <ctor-dtor-name> -- destructors
                switch (fInput[1]) {
                        case '0':
                        case '1':
                        case '2':
                                if (!NodeCreator<XtructorNode>(this)(false, fInput[1] - '0',
                                                _node)) {
                                        return false;
                                }

                                fInput.Skip(2);
                                return true;
                        default:
                                return _SetError(ERROR_INVALID);
                }
        }

        // must be an <operator-name>
        return _ParseOperatorName(_node);
}


bool
Demangler::_ParseSourceName(Node*& _node)
{
        DEBUG_SCOPE("_ParseSourceName");

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        number_type number;
        if (!_ParseNumber(number))
                return false;

        if (number <= 0 || number > fInput.CharsRemaining())
                return _SetError(ERROR_INVALID);

        return _CreateNodeAndSkip(fInput.String(), number, number, _node);
}


bool
Demangler::_ParseOperatorName(Node*& _node)
{
        DEBUG_SCOPE("_ParseOperatorName");

        if (fInput.CharsRemaining() < 2)
                return _SetError(ERROR_INVALID);

        const operator_info* info = NULL;
        for (int i = 0; kOperatorInfos[i].name != NULL; i++) {
                if (fInput.SkipPrefix(kOperatorInfos[i].mangled_name)) {
                        info = &kOperatorInfos[i];
                        break;
                }
        }

        if (info != NULL)
                return NodeCreator<OperatorNode>(this)(info, _node);

        // <operator-name> ::= cv <type>        # (cast)
        if (fInput.SkipPrefix("cv")) {
                Node* typeNode;
                if (!_ParseType(typeNode))
                        return false;

                return NodeCreator<CastOperatorNode>(this)(typeNode, _node);
        }

        //  <operator-name> ::= v <digit> <source-name> # vendor extended
        //                                                operator
        if (fInput.SkipPrefix('v')) {
                if (fInput.CharsRemaining() == 0 || !isdigit(fInput[0]))
                        return _SetError(ERROR_INVALID);
                fInput.Skip(1);

                Node* name;
                return _ParseSourceName(name)
                        && NodeCreator<VendorOperatorNode>(this)(name, _node);
        }

        return _SetError(ERROR_INVALID);
}


bool
Demangler::_ParseType(Node*& _node)
{
        DEBUG_SCOPE("_ParseType");

        if (!_ParseTypeInternal(_node))
                return false;

        _RegisterReferenceableNode(_node);
        return true;
}


bool
Demangler::_ParseTypeInternal(Node*& _node)
{
        DEBUG_SCOPE("_ParseTypeInternal");

        // <type> ::= <builtin-type>
        //        ::= <function-type>
        //        ::= <class-enum-type>
        //        ::= <array-type>
        //        ::= <pointer-to-member-type>
        //        ::= <template-param>
        //        ::= <template-template-param> <template-args>
        //        ::= <substitution> # See Compression below
        //
        // <template-template-param> ::= <template-param>
        //                           ::= <substitution>
        //
        // <type> ::= <CV-qualifiers> <type>
        //        ::= P <type>  # pointer-to
        //        ::= R <type>  # reference-to
        //        ::= O <type>  # rvalue reference-to (C++0x)
        //        ::= C <type>  # complex pair (C 2000)
        //        ::= G <type>  # imaginary (C 2000)
        //        ::= U <source-name> <type>    # vendor extended type qualifier
        //
        // <CV-qualifiers> ::= [r] [V] [K]      # restrict (C99), volatile, const
        //
        // <type>  ::= Dp <type>          # pack expansion of (C++0x)
        //         ::= Dt <expression> E  # decltype of an id-expression or
        //                                # class member access (C++0x)
        //         ::= DT <expression> E  # decltype of an expression (C++0x)

        if (_TryParseBuiltinType(_node)) {
                _node->SetReferenceable(false);
                return true;
        }
        if (fError != ERROR_OK)
                return false;

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        switch (fInput[0]) {
                // function type
                case 'F':
                {
                        FunctionNode* functionNode;
                        if (!_ParseFunctionType(functionNode))
                                return false;
                        _node = functionNode;
                        return true;
                }

                // array type
                case 'A':
                        return _ParseArrayType(_node);

                // pointer to member type
                case 'M':
                        return _ParsePointerToMemberType(_node);

                // template param
                case 'T':
                        if (!_ParseTemplateParam(_node))
                                return false;
                        break;

                // CV qualifiers
                case 'r':
                case 'V':
                case 'K':
                {
                        // parse CV qualifiers
                        int qualifiers;
                        _ParseCVQualifiers(qualifiers);

                        // parse the type
                        if (!_ParseType(_node))
                                return false;

                        // create the wrapper node
                        return NodeCreator<CVQualifiersNode>(this)(qualifiers, _node,
                                _node);
                }

                // pointer, reference, etc.
                case 'P':
                        return _ParseTypeWithModifier(TYPE_QUALIFIER_POINTER, 1, _node);
                case 'R':
                        return _ParseTypeWithModifier(TYPE_QUALIFIER_REFERENCE, 1,
                                _node);
                case 'O':
                        return _ParseTypeWithModifier(
                                TYPE_QUALIFIER_RVALUE_REFERENCE, 1, _node);
                case 'C':
                        return _ParseTypeWithModifier(TYPE_QUALIFIER_COMPLEX, 1, _node);
                case 'G':
                        return _ParseTypeWithModifier(TYPE_QUALIFIER_IMAGINARY, 1,
                                _node);

                // pack and decltype
                case 'D':
#if 0
                        if (fInput.CharsRemaining() < 2)
                                return _SetError(ERROR_INVALID);

                        switch(fInput[1]) {
                                case 'p':
                                        fInput.Skip(2);
                                        return _ParseType(_node);
                                case 't':
                                case 'T':
                                {
                                        fInput.Skip(2);
                                        Node* nameNode;
                                        if (!_ParseExpression(nameNode))
                                                return false;
                                        if (!fInput.SkipPrefix('E'))
                                                return ERROR_INVALID;
                                }
                        }
#endif
                        // NOTE: Unsupported by the GNU demangler.
                        return _SetError(ERROR_UNSUPPORTED);

                // vendor extended type qualifier
                case 'U':
                        fInput.Skip(1);
                        Node* name;
                        Node* type;
                        return _ParseSourceName(name) && _ParseType(type)
                                && NodeCreator<VendorTypeModifierNode>(this)(name, type,
                                        _node);

                // substitution
                case 'S':
                        if (!fInput.HasPrefix("St")) {
                                if (!_ParseSubstitution(_node))
                                        return false;
                                break;
                        }

                        // "St" -- the "std" namespace. The grammar is ambiguous here,
                        // since we could parse that as <substitution> or as
                        // <class-enum-type>. We assume the latter and fall through.

                default:
                {
                        // <class-enum-type> ::= <name>
                        Node* nameNode;
                        return _ParseName(nameNode)
                                && NodeCreator<NamedTypeNode>(this)(nameNode, _node);
                }
        }

        // We get here for the types that might be a <template-template-param>.
        // Check whether <template-args> are following.
        if (!fInput.HasPrefix('I'))
                return true;

        // <template-template-param> is referenceable
        _RegisterReferenceableNode(_node);

        return _ParseTemplateArgs(_node, _node);
}


void
Demangler::_ParseCVQualifiers(int& qualifiers)
{
        qualifiers = 0;

        if (fInput.SkipPrefix('r'))
                qualifiers |= CV_QUALIFIER_RESTRICT;
        if (fInput.SkipPrefix('V'))
                qualifiers |= CV_QUALIFIER_VOLATILE;
        if (fInput.SkipPrefix('K'))
                qualifiers |= CV_QUALIFIER_CONST;
}


bool
Demangler::_ParseTypeWithModifier(type_modifier modifier, int toSkip,
        Node*& _node)
{
        if (toSkip > 0)
                fInput.Skip(toSkip);

        Node* node;
        if (!_ParseType(node))
                return false;

        return NodeCreator<TypeModifierNode>(this)(modifier, node, _node);
}


bool
Demangler::_TryParseBuiltinType(Node*& _node)
{
        DEBUG_SCOPE("_TryParseBuiltinType");

        // <builtin-type> ::= v # void
        //                ::= w # wchar_t
        //                ::= b # bool
        //                ::= c # char
        //                ::= a # signed char
        //                ::= h # unsigned char
        //                ::= s # short
        //                ::= t # unsigned short
        //                ::= i # int
        //                ::= j # unsigned int
        //                ::= l # long
        //                ::= m # unsigned long
        //                ::= x # long long, __int64
        //                ::= y # unsigned long long, __int64
        //                ::= n # __int128
        //                ::= o # unsigned __int128
        //                ::= f # float
        //                ::= d # double
        //                ::= e # long double, __float80
        //                ::= g # __float128
        //                ::= z # ellipsis
        //                ::= Dd # IEEE 754r decimal floating point (64 bits)
        //                ::= De # IEEE 754r decimal floating point (128 bits)
        //                ::= Df # IEEE 754r decimal floating point (32 bits)
        //                ::= Dh # IEEE 754r half-precision floating point
        //                       # (16 bits)
        //                ::= Di # char32_t
        //                ::= Ds # char16_t
        //                ::= u <source-name>   # vendor extended type

        if (fInput.CharsRemaining() == 0)
                return false;

        switch (fInput[0]) {
                case 'v':
                        return _CreateTypeNodeAndSkip(TYPE_VOID, 1, _node);
                case 'w':
                        return _CreateTypeNodeAndSkip(TYPE_WCHAR_T, 1, _node);
                case 'b':
                        return _CreateTypeNodeAndSkip(TYPE_BOOL, 1, _node);
                case 'c':
                        return _CreateTypeNodeAndSkip(TYPE_CHAR, 1, _node);
                case 'a':
                        return _CreateTypeNodeAndSkip(TYPE_SIGNED_CHAR, 1, _node);
                case 'h':
                        return _CreateTypeNodeAndSkip(TYPE_UNSIGNED_CHAR, 1, _node);
                case 's':
                        return _CreateTypeNodeAndSkip(TYPE_SHORT, 1, _node);
                case 't':
                        return _CreateTypeNodeAndSkip(TYPE_UNSIGNED_SHORT, 1,
                                _node);
                case 'i':
                        return _CreateTypeNodeAndSkip(TYPE_INT, 1, _node);
                case 'j':
                        return _CreateTypeNodeAndSkip(TYPE_UNSIGNED_INT, 1, _node);
                case 'l':
                        return _CreateTypeNodeAndSkip(TYPE_LONG, 1, _node);
                case 'm':
                        return _CreateTypeNodeAndSkip(TYPE_UNSIGNED_LONG, 1, _node);
                case 'x':
                        return _CreateTypeNodeAndSkip(TYPE_LONG_LONG, 1, _node);
                case 'y':
                        return _CreateTypeNodeAndSkip(TYPE_UNSIGNED_LONG_LONG, 1, _node);
                case 'n':
                        return _CreateTypeNodeAndSkip(TYPE_INT128, 1, _node);
                case 'o':
                        return _CreateTypeNodeAndSkip(TYPE_UNSIGNED_INT128, 1, _node);
                case 'f':
                        return _CreateTypeNodeAndSkip(TYPE_FLOAT, 1, _node);
                case 'd':
                        return _CreateTypeNodeAndSkip(TYPE_DOUBLE, 1, _node);
                case 'e':
                        return _CreateTypeNodeAndSkip(TYPE_LONG_DOUBLE, 1, _node);
                case 'g':
                        return _CreateTypeNodeAndSkip(TYPE_FLOAT128, 1, _node);
                case 'z':
                        return _CreateTypeNodeAndSkip(TYPE_ELLIPSIS, 1, _node);

                case 'D':
                        if (fInput.CharsRemaining() < 2)
                                return false;

                        // TODO: Official names for the __dfloat*!
                        switch (fInput[1]) {
                                case 'd':
                                        return _CreateTypeNodeAndSkip(TYPE_DFLOAT64, 2, _node);
                                case 'e':
                                        return _CreateTypeNodeAndSkip(TYPE_DFLOAT128, 2, _node);
                                case 'f':
                                        return _CreateTypeNodeAndSkip(TYPE_DFLOAT32, 2, _node);
                                case 'h':
                                        return _CreateTypeNodeAndSkip(TYPE_DFLOAT16, 2, _node);
                                case 'i':
                                        return _CreateTypeNodeAndSkip(TYPE_CHAR16_T, 2, _node);
                                case 's':
                                        return _CreateTypeNodeAndSkip(TYPE_CHAR32_T, 2, _node);
                                default:
                                        return false;
                        }

                case 'u':
                {
                        fInput.Skip(1);
                        Node* nameNode;
                        return _ParseSourceName(nameNode)
                                && NodeCreator<NamedTypeNode>(this)(nameNode, _node);
                }

                default:
                        return false;
        }
}


bool
Demangler::_ParseFunctionType(FunctionNode*& _node)
{
        DEBUG_SCOPE("_ParseFunctionType");

        // <function-type> ::= F [Y] <bare-function-type> E

        if (!_SkipExpected('F'))
                return false;

        // is 'extern "C"'?
        bool isExternC = fInput.SkipPrefix('Y');

        // create function and parse function type
        if (!NodeCreator<FunctionNode>(this)((Node*)NULL, true, isExternC,
                        _node)
                || !_ParseBareFunctionType(_node)) {
                return false;
        }

        // skip terminating 'E'
        return _SkipExpected('E');
}


bool
Demangler::_ParseArrayType(Node*& _node)
{
        DEBUG_SCOPE("_ParseArrayType");

        // <array-type> ::= A <positive dimension number> _ <element type>
        //              ::= A [<dimension expression>] _ <element type>

        if (fInput.CharsRemaining() < 2 || !fInput.SkipPrefix('A'))
                return _SetError(ERROR_INVALID);

        number_type dimensionNumber;
        Node* dimensionExpression = NULL;

        // If it looks like a number, it must be the first production, otherwise
        // the second one.
        if (isdigit(fInput[0])
                || (fInput[0] == 'n' && fInput.CharsRemaining() >= 2
                        && isdigit(fInput[1]))) {
                if (!_ParseNumber(dimensionNumber))
                        return false;
        } else {
                if (!_ParseExpression(dimensionExpression))
                        return false;
        }

        // parse the type
        Node* type;
        if (!_SkipExpected('_') || !_ParseType(type))
                return false;

        // create the array node
        return dimensionExpression != NULL
                ? NodeCreator<ArrayNode>(this)(type, dimensionExpression, _node)
                : NodeCreator<ArrayNode>(this)(type, dimensionNumber, _node);
}


bool
Demangler::_ParsePointerToMemberType(Node*& _node)
{
        DEBUG_SCOPE("_ParsePointerToMemberType");

        // <pointer-to-member-type> ::= M <class type> <member type>
        Node* classType;
        Node* memberType;
        return _SkipExpected('M')
                && _ParseType(classType)
                && _ParseType(memberType)
                && NodeCreator<PointerToMemberNode>(this)(classType, memberType,
                        _node);
}


bool
Demangler::_ParseTemplateParam(Node*& _node)
{
        DEBUG_SCOPE("_ParseTemplateParam");

        // <template-param> ::= T_      # first template parameter
        //                  ::= T <parameter-2 non-negative number> _

        if (!_SkipExpected('T'))
                return false;
        if (fTemplatizedNode == NULL)
                return _SetError(ERROR_INVALID);

        // get the index;
        number_type index = 0;
        if (!fInput.HasPrefix('_')) {
                if (!_ParseNumber(index))
                        return false;

                if (index < 0)
                        return _SetError(ERROR_INVALID);
                index++;
        }

        if (!_SkipExpected('_'))
                return false;

        // get the parameter
        Node* parameter = fTemplatizedNode->TemplateParameterAt(index);
        if (parameter == NULL)
                return _SetError(ERROR_INVALID);

        // create a substitution node
        return NodeCreator<SubstitutionNode>(this)(parameter, _node);
}


bool
Demangler::_ParseSubstitution(Node*& _node)
{
        DEBUG_SCOPE("_ParseSubstitution");

        if (!_ParseSubstitutionInternal(_node))
                return false;

        // substitutions are never referenceable
        _node->SetReferenceable(false);

        return true;
}


bool
Demangler::_ParseSubstitutionInternal(Node*& _node)
{
        DEBUG_SCOPE("_ParseSubstitutionInternal");

        // <substitution> ::= S <seq-id> _
        //                ::= S_
        //
        // <substitution> ::= St # ::std::
        // <substitution> ::= Sa # ::std::allocator
        // <substitution> ::= Sb # ::std::basic_string
        // <substitution> ::= Ss # ::std::basic_string < char,
        //                         ::std::char_traits<char>,
        //                         ::std::allocator<char> >
        // <substitution> ::= Si # ::std::basic_istream<char,
        //                             std::char_traits<char> >
        // <substitution> ::= So # ::std::basic_ostream<char,
        //                             std::char_traits<char> >
        // <substitution> ::= Sd # ::std::basic_iostream<char,
        //                             std::char_traits<char> >

        if (fInput.CharsRemaining() < 2 || !fInput.SkipPrefix('S'))
                return _SetError(ERROR_INVALID);

        switch (fInput[0]) {
                case 't':
                        return _CreateNodeAndSkip("std", 1, _node);
                case 'a':
                        return _CreateTypeNodeAndSkip("allocator", "std", NULL, 1,
                                _node);
                case 'b':
                        return _CreateTypeNodeAndSkip("basic_string", "std", NULL, 1,
                                _node);
                case 's':
                        return _CreateTypeNodeAndSkip("basic_string", "std",
                                "char, std::char_traits<char>, std::allocator<char>", 1,
                                _node);
                case 'i':
                        return _CreateTypeNodeAndSkip("basic_istream", "std",
                                "char, std::char_traits<char>", 1, _node);
                case 'o':
                        return _CreateTypeNodeAndSkip("basic_ostream", "std",
                                "char, std::char_traits<char>", 1, _node);
                case 'd':
                        return _CreateTypeNodeAndSkip("basic_iostream", "std",
                                "char, std::char_traits<char>", 1, _node);
                case '_':
                        fInput.Skip(1);
                        return _CreateSubstitutionNode(0, _node);
        }

        // parse <seq-id>
        int seqID = 0;
        int count = fInput.CharsRemaining();
        int i = 0;
        for (; i < count && fInput[i] != '_'; i++) {
                char c = fInput[i];
                if (isdigit(c))
                        seqID = seqID * 36 + (c - '0');
                else if (c >= 'A' && c <= 'Z')
                        seqID = seqID * 36 + 10 + (c - 'A');
                else
                        return _SetError(ERROR_INVALID);
        }

        if (i == count)
                return _SetError(ERROR_INVALID);

        // skip digits and '_'
        fInput.Skip(i + 1);

        return _CreateSubstitutionNode(seqID + 1, _node);
}


bool
Demangler::_ParseBareFunctionType(FunctionNode* node)
{
        DEBUG_SCOPE("_ParseBareFunctionType");

        // <bare-function-type> ::= <signature type>+
        //     # types are possible return type, then parameter types

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        do {
                Node* typeNode;
                if (!_ParseType(typeNode))
                        return false;

                node->AddType(typeNode);
        } while (fInput.CharsRemaining() > 0 && fInput[0] != 'E'
                && fInput[0] != '.');
                // 'E' und '.' delimit <function-type>

        return true;
}


bool
Demangler::_ParseTemplateArgs(Node* node, Node*& _node)
{
        DEBUG_SCOPE("_ParseTemplateArgs");

        // <template-args> ::= I <template-arg>+ E

        if (!_SkipExpected('I'))
                return false;

        // we need at least one <template-arg>
        if (fInput.CharsRemaining() == 0 || fInput[0] == 'E')
                return _SetError(ERROR_INVALID);

        // create the node
        TemplateNode* templateNode;
        if (!NodeCreator<TemplateNode>(this)(node, templateNode))
                return false;
        _node = templateNode;

        // parse the args
        while (fInput.CharsRemaining() > 0 && fInput[0] != 'E') {
                Node* arg;
                if (!_ParseTemplateArg(arg))
                        return false;
                templateNode->AddArgument(arg);
        }

        // skip the trailing 'E'
        return _SkipExpected('E');
}


bool
Demangler::_ParseTemplateArg(Node*& _node)
{
        DEBUG_SCOPE("_ParseTemplateArg");

        // <template-arg> ::= <type>                       # type or template
        //                ::= X <expression> E     # expression
        //                ::= <expr-primary>       # simple expressions
        //                ::= I <template-arg>* E  # argument pack
        //                ::= sp <expression>      # pack expansion of (C++0x)

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        switch (fInput[0]) {
                case 'X':       // X <expression> E
                        fInput.Skip(1);
                        return _ParseExpression(_node) && _SkipExpected('E');

                case 'L':       // <expr-primary>
                        return _ParseExpressionPrimary(_node);

                case 'I':       // I <template-arg>* E
                {
#if 0
                        fInput.Skip(1);

                        while (fInput.CharsRemaining() > 0 && fInput[0] != 'E') {
                                Node* arg;
                                if (!_ParseTemplateArg(arg))
                                        return false;
                        }

                        if (!fInput.SkipPrefix('E'))
                                return _SetError(ERROR_INVALID);
                        return true;
#endif
                        // NOTE: Unsupported by the GNU demangler.
                        return _SetError(ERROR_UNSUPPORTED);
                }

                case 's':
                        if (fInput.SkipPrefix("sp")) {
                                // sp <expression>
#if 0
                                return _ParseExpression(_node);
#endif
                                // NOTE: Unsupported by the GNU demangler.
                                return _SetError(ERROR_UNSUPPORTED);
                        }

                        // fall through...

                default:        // <type>
                        return _ParseType(_node);
        }
}


bool
Demangler::_ParseExpression(Node*& _node)
{
        DEBUG_SCOPE("_ParseExpression");

        // <expression> ::= <unary operator-name> <expression>
        //              ::= <binary operator-name> <expression> <expression>
        //              ::= <trinary operator-name> <expression> <expression>
        //                  <expression>
        //              ::= cl <expression>* E          # call
        //              ::= cv <type> expression        # conversion with one
        //                                                argument
        //              ::= cv <type> _ <expression>* E # conversion with a
        //                                                different number of
        //                                                arguments
        //              ::= st <type>                       # sizeof (a type)
        //              ::= at <type>                   # alignof (a type)
        //              ::= <template-param>
        //              ::= <function-param>
        //              ::= sr <type> <unqualified-name>
        //                    # dependent name
        //              ::= sr <type> <unqualified-name> <template-args>
        //                    # dependent template-id
        //              ::= sZ <template-param>
        //                    # size of a parameter pack
        //              ::= <expr-primary>
        //
        // <expr-primary> ::= L <type> <value number> E  # integer literal
        //                ::= L <type <value float> E    # floating literal
        //                ::= L <mangled-name> E         # external name

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        switch (fInput[0]) {
                case 'L':
                        return _ParseExpressionPrimary(_node);
                case 'T':
                        return _ParseTemplateParam(_node);
                // NOTE: <function-param> is not defined in the specs!
        }

        // must be an operator
        if (fInput.CharsRemaining() < 2)
                return _SetError(ERROR_INVALID);

        // some operators need special handling

        if (fInput.SkipPrefix("cl")) {
                // cl <expression>* E          # call
                CallNode* callNode;
                if (!NodeCreator<CallNode>(this)(callNode))
                        return false;

                while (fInput.CharsRemaining() > 0 && fInput[0] != 'E') {
                        Node* subExpression;
                        if (!_ParseExpression(subExpression))
                                return false;
                        callNode->AddSubExpression(subExpression);
                }

                _node = callNode;
                return _SkipExpected('E');
        }

        if (fInput.SkipPrefix("cv")) {
                // cv <type> expression        # conversion with one argument
                // cv <type> _ <expression>* E # conversion with a different number
                //                               of arguments

                // parse the type
                Node* type;
                if (!_ParseType(type))
                        return false;

                // create a conversion expression node
                ConversionExpressionNode* expression;
                if (!NodeCreator<ConversionExpressionNode>(this)(type, expression))
                        return false;
                _node = expression;

                if (fInput.SkipPrefix('_')) {
                        // multi argument conversion
                        while (fInput.CharsRemaining() > 0 && fInput[0] != 'E') {
                                Node* subExpression;
                                if (!_ParseExpression(subExpression))
                                        return false;
                                expression->AddSubExpression(subExpression);
                        }

                        return _SkipExpected('E');
                }

                // single argument conversion
                Node* subExpression;
                if (!_ParseExpression(subExpression))
                        return false;
                expression->AddSubExpression(subExpression);

                return true;
        }

        if (fInput.SkipPrefix("sr")) {
                // sr <type> <unqualified-name>
                // sr <type> <unqualified-name> <template-args>

                // parse type and unqualified name and create the node
                Node* type;
                Node* name;
                if (!_ParseType(type) || !_ParseUnqualifiedName(name)
                        || !NodeCreator<DependentNameNode>(this)(type, name, _node)) {
                        return false;
                }

                // If there are template arguments left, add them.
                if (!fInput.HasPrefix('I'))
                        return true;

                return _ParseTemplateArgs(_node, _node);
        }

        if (fInput.SkipPrefix("sZ")) {
                // sZ <template-param>

                // NOTE: Unsupported by the GNU demangler.
                return _SetError(ERROR_UNSUPPORTED);
        }

        // no special operator, so have a look for the others

        const operator_info* info = NULL;
        for (int i = 0; kOperatorInfos[i].name != NULL; i++) {
                if (fInput.SkipPrefix(kOperatorInfos[i].mangled_name)) {
                        info = &kOperatorInfos[i];
                        break;
                }
        }

        // We can only deal with operators with a fixed argument count at this
        // point.
        if (info == NULL || info->argument_count < 0)
                return _SetError(ERROR_INVALID);

        // create an operator node
        OperatorExpressionNode* operatorNode;
        if (!NodeCreator<OperatorExpressionNode>(this)(info, operatorNode))
                return false;

        // parse the arguments
        int i = 0;

        // the first one might be a type
        if ((info->flags & OPERATOR_TYPE_PARAM) != 0) {
                Node* type;
                if (!_ParseType(type))
                        return false;

                operatorNode->AddSubExpression(type);
                i++;
        }

        // the others are expressions
        for (; i < info->argument_count; i++) {
                Node* subExpression;
                if (!_ParseExpression(subExpression))
                        return false;
                operatorNode->AddSubExpression(subExpression);
        }

        _node = operatorNode;
        return true;
}


bool
Demangler::_ParseExpressionPrimary(Node*& _node)
{
        DEBUG_SCOPE("_ParseExpressionPrimary");

        // <expr-primary> ::= L <type> <value number> E  # integer literal
        //                ::= L <type <value float> E    # floating literal
        //                ::= L <mangled-name> E         # external name

        if (!_SkipExpected('L'))
                return false;

        if (fInput.SkipPrefix("_Z")) {
                ObjectNode* node;
                if (!_ParseEncoding(node))
                        return false;
                _node = node;
        } else {
                // number or float literal
                Node* type;
                if (!_ParseType(type))
                        return false;

                // GNU's demangler doesn't really seem to parse the integer/float,
                // but only replaces a leading 'n' by '-'. Good enough for us, too.

                // determine the length
                int maxLength = fInput.CharsRemaining();
                int length = 0;
                while (length < maxLength && fInput[length] != 'E')
                        length++;

                if (length == 0)
                        return _SetError(ERROR_INVALID);

                if (!NodeCreator<TypedNumberLiteralNode>(this)(type,
                                fInput.String(), length, _node)) {
                        return false;
                }

                fInput.Skip(length);
        }

        return _SkipExpected('E');
}


bool
Demangler::_ParseNumber(number_type& number)
{
        DEBUG_SCOPE("_ParseNumber");

        bool negative = fInput.SkipPrefix('n');

        if (fInput.CharsRemaining() == 0)
                return _SetError(ERROR_INVALID);

        number = 0;
        int count = fInput.CharsRemaining();
        int i = 0;
        for (; i < count && isdigit(fInput[i]); i++)
                number = number * 10 + (fInput[i] - '0');

        fInput.Skip(i);

        if (negative)
                number =-number;
        return true;
}


bool
Demangler::_CreateNodeAndSkip(const char* name, size_t length, int toSkip,
        Node*& _node)
{
        if (toSkip > 0)
                fInput.Skip(toSkip);

        return NodeCreator<SimpleNameNode>(this)(name, length, _node);
}


bool
Demangler::_CreateNodeAndSkip(const char* name, int toSkip, Node*& _node)
{
        return _CreateNodeAndSkip(name, strlen(name), toSkip, _node);
}


bool
Demangler::_CreateTypeNodeAndSkip(type_type type, int toSkip, Node*& _node)
{
        if (toSkip > 0)
                fInput.Skip(toSkip);

        return NodeCreator<SimpleTypeNode>(this)(type, _node);
}


bool
Demangler::_CreateTypeNodeAndSkip(const char* name, const char* prefix,
        const char* templateArgs, int toSkip, Node*& _node)
{
        if (toSkip > 0)
                fInput.Skip(toSkip);

        // create the name node
        if (!NodeCreator<SimpleTypeNode>(this)(name, _node))
                return false;

        // add the prefix
        if (prefix != NULL) {
                Node* prefixNode;
                if (!NodeCreator<SimpleTypeNode>(this)(prefix, prefixNode)
                        || !NodeCreator<PrefixedNode>(this)(prefixNode, _node, _node)) {
                        return false;
                }
        }

        // wrap the node to add the template args
        if (templateArgs != NULL) {
                TemplateNode* templateNode;
                Node* argsNode;
                if (!NodeCreator<TemplateNode>(this)(_node, templateNode)
                        || !NodeCreator<SimpleTypeNode>(this)(templateArgs, argsNode)) {
                        return false;
                }
                templateNode->AddArgument(argsNode);
                _node = templateNode;
        }

        return true;
}


void
Demangler::_RegisterReferenceableNode(Node* node)
{
        // check, if not referenceable or already registered
        if (!node->IsReferenceable() || node == fLastReferenceableNode
                || node->NextReferenceable() != NULL) {
                return;
        }

        if (fFirstReferenceableNode == NULL) {
                fFirstReferenceableNode = node;
                fLastReferenceableNode = node;
        } else {
                fLastReferenceableNode->SetNextReferenceable(node);
                fLastReferenceableNode = node;
        }
}


bool
Demangler::_CreateSubstitutionNode(int index, Node*& _node)
{
        Node* node = fFirstReferenceableNode;
        while (node != NULL && index > 0) {
                node = node->NextReferenceable();
                index--;
        }

        if (node == NULL)
                return _SetError(ERROR_INVALID);

        // create a substitution node
        return NodeCreator<SubstitutionNode>(this)(node, _node);
}


// #pragma mark -


const char*
demangle_symbol_gcc3(const char* mangledName, char* buffer, size_t bufferSize,
        bool* _isObjectMethod)
{
        bool isObjectMethod;
        if (_isObjectMethod == NULL)
                _isObjectMethod = &isObjectMethod;

        Demangler demangler;
        DemanglingInfo info(true);
        if (demangler.Demangle(mangledName, buffer, bufferSize, info) != ERROR_OK)
                return NULL;

        // Set the object method return value. Unless we know for sure that it isn't
        // an object method, we assume that it is.
        switch (info.objectType) {
                case OBJECT_TYPE_DATA:
                case OBJECT_TYPE_FUNCTION:
                case OBJECT_TYPE_METHOD_CLASS:
                        *_isObjectMethod = false;
                        break;
                case OBJECT_TYPE_METHOD_OBJECT:
                        *_isObjectMethod = true;
                        break;
                case OBJECT_TYPE_UNKNOWN:
                case OBJECT_TYPE_METHOD_UNKNOWN:
                        *_isObjectMethod = strstr(buffer, "::") != NULL;
                        break;
        }

        return buffer;
}


status_t
get_next_argument_gcc3(uint32* _cookie, const char* mangledName, char* name,
        size_t nameSize, int32* _type, size_t* _argumentLength)
{
        Demangler demangler;
        ParameterInfo info;
        int result = demangler.GetParameterInfo(mangledName, *_cookie, name,
                nameSize, info);
        if (result != ERROR_OK) {
                switch (result) {
                        case ERROR_NOT_MANGLED:
                                return B_BAD_VALUE;
                        case ERROR_UNSUPPORTED:
                                return B_BAD_VALUE;
                        case ERROR_INVALID:
                                return B_BAD_VALUE;
                        case ERROR_BUFFER_TOO_SMALL:
                                return B_BUFFER_OVERFLOW;
                        case ERROR_NO_MEMORY:
                                return B_NO_MEMORY;
                        case ERROR_INVALID_PARAMETER_INDEX:
                                return B_BAD_INDEX;
                        case ERROR_INTERNAL:
                        default:
                                return B_ERROR;
                }
        }

        // translate the type
        switch (info.type.type) {
                case TYPE_BOOL:
                        *_type = B_BOOL_TYPE;
                        *_argumentLength = 1;
                        break;

                case TYPE_CHAR:
                        *_type = B_CHAR_TYPE;
                        *_argumentLength = 1;
                        break;

                case TYPE_SIGNED_CHAR:
                        *_type = B_INT8_TYPE;
                        *_argumentLength = 1;
                        break;
                case TYPE_UNSIGNED_CHAR:
                        *_type = B_UINT8_TYPE;
                        *_argumentLength = 1;
                        break;

                case TYPE_SHORT:
                        *_type = B_INT16_TYPE;
                        *_argumentLength = 2;
                        break;
                case TYPE_UNSIGNED_SHORT:
                        *_type = B_UINT16_TYPE;
                        *_argumentLength = 2;
                        break;

                case TYPE_INT:
                        *_type = B_INT32_TYPE;
                        *_argumentLength = 4;
                        break;
                case TYPE_UNSIGNED_INT:
                        *_type = B_UINT32_TYPE;
                        *_argumentLength = 4;
                        break;

                case TYPE_LONG:
                        *_type = sizeof(long) == 4 ? B_INT32_TYPE : B_INT64_TYPE;
                        *_argumentLength = sizeof(long);
                        break;
                case TYPE_UNSIGNED_LONG:
                        *_type = sizeof(long) == 4 ? B_UINT32_TYPE : B_UINT64_TYPE;
                        *_argumentLength = sizeof(long);
                        break;

                case TYPE_LONG_LONG:
                        *_type = B_INT64_TYPE;
                        *_argumentLength = 8;
                        break;
                case TYPE_UNSIGNED_LONG_LONG:
                        *_type = B_INT64_TYPE;
                        *_argumentLength = 8;
                        break;

                case TYPE_INT128:
                        *_type = 0;
                        *_argumentLength = 16;
                        break;
                case TYPE_UNSIGNED_INT128:
                        *_type = 0;
                        *_argumentLength = 16;
                        break;

                case TYPE_FLOAT:
                        *_type = B_FLOAT_TYPE;
                        *_argumentLength = sizeof(float);
                        break;
                case TYPE_DOUBLE:
                        *_type = B_DOUBLE_TYPE;
                        *_argumentLength = sizeof(double);
                        break;

                case TYPE_LONG_DOUBLE:
                        *_type = 0;
                        *_argumentLength = sizeof(long double);
                        break;

                case TYPE_FLOAT128:
                        *_type = 0;
                        *_argumentLength = 16;
                        break;

                case TYPE_DFLOAT16:
                        *_argumentLength = 2;
                case TYPE_DFLOAT32:
                        *_argumentLength *= 2;
                case TYPE_DFLOAT64:
                        *_argumentLength *= 2;
                case TYPE_DFLOAT128:
                        *_argumentLength *= 2;
                        *_type = 0;
                        break;

                case TYPE_CHAR16_T:
                        *_type = B_UINT16_TYPE;
                        *_argumentLength = 2;
                        break;

                case TYPE_CHAR32_T:
                        *_type = B_UINT32_TYPE;
                        *_argumentLength = 2;
                        break;

                case TYPE_CONST_CHAR_POINTER:
                        *_type = B_STRING_TYPE;
                        *_argumentLength = sizeof(void*);
                        break;

                case TYPE_POINTER:
                        *_type = B_POINTER_TYPE;
                        *_argumentLength = sizeof(void*);
                        break;

                case TYPE_REFERENCE:
                        *_type = B_REF_TYPE;
                                // TODO: That's actually entry_ref!
                        *_argumentLength = sizeof(void*);
                        break;

                case TYPE_WCHAR_T:
                        // TODO: Type/size might change!
                        *_type = B_UINT16_TYPE;
                        *_argumentLength = 2;
                        break;

                case TYPE_UNKNOWN:
                case TYPE_ELLIPSIS:
                case TYPE_VOID:
                default:
                        // Well, tell our caller *something*.
                        *_type = 0;
                        *_argumentLength = sizeof(int);
        }

        // assume sizeof(int) argument alignment
        if (*_argumentLength < sizeof(int))
                *_argumentLength = sizeof(int);

        ++*_cookie;
        return B_OK;
}


#ifndef _KERNEL_MODE

const char*
demangle_name_gcc3(const char* mangledName, char* buffer, size_t bufferSize)
{
        Demangler demangler;
        DemanglingInfo info(false);
        if (demangler.Demangle(mangledName, buffer, bufferSize, info) != ERROR_OK)
                return NULL;
        return buffer;
}

#endif