Deleted vendor folder

1 files changed, 0 insertions, 612 deletions

diff --git a/vendor/gimli/src/leb128.rs b/vendor/gimli/src/leb128.rs
deleted file mode 100644
index de81cfd..0000000
--- a/vendor/gimli/src/leb128.rs
+++ /dev/null
@@ -1,612 +0,0 @@
-//! Read and write DWARF's "Little Endian Base 128" (LEB128) variable length
-//! integer encoding.
-//!
-//! The implementation is a direct translation of the psuedocode in the DWARF 4
-//! standard's appendix C.
-//!
-//! Read and write signed integers:
-//!
-//! ```
-//! # #[cfg(all(feature = "read", feature = "write"))] {
-//! use gimli::{EndianSlice, NativeEndian, leb128};
-//!
-//! let mut buf = [0; 1024];
-//!
-//! // Write to anything that implements `std::io::Write`.
-//! {
-//!     let mut writable = &mut buf[..];
-//!     leb128::write::signed(&mut writable, -12345).expect("Should write number");
-//! }
-//!
-//! // Read from anything that implements `gimli::Reader`.
-//! let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-//! let val = leb128::read::signed(&mut readable).expect("Should read number");
-//! assert_eq!(val, -12345);
-//! # }
-//! ```
-//!
-//! Or read and write unsigned integers:
-//!
-//! ```
-//! # #[cfg(all(feature = "read", feature = "write"))] {
-//! use gimli::{EndianSlice, NativeEndian, leb128};
-//!
-//! let mut buf = [0; 1024];
-//!
-//! {
-//!     let mut writable = &mut buf[..];
-//!     leb128::write::unsigned(&mut writable, 98765).expect("Should write number");
-//! }
-//!
-//! let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-//! let val = leb128::read::unsigned(&mut readable).expect("Should read number");
-//! assert_eq!(val, 98765);
-//! # }
-//! ```
-
-const CONTINUATION_BIT: u8 = 1 << 7;
-#[cfg(feature = "read-core")]
-const SIGN_BIT: u8 = 1 << 6;
-
-#[inline]
-fn low_bits_of_byte(byte: u8) -> u8 {
-    byte & !CONTINUATION_BIT
-}
-
-#[inline]
-#[allow(dead_code)]
-fn low_bits_of_u64(val: u64) -> u8 {
-    let byte = val & u64::from(core::u8::MAX);
-    low_bits_of_byte(byte as u8)
-}
-
-/// A module for reading signed and unsigned integers that have been LEB128
-/// encoded.
-#[cfg(feature = "read-core")]
-pub mod read {
-    use super::{low_bits_of_byte, CONTINUATION_BIT, SIGN_BIT};
-    use crate::read::{Error, Reader, Result};
-
-    /// Read bytes until the LEB128 continuation bit is not set.
-    pub fn skip<R: Reader>(r: &mut R) -> Result<()> {
-        loop {
-            let byte = r.read_u8()?;
-            if byte & CONTINUATION_BIT == 0 {
-                return Ok(());
-            }
-        }
-    }
-
-    /// Read an unsigned LEB128 number from the given `Reader` and
-    /// return it or an error if reading failed.
-    pub fn unsigned<R: Reader>(r: &mut R) -> Result<u64> {
-        let mut result = 0;
-        let mut shift = 0;
-
-        loop {
-            let byte = r.read_u8()?;
-            if shift == 63 && byte != 0x00 && byte != 0x01 {
-                return Err(Error::BadUnsignedLeb128);
-            }
-
-            let low_bits = u64::from(low_bits_of_byte(byte));
-            result |= low_bits << shift;
-
-            if byte & CONTINUATION_BIT == 0 {
-                return Ok(result);
-            }
-
-            shift += 7;
-        }
-    }
-
-    /// Read an LEB128 u16 from the given `Reader` and
-    /// return it or an error if reading failed.
-    pub fn u16<R: Reader>(r: &mut R) -> Result<u16> {
-        let byte = r.read_u8()?;
-        let mut result = u16::from(low_bits_of_byte(byte));
-        if byte & CONTINUATION_BIT == 0 {
-            return Ok(result);
-        }
-
-        let byte = r.read_u8()?;
-        result |= u16::from(low_bits_of_byte(byte)) << 7;
-        if byte & CONTINUATION_BIT == 0 {
-            return Ok(result);
-        }
-
-        let byte = r.read_u8()?;
-        if byte > 0x03 {
-            return Err(Error::BadUnsignedLeb128);
-        }
-        result += u16::from(byte) << 14;
-        Ok(result)
-    }
-
-    /// Read a signed LEB128 number from the given `Reader` and
-    /// return it or an error if reading failed.
-    pub fn signed<R: Reader>(r: &mut R) -> Result<i64> {
-        let mut result = 0;
-        let mut shift = 0;
-        let size = 64;
-        let mut byte;
-
-        loop {
-            byte = r.read_u8()?;
-            if shift == 63 && byte != 0x00 && byte != 0x7f {
-                return Err(Error::BadSignedLeb128);
-            }
-
-            let low_bits = i64::from(low_bits_of_byte(byte));
-            result |= low_bits << shift;
-            shift += 7;
-
-            if byte & CONTINUATION_BIT == 0 {
-                break;
-            }
-        }
-
-        if shift < size && (SIGN_BIT & byte) == SIGN_BIT {
-            // Sign extend the result.
-            result |= !0 << shift;
-        }
-
-        Ok(result)
-    }
-}
-
-/// A module for writing integers encoded as LEB128.
-#[cfg(feature = "write")]
-pub mod write {
-    use super::{low_bits_of_u64, CONTINUATION_BIT};
-    use std::io;
-
-    /// Write the given unsigned number using the LEB128 encoding to the given
-    /// `std::io::Write`able. Returns the number of bytes written to `w`, or an
-    /// error if writing failed.
-    pub fn unsigned<W>(w: &mut W, mut val: u64) -> Result<usize, io::Error>
-    where
-        W: io::Write,
-    {
-        let mut bytes_written = 0;
-        loop {
-            let mut byte = low_bits_of_u64(val);
-            val >>= 7;
-            if val != 0 {
-                // More bytes to come, so set the continuation bit.
-                byte |= CONTINUATION_BIT;
-            }
-
-            let buf = [byte];
-            w.write_all(&buf)?;
-            bytes_written += 1;
-
-            if val == 0 {
-                return Ok(bytes_written);
-            }
-        }
-    }
-
-    /// Return the size of the LEB128 encoding of the given unsigned number.
-    pub fn uleb128_size(mut val: u64) -> usize {
-        let mut size = 0;
-        loop {
-            val >>= 7;
-            size += 1;
-            if val == 0 {
-                return size;
-            }
-        }
-    }
-
-    /// Write the given signed number using the LEB128 encoding to the given
-    /// `std::io::Write`able. Returns the number of bytes written to `w`, or an
-    /// error if writing failed.
-    pub fn signed<W>(w: &mut W, mut val: i64) -> Result<usize, io::Error>
-    where
-        W: io::Write,
-    {
-        let mut bytes_written = 0;
-        loop {
-            let mut byte = val as u8;
-            // Keep the sign bit for testing
-            val >>= 6;
-            let done = val == 0 || val == -1;
-            if done {
-                byte &= !CONTINUATION_BIT;
-            } else {
-                // Remove the sign bit
-                val >>= 1;
-                // More bytes to come, so set the continuation bit.
-                byte |= CONTINUATION_BIT;
-            }
-
-            let buf = [byte];
-            w.write_all(&buf)?;
-            bytes_written += 1;
-
-            if done {
-                return Ok(bytes_written);
-            }
-        }
-    }
-
-    /// Return the size of the LEB128 encoding of the given signed number.
-    pub fn sleb128_size(mut val: i64) -> usize {
-        let mut size = 0;
-        loop {
-            val >>= 6;
-            let done = val == 0 || val == -1;
-            val >>= 1;
-            size += 1;
-            if done {
-                return size;
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-#[cfg(all(feature = "read", feature = "write"))]
-mod tests {
-    use super::{low_bits_of_byte, low_bits_of_u64, read, write, CONTINUATION_BIT};
-    use crate::endianity::NativeEndian;
-    use crate::read::{EndianSlice, Error, ReaderOffsetId};
-
-    trait ResultExt {
-        fn map_eof(self, input: &[u8]) -> Self;
-    }
-
-    impl<T> ResultExt for Result<T, Error> {
-        fn map_eof(self, input: &[u8]) -> Self {
-            match self {
-                Err(Error::UnexpectedEof(id)) => {
-                    let id = ReaderOffsetId(id.0 - input.as_ptr() as u64);
-                    Err(Error::UnexpectedEof(id))
-                }
-                r => r,
-            }
-        }
-    }
-
-    #[test]
-    fn test_low_bits_of_byte() {
-        for i in 0..127 {
-            assert_eq!(i, low_bits_of_byte(i));
-            assert_eq!(i, low_bits_of_byte(i | CONTINUATION_BIT));
-        }
-    }
-
-    #[test]
-    fn test_low_bits_of_u64() {
-        for i in 0u64..127 {
-            assert_eq!(i as u8, low_bits_of_u64(1 << 16 | i));
-            assert_eq!(
-                i as u8,
-                low_bits_of_u64(i << 16 | i | (u64::from(CONTINUATION_BIT)))
-            );
-        }
-    }
-
-    // Examples from the DWARF 4 standard, section 7.6, figure 22.
-    #[test]
-    fn test_read_unsigned() {
-        let buf = [2u8];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            2,
-            read::unsigned(&mut readable).expect("Should read number")
-        );
-
-        let buf = [127u8];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            127,
-            read::unsigned(&mut readable).expect("Should read number")
-        );
-
-        let buf = [CONTINUATION_BIT, 1];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            128,
-            read::unsigned(&mut readable).expect("Should read number")
-        );
-
-        let buf = [1u8 | CONTINUATION_BIT, 1];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            129,
-            read::unsigned(&mut readable).expect("Should read number")
-        );
-
-        let buf = [2u8 | CONTINUATION_BIT, 1];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            130,
-            read::unsigned(&mut readable).expect("Should read number")
-        );
-
-        let buf = [57u8 | CONTINUATION_BIT, 100];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            12857,
-            read::unsigned(&mut readable).expect("Should read number")
-        );
-    }
-
-    // Examples from the DWARF 4 standard, section 7.6, figure 23.
-    #[test]
-    fn test_read_signed() {
-        let buf = [2u8];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(2, read::signed(&mut readable).expect("Should read number"));
-
-        let buf = [0x7eu8];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(-2, read::signed(&mut readable).expect("Should read number"));
-
-        let buf = [127u8 | CONTINUATION_BIT, 0];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            127,
-            read::signed(&mut readable).expect("Should read number")
-        );
-
-        let buf = [1u8 | CONTINUATION_BIT, 0x7f];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            -127,
-            read::signed(&mut readable).expect("Should read number")
-        );
-
-        let buf = [CONTINUATION_BIT, 1];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            128,
-            read::signed(&mut readable).expect("Should read number")
-        );
-
-        let buf = [CONTINUATION_BIT, 0x7f];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            -128,
-            read::signed(&mut readable).expect("Should read number")
-        );
-
-        let buf = [1u8 | CONTINUATION_BIT, 1];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            129,
-            read::signed(&mut readable).expect("Should read number")
-        );
-
-        let buf = [0x7fu8 | CONTINUATION_BIT, 0x7e];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            -129,
-            read::signed(&mut readable).expect("Should read number")
-        );
-    }
-
-    #[test]
-    fn test_read_signed_63_bits() {
-        let buf = [
-            CONTINUATION_BIT,
-            CONTINUATION_BIT,
-            CONTINUATION_BIT,
-            CONTINUATION_BIT,
-            CONTINUATION_BIT,
-            CONTINUATION_BIT,
-            CONTINUATION_BIT,
-            CONTINUATION_BIT,
-            0x40,
-        ];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            -0x4000_0000_0000_0000,
-            read::signed(&mut readable).expect("Should read number")
-        );
-    }
-
-    #[test]
-    fn test_read_unsigned_not_enough_data() {
-        let buf = [CONTINUATION_BIT];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            read::unsigned(&mut readable).map_eof(&buf),
-            Err(Error::UnexpectedEof(ReaderOffsetId(1)))
-        );
-    }
-
-    #[test]
-    fn test_read_signed_not_enough_data() {
-        let buf = [CONTINUATION_BIT];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            read::signed(&mut readable).map_eof(&buf),
-            Err(Error::UnexpectedEof(ReaderOffsetId(1)))
-        );
-    }
-
-    #[test]
-    fn test_write_unsigned_not_enough_space() {
-        let mut buf = [0; 1];
-        let mut writable = &mut buf[..];
-        match write::unsigned(&mut writable, 128) {
-            Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::WriteZero),
-            otherwise => panic!("Unexpected: {:?}", otherwise),
-        }
-    }
-
-    #[test]
-    fn test_write_signed_not_enough_space() {
-        let mut buf = [0; 1];
-        let mut writable = &mut buf[..];
-        match write::signed(&mut writable, 128) {
-            Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::WriteZero),
-            otherwise => panic!("Unexpected: {:?}", otherwise),
-        }
-    }
-
-    #[test]
-    fn dogfood_signed() {
-        fn inner(i: i64) {
-            let mut buf = [0u8; 1024];
-
-            {
-                let mut writable = &mut buf[..];
-                write::signed(&mut writable, i).expect("Should write signed number");
-            }
-
-            let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-            let result = read::signed(&mut readable).expect("Should be able to read it back again");
-            assert_eq!(i, result);
-        }
-        for i in -513..513 {
-            inner(i);
-        }
-        inner(core::i64::MIN);
-    }
-
-    #[test]
-    fn dogfood_unsigned() {
-        for i in 0..1025 {
-            let mut buf = [0u8; 1024];
-
-            {
-                let mut writable = &mut buf[..];
-                write::unsigned(&mut writable, i).expect("Should write signed number");
-            }
-
-            let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-            let result =
-                read::unsigned(&mut readable).expect("Should be able to read it back again");
-            assert_eq!(i, result);
-        }
-    }
-
-    #[test]
-    fn test_read_unsigned_overflow() {
-        let buf = [
-            2u8 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            1,
-        ];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert!(read::unsigned(&mut readable).is_err());
-    }
-
-    #[test]
-    fn test_read_signed_overflow() {
-        let buf = [
-            2u8 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            2 | CONTINUATION_BIT,
-            1,
-        ];
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert!(read::signed(&mut readable).is_err());
-    }
-
-    #[test]
-    fn test_read_multiple() {
-        let buf = [2u8 | CONTINUATION_BIT, 1u8, 1u8];
-
-        let mut readable = EndianSlice::new(&buf[..], NativeEndian);
-        assert_eq!(
-            read::unsigned(&mut readable).expect("Should read first number"),
-            130u64
-        );
-        assert_eq!(
-            read::unsigned(&mut readable).expect("Should read first number"),
-            1u64
-        );
-    }
-
-    #[test]
-    fn test_read_u16() {
-        for (buf, val) in [
-            (&[2][..], 2),
-            (&[0x7f][..], 0x7f),
-            (&[0x80, 1][..], 0x80),
-            (&[0x81, 1][..], 0x81),
-            (&[0x82, 1][..], 0x82),
-            (&[0xff, 0x7f][..], 0x3fff),
-            (&[0x80, 0x80, 1][..], 0x4000),
-            (&[0xff, 0xff, 1][..], 0x7fff),
-            (&[0xff, 0xff, 3][..], 0xffff),
-        ]
-        .iter()
-        {
-            let mut readable = EndianSlice::new(buf, NativeEndian);
-            assert_eq!(*val, read::u16(&mut readable).expect("Should read number"));
-        }
-
-        for buf in [
-            &[0x80][..],
-            &[0x80, 0x80][..],
-            &[0x80, 0x80, 4][..],
-            &[0x80, 0x80, 0x80, 3][..],
-        ]
-        .iter()
-        {
-            let mut readable = EndianSlice::new(buf, NativeEndian);
-            assert!(read::u16(&mut readable).is_err(), "{:?}", buf);
-        }
-    }
-}