Remove vendored dependencies

While it appears that by now we actually can get successful builds
without Cargo insisting on Internet access by virtue of using the
--frozen flag, maintaining vendored dependencies is somewhat of a pain
point. This state will also get worse with upcoming changes that replace
argparse in favor of structopt and pull in a slew of new dependencies by
doing so. Then there is also the repository structure aspect, which is
non-standard due to the way we vendor dependencies and a potential
source of confusion.
In order to fix these problems, this change removes all the vendored
dependencies we have.

Delete subrepo argparse/:argparse
Delete subrepo base32/:base32
Delete subrepo cc/:cc
Delete subrepo cfg-if/:cfg-if
Delete subrepo getrandom/:getrandom
Delete subrepo lazy-static/:lazy-static
Delete subrepo libc/:libc
Delete subrepo nitrokey-sys/:nitrokey-sys
Delete subrepo nitrokey/:nitrokey
Delete subrepo rand/:rand

1 files changed, 0 insertions, 136 deletions

diff --git a/rand/rand_isaac/src/isaac_array.rs b/rand/rand_isaac/src/isaac_array.rs
deleted file mode 100644
index cbe4a59..0000000
--- a/rand/rand_isaac/src/isaac_array.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2018 Developers of the Rand project.
-// Copyright 2017-2018 The Rust Project Developers.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! ISAAC helper functions for 256-element arrays.
-
-// Terrible workaround because arrays with more than 32 elements do not
-// implement `AsRef`, `Default`, `Serialize`, `Deserialize`, or any other
-// traits for that matter.
-
-#[cfg(feature="serde")] use serde::{Serialize, Deserialize};
-
-const RAND_SIZE_LEN: usize = 8;
-const RAND_SIZE: usize = 1 << RAND_SIZE_LEN;
-
-
-#[derive(Copy, Clone)]
-#[allow(missing_debug_implementations)]
-#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
-pub struct IsaacArray<T> {
-    #[cfg_attr(feature="serde",serde(with="isaac_array_serde"))]
-    #[cfg_attr(feature="serde", serde(bound(
-        serialize = "T: Serialize",
-        deserialize = "T: Deserialize<'de> + Copy + Default")))]
-    inner: [T; RAND_SIZE]
-}
-
-impl<T> ::core::convert::AsRef<[T]> for IsaacArray<T> {
-    #[inline(always)]
-    fn as_ref(&self) -> &[T] {
-        &self.inner[..]
-    }
-}
-
-impl<T> ::core::convert::AsMut<[T]> for IsaacArray<T> {
-    #[inline(always)]
-    fn as_mut(&mut self) -> &mut [T] {
-        &mut self.inner[..]
-    }
-}
-
-impl<T> ::core::ops::Deref for IsaacArray<T> {
-    type Target = [T; RAND_SIZE];
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<T> ::core::ops::DerefMut for IsaacArray<T> {
-    #[inline(always)]
-    fn deref_mut(&mut self) -> &mut [T; RAND_SIZE] {
-        &mut self.inner
-    }
-}
-
-impl<T> ::core::default::Default for IsaacArray<T> where T: Copy + Default {
-    fn default() -> IsaacArray<T> {
-        IsaacArray { inner: [T::default(); RAND_SIZE] }
-    }
-}
-
-
-#[cfg(feature="serde")]
-pub(super) mod isaac_array_serde {
-    const RAND_SIZE_LEN: usize = 8;
-    const RAND_SIZE: usize = 1 << RAND_SIZE_LEN;
-
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-    use serde::de::{Visitor,SeqAccess};
-    use serde::de;
-
-    use core::fmt;
-
-    pub fn serialize<T, S>(arr: &[T;RAND_SIZE], ser: S) -> Result<S::Ok, S::Error>
-    where
-        T: Serialize,
-        S: Serializer
-    {
-        use serde::ser::SerializeTuple;
-
-        let mut seq = ser.serialize_tuple(RAND_SIZE)?;
-
-        for e in arr.iter() {
-            seq.serialize_element(&e)?;
-        }
-
-        seq.end()
-    }
-
-    #[inline]
-    pub fn deserialize<'de, T, D>(de: D) -> Result<[T;RAND_SIZE], D::Error>
-    where
-        T: Deserialize<'de>+Default+Copy,
-        D: Deserializer<'de>,
-    {
-        use core::marker::PhantomData;
-        struct ArrayVisitor<T> {
-            _pd: PhantomData<T>,
-        };
-        impl<'de,T> Visitor<'de> for ArrayVisitor<T>
-        where
-            T: Deserialize<'de>+Default+Copy
-        {
-            type Value = [T; RAND_SIZE];
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("Isaac state array")
-            }
-
-            #[inline]
-            fn visit_seq<A>(self, mut seq: A) -> Result<[T; RAND_SIZE], A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let mut out = [Default::default();RAND_SIZE];
-
-                for i in 0..RAND_SIZE {
-                    match seq.next_element()? {
-                        Some(val) => out[i] = val,
-                        None => return Err(de::Error::invalid_length(i, &self)),
-                    };
-                }
-
-                Ok(out)
-            }
-        }
-
-        de.deserialize_tuple(RAND_SIZE, ArrayVisitor{_pd: PhantomData})
-    }
-}