//===-- FastDemangle.cpp ----------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

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

//#define DEBUG_FAILURES 1
//#define DEBUG_SUBSTITUTIONS 1
//#define DEBUG_TEMPLATE_ARGS 1
//#define DEBUG_HIGHWATER 1
//#define DEBUG_REORDERING 1

namespace {

/// @brief Represents the collection of qualifiers on a type

enum Qualifiers
{
    QualifierNone = 0,
    QualifierConst = 1,
    QualifierRestrict = 2,
    QualifierVolatile = 4,
    QualifierReference = 8,
    QualifierRValueReference = 16,
    QualifierPointer = 32
};

/// @brief Categorizes the recognized operators

enum class OperatorKind
{
    Unary,
    Postfix,
    Binary,
    Ternary,
    Other,
    ConversionOperator,
    Vendor,
    NoMatch
};

/// @brief Represents one of the recognized two-character operator
/// abbreviations used when parsing operators as names and expressions

struct Operator
{
    const char *name;
    OperatorKind kind;
};

/// @brief Represents a range of characters in the output buffer, typically for
/// use with RewriteRange()

struct BufferRange
{
    int offset;
    int length;
};

/// @brief Transient state required while parsing a name

struct NameState
{
    bool parse_function_params;
    bool is_last_generic;
    bool has_no_return_type;
    BufferRange last_name_range;
};

/// @brief LLDB's fast C++ demangler
///
/// This is an incomplete implementation designed to speed up the demangling
/// process that is often a bottleneck when LLDB stops a process for the first
/// time.  Where the implementation doesn't know how to demangle a symbol it
/// fails gracefully to allow the caller to fall back to the existing demangler.
///
/// Over time the full mangling spec should be supported without compromising
/// performance for the most common cases.

class SymbolDemangler
{
public:

    //----------------------------------------------------
    // Public API
    //----------------------------------------------------

    /// @brief Create a SymbolDemangler
    ///
    /// The newly created demangler allocates and owns scratch memory sufficient
    /// for demangling typical symbols.  Additional memory will be allocated if
    /// needed and managed by the demangler instance.

    SymbolDemangler()
    {
        m_buffer = (char *) malloc(8192);
        m_buffer_end = m_buffer + 8192;
        m_owns_buffer = true;

        m_rewrite_ranges = (BufferRange *) malloc(128 * sizeof (BufferRange));
        m_rewrite_ranges_size = 128;
        m_owns_m_rewrite_ranges = true;
    }

    /// @brief Create a SymbolDemangler that uses provided scratch memory
    ///
    /// The provided memory is not owned by the demangler.  It will be
    /// overwritten during calls to GetDemangledCopy() but can be used for
    /// other purposes between calls.  The provided memory will not be freed
    /// when this instance is destroyed.
    ///
    /// If demangling a symbol requires additional space it will be allocated
    /// and managed by the demangler instance.
    ///
    /// @param storage_ptr Valid pointer to at least storage_size bytes of
    /// space that the SymbolDemangler can use during demangling
    ///
    /// @param storage_size Number of bytes of space available scratch memory
    /// referenced by storage_ptr

    SymbolDemangler(void *storage_ptr, int storage_size)
    {
        // Use up to 1/8th of the provided space for rewrite ranges
        m_rewrite_ranges_size = (storage_size >> 3) / sizeof (BufferRange);
        m_rewrite_ranges = (BufferRange *) storage_ptr;
        m_owns_m_rewrite_ranges = false;

        // Use the rest for the character buffer
        m_buffer = (char *) storage_ptr + m_rewrite_ranges_size * sizeof (BufferRange);
        m_buffer_end = (const char *)storage_ptr + storage_size;
        m_owns_buffer = false;
    }

    /// @brief Destroys the SymbolDemangler and deallocates any scratch
    /// memory that it owns

    ~SymbolDemangler()
    {
        if (m_owns_buffer)
            free(m_buffer);
        if (m_owns_m_rewrite_ranges)
            free(m_rewrite_ranges);
    }

#ifdef DEBUG_HIGHWATER
    int highwater_store = 0;
    int highwater_buffer = 0;
#endif

    /// @brief Parses the provided mangled name and returns a newly allocated
    /// demangling
    ///
    /// @param mangled_name Valid null-terminated C++ mangled name following
    /// the Itanium C++ ABI mangling specification as implemented by Clang
    ///
    /// @result Newly allocated null-terminated demangled name when demangling
    /// is succesful, and nullptr when demangling fails.  The caller is
    /// responsible for freeing the allocated memory.

    char *
    GetDemangledCopy(const char *mangled_name,
                     long mangled_name_length = 0)
    {
        if (!ParseMangling(mangled_name, mangled_name_length))
            return nullptr;

#ifdef DEBUG_HIGHWATER
        int rewrite_count = m_next_substitute_index +
        (m_rewrite_ranges_size - 1 - m_next_template_arg_index);
        int buffer_size = (int)(m_write_ptr - m_buffer);
        if (rewrite_count > highwater_store)
            highwater_store = rewrite_count;
        if (buffer_size > highwater_buffer)
            highwater_buffer = buffer_size;
#endif

        int length = (int)(m_write_ptr - m_buffer);
        char *copy = (char *)malloc(length + 1);
        memcpy(copy, m_buffer, length);
        copy[length] = '\0';
        return copy;
    }

private:

    //----------------------------------------------------
    // Grow methods
    //
    // Manage the storage used during demangling
    //----------------------------------------------------

    void GrowBuffer(long min_growth = 0)
    {
        // By default, double the size of the buffer
        long growth = m_buffer_end - m_buffer;

        // Avoid growing by more than 1MB at a time
        if (growth > 1 << 20)
            growth = 1 << 20;

        // ... but never grow by less than requested,
        // or 1K, whichever is greater
        if (min_growth < 1024)
            min_growth = 1024;
        if (growth < min_growth)
            growth = min_growth;

        // Allocate the new m_buffer and migrate content
        long new_size = (m_buffer_end - m_buffer) + growth;
        char *new_buffer = (char *) malloc(new_size);
        memcpy(new_buffer, m_buffer, m_write_ptr - m_buffer);
        if (m_owns_buffer)
            free(m_buffer);
        m_owns_buffer = true;

        // Update references to the new buffer
        m_write_ptr = new_buffer + (m_write_ptr - m_buffer);
        m_buffer = new_buffer;
        m_buffer_end = m_buffer + new_size;
    }

    void
    GrowRewriteRanges()
    {
        // By default, double the size of the array
        int growth = m_rewrite_ranges_size;

        // Apply reasonable minimum and maximum sizes for growth
        if (growth > 128)
            growth = 128;
        if (growth < 16)
            growth = 16;

        // Allocate the new array and migrate content
        int bytes = (m_rewrite_ranges_size + growth) * sizeof (BufferRange);
        BufferRange *new_ranges = (BufferRange *) malloc (bytes);
        for (int index = 0; index < m_next_substitute_index; index++)
        {
            new_ranges[index] = m_rewrite_ranges[index];
        }
        for (int index = m_rewrite_ranges_size - 1;
             index > m_next_template_arg_index; index--)
        {
            new_ranges[index + growth] = m_rewrite_ranges[index];
        }
        if (m_owns_m_rewrite_ranges)
            free(m_rewrite_ranges);
        m_owns_m_rewrite_ranges = true;

        // Update references to the new array
        m_rewrite_ranges = new_ranges;
        m_rewrite_ranges_size += growth;
        m_next_template_arg_index += growth;
    }

    //----------------------------------------------------
    // Range and state management
    //----------------------------------------------------

    int
    GetStartCookie()
    {
        return (int)(m_write_ptr - m_buffer);
    }

    BufferRange
    EndRange(int start_cookie)
    {
        return { start_cookie, (int)(m_write_ptr - (m_buffer + start_cookie)) };
    }

    void
    ReorderRange(BufferRange source_range, int insertion_point_cookie)
    {
        // Ensure there's room the preserve the source range
        if (m_write_ptr + source_range.length > m_buffer_end)
        {
            GrowBuffer(m_write_ptr + source_range.length - m_buffer_end);
        }

        // Reorder the content
        memcpy(m_write_ptr, m_buffer + source_range.offset, source_range.length);
        memmove(m_buffer + insertion_point_cookie + source_range.length,
                m_buffer + insertion_point_cookie,
                source_range.offset - insertion_point_cookie);
        memcpy(m_buffer + insertion_point_cookie, m_write_ptr, source_range.length);

        // Fix up rewritable ranges, covering both substitutions and templates
        int index = 0;
        while (true)
        {
            if (index == m_next_substitute_index)
                index = m_next_template_arg_index + 1;
            if (index == m_rewrite_ranges_size)
                break;

            // Affected ranges are either shuffled forward when after the
            // insertion but before the source, or backward when inside the
            // source
            int candidate_offset = m_rewrite_ranges[index].offset;
            if (candidate_offset >= insertion_point_cookie)
            {
                if (candidate_offset < source_range.offset)
                {
                    m_rewrite_ranges[index].offset += source_range.length;
                }
                else if (candidate_offset >= source_range.offset)
                {
                    m_rewrite_ranges[index].offset -= (source_range.offset - insertion_point_cookie);
                }
            }
            ++index;
        }
    }

    void
    EndSubstitution(int start_cookie)
    {
        if (m_next_substitute_index == m_next_template_arg_index)
            GrowRewriteRanges();

        int index = m_next_substitute_index++;
        m_rewrite_ranges[index] = EndRange(start_cookie);
#ifdef DEBUG_SUBSTITUTIONS
        printf("Saved substitution # %d = %.*s\n", index,
               m_rewrite_ranges[index].length, m_buffer + start_cookie);
#endif
    }

    void
    EndTemplateArg(int start_cookie)
    {
        if (m_next_substitute_index == m_next_template_arg_index)
            GrowRewriteRanges();

        int index = m_next_template_arg_index--;
        m_rewrite_ranges[index] = EndRange(start_cookie);
#ifdef DEBUG_TEMPLATE_ARGS
        printf("Saved template arg # %d = %.*s\n",
               m_rewrite_ranges_size - index - 1,
               m_rewrite_ranges[index].length, m_buffer + start_cookie);
#endif
    }

    void
    ResetTemplateArgs()
    {
        //TODO: this works, but is it the right thing to do?
        // Should we push/pop somehow at the call sites?
        m_next_template_arg_index = m_rewrite_ranges_size - 1;
    }

    //----------------------------------------------------
    // Write methods
    //
    // Appends content to the existing output buffer
    //----------------------------------------------------

    void
    Write(char character)
    {
        if (m_write_ptr == m_buffer_end)
            GrowBuffer();
        *m_write_ptr++ = character;
    }

    void
    Write(const char *content)
    {
        Write(content, strlen(content));
    }

    void
    Write(const char *content, long content_length)
    {
        char *end_m_write_ptr = m_write_ptr + content_length;
        if (end_m_write_ptr > m_buffer_end)
        {
            if (content >= m_buffer && content < m_buffer_end) 
            {
                long offset = content - m_buffer;
                GrowBuffer (end_m_write_ptr - m_buffer_end);
                content = m_buffer + offset;
            }
            else 
            {
                GrowBuffer (end_m_write_ptr - m_buffer_end);
            }
            end_m_write_ptr = m_write_ptr + content_length;
        }
        memcpy (m_write_ptr, content, content_length);
        m_write_ptr = end_m_write_ptr;
    }
#define WRITE(x) Write(x, sizeof (x) - 1)

    void
    WriteTemplateStart()
    {
        Write('<');
    }

    void
    WriteTemplateEnd()
    {
        // Put a space between terminal > characters when nesting templates
        if (m_write_ptr != m_buffer && *(m_write_ptr - 1) == '>')
            WRITE(" >");
        else Write('>');
    }

    void
    WriteCommaSpace()
    {
        WRITE(", ");
    }

    void
    WriteNamespaceSeparator()
    {
        WRITE("::");
    }

    void
    WriteStdPrefix()
    {
        WRITE("std::");
    }

    void
    WriteQualifiers(int qualifiers, bool space_before_reference = true)
    {
        if (qualifiers & QualifierPointer)
            Write('*');
        if (qualifiers & QualifierConst)
            WRITE(" const");
        if (qualifiers & QualifierVolatile)
            WRITE(" volatile");
        if (qualifiers & QualifierRestrict)
            WRITE(" restrict");
        if (qualifiers & QualifierReference)
        {
            if (space_before_reference)
                WRITE(" &");
            else Write('&');
        }
        if (qualifiers & QualifierRValueReference)
        {
            if (space_before_reference)
                WRITE(" &&");
            else WRITE("&&");
        }
    }

    //----------------------------------------------------
    // Rewrite methods
    //
    // Write another copy of content already present
    // earlier in the output buffer
    //----------------------------------------------------

    void
    RewriteRange(BufferRange range)
    {
        Write(m_buffer + range.offset, range.length);
    }

    bool
    RewriteSubstitution(int index)
    {
        if (index < 0 || index >= m_next_substitute_index)
        {
#ifdef DEBUG_FAILURES
            printf("*** Invalid substitution #%d\n", index);
#endif
            return false;
        }
        RewriteRange(m_rewrite_ranges[index]);
        return true;
    }

    bool
    RewriteTemplateArg(int template_index)
    {
        int index = m_rewrite_ranges_size - 1 - template_index;
        if (template_index < 0 || index <= m_next_template_arg_index)
        {
#ifdef DEBUG_FAILURES
            printf("*** Invalid template arg reference #%d\n", template_index);
#endif
            return false;
        }
        RewriteRange(m_rewrite_ranges[index]);
        return true;
    }

    //----------------------------------------------------
    // TryParse methods
    //
    // Provide information with return values instead of
    // writing to the output buffer
    //
    // Values indicating failure guarantee that the pre-
    // call m_read_ptr is unchanged
    //----------------------------------------------------

    int
    TryParseNumber()
    {
        unsigned char digit = *m_read_ptr - '0';
        if (digit > 9)
            return -1;

        int count = digit;
        while (true)
        {
            digit = *++m_read_ptr - '0';
            if (digit > 9)
                break;

            count = count * 10 + digit;
        }
        return count;
    }

    int
    TryParseBase36Number()
    {
        char digit = *m_read_ptr;
        int count;
        if (digit >= '0' && digit <= '9')
            count = digit -= '0';
        else if (digit >= 'A' && digit <= 'Z')
            count = digit -= ('A' - 10);
        else return -1;

        while (true)
        {
            digit = *++m_read_ptr;
            if (digit >= '0' && digit <= '9')
                digit -= '0';
            else if (digit >= 'A' && digit <= 'Z')
                digit -= ('A' - 10);
            else break;

            count = count * 36 + digit;
        }
        return count;
    }

    // <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
    //                ::= Da   # auto (in dependent new-expressions)
    //                ::= Dn   # std::nullptr_t (i.e., decltype(nullptr))
    //                ::= u <source-name>    # vendor extended type

    const char *
    TryParseBuiltinType()
    {
        switch (*m_read_ptr++)
        {
            case 'v': return "void";
            case 'w': return "wchar_t";
            case 'b': return "bool";
            case 'c': return "char";
            case 'a': return "signed char";
            case 'h': return "unsigned char";
            case 's': return "short";
            case 't': return "unsigned short";
            case 'i': return "int";
            case 'j': return "unsigned int";
            case 'l': return "long";
            case 'm': return "unsigned long";
            case 'x': return "long long";
            case 'y': return "unsigned long long";
            case 'n': return "__int128";
            case 'o': return "unsigned __int128";
            case 'f': return "float";
            case 'd': return "double";
            case 'e': return "long double";
            case 'g': return "__float128";
            case 'z': return "...";
            case 'D':
            {
                switch (*m_read_ptr++)
                {
                    case 'd': return "decimal64";
                    case 'e': return "decimal128";
                    case 'f': return "decimal32";
                    case 'h': return "decimal16";
                    case 'i': return "char32_t";
                    case 's': return "char16_t";
                    case 'a': return "auto";
                    case 'c': return "decltype(auto)";
                    case 'n': return "std::nullptr_t";
                    default:
                        --m_read_ptr;
                }
            }
        }
        --m_read_ptr;
        return nullptr;
    }

    //   <operator-name>
    //                   ::= aa    # &&
    //                   ::= ad    # & (unary)
    //                   ::= an    # &
    //                   ::= aN    # &=
    //                   ::= aS    # =
    //                   ::= cl    # ()
    //                   ::= cm    # ,
    //                   ::= co    # ~
    //                   ::= da    # delete[]
    //                   ::= de    # * (unary)
    //                   ::= dl    # delete
    //                   ::= dv    # /
    //                   ::= dV    # /=
    //                   ::= eo    # ^
    //                   ::= eO    # ^=
    //                   ::= eq    # ==
    //                   ::= ge    # >=
    //                   ::= gt    # >
    //                   ::= ix    # []
    //                   ::= le    # <=
    //                   ::= ls    # <<
    //                   ::= lS    # <<=
    //                   ::= lt    # <
    //                   ::= mi    # -
    //                   ::= mI    # -=
    //                   ::= ml    # *
    //                   ::= mL    # *=
    //                   ::= mm    # -- (postfix in <expression> context)
    //                   ::= na    # new[]
    //                   ::= ne    # !=
    //                   ::= ng    # - (unary)
    //                   ::= nt    # !
    //                   ::= nw    # new
    //                   ::= oo    # ||
    //                   ::= or    # |
    //                   ::= oR    # |=
    //                   ::= pm    # ->*
    //                   ::= pl    # +
    //                   ::= pL    # +=
    //                   ::= pp    # ++ (postfix in <expression> context)
    //                   ::= ps    # + (unary)
    //                   ::= pt    # ->
    //                   ::= qu    # ?
    //                   ::= rm    # %
    //                   ::= rM    # %=
    //                   ::= rs    # >>
    //                   ::= rS    # >>=
    //                   ::= cv <type>    # (cast)
    //                   ::= v <digit> <source-name>        # vendor extended operator

    Operator
    TryParseOperator()
    {
        switch (*m_read_ptr++)
        {
            case 'a':
                switch (*m_read_ptr++)
            {
                case 'a': return { "&&", OperatorKind::Binary };
                case 'd': return { "&", OperatorKind::Unary };
                case 'n': return { "&", OperatorKind::Binary };
                case 'N': return { "&=", OperatorKind::Binary };
                case 'S': return { "=", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'c':
                switch (*m_read_ptr++)
            {
                case 'l': return { "()", OperatorKind::Other };
                case 'm': return { ",", OperatorKind::Other };
                case 'o': return { "~", OperatorKind::Unary };
                case 'v': return { nullptr, OperatorKind::ConversionOperator };
            }
                --m_read_ptr;
                break;
            case 'd':
                switch (*m_read_ptr++)
            {
                case 'a': return { " delete[]", OperatorKind::Other };
                case 'e': return { "*", OperatorKind::Unary };
                case 'l': return { " delete", OperatorKind::Other };
                case 'v': return { "/", OperatorKind::Binary };
                case 'V': return { "/=", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'e':
                switch (*m_read_ptr++)
            {
                case 'o': return { "^", OperatorKind::Binary };
                case 'O': return { "^=", OperatorKind::Binary };
                case 'q': return { "==", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'g':
                switch (*m_read_ptr++)
            {
                case 'e': return { ">=", OperatorKind::Binary };
                case 't': return { ">", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'i':
                switch (*m_read_ptr++)
            {
                case 'x': return { "[]", OperatorKind::Other };
            }
                --m_read_ptr;
                break;
            case 'l':
                switch (*m_read_ptr++)
            {
                case 'e': return { "<=", OperatorKind::Binary };
                case 's': return { "<<", OperatorKind::Binary };
                case 'S': return { "<<=", OperatorKind::Binary };
                case 't': return { "<", OperatorKind::Binary };
                    // case 'i': return { "?", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'm':
                switch (*m_read_ptr++)
            {
                case 'i': return { "-", OperatorKind::Binary };
                case 'I': return { "-=", OperatorKind::Binary };
                case 'l': return { "*", OperatorKind::Binary };
                case 'L': return { "*=", OperatorKind::Binary };
                case 'm': return { "--", OperatorKind::Postfix };
            }
                --m_read_ptr;
                break;
            case 'n':
                switch (*m_read_ptr++)
            {
                case 'a': return { " new[]", OperatorKind::Other };
                case 'e': return { "!=", OperatorKind::Binary };
                case 'g': return { "-", OperatorKind::Unary };
                case 't': return { "!", OperatorKind::Unary };
                case 'w': return { " new", OperatorKind::Other };
            }
                --m_read_ptr;
                break;
            case 'o':
                switch (*m_read_ptr++)
            {
                case 'o': return { "||", OperatorKind::Binary };
                case 'r': return { "|", OperatorKind::Binary };
                case 'R': return { "|=", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'p':
                switch (*m_read_ptr++)
            {
                case 'm': return { "->*", OperatorKind::Binary };
                case 's': return { "+", OperatorKind::Unary };
                case 'l': return { "+", OperatorKind::Binary };
                case 'L': return { "+=", OperatorKind::Binary };
                case 'p': return { "++", OperatorKind::Postfix };
                case 't': return { "->", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'q':
                switch (*m_read_ptr++)
            {
                case 'u': return { "?", OperatorKind::Ternary };
            }
                --m_read_ptr;
                break;
            case 'r':
                switch (*m_read_ptr++)
            {
                case 'm': return { "%", OperatorKind::Binary };
                case 'M': return { "%=", OperatorKind::Binary };
                case 's': return { ">>", OperatorKind::Binary };
                case 'S': return { ">=", OperatorKind::Binary };
            }
                --m_read_ptr;
                break;
            case 'v':
                char digit = *m_read_ptr;
                if (digit >= '0' && digit <= '9')
                {
                    m_read_ptr++;
                    return { nullptr, OperatorKind::Vendor };
                }
                --m_read_ptr;
                break;
        }
        --m_read_ptr;
        return { nullptr, OperatorKind::NoMatch };
    }

    // <CV-qualifiers> ::= [r] [V] [K]
    // <ref-qualifier> ::= R                   # & ref-qualifier
    // <ref-qualifier> ::= O                   # && ref-qualifier

    int
    TryParseQualifiers(bool allow_cv, bool allow_ro)
    {
        int qualifiers = QualifierNone;
        char next = *m_read_ptr;
        if (allow_cv)
        {
            if (next == 'r') // restrict
            {
                qualifiers |= QualifierRestrict;
                next = *++m_read_ptr;
            }
            if (next == 'V') // volatile
            {
                qualifiers |= QualifierVolatile;
                next = *++m_read_ptr;
            }
            if (next == 'K') // const
            {
                qualifiers |= QualifierConst;
                next = *++m_read_ptr;
            }
        }
        if (allow_ro)
        {
            if (next == 'R')
            {
                ++m_read_ptr;
                qualifiers |= QualifierReference;
            }
            else if (next =='O')
            {
                ++m_read_ptr;
                qualifiers |= QualifierRValueReference;
            }
        }
        return qualifiers;
    }

    // <discriminator> := _ <non-negative number>      # when number < 10
    //                 := __ <non-negative number> _   # when number >= 10
    //  extension      := decimal-digit+

    int
    TryParseDiscriminator()
    {
        const char *discriminator_start = m_read_ptr;

        // Test the extension first, since it's what Clang uses
        int discriminator_value = TryParseNumber();
        if (discriminator_value != -1)
            return discriminator_value;

        char next = *m_read_ptr;
        if (next == '_')
        {
            next = *++m_read_ptr;
            if (next == '_')
            {
                ++m_read_ptr;
                discriminator_value = TryParseNumber();
                if (discriminator_value != -1 && *m_read_ptr++ != '_')
                {
                    return discriminator_value;
                }
            }
            else if (next >= '0' && next <= '9')
            {
                ++m_read_ptr;
                return next - '0';
            }
        }

        // Not a valid discriminator
        m_read_ptr = discriminator_start;
        return -1;
    }

    //----------------------------------------------------
    // Parse methods
    //
    // Consume input starting from m_read_ptr and produce
    // buffered output at m_write_ptr
    //
    // Failures return false and may leave m_read_ptr in an
    // indeterminate state
    //----------------------------------------------------

    bool
    Parse(char character)
    {
        if (*m_read_ptr++ == character)
            return true;
#ifdef DEBUG_FAILURES
        printf("*** Expected '%c'\n", character);
#endif
        return false;
    }

    // <number> ::= [n] <non-negative decimal integer>

    bool
    ParseNumber(bool allow_negative = false)
    {
        if (allow_negative && *m_read_ptr == 'n')
        {
            Write('-');
            ++m_read_ptr;
        }
        const char *before_digits = m_read_ptr;
        while (true)
        {
            unsigned char digit = *m_read_ptr - '0';
            if (digit > 9)
                break;
            ++m_read_ptr;
        }
        if (int digit_count = (int)(m_read_ptr - before_digits))
        {
            Write(before_digits, digit_count);
            return true;
        }
#ifdef DEBUG_FAILURES
        printf("*** Expected number\n");
#endif
        return false;
    }

    // <substitution> ::= S <seq-id> _
    //                ::= S_
    // <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> >

    bool
    ParseSubstitution()
    {
        const char *substitution;
        switch (*m_read_ptr)
        {
            case 'a': substitution = "std::allocator"; break;
            case 'b': substitution = "std::basic_string"; break;
            case 's': substitution = "std::string"; break;
            case 'i': substitution = "std::istream"; break;
            case 'o': substitution = "std::ostream"; break;
            case 'd': substitution = "std::iostream"; break;
            default:
                // A failed attempt to parse a number will return -1 which turns out to be
                // perfect here as S_ is the first substitution, S0_ the next and so forth
                int substitution_index = TryParseBase36Number();
                if (*m_read_ptr++ != '_')
                {
#ifdef DEBUG_FAILURES
                    printf("*** Expected terminal _ in substitution\n");
#endif
                    return false;
                }
                return RewriteSubstitution (substitution_index + 1);
        }
        Write(substitution);
        ++m_read_ptr;
        return true;
    }

    // <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
    //
    // <bare-function-type> ::= <signature type>+      # types are possible return type, then parameter types

    bool
    ParseFunctionType (int inner_qualifiers = QualifierNone)
    {
#ifdef DEBUG_FAILURES
        printf("*** Function types not supported\n");
#endif
        //TODO: first steps toward an implementation follow, but they're far
        // from complete.  Function types tend to bracket other types eg:
        // int (*)() when used as the type for "name" becomes int (*name)().
        // This makes substitution et al ... interesting.
        return false;

#if 0 // TODO
        if (*m_read_ptr == 'Y')
            ++m_read_ptr;

        int return_type_start_cookie = GetStartCookie();
        if (!ParseType())
            return false;
        Write(' ');

        int insert_cookie = GetStartCookie();
        Write('(');
        bool first_param = true;
        int qualifiers = QualifierNone;
        while (true)
        {
            switch (*m_read_ptr)
            {
                case 'E':
                    ++m_read_ptr;
                    Write(')');
                    break;
                case 'v':
                    ++m_read_ptr;
                    continue;
                case 'R':
                case 'O':
                    if (*(m_read_ptr + 1) == 'E')
                    {
                        qualifiers = TryParseQualifiers (false, true);
                        Parse('E');
                        break;
                    }
                    // fallthrough
                default:
                {
                    if (first_param)
                        first_param = false;
                    else WriteCommaSpace();

                    if (!ParseType())
                        return false;
                    continue;
                }
            }
            break;
        }

        if (qualifiers)
        {
            WriteQualifiers (qualifiers);
            EndSubstitution (return_type_start_cookie);
        }

        if (inner_qualifiers)
        {
            int qualifier_start_cookie = GetStartCookie();
            Write ('(');
            WriteQualifiers (inner_qualifiers);
            Write (')');
            ReorderRange (EndRange (qualifier_start_cookie), insert_cookie);
        }
        return true;
#endif // TODO 
    }

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

    bool
    ParseArrayType(int qualifiers = QualifierNone)
    {
#ifdef DEBUG_FAILURES
        printf("*** Array type unsupported\n");
#endif
        //TODO: We fail horribly when recalling these as substitutions or
        // templates and trying to constify them eg:
        // _ZN4llvm2cl5applyIA28_cNS0_3optIbLb0ENS0_6parserIbEEEEEEvRKT_PT0_
        //
        //TODO: Chances are we don't do any better with references and pointers
        // that should be type (&) [] instead of type & []

        return false;

#if 0 // TODO
        if (*m_read_ptr == '_')
        {
            ++m_read_ptr;
            if (!ParseType())
                return false;
            if (qualifiers)
                WriteQualifiers(qualifiers);
            WRITE(" []");
            return true;
        }
        else
        {
            const char *before_digits = m_read_ptr;
            if (TryParseNumber() != -1)
            {
                const char *after_digits = m_read_ptr;
                if (!Parse('_'))
                    return false;
                if (!ParseType())
                    return false;
                if (qualifiers)
                    WriteQualifiers(qualifiers);
                Write(' ');
                Write('[');
                Write(before_digits, after_digits - before_digits);
            }
            else
            {
                int type_insertion_cookie = GetStartCookie();
                if (!ParseExpression())
                    return false;
                if (!Parse('_'))
                    return false;

                int type_start_cookie = GetStartCookie();
                if (!ParseType())
                    return false;
                if (qualifiers)
                    WriteQualifiers(qualifiers);
                Write(' ');
                Write('[');
                ReorderRange (EndRange (type_start_cookie), type_insertion_cookie);
            }
            Write(']');
            return true;
        }
#endif // TODO
    }

    // <pointer-to-member-type> ::= M <class type> <member type>

    //TODO: Determine how to handle pointers to function members correctly,
    // currently not an issue because we don't have function types at all...
    bool
    ParsePointerToMemberType()
    {
        int insertion_cookie = GetStartCookie();
        Write(' ');
        if (!ParseType())
            return false;
        WRITE("::*");

        int type_cookie = GetStartCookie();
        if (!ParseType())
            return false;
        ReorderRange (EndRange (type_cookie), insertion_cookie);
        return true;
    }

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

    bool
    ParseTemplateParam()
    {
        int count = TryParseNumber();
        if (!Parse('_'))
            return false;

        // When no number is present we get -1, which is convenient since
        // T_ is the zeroth element T0_ is element 1, and so on
        return RewriteTemplateArg (count + 1);
    }

    // <type> ::= <builtin-type>
    //        ::= <function-type>
    //        ::= <class-enum-type>
    //        ::= <array-type>
    //        ::= <pointer-to-member-type>
    //        ::= <template-param>
    //        ::= <template-template-param> <template-args>
    //        ::= <decltype>
    //        ::= <substitution>
    //        ::= <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)
    //        ::= Dp <type>       # pack expansion (C++0x)
    //        ::= U <source-name> <type>  # vendor extended type qualifier
    // extension := U <objc-name> <objc-type>  # objc-type<identifier>
    // extension := <vector-type> # <vector-type> starts with Dv

    // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0 = 9 + <number of digits in k1> + k1
    // <objc-type> := <source-name>  # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>

    bool
    ParseType()
    {
#ifdef DEBUG_FAILURES
        const char *failed_type = m_read_ptr;
#endif
        int type_start_cookie = GetStartCookie();
        bool suppress_substitution = false;

        int qualifiers = TryParseQualifiers (true, false);
        switch (*m_read_ptr)
        {
            case 'D':
                ++m_read_ptr;
                switch (*m_read_ptr++)
            {
                case 'p':
                    if (!ParseType())
                        return false;
                    break;
                case 'T':
                case 't':
                case 'v':
                default:
#ifdef DEBUG_FAILURES
                    printf("*** Unsupported type: %.3s\n", failed_type);
#endif
                    return false;
            }
                break;
            case 'T':
                ++m_read_ptr;
                if (!ParseTemplateParam())
                    return false;
                break;
            case 'M':
                ++m_read_ptr;
                if (!ParsePointerToMemberType())
                    return false;
                break;
            case 'A':
                ++m_read_ptr;
                if (!ParseArrayType())
                    return false;
                break;
            case 'F':
                ++m_read_ptr;
                if (!ParseFunctionType())
                    return false;
                break;
            case 'S':
                if (*++m_read_ptr == 't')
                {
                    ++m_read_ptr;
                    WriteStdPrefix();
                    if (!ParseName())
                        return false;
                }
                else
                {
                    suppress_substitution = true;
                    if (!ParseSubstitution())
                        return false;
                }
                break;
            case 'P':
            {
                switch (*++m_read_ptr)
                {
                    case 'F':
                        ++m_read_ptr;
                        if (!ParseFunctionType(QualifierPointer))
                            return false;
                        break;
                    default:
                        if (!ParseType())
                            return false;
                        Write('*');
                        break;
                }
                break;
            }
            case 'R':
            {
                ++m_read_ptr;
                if (!ParseType())
                    return false;
                Write('&');
                break;
            }
            case 'O':
            {
                ++m_read_ptr;
                if (!ParseType())
                    return false;
                Write('&');
                Write('&');
                break;
            }
            case 'C':
            case 'G':
            case 'U':
#ifdef DEBUG_FAILURES
                printf("*** Unsupported type: %.3s\n", failed_type);
#endif
                return false;
                // Test for common cases to avoid TryParseBuiltinType() overhead
            case 'N':
            case 'Z':
            case 'L':
                if (!ParseName())
                    return false;
                break;
            default:
                if (const char *builtin = TryParseBuiltinType())
                {
                    Write(builtin);
                    suppress_substitution = true;
                }
                else
                {
                    if (!ParseName())
                        return false;
                }
                break;
        }

        // Allow base substitutions to be suppressed, but always record
        // substitutions for the qualified variant
        if (!suppress_substitution)
            EndSubstitution(type_start_cookie);
        if (qualifiers)
        {
            WriteQualifiers(qualifiers, false);
            EndSubstitution(type_start_cookie);
        }
        return true;
    }

    // <unnamed-type-name> ::= Ut [ <nonnegative number> ] _
    //                     ::= <closure-type-name>
    //
    // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
    //
    // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters

    bool
    ParseUnnamedTypeName(NameState & name_state)
    {
        switch (*m_read_ptr++)
        {
            case 't':
            {
                int cookie = GetStartCookie();
                WRITE("'unnamed");
                const char *before_digits = m_read_ptr;
                if (TryParseNumber() != -1) Write (before_digits,
                                                   m_read_ptr - before_digits);
                if (!Parse('_'))
                    return false;
                Write('\'');
                name_state.last_name_range = EndRange (cookie);
                return true;
            }
            case 'b':
            {
                int cookie = GetStartCookie();
                WRITE("'block");
                const char *before_digits = m_read_ptr;
                if (TryParseNumber() != -1) Write (before_digits,
                                                   m_read_ptr - before_digits);
                if (!Parse('_'))
                    return false;
                Write('\'');
                name_state.last_name_range = EndRange (cookie);
                return true;
            }
            case 'l':
#ifdef DEBUG_FAILURES
                printf("*** Lambda type names unsupported\n");
#endif
                return false;
        }
#ifdef DEBUG_FAILURES
        printf("*** Unknown unnamed type %.3s\n", m_read_ptr - 2);
#endif
        return false;
    }

    // <ctor-dtor-name> ::= C1      # complete object constructor
    //                  ::= C2      # base object constructor
    //                  ::= C3      # complete object allocating constructor

    bool
    ParseCtor(NameState & name_state)
    {
        char next = *m_read_ptr;
        if (next == '1' || next == '2' || next == '3' || next == '5')
        {
            RewriteRange (name_state.last_name_range);
            name_state.has_no_return_type = true;
            ++m_read_ptr;
            return true;
        }
#ifdef DEBUG_FAILURES
        printf("*** Broken constructor\n");
#endif
        return false;
    }

    // <ctor-dtor-name> ::= D0      # deleting destructor
    //                  ::= D1      # complete object destructor
    //                  ::= D2      # base object destructor

    bool
    ParseDtor(NameState & name_state)
    {
        char next = *m_read_ptr;
        if (next == '0' || next == '1' || next == '2' || next == '5')
        {
            Write('~');
            RewriteRange(name_state.last_name_range);
            name_state.has_no_return_type = true;
            ++m_read_ptr;
            return true;
        }
#ifdef DEBUG_FAILURES
        printf("*** Broken destructor\n");
#endif
        return false;
    }

    // See TryParseOperator()

    bool
    ParseOperatorName(NameState & name_state)
    {
#ifdef DEBUG_FAILURES
        const char *operator_ptr = m_read_ptr;
#endif
        Operator parsed_operator = TryParseOperator();
        if (parsed_operator.name)
        {
            WRITE("operator");
            Write(parsed_operator.name);
            return true;
        }

        // Handle special operators
        switch (parsed_operator.kind)
        {
            case OperatorKind::Vendor:
                WRITE("operator ");
                return ParseSourceName();
            case OperatorKind::ConversionOperator:
                ResetTemplateArgs();
                name_state.has_no_return_type = true;
                WRITE("operator ");
                return ParseType();
            default:
#ifdef DEBUG_FAILURES
                printf("*** Unknown operator: %.2s\n", operator_ptr);
#endif
                return false;
        }
    }

    // <source-name> ::= <positive length number> <identifier>

    bool
    ParseSourceName()
    {
        int count = TryParseNumber();
        if (count == -1)
        {
#ifdef DEBUG_FAILURES
            printf("*** Malformed source name, missing length count\n");
#endif
            return false;
        }

        const char *next_m_read_ptr = m_read_ptr + count;
        if (next_m_read_ptr > m_read_end)
        {
#ifdef DEBUG_FAILURES
            printf("*** Malformed source name, premature termination\n");
#endif
            return false;
        }

        if (count >= 10 && strncmp(m_read_ptr, "_GLOBAL__N", 10) == 0)
            WRITE("(anonymous namespace)");
        else Write(m_read_ptr, count);

        m_read_ptr = next_m_read_ptr;
        return true;
    }

    // <unqualified-name> ::= <operator-name>
    //                    ::= <ctor-dtor-name>
    //                    ::= <source-name>
    //                    ::= <unnamed-type-name>

    bool
    ParseUnqualifiedName(NameState & name_state)
    {
        // Note that these are detected directly in ParseNestedName for
        // performance rather than switching on the same options twice
        char next = *m_read_ptr;
        switch (next)
        {
            case 'C':
                ++m_read_ptr;
                return ParseCtor(name_state);
            case 'D':
                ++m_read_ptr;
                return ParseDtor(name_state);
            case 'U':
                ++m_read_ptr;
                return ParseUnnamedTypeName(name_state);
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                int name_start_cookie = GetStartCookie();
                if (!ParseSourceName())
                    return false;
                name_state.last_name_range = EndRange(name_start_cookie);
                return true;
            }
            default:
                return ParseOperatorName(name_state);
        };
    }

    // <unscoped-name> ::= <unqualified-name>
    //                 ::= St <unqualified-name>   # ::std::
    // extension       ::= StL<unqualified-name>

    bool
    ParseUnscopedName(NameState & name_state)
    {
        if (*m_read_ptr == 'S' && *(m_read_ptr + 1) == 't')
        {
            WriteStdPrefix();
            if (*(m_read_ptr += 2) == 'L')
                ++m_read_ptr;
        }
        return ParseUnqualifiedName(name_state);
    }

    bool
    ParseIntegerLiteral(const char *prefix, const char *suffix,
                             bool allow_negative)
    {
        if (prefix)
            Write(prefix);
        if (!ParseNumber(allow_negative))
            return false;
        if (suffix)
            Write(suffix);
        return Parse('E');
    }

    bool
    ParseBooleanLiteral()
    {
        switch (*m_read_ptr++)
        {
            case '0': WRITE("false"); break;
            case '1': WRITE("true"); break;
            default:
#ifdef DEBUG_FAILURES
                printf("*** Boolean literal not 0 or 1\n");
#endif
                return false;
        }
        return Parse('E');
    }

    // <expr-primary> ::= L <type> <value number> E                          # integer literal
    //                ::= L <type> <value float> E                           # floating literal
    //                ::= L <string type> E                                  # string literal
    //                ::= L <nullptr type> E                                 # nullptr literal (i.e., "LDnE")
    //                ::= L <type> <real-part float> _ <imag-part float> E   # complex floating point literal (C 2000)
    //                ::= L <mangled-name> E                                 # external name

    bool
    ParseExpressionPrimary()
    {
        switch (*m_read_ptr++)
        {
            case 'b': return ParseBooleanLiteral();
            case 'x': return ParseIntegerLiteral(nullptr, "ll", true);
            case 'l': return ParseIntegerLiteral(nullptr, "l", true);
            case 'i': return ParseIntegerLiteral(nullptr, nullptr, true);
            case 'n': return ParseIntegerLiteral("(__int128)", nullptr, true);
            case 'j': return ParseIntegerLiteral(nullptr, "u", false);
            case 'm': return ParseIntegerLiteral(nullptr, "ul", false);
            case 'y': return ParseIntegerLiteral(nullptr, "ull", false);
            case 'o': return ParseIntegerLiteral("(unsigned __int128)",
                                                 nullptr, false);
            case '_':
                if (*m_read_ptr++ == 'Z')
                {
                    if (!ParseEncoding())
                        return false;
                    return Parse('E');
                }
                --m_read_ptr;
                // fallthrough
            case 'w':
            case 'c':
            case 'a':
            case 'h':
            case 's':
            case 't':
            case 'f':
            case 'd':
            case 'e':
#ifdef DEBUG_FAILURES
                printf("*** Unsupported primary expression %.5s\n", m_read_ptr - 1);
#endif
                return false;
            case 'T':
                // Invalid mangled name per
                //   http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html
#ifdef DEBUG_FAILURES
                printf("*** Invalid primary expr encoding\n");
#endif
                return false;
            default:
                --m_read_ptr;
                Write('(');
                if (!ParseType())
                    return false;
                Write(')');
                if (!ParseNumber())
                    return false;
                return Parse('E');
        }
    }

    // <unresolved-type> ::= <template-param>
    //                   ::= <decltype>
    //                   ::= <substitution>

    bool
    ParseUnresolvedType()
    {
        int type_start_cookie = GetStartCookie();
        switch (*m_read_ptr++)
        {
            case 'T':
                if (!ParseTemplateParam())
                    return false;
                EndSubstitution(type_start_cookie);
                return true;
            case 'S':
            {
                if (*m_read_ptr != 't')
                    return ParseSubstitution();

                ++m_read_ptr;
                WriteStdPrefix();
                NameState type_name = {};
                if (!ParseUnqualifiedName(type_name))
                    return false;
                EndSubstitution(type_start_cookie);
                return true;

            }
            case 'D':
            default:
#ifdef DEBUG_FAILURES
                printf("*** Unsupported unqualified type: %3s\n", m_read_ptr - 1);
#endif
                return false;
        }
    }

    // <base-unresolved-name> ::= <simple-id>                                # unresolved name
    //          extension     ::= <operator-name>                            # unresolved operator-function-id
    //          extension     ::= <operator-name> <template-args>            # unresolved operator template-id
    //                        ::= on <operator-name>                         # unresolved operator-function-id
    //                        ::= on <operator-name> <template-args>         # unresolved operator template-id
    //                        ::= dn <destructor-name>                       # destructor or pseudo-destructor;
    //                                                                         # e.g. ~X or ~X<N-1>

    bool
    ParseBaseUnresolvedName()
    {
#ifdef DEBUG_FAILURES
        printf("*** Base unresolved name unsupported\n");
#endif
        return false;
    }

    // <unresolved-name>
    //  extension        ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
    //                   ::= [gs] <base-unresolved-name>                     # x or (with "gs") ::x
    //                   ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
    //                                                                       # A::x, N::y, A<T>::z; "gs" means leading "::"
    //                   ::= sr <unresolved-type> <base-unresolved-name>     # T::x / decltype(p)::x
    //  extension        ::= sr <unresolved-type> <template-args> <base-unresolved-name>
    //                                                                       # T::N::x /decltype(p)::N::x
    //  (ignored)        ::= srN <unresolved-type>  <unresolved-qualifier-level>+ E <base-unresolved-name>

    bool
    ParseUnresolvedName()
    {
#ifdef DEBUG_FAILURES
        printf("*** Unresolved names not supported\n");
#endif
        //TODO: grammar for all of this seems unclear...
        return false;

#if 0  // TODO
        if (*m_read_ptr == 'g' && *(m_read_ptr + 1) == 's')
        {
            m_read_ptr += 2;
            WriteNamespaceSeparator();
        }
#endif // TODO
    }

    // <expression> ::= <unary operator-name> <expression>
    //              ::= <binary operator-name> <expression> <expression>
    //              ::= <ternary 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
    //              ::= [gs] nw <expression>* _ <type> E                     # new (expr-list) type
    //              ::= [gs] nw <expression>* _ <type> <initializer>         # new (expr-list) type (init)
    //              ::= [gs] na <expression>* _ <type> E                     # new[] (expr-list) type
    //              ::= [gs] na <expression>* _ <type> <initializer>         # new[] (expr-list) type (init)
    //              ::= [gs] dl <expression>                                 # delete expression
    //              ::= [gs] da <expression>                                 # delete[] expression
    //              ::= pp_ <expression>                                     # prefix ++
    //              ::= mm_ <expression>                                     # prefix --
    //              ::= ti <type>                                            # typeid (type)
    //              ::= te <expression>                                      # typeid (expression)
    //              ::= dc <type> <expression>                               # dynamic_cast<type> (expression)
    //              ::= sc <type> <expression>                               # static_cast<type> (expression)
    //              ::= cc <type> <expression>                               # const_cast<type> (expression)
    //              ::= rc <type> <expression>                               # reinterpret_cast<type> (expression)
    //              ::= st <type>                                            # sizeof (a type)
    //              ::= sz <expression>                                      # sizeof (an expression)
    //              ::= at <type>                                            # alignof (a type)
    //              ::= az <expression>                                      # alignof (an expression)
    //              ::= nx <expression>                                      # noexcept (expression)
    //              ::= <template-param>
    //              ::= <function-param>
    //              ::= dt <expression> <unresolved-name>                    # expr.name
    //              ::= pt <expression> <unresolved-name>                    # expr->name
    //              ::= ds <expression> <expression>                         # expr.*expr
    //              ::= sZ <template-param>                                  # size of a parameter pack
    //              ::= sZ <function-param>                                  # size of a function parameter pack
    //              ::= sp <expression>                                      # pack expansion
    //              ::= tw <expression>                                      # throw expression
    //              ::= tr                                                   # throw with no operand (rethrow)
    //              ::= <unresolved-name>                                    # f(p), N::f(p), ::f(p),
    //                                                                       # freestanding dependent name (e.g., T::x),
    //                                                                       # objectless nonstatic member reference
    //              ::= <expr-primary>

    bool
    ParseExpression()
    {
        Operator expression_operator = TryParseOperator();
        switch (expression_operator.kind)
        {
            case OperatorKind::Unary:
                Write(expression_operator.name);
                Write('(');
                if (!ParseExpression())
                    return false;
                Write(')');
                return true;
            case OperatorKind::Binary:
                if (!ParseExpression())
                    return false;
                Write(expression_operator.name);
                return ParseExpression();
            case OperatorKind::Ternary:
                if (!ParseExpression())
                    return false;
                Write('?');
                if (!ParseExpression())
                    return false;
                Write(':');
                return ParseExpression();
            case OperatorKind::NoMatch:
                break;
            case OperatorKind::Other:
            default:
#ifdef DEBUG_FAILURES
                printf("*** Unsupported operator: %s\n", expression_operator.name);
#endif
                return false;
        }

        switch (*m_read_ptr++)
        {
            case 'T': return ParseTemplateParam();
            case 'L': return ParseExpressionPrimary();
            case 's':
                if (*m_read_ptr++ == 'r')
                    return ParseUnresolvedName();
                --m_read_ptr;
                // fallthrough
            default:
                return ParseExpressionPrimary();
        }
    }

    // <template-arg> ::= <type>                                             # type or template
    //                ::= X <expression> E                                   # expression
    //                ::= <expr-primary>                                     # simple expressions
    //                ::= J <template-arg>* E                                # argument pack
    //                ::= LZ <encoding> E                                    # extension

    bool
    ParseTemplateArg()
    {
        switch (*m_read_ptr) {
            case 'J':
#ifdef DEBUG_FAILURES
                printf("*** Template argument packs unsupported\n");
#endif
                return false;
            case 'X':
                ++m_read_ptr;
                if (!ParseExpression())
                    return false;
                return Parse('E');
            case 'L':
                ++m_read_ptr;
                return ParseExpressionPrimary();
            default:
                return ParseType();
        }
    }

    // <template-args> ::= I <template-arg>* E
    //     extension, the abi says <template-arg>+

    bool
    ParseTemplateArgs(bool record_template_args = false)
    {
        if (record_template_args)
            ResetTemplateArgs();

        bool first_arg = true;
        while (*m_read_ptr != 'E')
        {
            if (first_arg)
                first_arg = false;
            else WriteCommaSpace();

            int template_start_cookie = GetStartCookie();
            if (!ParseTemplateArg())
                return false;
            if (record_template_args)
                EndTemplateArg(template_start_cookie);
        }
        ++m_read_ptr;
        return true;
    }

    // <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
    //               ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
    //
    // <prefix> ::= <prefix> <unqualified-name>
    //          ::= <template-prefix> <template-args>
    //          ::= <template-param>
    //          ::= <decltype>
    //          ::= # empty
    //          ::= <substitution>
    //          ::= <prefix> <data-member-prefix>
    //  extension ::= L
    //
    // <template-prefix> ::= <prefix> <template unqualified-name>
    //                   ::= <template-param>
    //                   ::= <substitution>
    //
    // <unqualified-name> ::= <operator-name>
    //                    ::= <ctor-dtor-name>
    //                    ::= <source-name>
    //                    ::= <unnamed-type-name>

    bool
    ParseNestedName(NameState & name_state, bool parse_discriminator = false)
    {
        int qualifiers = TryParseQualifiers(true, true);
        bool first_part = true;
        bool suppress_substitution = true;
        int name_start_cookie = GetStartCookie();
        while (true)
        {
            char next = *m_read_ptr;
            if (next == 'E')
            {
                ++m_read_ptr;
                break;
            }

            // Record a substitution candidate for all prefixes, but not the full name
            if (suppress_substitution)
                suppress_substitution = false;
            else EndSubstitution(name_start_cookie);

            if (next == 'I')
            {
                ++m_read_ptr;
                name_state.is_last_generic = true;
                WriteTemplateStart();
                if (!ParseTemplateArgs(name_state.parse_function_params))
                    return false;
                WriteTemplateEnd();
                continue;
            }

            if (first_part)
                first_part = false;
            else WriteNamespaceSeparator();

            name_state.is_last_generic = false;
            switch (next)
            {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                {
                    int name_start_cookie = GetStartCookie();
                    if (!ParseSourceName())
                        return false;
                    name_state.last_name_range = EndRange(name_start_cookie);
                    continue;
                }
                case 'S':
                    if (*++m_read_ptr == 't')
                    {
                        WriteStdPrefix();
                        ++m_read_ptr;
                        if (!ParseUnqualifiedName(name_state))
                            return false;
                    }
                    else
                    {
                        if (!ParseSubstitution())
                            return false;
                        suppress_substitution = true;
                    }
                    continue;
                case 'T':
                    ++m_read_ptr;
                    if (!ParseTemplateParam())
                        return false;
                    continue;
                case 'C':
                    ++m_read_ptr;
                    if (!ParseCtor(name_state))
                        return false;
                    continue;
                case 'D':
                {
                    switch (*(m_read_ptr + 1))
                    {
                        case 't':
                        case 'T':
#ifdef DEBUG_FAILURES
                            printf("*** Decltype unsupported\n");
#endif
                            return false;
                    }
                    ++m_read_ptr;
                    if (!ParseDtor(name_state))
                        return false;
                    continue;
                }
                case 'U':
                    ++m_read_ptr;
                    if (!ParseUnnamedTypeName(name_state))
                        return false;
                    continue;
                case 'L':
                    ++m_read_ptr;
                    if (!ParseUnqualifiedName(name_state))
                        return false;
                    continue;
                default:
                    if (!ParseOperatorName(name_state))
                        return false;
            }
        }

        if (parse_discriminator)
            TryParseDiscriminator();
        if (name_state.parse_function_params
            && !ParseFunctionArgs(name_state, name_start_cookie))
        {
            return false;
        }
        if (qualifiers)
            WriteQualifiers(qualifiers);
        return true;
    }

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

    bool
    ParseLocalName(bool parse_function_params)
    {
        if (!ParseEncoding())
            return false;
        if (!Parse('E'))
            return false;

        switch (*m_read_ptr)
        {
            case 's':
                ++m_read_ptr;
                TryParseDiscriminator(); // Optional and ignored
                WRITE("::string literal");
                break;
            case 'd':
                ++m_read_ptr;
                TryParseNumber(); // Optional and ignored
                if (!Parse('_'))
                    return false;
                WriteNamespaceSeparator();
                if (!ParseName())
                    return false;
                break;
            default:
                WriteNamespaceSeparator();
                if (!ParseName(parse_function_params, true))
                    return false;
                TryParseDiscriminator(); // Optional and ignored
        }
        return true;
    }

    // <name> ::= <nested-name>
    //        ::= <local-name>
    //        ::= <unscoped-template-name> <template-args>
    //        ::= <unscoped-name>

    // <unscoped-template-name> ::= <unscoped-name>
    //                          ::= <substitution>

    bool
    ParseName(bool parse_function_params = false,
                   bool parse_discriminator = false)
    {
        NameState name_state = { parse_function_params, false, false, {0, 0}};
        int name_start_cookie = GetStartCookie();

        switch (*m_read_ptr)
        {
            case 'N':
                ++m_read_ptr;
                return ParseNestedName(name_state, parse_discriminator);
            case 'Z':
            {
                ++m_read_ptr;
                if (!ParseLocalName(parse_function_params))
                    return false;
                break;
            }
            case 'L':
                ++m_read_ptr;
                // fallthrough
            default:
            {
                if (!ParseUnscopedName(name_state))
                    return false;

                if (*m_read_ptr == 'I')
                {
                    EndSubstitution(name_start_cookie);

                    ++m_read_ptr;
                    name_state.is_last_generic = true;
                    WriteTemplateStart();
                    if (!ParseTemplateArgs(parse_function_params))
                        return false;
                    WriteTemplateEnd();
                }
                break;
            }
        }
        if (parse_discriminator)
            TryParseDiscriminator();
        if (parse_function_params &&
            !ParseFunctionArgs(name_state, name_start_cookie))
        {
            return false;
        }
        return true;
    }

    // <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

    bool
    ParseCallOffset()
    {
        switch (*m_read_ptr++)
        {
            case 'h':
                if (*m_read_ptr == 'n')
                    ++m_read_ptr;
                if (TryParseNumber() == -1 || *m_read_ptr++ != '_')
                    break;
                return true;
            case 'v':
                if (*m_read_ptr == 'n')
                    ++m_read_ptr;
                if (TryParseNumber() == -1 || *m_read_ptr++ != '_')
                    break;
                if (*m_read_ptr == 'n')
                    ++m_read_ptr;
                if (TryParseNumber() == -1 || *m_read_ptr++ != '_')
                    break;
                return true;
        }
#ifdef DEBUG_FAILURES
        printf("*** Malformed call offset\n");
#endif
        return false;
    }

    // <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)
    //                ::= 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
    //                ::= T <call-offset> <base encoding>
    //                    # base is the nominal target function of thunk
    //      extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first

    bool
    ParseSpecialNameT()
    {
        switch (*m_read_ptr++)
        {
            case 'V':
                WRITE("vtable for ");
                return ParseType();
            case 'T':
                WRITE("VTT for ");
                return ParseType();
            case 'I':
                WRITE("typeinfo for ");
                return ParseType();
            case 'S':
                WRITE("typeinfo name for ");
                return ParseType();
            case 'c':
            case 'C':
#ifdef DEBUG_FAILURES
                printf("*** Unsupported thunk or construction vtable name: %.3s\n", m_read_ptr - 1);
#endif
                return false;
            default:
                if (*--m_read_ptr == 'v')
                {
                    WRITE("virtual thunk to ");
                }
                else
                {
                    WRITE("non-virtual thunk to ");
                }
                if (!ParseCallOffset())
                    return false;
                return ParseEncoding();
        }
    }

    // <special-name> ::= GV <object name> # Guard variable for one-time initialization
    //                                     # No <type>
    //      extension ::= GR <object name> # reference temporary for object

    bool
    ParseSpecialNameG()
    {
        switch (*m_read_ptr++)
        {
            case 'V':
                WRITE("guard variable for ");
                if (!ParseName(true))
                    return false;
                break;
            case 'R':
                WRITE("reference temporary for ");
                if (!ParseName(true))
                    return false;
                break;
            default:
#ifdef DEBUG_FAILURES
                printf("*** Unknown G encoding\n");
#endif
                return false;
        }
        return true;
    }

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

    bool
    ParseFunctionArgs(NameState & name_state, int return_insert_cookie)
    {
        char next = *m_read_ptr;
        if (next == 'E' || next == '\0' || next == '.')
            return true;

        // Clang has a bad habit of making unique manglings by just sticking numbers on the end of a symbol,
        // which is ambiguous with malformed source name manglings
        const char *before_clang_uniquing_test = m_read_ptr;
        if (TryParseNumber())
        {
            if (*m_read_ptr == '\0')
                return true;
            m_read_ptr = before_clang_uniquing_test;
        }

        if (name_state.is_last_generic && !name_state.has_no_return_type)
        {
            int return_type_start_cookie = GetStartCookie();
            if (!ParseType())
                return false;
            Write(' ');
            ReorderRange(EndRange(return_type_start_cookie),
                         return_insert_cookie);
        }

        Write('(');
        bool first_param = true;
        while (true)
        {
            switch (*m_read_ptr)
            {
                case '\0':
                case 'E':
                case '.':
                    break;
                case 'v':
                    ++m_read_ptr;
                    continue;
                case '_':
                    // Not a formal part of the mangling specification, but clang emits suffixes starting with _block_invoke
                    if (strncmp(m_read_ptr, "_block_invoke", 13) == 0)
                    {
                        m_read_ptr += strlen(m_read_ptr);
                        break;
                    }
                    // fallthrough
                default:
                    if (first_param)
                        first_param = false;
                    else WriteCommaSpace();

                    if (!ParseType())
                        return false;
                    continue;
            }
            break;
        }
        Write(')');
        return true;
    }

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

    bool
    ParseEncoding()
    {
        switch (*m_read_ptr)
        {
            case 'T':
                ++m_read_ptr;
                if (!ParseSpecialNameT())
                    return false;
                break;
            case 'G':
                ++m_read_ptr;
                if (!ParseSpecialNameG())
                    return false;
                break;
            default:
                if (!ParseName(true))
                    return false;
                break;
        }
        return true;
    }

    bool
    ParseMangling(const char *mangled_name, long mangled_name_length = 0)
    {
        if (!mangled_name_length)
            mangled_name_length = strlen(mangled_name);
        m_read_end = mangled_name + mangled_name_length;
        m_read_ptr = mangled_name;
        m_write_ptr = m_buffer;
        m_next_substitute_index = 0;
        m_next_template_arg_index = m_rewrite_ranges_size - 1;

        if (*m_read_ptr++ != '_' || *m_read_ptr++ != 'Z')
        {
#ifdef DEBUG_FAILURES
            printf("*** Missing _Z prefix\n");
#endif
            return false;
        }
        if (!ParseEncoding())
            return false;
        switch (*m_read_ptr)
        {
            case '.':
                Write(' ');
                Write('(');
                Write(m_read_ptr, m_read_end - m_read_ptr);
                Write(')');
            case '\0':
                return true;
            default:
#ifdef DEBUG_FAILURES
                printf("*** Unparsed mangled content\n");
#endif
                return false;
        }
    }

private:

    // External scratch storage used during demanglings

    char *m_buffer;
    const char *m_buffer_end;
    BufferRange *m_rewrite_ranges;
    int m_rewrite_ranges_size;
    bool m_owns_buffer;
    bool m_owns_m_rewrite_ranges;

    // Internal state used during demangling

    const char *m_read_ptr;
    const char *m_read_end;
    char *m_write_ptr;
    int m_next_template_arg_index;
    int m_next_substitute_index;
};

} // Anonymous namespace

// Public entry points referenced from Mangled.cpp
namespace lldb_private
{
    char *
    FastDemangle(const char *mangled_name)
    {
        char buffer[16384];
        SymbolDemangler demangler(buffer, sizeof (buffer));
        return demangler.GetDemangledCopy(mangled_name);
    }

    char *
    FastDemangle(const char *mangled_name, long mangled_name_length)
    {
        char buffer[16384];
        SymbolDemangler demangler(buffer, sizeof (buffer));
        return demangler.GetDemangledCopy(mangled_name, mangled_name_length);
    }
} // lldb_private namespace