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
sourceimpl<T> Symbol<T> where
T: AsRef<[u8]>,
impl<T> Symbol<T> where
T: AsRef<[u8]>,
sourcepub fn new(raw: T) -> Result<Symbol<T>>
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>)"
);
sourcepub fn new_with_options(raw: T, options: &ParseOptions) -> Result<Symbol<T>>
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>)"
);
sourcepub fn demangle(&self, options: &DemangleOptions) -> Result<String, Error>
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);
sourcepub fn structured_demangle<W: DemangleWrite>(
&self,
out: &mut W,
options: &DemangleOptions
) -> Result
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.
sourceimpl<'a, T> Symbol<&'a T> where
T: AsRef<[u8]> + ?Sized,
impl<'a, T> Symbol<&'a T> where
T: AsRef<[u8]> + ?Sized,
sourcepub fn with_tail(input: &'a T) -> Result<(BorrowedSymbol<'a>, &'a [u8])>
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)");
sourcepub fn with_tail_and_options(
input: &'a T,
options: &ParseOptions
) -> Result<(BorrowedSymbol<'a>, &'a [u8])>
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> StructuralPartialEq for Symbol<T>
Auto Trait Implementations
impl<T> RefUnwindSafe for Symbol<T> where
T: RefUnwindSafe,
impl<T> Send for Symbol<T> where
T: Send,
impl<T> Sync for Symbol<T> where
T: Sync,
impl<T> Unpin for Symbol<T> where
T: Unpin,
impl<T> UnwindSafe for Symbol<T> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more