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, 133 deletions

diff --git a/argparse/src/generic.rs b/argparse/src/generic.rs
deleted file mode 100644
index 1b1b7dc..0000000
--- a/argparse/src/generic.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use std::cell::RefCell;
-use std::str::FromStr;
-use std::rc::Rc;
-
-use super::{StoreConst, Store, StoreOption, List, Collect, PushConst};
-use super::action::Action;
-use super::action::{TypedAction, IFlagAction, IArgAction, IArgsAction};
-use super::action::ParseResult;
-use super::action::ParseResult::{Parsed, Error};
-use super::action::Action::{Flag, Single, Push, Many};
-
-pub struct StoreConstAction<'a, T: 'a> {
-    pub value: T,
-    pub cell: Rc<RefCell<&'a mut T>>,
-}
-
-pub struct PushConstAction<'a, T: 'a> {
-    pub value: T,
-    pub cell: Rc<RefCell<&'a mut Vec<T>>>,
-}
-
-pub struct StoreAction<'a, T: 'a> {
-    pub cell: Rc<RefCell<&'a mut T>>,
-}
-
-pub struct StoreOptionAction<'a, T: 'a> {
-    cell: Rc<RefCell<&'a mut Option<T>>>,
-}
-
-pub struct ListAction<'a, T: 'a> {
-    cell: Rc<RefCell<&'a mut Vec<T>>>,
-}
-
-impl<T: 'static + Clone> TypedAction<T> for StoreConst<T> {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
-        let StoreConst(ref val) = *self;
-        return Flag(Box::new(StoreConstAction { cell: cell, value: val.clone() }));
-    }
-}
-
-impl<T: 'static + Clone> TypedAction<Vec<T>> for PushConst<T> {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        let PushConst(ref val) = *self;
-        return Flag(Box::new(PushConstAction { cell: cell, value: val.clone() }));
-    }
-}
-
-impl<T: 'static + FromStr> TypedAction<T> for Store {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
-        return Single(Box::new(StoreAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromStr> TypedAction<Option<T>> for StoreOption {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Option<T>>>) -> Action<'x> {
-        return Single(Box::new(StoreOptionAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromStr + Clone> TypedAction<Vec<T>> for List {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        return Many(Box::new(ListAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromStr + Clone> TypedAction<Vec<T>> for Collect {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        return Push(Box::new(ListAction { cell: cell }));
-    }
-}
-
-impl<'a, T: Clone> IFlagAction for StoreConstAction<'a, T> {
-    fn parse_flag(&self) -> ParseResult {
-        let mut targ = self.cell.borrow_mut();
-        **targ = self.value.clone();
-        return Parsed;
-    }
-}
-
-impl<'a, T: Clone> IFlagAction for PushConstAction<'a, T> {
-    fn parse_flag(&self) -> ParseResult {
-        let mut targ = self.cell.borrow_mut();
-        targ.push(self.value.clone());
-        return Parsed;
-    }
-}
-
-impl<'a, T: FromStr> IArgAction for StoreAction<'a, T> {
-    fn parse_arg(&self, arg: &str) -> ParseResult {
-        match FromStr::from_str(arg) {
-            Ok(x) => {
-                **self.cell.borrow_mut() = x;
-                return Parsed;
-            }
-            Err(_) => {
-                return Error(format!("Bad value {}", arg));
-            }
-        }
-    }
-}
-
-impl<'a, T: FromStr> IArgAction for StoreOptionAction<'a, T> {
-    fn parse_arg(&self, arg: &str) -> ParseResult {
-        match FromStr::from_str(arg) {
-            Ok(x) => {
-                **self.cell.borrow_mut() = Some(x);
-                return Parsed;
-            }
-            Err(_) => {
-                return Error(format!("Bad value {}", arg));
-            }
-        }
-    }
-}
-
-impl<'a, T: FromStr + Clone> IArgsAction for ListAction<'a, T> {
-    fn parse_args(&self, args: &[&str]) -> ParseResult {
-        let mut result = vec!();
-        for arg in args.iter() {
-            match FromStr::from_str(*arg) {
-                Ok(x) => {
-                    result.push(x);
-                }
-                Err(_) => {
-                    return Error(format!("Bad value {}", arg));
-                }
-            }
-        }
-        **self.cell.borrow_mut() = result;
-        return Parsed;
-    }
-}
-