1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

pub use self::os::{imaxdiv_t};

use {char_t, int_t};
use stdint::{intmax_t, uintmax_t};
use stddef::{wchar_t};

#[cfg(target_os = "linux")]
#[path = "linux/mod.rs"]
mod os;

pub fn imaxabs(n: intmax_t) -> intmax_t {
    extern { fn imaxabs(n: intmax_t) -> intmax_t; }
    unsafe { imaxabs(n) }
}

pub fn imaxdiv(numer: intmax_t, denom: intmax_t) -> imaxdiv_t {
    extern { fn imaxdiv(numer: intmax_t, denom: intmax_t) -> imaxdiv_t; }
    unsafe { imaxdiv(numer, denom) }
}

extern "C" {
    pub fn strtoimax(nptr: *const char_t, endptr: *mut *mut char_t,
                     base: int_t) -> intmax_t;
    pub fn strtoumax(nptr: *const char_t, endptr: *mut *mut char_t,
                     base: int_t) -> uintmax_t;
    pub fn wcstoimax(nptr: *const wchar_t, endptr: *mut *mut wchar_t,
                     base: int_t) -> intmax_t;
    pub fn wcstoumax(nptr: *const wchar_t, endptr: *mut *mut wchar_t,
                     base: int_t) -> uintmax_t;
}

#[cfg(test)]
mod tests {
    use stdint::{intmax_t};
    use std::num::{Bounded, SignedInt};

    #[test]
    fn test_abs() {
        assert_eq!(super::imaxabs(-55), 55);
        assert_eq!(super::imaxabs(44), 44);
        let min: intmax_t = Bounded::min_value();
        assert_eq!(super::imaxabs(min + 55), SignedInt::abs(min + 55));
    }

    #[test]
    fn test_div() {
        let div = super::imaxdiv(4, 2);
        assert_eq!(div.quot, 2);
        assert_eq!(div.rem, 0);
        let div = super::imaxdiv(5, 2);
        assert_eq!(div.quot, 2);
        assert_eq!(div.rem, 1);
    }
}