Struct cpp_demangle::Symbol

source ·

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

Expand description

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§

source §

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

source

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

source

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

source

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

source

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.

source §

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

source

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

source

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