Fenrir
8 years ago
45 changed files with 4925 additions and 413 deletions
@ -1,19 +1,40 @@
@@ -1,19 +1,40 @@
|
||||
//TODO: Implement stuff that bindgen doesn't catch
|
||||
/* automatically generated by rust-bindgen */ |
||||
|
||||
use Handle; |
||||
#![allow(dead_code,
|
||||
non_camel_case_types, |
||||
non_upper_case_globals, |
||||
non_snake_case)] |
||||
|
||||
use Handle; |
||||
use svc::ResetType; |
||||
use super::lock::*; |
||||
|
||||
pub type LightLock = _LOCK_T; |
||||
pub type RecursiveLock = _LOCK_RECURSIVE_T; |
||||
#[repr(C)] |
||||
#[derive(Copy, Clone)] |
||||
#[derive(Debug)] |
||||
pub struct LightEvent { |
||||
pub state: i32, |
||||
pub lock: LightLock, |
||||
} |
||||
impl ::core::default::Default for LightEvent { |
||||
fn default() -> Self { unsafe { ::core::mem::zeroed() } } |
||||
} |
||||
extern "C" { |
||||
pub fn __sync_get_arbiter() -> Handle; |
||||
pub fn LightLock_Init(lock: *mut LightLock); |
||||
pub fn LightLock_Lock(lock: *mut LightLock); |
||||
pub fn LightLock_TryLock(lock: *mut LightLock) -> i32; |
||||
pub fn LightLock_Unlock(lock: *mut LightLock); |
||||
pub fn LightLock_Lock(lock: *const LightLock); |
||||
pub fn LightLock_TryLock(lock: *const LightLock) -> ::libc::c_int; |
||||
pub fn LightLock_Unlock(lock: *const LightLock); |
||||
pub fn RecursiveLock_Init(lock: *mut RecursiveLock); |
||||
pub fn RecursiveLock_Lock(lock: *mut RecursiveLock); |
||||
pub fn RecursiveLock_TryLock(lock: *mut RecursiveLock) -> i32; |
||||
pub fn RecursiveLock_Unlock(lock: *mut RecursiveLock); |
||||
pub fn RecursiveLock_Lock(lock: *const RecursiveLock); |
||||
pub fn RecursiveLock_TryLock(lock: *const RecursiveLock) -> ::libc::c_int; |
||||
pub fn RecursiveLock_Unlock(lock: *const RecursiveLock); |
||||
pub fn LightEvent_Init(event: *mut LightEvent, reset_type: ResetType); |
||||
pub fn LightEvent_Clear(event: *mut LightEvent); |
||||
pub fn LightEvent_Pulse(event: *mut LightEvent); |
||||
pub fn LightEvent_Signal(event: *mut LightEvent); |
||||
pub fn LightEvent_TryWait(event: *mut LightEvent) -> ::libc::c_int; |
||||
pub fn LightEvent_Wait(event: *mut LightEvent); |
||||
} |
||||
|
||||
@ -1,9 +0,0 @@
@@ -1,9 +0,0 @@
|
||||
pub mod ascii; |
||||
pub mod error; |
||||
pub mod ffi; |
||||
pub mod io; |
||||
pub mod memchr; |
||||
pub mod panicking; |
||||
pub mod path; |
||||
pub mod rt; |
||||
mod sys; |
||||
@ -1,9 +0,0 @@
@@ -1,9 +0,0 @@
|
||||
use std::mem; |
||||
|
||||
//TODO: Handle argc/argv arguments
|
||||
#[lang = "start"] |
||||
#[allow(unused_variables)] |
||||
fn lang_start(main: *const u8, argc: isize, argv: *const *const u8) -> isize { |
||||
unsafe { mem::transmute::<_, fn()>(main)(); } |
||||
0 |
||||
} |
||||
@ -0,0 +1,17 @@
@@ -0,0 +1,17 @@
|
||||
[package] |
||||
name = "std" |
||||
version = "0.0.0" |
||||
authors = ["Ronald Kinard <furyhunter600@gmail.com>"] |
||||
license = "https://en.wikipedia.org/wiki/Zlib_License" |
||||
|
||||
[lib] |
||||
crate-type = ["rlib"] |
||||
|
||||
[dependencies.alloc_system3ds] |
||||
git = "https://github.com/rust3ds/alloc_system3ds" |
||||
|
||||
[dependencies.ctru-sys] |
||||
path = "../ctru-sys" |
||||
|
||||
[dependencies.spin] |
||||
version = "0.4" |
||||
@ -0,0 +1,32 @@
@@ -0,0 +1,32 @@
|
||||
use fmt; |
||||
use io::{self, Write}; |
||||
|
||||
// NOTE: We're just gonna use the spin mutex until we figure out how to properly
|
||||
// implement mutexes with ctrulib functions
|
||||
use spin::Mutex; |
||||
use libctru::libc; |
||||
|
||||
pub static STDOUT: Mutex<StdoutRaw> = Mutex::new(StdoutRaw(())); |
||||
|
||||
pub struct StdoutRaw(()); |
||||
|
||||
impl Write for StdoutRaw { |
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
||||
unsafe { |
||||
// devkitPro's version of write(2) fails if zero bytes are written,
|
||||
// so let's just exit if the buffer size is zero
|
||||
if buf.is_empty() { |
||||
return Ok(buf.len()) |
||||
} |
||||
libc::write(libc::STDOUT_FILENO, buf.as_ptr() as *const _, buf.len()); |
||||
Ok(buf.len()) |
||||
} |
||||
} |
||||
|
||||
fn flush(&mut self) -> io::Result<()> { Ok(()) } |
||||
} |
||||
|
||||
#[doc(hidden)] |
||||
pub fn _print(args: fmt::Arguments) { |
||||
STDOUT.lock().write_fmt(args).unwrap(); |
||||
} |
||||
@ -0,0 +1,100 @@
@@ -0,0 +1,100 @@
|
||||
#![feature(alloc)] |
||||
#![feature(allow_internal_unstable)] |
||||
#![feature(collections)] |
||||
#![feature(const_fn)] |
||||
#![feature(core_intrinsics)] |
||||
#![feature(char_escape_debug)] |
||||
#![feature(float_extras)] |
||||
#![feature(int_error_internals)] |
||||
#![feature(lang_items)] |
||||
#![feature(macro_reexport)] |
||||
#![feature(optin_builtin_traits)] |
||||
#![feature(prelude_import)] |
||||
#![feature(raw)] |
||||
#![feature(slice_concat_ext)] |
||||
#![feature(slice_patterns)] |
||||
#![feature(str_internals)] |
||||
#![feature(try_from)] |
||||
#![feature(unicode)] |
||||
#![feature(zero_one)] |
||||
#![allow(non_camel_case_types)] |
||||
#![no_std] |
||||
|
||||
#[prelude_import] |
||||
#[allow(unused)] |
||||
use prelude::v1::*;
|
||||
#[macro_reexport(assert, assert_eq, debug_assert, debug_assert_eq,
|
||||
unreachable, unimplemented, write, writeln)] |
||||
extern crate core as __core; |
||||
#[macro_use] |
||||
#[macro_reexport(vec, format)] |
||||
extern crate collections as core_collections; |
||||
extern crate alloc; |
||||
extern crate rustc_unicode; |
||||
|
||||
extern crate alloc_system; |
||||
|
||||
extern crate ctru_sys as libctru; |
||||
extern crate spin; |
||||
|
||||
pub use core::any; |
||||
pub use core::cell; |
||||
pub use core::clone; |
||||
pub use core::cmp; |
||||
pub use core::convert; |
||||
pub use core::default; |
||||
pub use core::hash; |
||||
pub use core::intrinsics; |
||||
pub use core::iter; |
||||
pub use core::marker; |
||||
pub use core::mem; |
||||
pub use core::ops; |
||||
pub use core::ptr; |
||||
pub use core::raw; |
||||
pub use core::result; |
||||
pub use core::option; |
||||
|
||||
pub use alloc::arc; |
||||
pub use alloc::boxed; |
||||
pub use alloc::rc; |
||||
|
||||
pub use core_collections::borrow; |
||||
pub use core_collections::fmt; |
||||
pub use core_collections::slice; |
||||
pub use core_collections::str; |
||||
pub use core_collections::string; |
||||
pub use core_collections::vec; |
||||
|
||||
pub use rustc_unicode::char; |
||||
|
||||
#[macro_use] |
||||
pub mod macros; |
||||
|
||||
pub mod prelude; |
||||
|
||||
pub use core::isize; |
||||
pub use core::i8; |
||||
pub use core::i16; |
||||
pub use core::i32; |
||||
pub use core::i64; |
||||
|
||||
pub use core::usize; |
||||
pub use core::u8; |
||||
pub use core::u16; |
||||
pub use core::u32; |
||||
pub use core::u64; |
||||
|
||||
#[path = "num/f32.rs"] pub mod f32; |
||||
#[path = "num/f64.rs"] pub mod f64; |
||||
|
||||
pub mod ascii; |
||||
pub mod error; |
||||
pub mod ffi; |
||||
pub mod io; |
||||
pub mod num; |
||||
pub mod path; |
||||
pub mod rt; |
||||
pub mod sync; |
||||
mod memchr; |
||||
mod panicking; |
||||
mod sys; |
||||
@ -0,0 +1,394 @@
@@ -0,0 +1,394 @@
|
||||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
/// The entry point for panic of Rust threads.
|
||||
///
|
||||
/// This macro is used to inject panic into a Rust thread, causing the thread to
|
||||
/// panic entirely. Each thread's panic can be reaped as the `Box<Any>` type,
|
||||
/// and the single-argument form of the `panic!` macro will be the value which
|
||||
/// is transmitted.
|
||||
///
|
||||
/// The multi-argument form of this macro panics with a string and has the
|
||||
/// `format!` syntax for building a string.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```should_panic
|
||||
/// # #![allow(unreachable_code)]
|
||||
/// panic!();
|
||||
/// panic!("this is a terrible mistake!");
|
||||
/// panic!(4); // panic with the value of 4 to be collected elsewhere
|
||||
/// panic!("this is a {} {message}", "fancy", message = "message");
|
||||
/// ```
|
||||
#[macro_export] |
||||
#[allow_internal_unstable] |
||||
macro_rules! panic { |
||||
() => ({ |
||||
panic!("explicit panic") |
||||
}); |
||||
($msg:expr) => ({ |
||||
$crate::rt::begin_panic($msg, { |
||||
// static requires less code at runtime, more constant data
|
||||
static _FILE_LINE: (&'static str, u32) = (file!(), line!()); |
||||
&_FILE_LINE |
||||
}) |
||||
}); |
||||
($fmt:expr, $($arg:tt)+) => ({ |
||||
$crate::rt::begin_panic_fmt(&format_args!($fmt, $($arg)+), { |
||||
// The leading _'s are to avoid dead code warnings if this is
|
||||
// used inside a dead function. Just `#[allow(dead_code)]` is
|
||||
// insufficient, since the user may have
|
||||
// `#[forbid(dead_code)]` and which cannot be overridden.
|
||||
static _FILE_LINE: (&'static str, u32) = (file!(), line!()); |
||||
&_FILE_LINE |
||||
}) |
||||
}); |
||||
} |
||||
|
||||
/// 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
|
||||
/// it provides.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::io;
|
||||
/// use std::fs::File;
|
||||
/// use std::io::prelude::*;
|
||||
///
|
||||
/// fn write_to_file_using_try() -> Result<(), io::Error> {
|
||||
/// let mut file = try!(File::create("my_best_friends.txt"));
|
||||
/// try!(file.write_all(b"This is a list of my best friends."));
|
||||
/// println!("I wrote to the file");
|
||||
/// Ok(())
|
||||
/// }
|
||||
/// // This is equivalent to:
|
||||
/// fn write_to_file_using_match() -> Result<(), io::Error> {
|
||||
/// let mut file = try!(File::create("my_best_friends.txt"));
|
||||
/// match file.write_all(b"This is a list of my best friends.") {
|
||||
/// Ok(v) => v,
|
||||
/// Err(e) => return Err(e),
|
||||
/// }
|
||||
/// println!("I wrote to the file");
|
||||
/// Ok(())
|
||||
/// }
|
||||
/// ```
|
||||
#[macro_export] |
||||
macro_rules! try { |
||||
($expr:expr) => (match $expr { |
||||
$crate::result::Result::Ok(val) => val, |
||||
$crate::result::Result::Err(err) => { |
||||
return $crate::result::Result::Err($crate::convert::From::from(err)) |
||||
} |
||||
}) |
||||
} |
||||
|
||||
/// 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<i32>) {
|
||||
/// 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)*)); |
||||
); |
||||
} |
||||
|
||||
#[macro_export] |
||||
macro_rules! println { |
||||
() => (print!("\n")); |
||||
($fmt:expr) => (print!(concat!($fmt, "\n"))); |
||||
($fmt:expr, $($arg:tt)*) => (print!(concat!($fmt, "\n"), $($arg)*)); |
||||
} |
||||
@ -0,0 +1,293 @@
@@ -0,0 +1,293 @@
|
||||
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
//! Additional functionality for numerics.
|
||||
//!
|
||||
//! This module provides some extra types that are useful when doing numerical
|
||||
//! work. See the individual documentation for each piece for more information.
|
||||
|
||||
#![allow(missing_docs)] |
||||
|
||||
#[allow(deprecated)] |
||||
pub use core::num::{Zero, One}; |
||||
pub use core::num::{FpCategory, ParseIntError, ParseFloatError, TryFromIntError}; |
||||
pub use core::num::Wrapping; |
||||
|
||||
#[cfg(test)] |
||||
use fmt; |
||||
#[cfg(test)] |
||||
use ops::{Add, Sub, Mul, Div, Rem}; |
||||
|
||||
/// Helper function for testing numeric operations
|
||||
#[cfg(test)] |
||||
pub fn test_num<T>(ten: T, two: T) where |
||||
T: PartialEq |
||||
+ Add<Output=T> + Sub<Output=T> |
||||
+ Mul<Output=T> + Div<Output=T> |
||||
+ Rem<Output=T> + fmt::Debug |
||||
+ Copy |
||||
{ |
||||
assert_eq!(ten.add(two), ten + two); |
||||
assert_eq!(ten.sub(two), ten - two); |
||||
assert_eq!(ten.mul(two), ten * two); |
||||
assert_eq!(ten.div(two), ten / two); |
||||
assert_eq!(ten.rem(two), ten % two); |
||||
} |
||||
|
||||
#[cfg(test)] |
||||
mod tests { |
||||
use u8; |
||||
use u16; |
||||
use u32; |
||||
use u64; |
||||
use usize; |
||||
use ops::Mul; |
||||
|
||||
#[test] |
||||
fn test_saturating_add_uint() { |
||||
use usize::MAX; |
||||
assert_eq!(3_usize.saturating_add(5_usize), 8_usize); |
||||
assert_eq!(3_usize.saturating_add(MAX - 1), MAX); |
||||
assert_eq!(MAX.saturating_add(MAX), MAX); |
||||
assert_eq!((MAX - 2).saturating_add(1), MAX - 1); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_saturating_sub_uint() { |
||||
use usize::MAX; |
||||
assert_eq!(5_usize.saturating_sub(3_usize), 2_usize); |
||||
assert_eq!(3_usize.saturating_sub(5_usize), 0_usize); |
||||
assert_eq!(0_usize.saturating_sub(1_usize), 0_usize); |
||||
assert_eq!((MAX - 1).saturating_sub(MAX), 0); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_saturating_add_int() { |
||||
use isize::{MIN, MAX}; |
||||
assert_eq!(3i32.saturating_add(5), 8); |
||||
assert_eq!(3isize.saturating_add(MAX - 1), MAX); |
||||
assert_eq!(MAX.saturating_add(MAX), MAX); |
||||
assert_eq!((MAX - 2).saturating_add(1), MAX - 1); |
||||
assert_eq!(3i32.saturating_add(-5), -2); |
||||
assert_eq!(MIN.saturating_add(-1), MIN); |
||||
assert_eq!((-2isize).saturating_add(-MAX), MIN); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_saturating_sub_int() { |
||||
use isize::{MIN, MAX}; |
||||
assert_eq!(3i32.saturating_sub(5), -2); |
||||
assert_eq!(MIN.saturating_sub(1), MIN); |
||||
assert_eq!((-2isize).saturating_sub(MAX), MIN); |
||||
assert_eq!(3i32.saturating_sub(-5), 8); |
||||
assert_eq!(3isize.saturating_sub(-(MAX - 1)), MAX); |
||||
assert_eq!(MAX.saturating_sub(-MAX), MAX); |
||||
assert_eq!((MAX - 2).saturating_sub(-1), MAX - 1); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_checked_add() { |
||||
let five_less = usize::MAX - 5; |
||||
assert_eq!(five_less.checked_add(0), Some(usize::MAX - 5)); |
||||
assert_eq!(five_less.checked_add(1), Some(usize::MAX - 4)); |
||||
assert_eq!(five_less.checked_add(2), Some(usize::MAX - 3)); |
||||
assert_eq!(five_less.checked_add(3), Some(usize::MAX - 2)); |
||||
assert_eq!(five_less.checked_add(4), Some(usize::MAX - 1)); |
||||
assert_eq!(five_less.checked_add(5), Some(usize::MAX)); |
||||
assert_eq!(five_less.checked_add(6), None); |
||||
assert_eq!(five_less.checked_add(7), None); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_checked_sub() { |
||||
assert_eq!(5_usize.checked_sub(0), Some(5)); |
||||
assert_eq!(5_usize.checked_sub(1), Some(4)); |
||||
assert_eq!(5_usize.checked_sub(2), Some(3)); |
||||
assert_eq!(5_usize.checked_sub(3), Some(2)); |
||||
assert_eq!(5_usize.checked_sub(4), Some(1)); |
||||
assert_eq!(5_usize.checked_sub(5), Some(0)); |
||||
assert_eq!(5_usize.checked_sub(6), None); |
||||
assert_eq!(5_usize.checked_sub(7), None); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_checked_mul() { |
||||
let third = usize::MAX / 3; |
||||
assert_eq!(third.checked_mul(0), Some(0)); |
||||
assert_eq!(third.checked_mul(1), Some(third)); |
||||
assert_eq!(third.checked_mul(2), Some(third * 2)); |
||||
assert_eq!(third.checked_mul(3), Some(third * 3)); |
||||
assert_eq!(third.checked_mul(4), None); |
||||
} |
||||
|
||||
macro_rules! test_is_power_of_two { |
||||
($test_name:ident, $T:ident) => ( |
||||
fn $test_name() { |
||||
#![test] |
||||
assert_eq!((0 as $T).is_power_of_two(), false); |
||||
assert_eq!((1 as $T).is_power_of_two(), true); |
||||
assert_eq!((2 as $T).is_power_of_two(), true); |
||||
assert_eq!((3 as $T).is_power_of_two(), false); |
||||
assert_eq!((4 as $T).is_power_of_two(), true); |
||||
assert_eq!((5 as $T).is_power_of_two(), false); |
||||
assert_eq!(($T::MAX / 2 + 1).is_power_of_two(), true); |
||||
} |
||||
) |
||||
} |
||||
|
||||
test_is_power_of_two!{ test_is_power_of_two_u8, u8 } |
||||
test_is_power_of_two!{ test_is_power_of_two_u16, u16 } |
||||
test_is_power_of_two!{ test_is_power_of_two_u32, u32 } |
||||
test_is_power_of_two!{ test_is_power_of_two_u64, u64 } |
||||
test_is_power_of_two!{ test_is_power_of_two_uint, usize } |
||||
|
||||
macro_rules! test_next_power_of_two { |
||||
($test_name:ident, $T:ident) => ( |
||||
fn $test_name() { |
||||
#![test] |
||||
assert_eq!((0 as $T).next_power_of_two(), 1); |
||||
let mut next_power = 1; |
||||
for i in 1 as $T..40 { |
||||
assert_eq!(i.next_power_of_two(), next_power); |
||||
if i == next_power { next_power *= 2 } |
||||
} |
||||
} |
||||
) |
||||
} |
||||
|
||||
test_next_power_of_two! { test_next_power_of_two_u8, u8 } |
||||
test_next_power_of_two! { test_next_power_of_two_u16, u16 } |
||||
test_next_power_of_two! { test_next_power_of_two_u32, u32 } |
||||
test_next_power_of_two! { test_next_power_of_two_u64, u64 } |
||||
test_next_power_of_two! { test_next_power_of_two_uint, usize } |
||||
|
||||
macro_rules! test_checked_next_power_of_two { |
||||
($test_name:ident, $T:ident) => ( |
||||
fn $test_name() { |
||||
#![test] |
||||
assert_eq!((0 as $T).checked_next_power_of_two(), Some(1)); |
||||
assert!(($T::MAX / 2).checked_next_power_of_two().is_some()); |
||||
assert_eq!(($T::MAX - 1).checked_next_power_of_two(), None); |
||||
assert_eq!($T::MAX.checked_next_power_of_two(), None); |
||||
let mut next_power = 1; |
||||
for i in 1 as $T..40 { |
||||
assert_eq!(i.checked_next_power_of_two(), Some(next_power)); |
||||
if i == next_power { next_power *= 2 } |
||||
} |
||||
} |
||||
) |
||||
} |
||||
|
||||
test_checked_next_power_of_two! { test_checked_next_power_of_two_u8, u8 } |
||||
test_checked_next_power_of_two! { test_checked_next_power_of_two_u16, u16 } |
||||
test_checked_next_power_of_two! { test_checked_next_power_of_two_u32, u32 } |
||||
test_checked_next_power_of_two! { test_checked_next_power_of_two_u64, u64 } |
||||
test_checked_next_power_of_two! { test_checked_next_power_of_two_uint, usize } |
||||
|
||||
#[test] |
||||
fn test_pow() { |
||||
fn naive_pow<T: Mul<Output = T> + Copy>(one: T, base: T, exp: usize) -> T { |
||||
(0..exp).fold(one, |acc, _| acc * base) |
||||
} |
||||
macro_rules! assert_pow { |
||||
(($num:expr, $exp:expr) => $expected:expr) => {{ |
||||
let result = $num.pow($exp); |
||||
assert_eq!(result, $expected); |
||||
assert_eq!(result, naive_pow(1, $num, $exp)); |
||||
}} |
||||
} |
||||
assert_pow!((3u32, 0 ) => 1); |
||||
assert_pow!((5u32, 1 ) => 5); |
||||
assert_pow!((-4i32, 2 ) => 16); |
||||
assert_pow!((8u32, 3 ) => 512); |
||||
assert_pow!((2u64, 50) => 1125899906842624); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_uint_to_str_overflow() { |
||||
let mut u8_val: u8 = 255; |
||||
assert_eq!(u8_val.to_string(), "255"); |
||||
|
||||
u8_val = u8_val.wrapping_add(1); |
||||
assert_eq!(u8_val.to_string(), "0"); |
||||
|
||||
let mut u16_val: u16 = 65_535; |
||||
assert_eq!(u16_val.to_string(), "65535"); |
||||
|
||||
u16_val = u16_val.wrapping_add(1); |
||||
assert_eq!(u16_val.to_string(), "0"); |
||||
|
||||
let mut u32_val: u32 = 4_294_967_295; |
||||
assert_eq!(u32_val.to_string(), "4294967295"); |
||||
|
||||
u32_val = u32_val.wrapping_add(1); |
||||
assert_eq!(u32_val.to_string(), "0"); |
||||
|
||||
let mut u64_val: u64 = 18_446_744_073_709_551_615; |
||||
assert_eq!(u64_val.to_string(), "18446744073709551615"); |
||||
|
||||
u64_val = u64_val.wrapping_add(1); |
||||
assert_eq!(u64_val.to_string(), "0"); |
||||
} |
||||
|
||||
fn from_str<T: ::str::FromStr>(t: &str) -> Option<T> { |
||||
::str::FromStr::from_str(t).ok() |
||||
} |
||||
|
||||
#[test] |
||||
fn test_uint_from_str_overflow() { |
||||
let mut u8_val: u8 = 255; |
||||
assert_eq!(from_str::<u8>("255"), Some(u8_val)); |
||||
assert_eq!(from_str::<u8>("256"), None); |
||||
|
||||
u8_val = u8_val.wrapping_add(1); |
||||
assert_eq!(from_str::<u8>("0"), Some(u8_val)); |
||||
assert_eq!(from_str::<u8>("-1"), None); |
||||
|
||||
let mut u16_val: u16 = 65_535; |
||||
assert_eq!(from_str::<u16>("65535"), Some(u16_val)); |
||||
assert_eq!(from_str::<u16>("65536"), None); |
||||
|
||||
u16_val = u16_val.wrapping_add(1); |
||||
assert_eq!(from_str::<u16>("0"), Some(u16_val)); |
||||
assert_eq!(from_str::<u16>("-1"), None); |
||||
|
||||
let mut u32_val: u32 = 4_294_967_295; |
||||
assert_eq!(from_str::<u32>("4294967295"), Some(u32_val)); |
||||
assert_eq!(from_str::<u32>("4294967296"), None); |
||||
|
||||
u32_val = u32_val.wrapping_add(1); |
||||
assert_eq!(from_str::<u32>("0"), Some(u32_val)); |
||||
assert_eq!(from_str::<u32>("-1"), None); |
||||
|
||||
let mut u64_val: u64 = 18_446_744_073_709_551_615; |
||||
assert_eq!(from_str::<u64>("18446744073709551615"), Some(u64_val)); |
||||
assert_eq!(from_str::<u64>("18446744073709551616"), None); |
||||
|
||||
u64_val = u64_val.wrapping_add(1); |
||||
assert_eq!(from_str::<u64>("0"), Some(u64_val)); |
||||
assert_eq!(from_str::<u64>("-1"), None); |
||||
} |
||||
} |
||||
|
||||
|
||||
#[cfg(test)] |
||||
mod bench { |
||||
extern crate test; |
||||
use self::test::Bencher; |
||||
|
||||
#[bench] |
||||
fn bench_pow_function(b: &mut Bencher) { |
||||
let v = (0..1024).collect::<Vec<u32>>(); |
||||
b.iter(|| { |
||||
v.iter().fold(0u32, |old, new| old.pow(*new as u32)); |
||||
}); |
||||
} |
||||
} |
||||
@ -0,0 +1,49 @@
@@ -0,0 +1,49 @@
|
||||
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
//! The first version of the prelude of The Rust Standard Library.
|
||||
|
||||
// Reexported core operators
|
||||
#[doc(no_inline)] |
||||
pub use marker::{Copy, Send, Sized, Sync}; |
||||
#[doc(no_inline)] |
||||
pub use ops::{Drop, Fn, FnMut, FnOnce}; |
||||
|
||||
// Reexported functions
|
||||
#[doc(no_inline)] |
||||
pub use mem::drop; |
||||
|
||||
// Reexported types and traits
|
||||
#[doc(no_inline)] |
||||
pub use boxed::Box; |
||||
#[doc(no_inline)] |
||||
pub use borrow::ToOwned; |
||||
#[doc(no_inline)] |
||||
pub use clone::Clone; |
||||
#[doc(no_inline)] |
||||
pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; |
||||
#[doc(no_inline)] |
||||
pub use convert::{AsRef, AsMut, Into, From}; |
||||
#[doc(no_inline)] |
||||
pub use default::Default; |
||||
#[doc(no_inline)] |
||||
pub use iter::{Iterator, Extend, IntoIterator}; |
||||
#[doc(no_inline)] |
||||
pub use iter::{DoubleEndedIterator, ExactSizeIterator}; |
||||
#[doc(no_inline)] |
||||
pub use option::Option::{self, Some, None}; |
||||
#[doc(no_inline)] |
||||
pub use result::Result::{self, Ok, Err}; |
||||
#[doc(no_inline)] |
||||
pub use slice::SliceConcatExt; |
||||
#[doc(no_inline)] |
||||
pub use string::{String, ToString}; |
||||
#[doc(no_inline)] |
||||
pub use vec::Vec; |
||||
@ -0,0 +1,30 @@
@@ -0,0 +1,30 @@
|
||||
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
//! Runtime services
|
||||
//!
|
||||
//! The `rt` module provides a narrow set of runtime services,
|
||||
//! including the global heap (exported in `heap`) and unwinding and
|
||||
//! backtrace support. The APIs in this module are highly unstable,
|
||||
//! and should be considered as private implementation details for the
|
||||
//! time being.
|
||||
|
||||
use mem; |
||||
|
||||
// Reexport some of our utilities which are expected by other crates.
|
||||
pub use panicking::{begin_panic, begin_panic_fmt}; |
||||
|
||||
//TODO: Handle argc/argv arguments
|
||||
#[lang = "start"] |
||||
#[allow(unused_variables)] |
||||
fn lang_start(main: *const u8, argc: isize, argv: *const *const u8) -> isize { |
||||
unsafe { mem::transmute::<_, fn()>(main)(); } |
||||
0 |
||||
} |
||||
@ -0,0 +1,5 @@
@@ -0,0 +1,5 @@
|
||||
mod mutex; |
||||
|
||||
pub use self::mutex::{Mutex, MutexGuard}; |
||||
|
||||
pub type LockResult<T> = Result<T, ()>; |
||||
@ -0,0 +1,92 @@
@@ -0,0 +1,92 @@
|
||||
use cell::UnsafeCell; |
||||
use borrow::{Borrow, BorrowMut}; |
||||
use ops::{Deref, DerefMut}; |
||||
|
||||
use super::LockResult; |
||||
|
||||
use libctru::synchronization::*; |
||||
|
||||
/// A mutex based on libctru's LightLock primitive
|
||||
pub struct Mutex<T: ?Sized> { |
||||
mutex: Box<LightLock>, |
||||
data: UnsafeCell<T>, |
||||
} |
||||
|
||||
/// Mutex guard
|
||||
#[must_use] |
||||
pub struct MutexGuard<'a, T: ?Sized + 'a> { |
||||
inner: &'a Mutex<T>, |
||||
} |
||||
|
||||
// NOTE: This is used when implementing condvar, which hasn't been done yet
|
||||
#[allow(dead_code)] |
||||
pub fn guard_lock<'a, T: ?Sized + 'a>(guard: &'a MutexGuard<'a, T>) -> &'a LightLock { |
||||
&guard.inner.mutex |
||||
} |
||||
|
||||
impl<T> Mutex<T> { |
||||
pub fn new(t: T) -> Mutex<T> { |
||||
unsafe { |
||||
let mut mutex = Box::new(0); |
||||
LightLock_Init(mutex.borrow_mut()); |
||||
Mutex { |
||||
mutex: mutex, |
||||
data: UnsafeCell::new(t), |
||||
} |
||||
} |
||||
} |
||||
|
||||
pub fn into_inner(self) -> T { |
||||
unsafe { self.data.into_inner() } |
||||
} |
||||
} |
||||
|
||||
impl<T: ?Sized> Mutex<T> { |
||||
pub fn lock(&self) -> MutexGuard<T> { |
||||
unsafe { |
||||
LightLock_Lock(self.mutex.borrow()); |
||||
MutexGuard { inner: self } |
||||
} |
||||
} |
||||
|
||||
pub fn try_lock(&self) -> LockResult<MutexGuard<T>> { |
||||
unsafe { |
||||
let locked = LightLock_TryLock(self.mutex.borrow()); |
||||
if locked == 0 { |
||||
Ok(MutexGuard { inner: self }) |
||||
} else { |
||||
Err(()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
pub fn get_mut(&mut self) -> &mut T { |
||||
unsafe { &mut *self.data.get() } |
||||
} |
||||
} |
||||
|
||||
unsafe impl<T: ?Sized + Send> Send for Mutex<T> {} |
||||
unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {} |
||||
|
||||
impl<'a, T: ?Sized> Drop for MutexGuard<'a, T> { |
||||
fn drop(&mut self) { |
||||
unsafe { LightLock_Unlock(self.inner.mutex.borrow()); |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<'mutex, T: ?Sized> Deref for MutexGuard<'mutex, T> { |
||||
type Target = T; |
||||
|
||||
fn deref(&self) -> &T { |
||||
unsafe { &*self.inner.data.get() } |
||||
} |
||||
} |
||||
|
||||
impl<'mutex, T: ?Sized> DerefMut for MutexGuard<'mutex, T> { |
||||
fn deref_mut(&mut self) -> &mut T { |
||||
unsafe { &mut *self.inner.data.get() } |
||||
} |
||||
} |
||||
|
||||
impl<'a, T: ?Sized> !Send for MutexGuard<'a, T> {} |
||||
Loading…
Reference in new issue