From bacd6c5e04f61b1eb51c7c8ba0a8a8b4202b0c1d Mon Sep 17 00:00:00 2001 From: Fenrir Date: Mon, 2 Jan 2017 16:00:23 -0700 Subject: [PATCH] Fixes for latest nightlies (Rust 1.16.0) --- Xargo.toml | 2 + src/lib.rs | 1 + std/src/ascii.rs | 2 +- std/src/io/mod.rs | 2 +- std/src/lib.rs | 4 +- std/src/macros.rs | 289 -------------------------------------------- std/src/sys/wtf8.rs | 2 +- 7 files changed, 8 insertions(+), 294 deletions(-) create mode 100644 Xargo.toml diff --git a/Xargo.toml b/Xargo.toml new file mode 100644 index 0000000..afe92d8 --- /dev/null +++ b/Xargo.toml @@ -0,0 +1,2 @@ +[target.3ds.dependencies] +collections = {} diff --git a/src/lib.rs b/src/lib.rs index 56e7011..a4252a1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,6 +3,7 @@ #[macro_use] extern crate bitflags; + extern crate ctru_sys as libctru; pub mod console; diff --git a/std/src/ascii.rs b/std/src/ascii.rs index 277d82a..5424921 100644 --- a/std/src/ascii.rs +++ b/std/src/ascii.rs @@ -430,7 +430,7 @@ static ASCII_UPPERCASE_MAP: [u8; 256] = [ #[cfg(test)] mod tests { use super::*; - use rustc_unicode::char::from_u32; + use std_unicode::char::from_u32; use collections::string::ToString; #[test] diff --git a/std/src/io/mod.rs b/std/src/io/mod.rs index 3e43a44..f66aa60 100644 --- a/std/src/io/mod.rs +++ b/std/src/io/mod.rs @@ -248,7 +248,7 @@ //! time and may call fewer or more syscalls/library functions. use cmp; -use rustc_unicode::str as core_str; +use std_unicode::str as core_str; use error as std_error; use fmt; use result; diff --git a/std/src/lib.rs b/std/src/lib.rs index 5f1b438..48d0e1d 100644 --- a/std/src/lib.rs +++ b/std/src/lib.rs @@ -30,7 +30,7 @@ extern crate core as __core; #[macro_reexport(vec, format)] extern crate collections as core_collections; extern crate alloc; -extern crate rustc_unicode; +extern crate std_unicode; extern crate alloc_system; @@ -65,7 +65,7 @@ pub use core_collections::str; pub use core_collections::string; pub use core_collections::vec; -pub use rustc_unicode::char; +pub use std_unicode::char; #[macro_use] pub mod macros; diff --git a/std/src/macros.rs b/std/src/macros.rs index a9b4336..f1a5b75 100644 --- a/std/src/macros.rs +++ b/std/src/macros.rs @@ -28,7 +28,6 @@ /// panic!("this is a {} {message}", "fancy", message = "message"); /// ``` #[macro_export] -#[allow_internal_unstable] macro_rules! panic { () => ({ panic!("explicit panic") @@ -52,132 +51,6 @@ macro_rules! panic { }); } -/// Ensure that a boolean expression is `true` at runtime. -/// -/// This will invoke the `panic!` macro if the provided expression cannot be -/// evaluated to `true` at runtime. -/// -/// This macro has a second version, where a custom panic message can be provided. -/// -/// # Examples -/// -/// ``` -/// // the panic message for these assertions is the stringified value of the -/// // expression given. -/// assert!(true); -/// -/// fn some_computation() -> bool { true } // a very simple function -/// -/// assert!(some_computation()); -/// -/// // assert with a custom message -/// let x = true; -/// assert!(x, "x wasn't true!"); -/// -/// let a = 3; let b = 27; -/// assert!(a + b == 30, "a = {}, b = {}", a, b); -/// ``` -#[macro_export] -macro_rules! assert { - ($cond:expr) => ( - if !$cond { - panic!(concat!("assertion failed: ", stringify!($cond))) - } - ); - ($cond:expr, $($arg:tt)+) => ( - if !$cond { - panic!($($arg)+) - } - ); -} - -/// Asserts that two expressions are equal to each other. -/// -/// On panic, this macro will print the values of the expressions with their -/// debug representations. -/// -/// # Examples -/// -/// ``` -/// let a = 3; -/// let b = 1 + 2; -/// assert_eq!(a, b); -/// ``` -#[macro_export] -macro_rules! assert_eq { - ($left:expr , $right:expr) => ({ - match (&$left, &$right) { - (left_val, right_val) => { - if !(*left_val == *right_val) { - panic!("assertion failed: `(left == right)` \ - (left: `{:?}`, right: `{:?}`)", left_val, right_val) - } - } - } - }) -} - -/// Ensure that a boolean expression is `true` at runtime. -/// -/// This will invoke the `panic!` macro if the provided expression cannot be -/// evaluated to `true` at runtime. -/// -/// Like `assert!`, this macro also has a second version, where a custom panic -/// message can be provided. -/// -/// Unlike `assert!`, `debug_assert!` statements are only enabled in non -/// optimized builds by default. An optimized build will omit all -/// `debug_assert!` statements unless `-C debug-assertions` is passed to the -/// compiler. This makes `debug_assert!` useful for checks that are too -/// expensive to be present in a release build but may be helpful during -/// development. -/// -/// # Examples -/// -/// ``` -/// // the panic message for these assertions is the stringified value of the -/// // expression given. -/// debug_assert!(true); -/// -/// fn some_expensive_computation() -> bool { true } // a very simple function -/// debug_assert!(some_expensive_computation()); -/// -/// // assert with a custom message -/// let x = true; -/// debug_assert!(x, "x wasn't true!"); -/// -/// let a = 3; let b = 27; -/// debug_assert!(a + b == 30, "a = {}, b = {}", a, b); -/// ``` -#[macro_export] -macro_rules! debug_assert { - ($($arg:tt)*) => (if cfg!(debug_assertions) { assert!($($arg)*); }) -} - -/// Asserts that two expressions are equal to each other. -/// -/// On panic, this macro will print the values of the expressions with their -/// debug representations. -/// -/// Unlike `assert_eq!`, `debug_assert_eq!` statements are only enabled in non -/// optimized builds by default. An optimized build will omit all -/// `debug_assert_eq!` statements unless `-C debug-assertions` is passed to the -/// compiler. This makes `debug_assert_eq!` useful for checks that are too -/// expensive to be present in a release build but may be helpful during -/// development. -/// -/// # Examples -/// -/// ``` -/// let a = 3; -/// let b = 1 + 2; -/// debug_assert_eq!(a, b); -/// ``` -#[macro_export] -macro_rules! debug_assert_eq { - ($($arg:tt)*) => (if cfg!(debug_assertions) { assert_eq!($($arg)*); }) -} - /// Helper macro for unwrapping `Result` values while returning early with an /// error if the value of the expression is `Err`. Can only be used in /// functions that return `Result` because of the early return of `Err` that @@ -217,169 +90,7 @@ macro_rules! try { }) } -/// Use the `format!` syntax to write data into a buffer. -/// -/// This macro is typically used with a buffer of `&mut `[`Write`][write]. -/// -/// See [`std::fmt`][fmt] for more information on format syntax. -/// -/// [fmt]: ../std/fmt/index.html -/// [write]: ../std/io/trait.Write.html -/// -/// # Examples -/// -/// ``` -/// use std::io::Write; -/// -/// let mut w = Vec::new(); -/// write!(&mut w, "test").unwrap(); -/// write!(&mut w, "formatted {}", "arguments").unwrap(); -/// -/// assert_eq!(w, b"testformatted arguments"); -/// ``` -#[macro_export] -macro_rules! write { - ($dst:expr, $($arg:tt)*) => ($dst.write_fmt(format_args!($($arg)*))) -} - -/// Use the `format!` syntax to write data into a buffer, appending a newline. -/// -/// This macro is typically used with a buffer of `&mut `[`Write`][write]. -/// -/// See [`std::fmt`][fmt] for more information on format syntax. -/// -/// [fmt]: ../std/fmt/index.html -/// [write]: ../std/io/trait.Write.html -/// -/// # Examples -/// -/// ``` -/// use std::io::Write; -/// -/// let mut w = Vec::new(); -/// writeln!(&mut w, "test").unwrap(); -/// writeln!(&mut w, "formatted {}", "arguments").unwrap(); -/// -/// assert_eq!(&w[..], "test\nformatted arguments\n".as_bytes()); -/// ``` -#[macro_export] -macro_rules! writeln { - ($dst:expr, $fmt:expr) => ( - write!($dst, concat!($fmt, "\n")) - ); - ($dst:expr, $fmt:expr, $($arg:tt)*) => ( - write!($dst, concat!($fmt, "\n"), $($arg)*) - ); -} - -/// A utility macro for indicating unreachable code. -/// -/// This is useful any time that the compiler can't determine that some code is unreachable. For -/// example: -/// -/// * Match arms with guard conditions. -/// * Loops that dynamically terminate. -/// * Iterators that dynamically terminate. -/// -/// # Panics -/// -/// This will always panic. -/// -/// # Examples -/// -/// Match arms: -/// -/// ``` -/// # #[allow(dead_code)] -/// fn foo(x: Option) { -/// match x { -/// Some(n) if n >= 0 => println!("Some(Non-negative)"), -/// Some(n) if n < 0 => println!("Some(Negative)"), -/// Some(_) => unreachable!(), // compile error if commented out -/// None => println!("None") -/// } -/// } -/// ``` -/// -/// Iterators: -/// -/// ``` -/// # #[allow(dead_code)] -/// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3 -/// for i in 0.. { -/// if 3*i < i { panic!("u32 overflow"); } -/// if x < 3*i { return i-1; } -/// } -/// unreachable!(); -/// } -/// ``` -#[macro_export] -macro_rules! unreachable { - () => ({ - panic!("internal error: entered unreachable code") - }); - ($msg:expr) => ({ - unreachable!("{}", $msg) - }); - ($fmt:expr, $($arg:tt)*) => ({ - panic!(concat!("internal error: entered unreachable code: ", $fmt), $($arg)*) - }); -} - -/// A standardized placeholder for marking unfinished code. It panics with the -/// message `"not yet implemented"` when executed. -/// -/// This can be useful if you are prototyping and are just looking to have your -/// code typecheck, or if you're implementing a trait that requires multiple -/// methods, and you're only planning on using one of them. -/// -/// # Examples -/// -/// Here's an example of some in-progress code. We have a trait `Foo`: -/// -/// ``` -/// trait Foo { -/// fn bar(&self); -/// fn baz(&self); -/// } -/// ``` -/// -/// We want to implement `Foo` on one of our types, but we also want to work on -/// just `bar()` first. In order for our code to compile, we need to implement -/// `baz()`, so we can use `unimplemented!`: -/// -/// ``` -/// # trait Foo { -/// # fn bar(&self); -/// # fn baz(&self); -/// # } -/// struct MyStruct; -/// -/// impl Foo for MyStruct { -/// fn bar(&self) { -/// // implementation goes here -/// } -/// -/// fn baz(&self) { -/// // let's not worry about implementing baz() for now -/// unimplemented!(); -/// } -/// } -/// -/// fn main() { -/// let s = MyStruct; -/// s.bar(); -/// -/// // we aren't even using baz() yet, so this is fine. -/// } -/// ``` -#[macro_export] -macro_rules! unimplemented { - () => (panic!("not yet implemented")) -} - #[macro_export] -#[allow_internal_unstable] macro_rules! print { ($($arg:tt)*) => ( $crate::io::_print(format_args!($($arg)*)); diff --git a/std/src/sys/wtf8.rs b/std/src/sys/wtf8.rs index 24cc205..8f0662c 100644 --- a/std/src/sys/wtf8.rs +++ b/std/src/sys/wtf8.rs @@ -29,7 +29,7 @@ use core::str::next_code_point; use ascii::*; use borrow::Cow; -use rustc_unicode::char; +use std_unicode::char; use fmt; use hash::{Hash, Hasher}; use iter::FromIterator;