Struct cpp_demangle::Symbol

pub struct Symbol<T> { /* private fields */ }

A mangled symbol that has been parsed into an AST.

This is generic over some storage type T which can be either owned or borrowed. See the OwnedSymbol and BorrowedSymbol type aliases.

Implementations

impl<T> Symbol<T>where T: AsRef<[u8]>,

pub fn new(raw: T) -> Result<Symbol<T>>

Given some raw storage, parse the mangled symbol from it with the default options.

use cpp_demangle::Symbol;
use std::string::ToString;

// First, something easy :)

let mangled = b"_ZN5space3fooEibc";

let sym = Symbol::new(&mangled[..])
    .expect("Could not parse mangled symbol!");

let demangled = sym.to_string();
assert_eq!(demangled, "space::foo(int, bool, char)");

// Now let's try something a little more complicated!

let mangled =
    b"__Z28JS_GetPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_18PropertyDescriptorEEE";

let sym = Symbol::new(&mangled[..])
    .expect("Could not parse mangled symbol!");

let demangled = sym.to_string();
assert_eq!(
    demangled,
    "JS_GetPropertyDescriptorById(JSContext*, JS::Handle<JSObject*>, JS::Handle<jsid>, JS::MutableHandle<JS::PropertyDescriptor>)"
);

pub fn new_with_options(raw: T, options: &ParseOptions) -> Result<Symbol<T>>

Given some raw storage, parse the mangled symbol from it.

use cpp_demangle::{ParseOptions, Symbol};
use std::string::ToString;

// First, something easy :)

let mangled = b"_ZN5space3fooEibc";

let parse_options = ParseOptions::default()
    .recursion_limit(1024);

let sym = Symbol::new_with_options(&mangled[..], &parse_options)
    .expect("Could not parse mangled symbol!");

let demangled = sym.to_string();
assert_eq!(demangled, "space::foo(int, bool, char)");

// Now let's try something a little more complicated!

let mangled =
    b"__Z28JS_GetPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_18PropertyDescriptorEEE";

let sym = Symbol::new(&mangled[..])
    .expect("Could not parse mangled symbol!");

let demangled = sym.to_string();
assert_eq!(
    demangled,
    "JS_GetPropertyDescriptorById(JSContext*, JS::Handle<JSObject*>, JS::Handle<jsid>, JS::MutableHandle<JS::PropertyDescriptor>)"
);

pub fn demangle(&self, options: &DemangleOptions) -> Result<String, Error>

Demangle the symbol and return it as a String.

Unlike the ToString implementation, this function allows options to be specified.

use cpp_demangle::{DemangleOptions, Symbol};
use std::string::ToString;

let mangled = b"_ZN5space3fooEibc";

let sym = Symbol::new(&mangled[..])
    .expect("Could not parse mangled symbol!");

let demangled = sym.to_string();
let options = DemangleOptions::default();
let demangled_again = sym.demangle(&options).unwrap();
assert_eq!(demangled_again, demangled);

pub fn structured_demangle<W: DemangleWrite>( &self, out: &mut W, options: &DemangleOptions ) -> Result

Demangle the symbol to a DemangleWrite, which lets the consumer be informed about syntactic structure.

impl<'a, T> Symbol<&'a T>where T: AsRef<[u8]> + ?Sized,

pub fn with_tail(input: &'a T) -> Result<(BorrowedSymbol<'a>, &'a [u8])>

Parse a mangled symbol from input and return it and the trailing tail of bytes that come after the symbol, with the default options.

While Symbol::new will return an error if there is unexpected trailing bytes, with_tail simply returns the trailing bytes along with the parsed symbol.

use cpp_demangle::BorrowedSymbol;
use std::string::ToString;

let mangled = b"_ZN5space3fooEibc and some trailing junk";

let (sym, tail) = BorrowedSymbol::with_tail(&mangled[..])
    .expect("Could not parse mangled symbol!");

assert_eq!(tail, b" and some trailing junk");

let demangled = sym.to_string();
assert_eq!(demangled, "space::foo(int, bool, char)");

pub fn with_tail_and_options( input: &'a T, options: &ParseOptions ) -> Result<(BorrowedSymbol<'a>, &'a [u8])>

Parse a mangled symbol from input and return it and the trailing tail of bytes that come after the symbol.

While Symbol::new_with_options will return an error if there is unexpected trailing bytes, with_tail_and_options simply returns the trailing bytes along with the parsed symbol.

use cpp_demangle::{BorrowedSymbol, ParseOptions};
use std::string::ToString;

let mangled = b"_ZN5space3fooEibc and some trailing junk";

let parse_options = ParseOptions::default()
    .recursion_limit(1024);

let (sym, tail) = BorrowedSymbol::with_tail_and_options(&mangled[..], &parse_options)
    .expect("Could not parse mangled symbol!");

assert_eq!(tail, b" and some trailing junk");

let demangled = sym.to_string();
assert_eq!(demangled, "space::foo(int, bool, char)");

Trait Implementations

impl<T: Clone> Clone for Symbol<T>

fn clone(&self) -> Symbol<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Symbol<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Display for Symbol<T>where T: AsRef<[u8]>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq<Symbol<T>> for Symbol<T>

fn eq(&self, other: &Symbol<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for Symbol<T>