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

2 files changed, 0 insertions, 160 deletions

diff --git a/rand/examples/monte-carlo.rs b/rand/examples/monte-carlo.rs
deleted file mode 100644
index 39c779f..0000000
--- a/rand/examples/monte-carlo.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2018 Developers of the Rand project.
-// Copyright 2013-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.
-
-//! # Monte Carlo estimation of π
-//!
-//! Imagine that we have a square with sides of length 2 and a unit circle
-//! (radius = 1), both centered at the origin. The areas are:
-//!
-//! ```text
-//!     area of circle  = πr² = π * r * r = π
-//!     area of square  = 2² = 4
-//! ```
-//!
-//! The circle is entirely within the square, so if we sample many points
-//! randomly from the square, roughly π / 4 of them should be inside the circle.
-//!
-//! We can use the above fact to estimate the value of π: pick many points in
-//! the square at random, calculate the fraction that fall within the circle,
-//! and multiply this fraction by 4.
-
-#![cfg(feature = "std")]
-
-use rand::distributions::{Distribution, Uniform};
-
-fn main() {
-    let range = Uniform::new(-1.0f64, 1.0);
-    let mut rng = rand::thread_rng();
-
-    let total = 1_000_000;
-    let mut in_circle = 0;
-
-    for _ in 0..total {
-        let a = range.sample(&mut rng);
-        let b = range.sample(&mut rng);
-        if a*a + b*b <= 1.0 {
-            in_circle += 1;
-        }
-    }
-
-    // prints something close to 3.14159...
-    println!("π is approximately {}", 4. * (in_circle as f64) / (total as f64));
-}
diff --git a/rand/examples/monty-hall.rs b/rand/examples/monty-hall.rs
deleted file mode 100644
index 9fe5839..0000000
--- a/rand/examples/monty-hall.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright 2018 Developers of the Rand project.
-// Copyright 2013-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.
-
-//! ## Monty Hall Problem
-//!
-//! This is a simulation of the [Monty Hall Problem][]:
-//!
-//! > Suppose you're on a game show, and you're given the choice of three doors:
-//! > Behind one door is a car; behind the others, goats. You pick a door, say
-//! > No. 1, and the host, who knows what's behind the doors, opens another
-//! > door, say No. 3, which has a goat. He then says to you, "Do you want to
-//! > pick door No. 2?" Is it to your advantage to switch your choice?
-//!
-//! The rather unintuitive answer is that you will have a 2/3 chance of winning
-//! if you switch and a 1/3 chance of winning if you don't, so it's better to
-//! switch.
-//!
-//! This program will simulate the game show and with large enough simulation
-//! steps it will indeed confirm that it is better to switch.
-//!
-//! [Monty Hall Problem]: https://en.wikipedia.org/wiki/Monty_Hall_problem
-
-#![cfg(feature = "std")]
-
-use rand::distributions::{Distribution, Uniform};
-use rand::Rng;
-
-struct SimulationResult {
-    win: bool,
-    switch: bool,
-}
-
-// Run a single simulation of the Monty Hall problem.
-fn simulate<R: Rng>(random_door: &Uniform<u32>, rng: &mut R) -> SimulationResult {
-    let car = random_door.sample(rng);
-
-    // This is our initial choice
-    let mut choice = random_door.sample(rng);
-
-    // The game host opens a door
-    let open = game_host_open(car, choice, rng);
-
-    // Shall we switch?
-    let switch = rng.gen();
-    if switch {
-        choice = switch_door(choice, open);
-    }
-
-    SimulationResult { win: choice == car, switch }
-}
-
-// Returns the door the game host opens given our choice and knowledge of
-// where the car is. The game host will never open the door with the car.
-fn game_host_open<R: Rng>(car: u32, choice: u32, rng: &mut R) -> u32 {
-    use rand::seq::SliceRandom;
-    *free_doors(&[car, choice]).choose(rng).unwrap()
-}
-
-// Returns the door we switch to, given our current choice and
-// the open door. There will only be one valid door.
-fn switch_door(choice: u32, open: u32) -> u32 {
-    free_doors(&[choice, open])[0]
-}
-
-fn free_doors(blocked: &[u32]) -> Vec<u32> {
-    (0..3).filter(|x| !blocked.contains(x)).collect()
-}
-
-fn main() {
-    // The estimation will be more accurate with more simulations
-    let num_simulations = 10000;
-
-    let mut rng = rand::thread_rng();
-    let random_door = Uniform::new(0u32, 3);
-
-    let (mut switch_wins, mut switch_losses) = (0, 0);
-    let (mut keep_wins, mut keep_losses) = (0, 0);
-
-    println!("Running {} simulations...", num_simulations);
-    for _ in 0..num_simulations {
-        let result = simulate(&random_door, &mut rng);
-
-        match (result.win, result.switch) {
-            (true, true) => switch_wins += 1,
-            (true, false) => keep_wins += 1,
-            (false, true) => switch_losses += 1,
-            (false, false) => keep_losses += 1,
-        }
-    }
-
-    let total_switches = switch_wins + switch_losses;
-    let total_keeps = keep_wins + keep_losses;
-
-    println!("Switched door {} times with {} wins and {} losses",
-             total_switches, switch_wins, switch_losses);
-
-    println!("Kept our choice {} times with {} wins and {} losses",
-             total_keeps, keep_wins, keep_losses);
-
-    // With a large number of simulations, the values should converge to
-    // 0.667 and 0.333 respectively.
-    println!("Estimated chance to win if we switch: {}",
-             switch_wins as f32 / total_switches as f32);
-    println!("Estimated chance to win if we don't: {}",
-             keep_wins as f32 / total_keeps as f32);
-}