//===-- 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 "lldb/Utility/FastDemangle.h"

#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH

#include <functional>

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

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

namespace {

/// Represents the collection of qualifiers on a type

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

/// Categorizes the recognized operators

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

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

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

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

struct BufferRange {
  int offset;
  int length;
};

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

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

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

  /// 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, size_t storage_size,
                  std::function<void(const char *)> builtins_hook = nullptr)
      : m_builtins_hook(builtins_hook) {
    // 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;
  }

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

  /// 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 successful, 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() {
    if (m_builtins_hook)
      m_builtins_hook(m_read_ptr);

    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);
  }

  // <vector-type>
  // Dv <dimension number> _ <vector type>
  bool TryParseVectorType() {
    const int dimension = TryParseNumber();
    if (dimension == -1)
      return false;

    if (*m_read_ptr++ != '_')
      return false;

    char vec_dimens[32] = {'\0'};
    ::snprintf(vec_dimens, sizeof vec_dimens - 1, " __vector(%d)", dimension);
    ParseType();
    Write(vec_dimens);
    return true;
  }

  // <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 'v':
        if (!TryParseVectorType())
          return false;
        break;
      case 'T':
      case 't':
      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;
      LLVM_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;
      LLVM_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;
      LLVM_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;
        }
        LLVM_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(')');
      LLVM_FALLTHROUGH;
    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;
  std::function<void(const char *s)> m_builtins_hook;
};

} // 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, size_t mangled_name_length,
                   std::function<void(const char *s)> builtins_hook) {
  char buffer[16384];
  SymbolDemangler demangler(buffer, sizeof(buffer), builtins_hook);
  return demangler.GetDemangledCopy(mangled_name, mangled_name_length);
}
} // lldb_private namespace