Struct gimli::read::EndianSlice

pub struct EndianSlice<'input, Endian> where
    Endian: Endianity,  { /* fields omitted */ }

A &[u8] slice with endianity metadata.

This implements the Reader trait, which is used for all reading of DWARF sections.

Implementations

impl<'input, Endian> EndianSlice<'input, Endian> where
    Endian: Endianity, 

pub fn new(slice: &'input [u8], endian: Endian) -> EndianSlice<'input, Endian>

Construct a new EndianSlice with the given slice and endianity.

pub fn slice(&self) -> &'input [u8]

Return a reference to the raw slice.

pub fn split_at(
    &self,
    idx: usize
) -> (EndianSlice<'input, Endian>, EndianSlice<'input, Endian>)

Split the slice in two at the given index, resulting in the tuple where the first item has range [0, idx), and the second has range [idx, len). Panics if the index is out of bounds.

pub fn find(&self, byte: u8) -> Option<usize>

Find the first occurence of a byte in the slice, and return its index.

pub fn offset_from(&self, base: EndianSlice<'input, Endian>) -> usize

Return the offset of the start of the slice relative to the start of the given slice.

pub fn to_string(&self) -> Result<&'input str>

Converts the slice to a string using str::from_utf8.

Returns an error if the slice contains invalid characters.

pub fn to_string_lossy(&self) -> Cow<'input, str>

Converts the slice to a string, including invalid characters, using String::from_utf8_lossy.

impl<'input, Endian> EndianSlice<'input, Endian> where
    Endian: Endianity, 

Range Methods

Unfortunately, std::ops::Index must return a reference, so we can't implement Index<Range<usize>> to return a new EndianSlice the way we would like to. Instead, we abandon fancy indexing operators and have these plain old methods.

pub fn range(&self, idx: Range<usize>) -> EndianSlice<'input, Endian>

Take the given start..end range of the underlying slice and return a new EndianSlice.

use gimli::{EndianSlice, LittleEndian};

let slice = &[0x01, 0x02, 0x03, 0x04];
let endian_slice = EndianSlice::new(slice, LittleEndian);
assert_eq!(endian_slice.range(1..3),
           EndianSlice::new(&slice[1..3], LittleEndian));

pub fn range_from(&self, idx: RangeFrom<usize>) -> EndianSlice<'input, Endian>

Take the given start.. range of the underlying slice and return a new EndianSlice.

use gimli::{EndianSlice, LittleEndian};

let slice = &[0x01, 0x02, 0x03, 0x04];
let endian_slice = EndianSlice::new(slice, LittleEndian);
assert_eq!(endian_slice.range_from(2..),
           EndianSlice::new(&slice[2..], LittleEndian));

pub fn range_to(&self, idx: RangeTo<usize>) -> EndianSlice<'input, Endian>

Take the given ..end range of the underlying slice and return a new EndianSlice.

use gimli::{EndianSlice, LittleEndian};

let slice = &[0x01, 0x02, 0x03, 0x04];
let endian_slice = EndianSlice::new(slice, LittleEndian);
assert_eq!(endian_slice.range_to(..3),
           EndianSlice::new(&slice[..3], LittleEndian));

Trait Implementations

impl<'input, Endian: Clone> Clone for EndianSlice<'input, Endian> where
    Endian: Endianity, 

fn clone(&self) -> EndianSlice<'input, Endian>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'input, Endian: Copy> Copy for EndianSlice<'input, Endian> where
    Endian: Endianity, 

impl<'input, Endian: Debug> Debug for EndianSlice<'input, Endian> where
    Endian: Endianity, 

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

Formats the value using the given formatter.

impl<'input, Endian: Default> Default for EndianSlice<'input, Endian> where
    Endian: Endianity, 

fn default() -> EndianSlice<'input, Endian>

Returns the "default value" for a type.

impl<'input, Endian> Deref for EndianSlice<'input, Endian> where
    Endian: Endianity, 

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'input, Endian: Eq> Eq for EndianSlice<'input, Endian> where
    Endian: Endianity, 

impl<'input, Endian: Hash> Hash for EndianSlice<'input, Endian> where
    Endian: Endianity, 

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<'input, Endian> Index<RangeFrom<usize>> for EndianSlice<'input, Endian> where
    Endian: Endianity, 

type Output = [u8]

The returned type after indexing.

fn index(&self, idx: RangeFrom<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'input, Endian> Index<usize> for EndianSlice<'input, Endian> where
    Endian: Endianity, 

type Output = u8

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'input, Endian> Into<&'input [u8]> for EndianSlice<'input, Endian> where
    Endian: Endianity, 

fn into(self) -> &'input [u8]

Performs the conversion.

impl<'input, Endian: PartialEq> PartialEq<EndianSlice<'input, Endian>> for EndianSlice<'input, Endian> where
    Endian: Endianity, 

fn eq(&self, other: &EndianSlice<'input, Endian>) -> bool

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

fn ne(&self, other: &EndianSlice<'input, Endian>) -> bool

This method tests for !=.

impl<'input, Endian> Reader for EndianSlice<'input, Endian> where
    Endian: Endianity, 

type Endian = Endian

The endianity of bytes that are read.

type Offset = usize

The type used for offsets and lengths.

fn endian(&self) -> Endian

Return the endianity of bytes that are read.

fn len(&self) -> usize

Return the number of bytes remaining.

fn is_empty(&self) -> bool

Return true if the number of bytes remaining is zero.

fn empty(&mut self)

Set the number of bytes remaining to zero.

fn truncate(&mut self, len: usize) -> Result<()>

Set the number of bytes remaining to the specified length.

fn offset_from(&self, base: &Self) -> usize

Return the offset of this reader's data relative to the start of the given base reader's data.

fn offset_id(&self) -> ReaderOffsetId

Return an identifier for the current reader offset.

fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<Self::Offset>

Return the offset corresponding to the given id if it is associated with this reader.

fn find(&self, byte: u8) -> Result<usize>

Find the index of the first occurence of the given byte. The offset of the reader is not changed.

fn skip(&mut self, len: usize) -> Result<()>

Discard the specified number of bytes.

fn split(&mut self, len: usize) -> Result<Self>

Split a reader in two.

fn to_slice(&self) -> Result<Cow<[u8]>>

Return all remaining data as a clone-on-write slice.

fn to_string(&self) -> Result<Cow<str>>

Convert all remaining data to a clone-on-write string.

fn to_string_lossy(&self) -> Result<Cow<str>>

Convert all remaining data to a clone-on-write string, including invalid characters.

fn read_slice(&mut self, buf: &mut [u8]) -> Result<()>

Read exactly buf.len() bytes into buf.

fn read_u8_array<A>(&mut self) -> Result<A> where
    A: Sized + Default + AsMut<[u8]>, 

Read a u8 array.

fn read_u8(&mut self) -> Result<u8>

Read a u8.

fn read_i8(&mut self) -> Result<i8>

Read an i8.

fn read_u16(&mut self) -> Result<u16>

Read a u16.

fn read_i16(&mut self) -> Result<i16>

Read an i16.

fn read_u32(&mut self) -> Result<u32>

Read a u32.

fn read_i32(&mut self) -> Result<i32>

Read an i32.

fn read_u64(&mut self) -> Result<u64>

Read a u64.

fn read_i64(&mut self) -> Result<i64>

Read an i64.

fn read_f32(&mut self) -> Result<f32>

Read a f32.

fn read_f64(&mut self) -> Result<f64>

Read a f64.

fn read_uint(&mut self, n: usize) -> Result<u64>

Read an unsigned n-bytes integer u64.

fn read_null_terminated_slice(&mut self) -> Result<Self>

Read a null-terminated slice, and return it (excluding the null).

fn read_uleb128(&mut self) -> Result<u64>

Read an unsigned LEB128 encoded integer.

fn read_uleb128_u16(&mut self) -> Result<u16>

Read an unsigned LEB128 encoded u16.

fn read_sleb128(&mut self) -> Result<i64>

Read a signed LEB128 encoded integer.

fn read_initial_length(&mut self) -> Result<(Self::Offset, Format)>

Read an initial length field.

fn read_address(&mut self, address_size: u8) -> Result<u64>

Read an address-sized integer, and return it as a u64.

fn read_word(&mut self, format: Format) -> Result<Self::Offset>

Parse a word-sized integer according to the DWARF format.

fn read_length(&mut self, format: Format) -> Result<Self::Offset>

Parse a word-sized section length according to the DWARF format.

fn read_offset(&mut self, format: Format) -> Result<Self::Offset>

Parse a word-sized section offset according to the DWARF format.

fn read_sized_offset(&mut self, size: u8) -> Result<Self::Offset>

Parse a section offset of the given size.

impl<'input, Endian> StructuralEq for EndianSlice<'input, Endian> where
    Endian: Endianity, 

impl<'input, Endian> StructuralPartialEq for EndianSlice<'input, Endian> where
    Endian: Endianity,