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

diff --git a/argparse/src/help.rs b/argparse/src/help.rs
deleted file mode 100644
index c7145be..0000000
--- a/argparse/src/help.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-use std::str::CharIndices;
-use std::io::Result as IoResult;
-use std::io::Write;
-
-use super::action::{IFlagAction, ParseResult};
-use super::action::ParseResult::Help;
-
-pub struct HelpAction;
-
-impl IFlagAction for HelpAction {
-    fn parse_flag(&self) -> ParseResult {
-        return Help;
-    }
-}
-
-
-struct WordsIter<'a> {
-    data: &'a str,
-    iter: CharIndices<'a>,
-}
-
-impl<'a> WordsIter<'a> {
-    fn new(data: &'a str) -> WordsIter<'a> {
-        return WordsIter {
-            data: data,
-            iter: data.char_indices(),
-            };
-    }
-}
-
-impl<'a> Iterator for WordsIter<'a> {
-    type Item = &'a str;
-    fn next(&mut self) -> Option<&'a str> {
-        let word_start;
-        loop {
-            let (idx, ch) = match self.iter.next() {
-                None => return None,
-                Some((idx, ch)) => ((idx, ch)),
-            };
-            match ch {
-                ' ' | '\t' | '\r' | '\n' => continue,
-                _ => {
-                    word_start = idx;
-                    break;
-                }
-            }
-        }
-        loop {
-            let (idx, ch) = match self.iter.next() {
-                None => break,
-                Some((idx, ch)) => ((idx, ch)),
-            };
-            match ch {
-                ' ' | '\t' | '\r' | '\n' => {
-                    return Some(&self.data[word_start..idx]);
-                }
-                _ => continue,
-            }
-        }
-        return Some(&self.data[word_start..self.data.len()]);
-    }
-}
-
-pub fn wrap_text(buf: &mut Write, data: &str, width: usize, indent: usize)
-    -> IoResult<()>
-{
-    let mut witer = WordsIter::new(data);
-    let mut off = indent;
-    match witer.next() {
-        None => {
-            return Ok(());
-        }
-        Some(word) => {
-            try!(buf.write(word.as_bytes()));
-            off += word.len();
-        }
-    }
-    for word in witer {
-        if off + word.len() + 1 > width {
-            try!(buf.write(b"\n"));
-            for _ in 0..indent {
-                try!(buf.write(b" "));
-            }
-            off = indent;
-        } else {
-            try!(buf.write(b" "));
-            off += 1;
-        }
-        try!(buf.write(word.as_bytes()));
-        off += word.len();
-    }
-    return Ok(());
-}