demangle 0.3.0__py3-none-any.whl

demangle/schemes/swift/symbolic.py

@@ -0,0 +1,201 @@
+"""Symbolic references: the part of the Swift mangling that points into the binary.
+
+A mangled name in a Swift binary's *metadata* is not always self-contained. Where a name
+would have to spell a type the image already describes, the compiler writes a symbolic
+reference instead: one byte saying what kind of thing is referred to and how, then a
+four-byte signed offset relative to itself. The bytes are transcribed from
+`Demangler.cpp::demangleSymbolicReference` in the Swift 5.10 sources.
+
+    01  a context descriptor, directly
+    02  a context descriptor, through a pointer
+    09  an accessor function that yields the entity when run
+    0A  a unique extended existential type shape
+    0B  a non-unique extended existential type shape
+    03-08, 0C  reserved, and refused: the reference itself refuses them
+    FF  alignment padding in front of a reference, and skipped
+
+Two consequences fall out of the encoding and both matter to a reader:
+
+*   **A metadata blob cannot be split on NUL.** The four-byte offset is arbitrary bytes
+    and very often contains a zero, so finding where a mangled name ends means parsing
+    it. `end_of_name` does exactly that and nothing else.
+*   **A name holding one is not text.** It is bytes, so the entry points here take
+    `bytes` where the rest of the package takes `str`.
+
+Resolving a reference needs the image the name came out of, which is why this is a
+separate entry point rather than something `demangle()` could do: see `resolve.py` for a
+resolver that reads one, and `demangle_symbolic` for the parse that uses it.
+"""
+
+import struct
+
+__all__ = [
+    "ACCESSOR_FUNCTION",
+    "CONTEXT",
+    "DIRECT",
+    "INDIRECT",
+    "KINDS",
+    "NON_UNIQUE_EXTENDED_EXISTENTIAL_TYPE_SHAPE",
+    "PADDING",
+    "RESERVED",
+    "UNIQUE_EXTENDED_EXISTENTIAL_TYPE_SHAPE",
+    "SymbolicReference",
+    "end_of_name",
+    "read",
+    "scan",
+]
+
+#: What a reference points at.
+CONTEXT = "context"
+ACCESSOR_FUNCTION = "accessor function"
+UNIQUE_EXTENDED_EXISTENTIAL_TYPE_SHAPE = "unique extended existential type shape"
+NON_UNIQUE_EXTENDED_EXISTENTIAL_TYPE_SHAPE = "non-unique extended existential type shape"
+
+#: Whether the offset reaches the entity or a pointer to it.
+DIRECT = "direct"
+INDIRECT = "indirect"
+
+#: Introducer byte -> `(kind, directness)`. Exactly the reference's switch, including
+#: which values it leaves out: 3 through 8 are reserved for protocol- and
+#: associated-conformance descriptors and are *not* emitted, and 0x0C reaches the
+#: switch only to fall through its default.
+KINDS = {
+    0x01: (CONTEXT, DIRECT),
+    0x02: (CONTEXT, INDIRECT),
+    0x09: (ACCESSOR_FUNCTION, DIRECT),
+    0x0A: (UNIQUE_EXTENDED_EXISTENTIAL_TYPE_SHAPE, DIRECT),
+    0x0B: (NON_UNIQUE_EXTENDED_EXISTENTIAL_TYPE_SHAPE, DIRECT),
+}
+
+#: Introducer bytes the grammar accepts and the reference then refuses.
+RESERVED = frozenset({0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0C})
+
+#: Every byte that begins a symbolic reference, refused or not.
+INTRODUCERS = frozenset(KINDS) | RESERVED
+
+#: Written in front of a reference where the platform's relocations need the offset
+#: aligned. It carries nothing and is skipped.
+PADDING = 0xFF
+
+#: The offset is a 32-bit signed little-endian integer, and it is relative to its own
+#: first byte -- not to the introducer, and not to the end of the field.
+_OFFSET = struct.Struct("<i")
+OFFSET_WIDTH = _OFFSET.size
+
+
+class SymbolicReference:
+    """One symbolic reference, as the bytes described it.
+
+    `at` is where the *offset field* begins, because that is what the offset is relative
+    to: the address a resolver wants is `address_of(at) + offset`. Keeping the position
+    rather than the resolved address is what lets this module know nothing about images.
+    """
+
+    __slots__ = ("at", "directness", "kind", "offset", "raw_kind")
+
+    def __init__(self, raw_kind, kind, directness, offset, at):
+        self.raw_kind = raw_kind
+        self.kind = kind
+        self.directness = directness
+        self.offset = offset
+        self.at = at
+
+    @property
+    def reserved(self):
+        """Whether this is one of the introducers the reference declines to read."""
+        return self.kind is None
+
+    def __repr__(self):  # pragma: no cover - debugging aid
+        kind = self.kind or f"reserved 0x{self.raw_kind:02x}"
+        return f"SymbolicReference({kind}, {self.directness}, {self.offset:+d}, at={self.at})"
+
+    def __eq__(self, other):
+        if not isinstance(other, SymbolicReference):
+            return NotImplemented
+        return (self.raw_kind, self.offset, self.at) == (other.raw_kind, other.offset, other.at)
+
+    def __hash__(self):
+        return hash((self.raw_kind, self.offset, self.at))
+
+
+def read(data, pos):
+    """Read the reference whose introducer is at `data[pos]`.
+
+    Returns `(reference, position after it)`. Raises `ValueError` if `pos` does not hold
+    an introducer, or if the four offset bytes are not all there -- which the reference
+    also treats as failure rather than reading a short integer.
+    """
+    if pos < 0 or pos >= len(data):
+        raise ValueError(f"no byte at {pos}")
+    raw = data[pos]
+    if raw not in INTRODUCERS:
+        raise ValueError(f"0x{raw:02x} does not introduce a symbolic reference")
+    start = pos + 1
+    if start + OFFSET_WIDTH > len(data):
+        raise ValueError("truncated symbolic reference")
+    (offset,) = _OFFSET.unpack_from(data, start)
+    kind, directness = KINDS.get(raw, (None, None))
+    return SymbolicReference(raw, kind, directness, offset, start), start + OFFSET_WIDTH
+
+
+def scan(data):
+    """Every symbolic reference in `data`, in order.
+
+    Reading rather than searching: a byte inside an offset can look like an introducer,
+    and a name that has been walked properly is the only way to know it is not one.
+    """
+    found = []
+    pos = 0
+    length = len(data)
+    while pos < length:
+        byte = data[pos]
+        if byte in INTRODUCERS:
+            reference, pos = read(data, pos)
+            found.append(reference)
+        else:
+            pos += 1
+    return tuple(found)
+
+
+def end_of_name(data, start=0):
+    """Where the NUL-terminated mangled name beginning at `start` ends.
+
+    The index returned is of the terminating NUL, or of the end of `data` if the name
+    runs to it. This exists because the obvious thing does not work: a reference's
+    four-byte offset is arbitrary bytes and very often holds a zero, so `data.index(0)`
+    cuts a name in half. Swift's own reflection reader walks the name for the same
+    reason.
+    """
+    if start < 0 or start > len(data):
+        raise ValueError(f"no byte at {start}")
+    pos = start
+    length = len(data)
+    while pos < length:
+        byte = data[pos]
+        if byte == 0:
+            return pos
+        if byte in INTRODUCERS:
+            if pos + 1 + OFFSET_WIDTH > length:
+                # Truncated. The name cannot be read, and neither can the one after it,
+                # so the whole remainder is this name.
+                return length
+            pos += 1 + OFFSET_WIDTH
+        else:
+            pos += 1
+    return length
+
+
+def names(data):
+    """Split a metadata blob of NUL-terminated mangled names into those names.
+
+    Empty entries are dropped: a section is padded with them.
+    """
+    found = []
+    pos = 0
+    length = len(data)
+    while pos < length:
+        stop = end_of_name(data, pos)
+        if stop > pos:
+            found.append(data[pos:stop])
+        pos = stop + 1
+    return tuple(found)

demangle-0.3.0.dist-info/METADATA

@@ -0,0 +1,382 @@
+Metadata-Version: 2.5
+Name: demangle
+Version: 0.3.0
+Summary: Read mangled symbol names -- Itanium C++, MSVC, pre-Itanium C++, Ada/GNAT, Rust, Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi and JNI -- in pure Python, with no dependencies.
+Project-URL: Homepage, https://github.com/r0ny123/demangle
+Project-URL: Issues, https://github.com/r0ny123/demangle/issues
+Project-URL: Changelog, https://github.com/r0ny123/demangle/blob/main/CHANGELOG.md
+Author: demangle contributors
+License-Expression: MIT
+License-File: LICENSE
+License-File: NOTICE
+Keywords: abi,binary-analysis,c++,demangle,demangler,disassembler,itanium,mangling,msvc,reverse-engineering,rust,symbol
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Disassemblers
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# demangle
+
+[![CI](https://github.com/r0ny123/demangle/actions/workflows/ci.yml/badge.svg)](https://github.com/r0ny123/demangle/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.13%2B-blue)](https://www.python.org/downloads/)
+[![Licence](https://img.shields.io/badge/licence-MIT-green)](https://github.com/r0ny123/demangle/blob/main/LICENSE)
+
+**Read mangled symbol names in pure Python** — Itanium C++ (GCC/Clang), MSVC, Rust,
+Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi, Ada/GNAT, JNI, and the pre-Itanium
+C++ families (g++ 2.x, cfront/ARM, Lucid, HP aCC, CodeWarrior). No dependencies, no
+native code, no compiler required.
+
+```python
+>>> import demangle
+>>> demangle.demangle("_ZNSt6vectorIiSaIiEE9push_backERKi")
+'std::vector<int, std::allocator<int>>::push_back(int const&)'
+>>> demangle.demangle("?f@@YAXH@Z")
+'void __cdecl f(int)'
+>>> demangle.demangle("_ZN4core3fmt9Formatter3pad17h9b2b3a0e5b4d1b31E")
+'core::fmt::Formatter::pad'
+>>> demangle.demangle("$s10Foundation4DataV5countSivg")
+'Foundation.Data.count.getter : Swift.Int'
+>>> demangle.demangle("example.com/m/v2%2e5.(*T).Method", language="go")
+'example.com/m/v2.5.(*T).Method'
+>>> demangle.demangle("eqdestroy___systemZassertions_23")
+'system/assertions.=destroy'
+>>> demangle.demangle("MYUNIT$_$TWIDGET_$__$$_AREA$$LONGINT")
+'MYUNIT.TWIDGET.AREA: LONGINT'
+>>> demangle.demangle("@Unit@Class@Method$qqrv")
+'__fastcall Unit::Class::Method()'
+>>> demangle.demangle("AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue")
+'ivTSolver::AddAlignment(unsigned int, ivInteractor *, ivTGlue *)'
+>>> demangle.demangle("__dt__6CActorFv")
+'CActor::~CActor()'
+```
+
+- **No toolchain.** Every other option in Python binds to a native demangler —
+  `cxxfilt` and `pycxxfilt` wrap LLVM or libstdc++, `undname` wraps Wine through CFFI —
+  which means a C compiler at install time, a platform-specific wheel, and for MSVC
+  nothing maintained at all. This is Python and nothing else.
+- **A tree, not just a string.** `parse()` answers with nodes to walk, so the namespace,
+  the template arguments and the parameter types are fields rather than a regular
+  expression against C++ declaration syntax, which nests and so cannot be parsed that
+  way.
+- **Measured, not asserted.** Every scheme is scored against the reference demangler for
+  its mangling, over about 2,400,000 symbols out of shipped libraries, and every name
+  that differs is accounted for by name. [CONFORMANCE.md](https://github.com/r0ny123/demangle/blob/main/CONFORMANCE.md) has the
+  numbers and what each is measured against.
+- **Safe on untrusted input.** `demangle()` never raises, for any input; recursion depth,
+  output size, substitution count and input length are all bounded, and every bound is
+  configurable per call.
+
+## Install
+
+```console
+pip install demangle
+```
+
+Python 3.13 or newer. That is the whole dependency list.
+
+## Use
+
+### The string you probably want
+
+```python
+demangle.demangle(name)  # never raises; returns `name` unchanged if unreadable
+demangle.demangle_strict(name)  # raises DemanglingError instead
+```
+
+`demangle()` is built for the case where you are labelling every symbol in a binary and
+most of them are not mangled at all. A name it cannot read comes back exactly as it went
+in, because a wrong expansion is worse than a mangled one — it matches neither the
+symbol nor the declaration.
+
+### The structure, when you need it
+
+```python
+>>> tree = demangle.parse("_ZNK3Foo3barIiEEvPKc")
+>>> tree.spell()
+'void Foo::bar<int>(char const*) const'
+>>> [node.text for node in tree.find("name")]
+['Foo', 'bar']
+>>> function = next(tree.find("function"))
+>>> len(function.parameters)
+1
+```
+
+Every node supports `.walk()`, `.find(kind)`, `.children()` and `.spell()`.
+
+All schemes return full trees. A Rust symbol comes back as a `symbol` holding a
+`path` of `name` components, with `impl`, `template`, `type` and `literal` nodes for what
+the path carries:
+
+```python
+>>> tree = demangle.parse("_ZN4core3fmt9Formatter3pad17h9b2b3a0e5b4d1b31E")
+>>> [node.text for node in tree.find("name")]
+['core', 'fmt', 'Formatter', 'pad']
+```
+
+### The parts, when the spelling is not what you want
+
+`signature()` gives the pieces rather than the string — the base name without its
+scope, the scope without the base name, the parameter types on their own:
+
+```python
+>>> parts = demangle.signature("_ZNSt6vectorIiSaIiEE9push_backERKi")
+>>> parts.namespace, parts.base_name
+('std::vector<int, std::allocator<int>>', 'push_back')
+>>> parts.parameters
+('int const&',)
+>>> demangle.signature("$s4main3FooV3baryS2i_SStF").return_type
+'Swift.Int'
+```
+
+`namespace`, the scheme's separator and `base_name` spell `qualified_name` exactly, so
+the three recombine. Splitting the *string* would not give that: `::` and `.` and `,`
+occur inside template arguments and inside operator names as well as between components.
+
+What each scheme records differs, and the fields say so rather than guessing. A C++ or
+Swift name carries a signature; a Rust or Go path does not, and its `parameters` is
+`None` — which is not `()`. `is_function` is `False` where the name does not say.
+
+### A type on its own, not a whole symbol
+
+A `typeinfo` name, an RTTI type descriptor and a Swift metadata typeref all carry a
+*type* rather than a symbol. `demangle_type()` reads one, and `parse_type()` gives its
+tree:
+
+```python
+>>> demangle.demangle_type("PKFvRiE", language="itanium")
+'void (*)(int&) const'
+>>> demangle.demangle_type(".PEAX", language="msvc")     # a type descriptor's own symbol
+'void *'
+>>> demangle.demangle_type("SaySiG", language="swift")
+'[Swift.Int]'
+```
+
+`language` is required, and that is not an oversight: a whole symbol announces its
+scheme — `_Z`, `?`, `$s` — and a type encoding announces nothing at all, so `Si` is
+`std::istream` to the Itanium reader and `Swift.Int` to the Swift one. Every reference
+tool puts this behind a flag for the same reason. On the command line it is
+`demangle --types -l itanium`, one encoding per argument rather than a filter over mixed
+text — `Pi` is an ordinary word, and `I like Pi` should stay as it is.
+
+### A file, not a name
+
+`nm` writes an address and a type letter before a name; a crash log writes a frame
+number. So the useful operation over a file is "substitute every symbol-shaped word and
+copy the rest through", which is what the command does with no arguments — and now what
+the library does too:
+
+```python
+>>> demangle.demangle_text("0000000000001139 T _ZN3foo3barEv")
+'0000000000001139 T foo::bar()'
+>>> demangle.demangle_stream(sys.stdin, sys.stdout)     # a line at a time, for pipes
+>>> [f.mangled for f in demangle.find_symbols("a _ZN3foo3barEv b")]
+['_ZN3foo3barEv']
+```
+
+`find_symbols` gives the span as well as the spelling, for a caller that needs to know
+*where* in a line a symbol was.
+
+### Detection and batches
+
+```python
+>>> demangle.detect("?f@@YAXH@Z")
+'msvc'
+>>> list(demangle.demangle_all(symbol_table))     # generator, shares the cache
+```
+
+### Bytes, when the names came from a symbol table
+
+An ELF or Mach-O string table holds bytes, and they are not reliably UTF-8 — a truncated
+table cuts a name mid-character. Every entry point has a bytes form, so reading one does
+not mean guessing an encoding first:
+
+```python
+>>> demangle.demangleb(b"_ZN3foo3barEv")
+b'foo::bar()'
+```
+
+`demangleb_strict`, `detectb`, `parseb`, `signatureb`, `demangleb_type` and
+`parseb_type` go with it. Undecodable bytes
+survive the round trip: `demangleb` hands back exactly what it was given, byte for byte,
+rather than raising.
+
+### The tree as data
+
+`parse()` returns a walkable tree; `to_dict()` turns it into plain data, `--json` prints
+it, and `node_kinds()` is the vocabulary to switch on rather than something to read out
+of our source:
+
+```python
+>>> demangle.parse("_Z1fPi").to_dict()
+{'kind': 'function', 'name': {'kind': 'name', 'text': 'f'}, 'parameters': [{'kind': 'pointer', 'inner': {'kind': 'builtin', 'spelling': 'int'}}], 'returns': None, 'suffix': ''}
+>>> demangle.node_kinds("d")
+('name', 'path', 'symbol')
+```
+
+The nodes carry `__match_args__`, so structural pattern matching works:
+
+```python
+>>> from demangle.core.ast import Builtin, Pointer
+>>> match demangle.parse("_Z1fPi").parameters[0]:
+...     case Pointer(Builtin(name)): print("pointer to", name)
+pointer to int
+```
+
+A node reached more than once — an Itanium substitution, a Rust node named both by
+position and by role — is written once with an `id` and afterwards as `{"$ref": id}`. The
+structure is a graph, and expanding it in full does not always terminate in useful time.
+
+### Styles
+
+The two reference demanglers legitimately disagree on some spellings. Both are
+available, and neither is wrong:
+
+```python
+>>> demangle.demangle("_ZNSt6vectorIiSaIiEE9push_backERKi", style="llvm")   # default
+'std::vector<int, std::allocator<int>>::push_back(int const&)'
+>>> demangle.demangle("_ZNSt6vectorIiSaIiEE9push_backERKi", style="gnu")
+'std::vector<int, std::allocator<int> >::push_back(int const&)'
+```
+
+### Printing less of a name
+
+A decorated name expands to a great deal more than the name. `style()` composes what to
+leave out, at the call site rather than by registering anything globally:
+
+```python
+>>> demangle.demangle("?g@C@@UEAAXXZ")
+'public: virtual void __cdecl C::g(void)'
+>>> narrow = demangle.style("llvm", msvc={"calling_convention": False, "access_specifier": False})
+>>> demangle.demangle("?g@C@@UEAAXXZ", style=narrow)
+'virtual void C::g(void)'
+```
+
+The MSVC scheme has nine such options: the five flags `llvm-undname` has —
+`calling_convention`, `access_specifier`, `member_type`, `return_type`, `variable_type`
+— and four `UnDecorateSymbolName` mask bits it has no flag for, `ms_keywords`,
+`leading_underscores`, `this_type` and `tag_kind`. The two kinds reach differently, which
+is the references' doing rather than a convenience:
+[`MsvcOptions`](https://github.com/r0ny123/demangle/blob/main/src/demangle/schemes/msvc/options.py) says which is which, field by
+field, and each kind is scored against its own reference in
+[CONFORMANCE.md](https://github.com/r0ny123/demangle/blob/main/CONFORMANCE.md). Every one of them has a command-line flag.
+
+Swift has the bundle Xcode and LLDB show instead of the full spelling — `Either` for
+`Monads.Either`, `(_:)` for `(Swift.Int) -> Swift.UInt`, `specialized f()` for a page of
+specialisation arguments. It is `--simplified` on the command line, and exact against
+Swift's own 217 vectors:
+
+```python
+>>> from demangle.schemes.swift import SIMPLIFIED_OPTIONS
+>>> demangle.demangle("_TtFSiSu", style=demangle.style("llvm", swift=SIMPLIFIED_OPTIONS))
+'(_:)'
+```
+
+### Command line
+
+```console
+$ nm -a libfoo.so | demangle
+$ demangle _ZNSt6vectorIiSaIiEE9push_backERKi
+$ demangle --tree _Z1fPKc
+$ demangle --detect _RNvC6_123foo3bar
+$ demangle -p _ZNSt6vectorIiSaIiEE9push_backERKi    # the name, without the signature
+$ demangle --base-name _ZSt4sortIPiEvT_S1_         # `sort<int*>`
+$ demangle --no-return-type _ZSt4sortIPiEvT_S1_    # the declaration, minus `void `
+$ demangle --ret-postfix _Z1fIiET_S0_              # `f<int>(int)int`, as `DMGL_RET_POSTFIX`
+$ demangle --strip-underscore '_?f@@YAXH@Z'        # ignore one leading underscore
+$ demangle --keep-hash _ZN4core3fmt5write17h05af221e174051e9E   # keep Rust's hash
+$ demangle --types -l itanium PKFvRiE              # a bare type, as `c++filt -t`
+$ demangle --no-calling-convention '?f@@YAXH@Z'    # `void f(int)`
+$ demangle --no-tag-kind '?g3@@YAXVV@@@Z'          # `void __cdecl g3(V)`
+$ demangle --simplified _TtFSiSu                   # Swift, the way Xcode shows it
+$ demangle --json _Z1fPi                           # the parse tree as JSON
+```
+
+## Correctness
+
+Correctness here is a measurement rather than a claim. Every scheme is scored against the
+reference implementation for its mangling — `llvm-cxxfilt`, GNU `c++filt`,
+`llvm-undname`, `rustfilt`, `swift-demangle`, `cwdemangle`, Embarcadero's own unmangler —
+and, where no reference exists, against a property the mangling itself has to satisfy:
+re-mangling what was read must reproduce the symbol the compiler wrote.
+
+The checked-in corpora are replayed by the test suite with no compiler and no reference
+demangler present. Beyond them, whole symbol tables are run live against the references:
+about 2,400,000 real symbols from shipped libraries, and every name that differs is
+accounted for one by one.
+
+**[CONFORMANCE.md](https://github.com/r0ny123/demangle/blob/main/CONFORMANCE.md) is the whole picture** — what each corpus is measured
+against, the notes behind every number, the live runs, and the places where following a
+reference would itself be the defect.
+
+## Safety
+
+A mangled name is untrusted input in any tool that opens files it did not produce, so
+the bounds on depth, output size, substitution count and input length are the design
+rather than a hardening pass. Results are deterministic, and the property-based suite
+runs every parser against arbitrary text, mangling-alphabet text, arbitrary bytes, every
+truncation of a known-good name, and inputs built to blow up a naive parser.
+[SECURITY.md](https://github.com/r0ny123/demangle/blob/main/SECURITY.md) has the threat model, what is in scope, and how to report
+privately.
+
+## Performance
+
+Pure Python, measured on the conformance corpora (`benchmarks/bench.py`):
+
+| Workload | Throughput |
+|---|---|
+| Cold — every name distinct | ~24,000 names/sec |
+| Warm — names repeat, as in a real symbol table | ~2,200,000 names/sec |
+| Non-mangled names rejected | ~510,000 names/sec |
+| Full AST construction | ~16,500 names/sec |
+
+Treat these as ratios rather than absolutes. The gap between cold and warm is the point:
+symbol tables repeat themselves relentlessly, and results are cached.
+
+`bench.py --check` gates CI against the committed baseline. It compares figures normalised
+against a calibration workload measured in the same run, so the gate reports a slower
+*demangler* rather than a slower *machine*.
+
+## Architecture
+
+The short version: **parsers never build their own output**. Each one is written against
+a `Builder` protocol and reports the grammar productions it recognises; a fast text
+builder or a tree builder decides what those become. That is what lets one parser serve
+both `demangle()` and `parse()` with no second implementation to drift.
+
+Schemes are plugins. `core` never imports one, they never import each other, and a
+separate distribution can add a language through the `demangle.languages`
+entry-point group without patching this package. Both rules are enforced by tests.
+
+[Working with the tree](https://github.com/r0ny123/demangle/blob/main/docs/analysing-a-binary.md) works
+one real task through `parse()` end to end — finding every function in libstdc++ that
+takes a string by const reference, and measuring what the regular-expression version of
+the same question gets wrong.
+
+See [ARCHITECTURE.md](https://github.com/r0ny123/demangle/blob/main/ARCHITECTURE.md) for the full picture and
+[Adding a scheme](https://github.com/r0ny123/demangle/blob/main/docs/adding-a-scheme.md) to add a language
+of your own. The API reference is published at <https://r0ny123.github.io/demangle/>.
+
+## Contributing
+
+New schemes, corpus contributions, and conformance bug reports are all welcome — see
+[CONTRIBUTING.md](https://github.com/r0ny123/demangle/blob/main/CONTRIBUTING.md). A good bug report is a mangled name, what the
+reference prints, and what this library prints.
+
+Fixing a spelling or adding a language should not require understanding the whole
+codebase. Where it does, that is a bug.
+
+## Licence
+
+MIT. The Rust demangler derives from Team bi0s' `rust_demangler` (MIT) and the MSVC
+demangler from [SMDA](https://github.com/danielplohmann/smda) (BSD 2-Clause); both are
+substantially modified, and both upstream licences are reproduced in
+[NOTICE](https://github.com/r0ny123/demangle/blob/main/NOTICE).

demangle-0.3.0.dist-info/RECORD

@@ -0,0 +1,82 @@
+demangle/__init__.py,sha256=ZXJT87l6tidPkQoe6QDhxtSfBDhbziOldBdCdkQTBlg,2516
+demangle/_signature.py,sha256=LKJWggi2rtMeYPua64LX1Sc_9jIA6joWIP9APrsTLzY,25959
+demangle/api.py,sha256=M8o7EGokKfTsx5N8PpQ8RlwJiatMK-osyQCsBleGKlo,32512
+demangle/cli.py,sha256=O6PV8fEEzyf5J2gdkEju6_LNZmpYYX6Tkam3AmWuk58,23715
+demangle/filter.py,sha256=8RPEru5Cl32_dyMT55pxxn-bRsabgwmvscGMbKWKjmc,10090
+demangle/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+demangle/core/__init__.py,sha256=AGi-0r12rDEdUf-MFVqOMVEGQipu_-buqoA-x4chqz4,1073
+demangle/core/ast.py,sha256=CiZe43i_kqSnrUUdkUg3K5YR9Ff6mJgJkRjuAR0Uhcg,33325
+demangle/core/builder.py,sha256=AZA7-RH90iMKQ6uW9HxGQdHPD6hr3SgkfQqJAKa6IJk,7352
+demangle/core/cache.py,sha256=411yLDifXOOHTYoUE6uVynqEJbh_bXYNySaJsuBLfuM,2081
+demangle/core/decorations.py,sha256=oWphv2iwfG8RZCt-hBGTE79lWknC44yORxT-eWglrro,3544
+demangle/core/errors.py,sha256=PxKzucafAgKZf4dHdeyh_QG0v8Dvdl2LixBX22RSd6k,3004
+demangle/core/limits.py,sha256=D1c1pEamvcG7H5xCFaWNbwA0WnBXc4S0cMC55odgcwQ,2174
+demangle/core/plugin.py,sha256=gHC31fx7isWyIBpvMmX3h0y4tk5_vZon4QNaEruHsLI,4261
+demangle/core/reader.py,sha256=RMfaH1plMC429T8wvBBXqVxKUQJRaCw7VuQEUBcKfy0,10635
+demangle/core/registry.py,sha256=mf7LpG5o5jnQXXKe_K7YuPww4eBRydfHxmnbk8UB8XA,8302
+demangle/core/spelling.py,sha256=65MxXgUHbZzHz3lXYXyvwtprvUtXMwpwuy5To2uAlOY,24062
+demangle/core/style.py,sha256=hddj1NJvaEsLLB74hLT1Mi0hIVdZAnYawObSZ7iuXj0,7883
+demangle/schemes/__init__.py,sha256=6AjYmDZPnvO4ED9lDqrxolaXzu0NlbYOlQ9pzg90CLo,319
+demangle/schemes/ada/__init__.py,sha256=VRHK5kTjyMF-TwuYHeEwOmJUwmAvPp5mgI5_qJ3jCSI,8998
+demangle/schemes/ada/_parser.py,sha256=VworSHrS85FoIm1hFqISO74JrS60qPbknLzdPLMZpUo,12235
+demangle/schemes/ada/nodes.py,sha256=qyf6mhIbkgHCkMPvANEKlzgrMzRmupEKD4HvuqvtoIU,2805
+demangle/schemes/codewarrior/__init__.py,sha256=1MQO5iYdrZv1T_y5lGC55RQ3QNiRNWrPLq8j8hq5myk,8895
+demangle/schemes/codewarrior/_parser.py,sha256=4N3DmfLdT9HejBlaxs7J47LXjtnb826zUBhl07GaJ_k,20653
+demangle/schemes/codewarrior/nodes.py,sha256=Fwu4vNKePMCd92OMWaYAI2VzAmz99YRuQF0ImDAmDEs,3996
+demangle/schemes/codewarrior/options.py,sha256=q0o5afuIyKSVXmGwvAf4-M2bGR6JIsDCofSxw0muFJI,1235
+demangle/schemes/d/__init__.py,sha256=unROT-mBlhdcktLtnPppSpOu6Ie19nU_48b3Cy7ImGk,4687
+demangle/schemes/d/_parser.py,sha256=jJ6a2JegjDPeCqqfwtckoErh_dVEE3829cHRlbyrCCA,81885
+demangle/schemes/d/nodes.py,sha256=y5HLVrYsAZ-JwODZgkc1Kn8r3FLyT8l5EOT54eX1pT4,2569
+demangle/schemes/delphi/__init__.py,sha256=LYdQluOHjJYs9mdxujpUCC6w7e5KuXpBD6ewMoZ-O4o,3210
+demangle/schemes/delphi/_parser.py,sha256=GdDbgvUPatUXRkA_YqOWDtuqPw_uWGOM8RTUoX8XmTY,34035
+demangle/schemes/delphi/nodes.py,sha256=EbQwhtPOwlMYWT_SVCzWGOfl0X_M31wjb5sJqT_8sZE,3521
+demangle/schemes/gnuv2/__init__.py,sha256=5GZ3Gsmt3qj5Ky3TlA5HLvMbSqb_qzIpR8-UGIdtZ0w,15853
+demangle/schemes/gnuv2/_parser.py,sha256=5ZS7_oOiIrSxcx0nX3ELbdG8rBAHggFgnivmT908vCI,86138
+demangle/schemes/gnuv2/nodes.py,sha256=J2jJqRP7vb6c7KjdbMpabcyGqCQhJKWzjBH8Lq04aj0,4745
+demangle/schemes/gnuv2/options.py,sha256=Sft-bJAI_qfzJYxnxKqf30RVGwLFtEIR1-EuFKo17sc,2184
+demangle/schemes/go/__init__.py,sha256=EKQ8Mj6RaVMju9fRq7tE_1lUnnA5F0h5pLTneeIvCD8,5144
+demangle/schemes/go/_parser.py,sha256=xiFjM5_11UwVbLAhDfPTvFyqSJ0AKMR4apEOR2B3-Wc,12083
+demangle/schemes/go/nodes.py,sha256=toeMLnKMFL_aD1htXdfRwN6xC2Qz-5umZ14XoLlBTj8,4083
+demangle/schemes/itanium/__init__.py,sha256=3k0t5OYGOi8jYY8dgsfvZezNiP982JZJoMWH5ANXkPY,1607
+demangle/schemes/itanium/options.py,sha256=G6__n1TD6jI-S1OUQfpdHDrXV1oYpQ0n0pwSLaPF4MI,17849
+demangle/schemes/itanium/parser.py,sha256=IPlIEqJK5Jqw6Cm3jIXSKx_bjGvC7TuhQR8kZ1KFfyQ,290679
+demangle/schemes/itanium/substitutions.py,sha256=szXj6aPrxTdqyn_aU8kC7DN1X3nAf7Ma-olAFNCsV-g,16471
+demangle/schemes/itanium/tables.py,sha256=Ek4s952qceOmMPb1mDw_rf6vv0GPxSPg_rX9xZynQHs,12799
+demangle/schemes/jni/__init__.py,sha256=E8Vb0Kr9FXye6QzRYK4mdCZ3bvrMxWO6CmCI2TRzT7I,3999
+demangle/schemes/jni/_parser.py,sha256=cIskDqwluojm0w2bw-f5F-DIzmkQSb0kiUi7SfKE0k0,9879
+demangle/schemes/jni/nodes.py,sha256=A7YCBHrNulVSZaUmDUUGtF7oMgt0OzdZMGL6gF7vYuQ,2634
+demangle/schemes/msvc/__init__.py,sha256=prgQAkOYVlb1CuDq0hqGteUYRp3n3Gd6OdTAwHgOdng,14735
+demangle/schemes/msvc/_parser.py,sha256=ZLG3JQNxpPom2ZYJp9wyUQxTWvMAkggX5_ml5M9Vrwo,97310
+demangle/schemes/msvc/nodes.py,sha256=5RBw7McmN4FLMK3_p9xb3SbmhcQoSy3hqhCVcojhUaM,22428
+demangle/schemes/msvc/options.py,sha256=SarkabnhN66O9UCMGcHEjFwCRdMxGKth6XlD4dEF1HI,6395
+demangle/schemes/nim/__init__.py,sha256=ADbv1ePyr5Z6YJp9FrmBGHOypzOe8io_xuxTSUle1Hw,3138
+demangle/schemes/nim/_parser.py,sha256=4QRh6uUIitr-4VbwNexNFoCZF-Ndngan0kudm0gx9HE,19032
+demangle/schemes/nim/nodes.py,sha256=DmNjGboIhIjTt5Qinx6TBPqNOGFm1g_KVUUpizJBd_w,2377
+demangle/schemes/objc/__init__.py,sha256=dxWSdbyZECxwn-fZeqiNUek8bsBlhznXYrHCM1j4X4Y,4970
+demangle/schemes/objc/_parser.py,sha256=zx35Ev_jDism1-6Jkm5m9-B8z9SMLrwHUV2Z1VLUYHs,38712
+demangle/schemes/objc/nodes.py,sha256=DnJJHjgsSV4dOfXGcumclUVzvN7qH6oYF12DUkhUHCg,3768
+demangle/schemes/pascal/__init__.py,sha256=23YaRZm255WL32rHrrEVSzZ-T2c-SvNqW7DhRh91wRc,3550
+demangle/schemes/pascal/_parser.py,sha256=apC5Ri8o6wS1upKWv5WvccqRQ-8OlqHQoCs4sIU3eNs,15397
+demangle/schemes/pascal/nodes.py,sha256=ij2qlpiqJWyySksN6kG66JJ42tgwDA5foXr1Z8JuINQ,4547
+demangle/schemes/rust/__init__.py,sha256=LwXnI5ZgOCORfI_h-HfqY8ojXyuXAiZN-_VT1FBICTY,11471
+demangle/schemes/rust/_dispatch.py,sha256=z_Xbup6nZlUJnjJqoI-IlanvhNb1KkHZkeMGFEfwnTw,3261
+demangle/schemes/rust/_legacy.py,sha256=XJY9t6xlbp6N4cfSKMdfpakdkWcsGS9kMklPx576Za8,11384
+demangle/schemes/rust/_v0.py,sha256=PKzfXj2ZJOwXAkBZY5A1xmTJLd4htRqeGQ1SJiJhwl0,73466
+demangle/schemes/rust/nodes.py,sha256=urcmSyZx0pnIz7uzzYkPRL2Fs8IUWdXowl3PiVAKeQs,6489
+demangle/schemes/rust/options.py,sha256=vVZYmEfiHNgtR9Amjjoy16qVoJZOPiVS3MxjI8ARib8,1489
+demangle/schemes/swift/__init__.py,sha256=WB5ju0yKWUE1bZTWr1RmBif4QvZmolGsD7enNCnnR1Y,10288
+demangle/schemes/swift/_demangler.py,sha256=M422fUZO4VcV-rbCO_x_mJnuMryhmpOLV5jTwWorvzE,132940
+demangle/schemes/swift/_node.py,sha256=LI8txslNyQA9nfVzzSzrd-iM99nsrP2W3IL7e7IXNLI,21212
+demangle/schemes/swift/_old_demangler.py,sha256=p2rgpR_BCLKVXjvFmOHNblowlOejDtvN8wjv6CDKNF4,57355
+demangle/schemes/swift/_printer.py,sha256=xm5_lbsGjI55zzrFA14EBIY9arKLV3tfm_JEpXklwtc,101774
+demangle/schemes/swift/_punycode.py,sha256=9j9yaydBVnjDvzho1A5TOXMgBZqDVoa0mvBmQCKARH8,4341
+demangle/schemes/swift/nodes.py,sha256=Vb_OtVjpGwl7yWV-NBWbLtq7mJ-Oo91pTRaa0DPowyY,5068
+demangle/schemes/swift/options.py,sha256=UTXZUIJTLrfIhHsceVtNw5BTsK-9ZVqDLyxtlk9Mu9Q,6340
+demangle/schemes/swift/resolve.py,sha256=OPC1Vr-aYwVrq_0M4oEQ_Lcrr4pqHfO7lyExgBF02Rs,26227
+demangle/schemes/swift/symbolic.py,sha256=Cz4hapUn1maZ92AjcrqE5XeAcsS7WCB30C75S1Fcty8,7493
+demangle-0.3.0.dist-info/METADATA,sha256=YpfBP3iUSHFjhabFq1EOcdWMDojMAojsrFY_4EkOHD0,17189
+demangle-0.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+demangle-0.3.0.dist-info/entry_points.txt,sha256=SEc09SLy0tnFqkFudxqACUKuPu2bCnfw2dpk_0Mspi0,47
+demangle-0.3.0.dist-info/licenses/LICENSE,sha256=BiVCDUXWJRpSX7YsgqxkhsUT_tcfVTFmNHHUfiujrh8,1078
+demangle-0.3.0.dist-info/licenses/NOTICE,sha256=cYig6w7q6AXFFJU8s2ClgR3SqYUpN_mmuz3DrAwXfnk,10123
+demangle-0.3.0.dist-info/RECORD,,

demangle-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

demangle-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+demangle = demangle.cli:main