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
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Macros for big integer literals.

/// Create a [UBig](crate::UBig) value.
///
/// Usually just pass use a numeric literal. This works for bases 2, 8, 10 or 16 using standard
/// prefixes:
/// ```
/// # use ibig::ubig;
/// let a = ubig!(100);
/// let b = ubig!(0b101);
/// let c = ubig!(0o202);
/// let d = ubig!(0x2ff);
/// ```
///
/// For an arbitrary base, add `base N`:
/// ```
/// # use ibig::ubig;
/// let e = ubig!(a3gp1 base 32);
/// ```
///
/// If the sequence of digits is not a valid Rust literal or identifier, put an underscore before
/// the digits. This may be necessary when:
/// * There are a lot of digits. Rust will fail to compile without an underscore if the number
///   wouldn't fit in `u128`.
/// * The first digit is decimal, but not all digits are decimal.
/// ```
/// # use ibig::ubig;
/// let f = ubig!(_314159265358979323846264338327950288419716939937);
/// let g = ubig!(_0b102 base 32);
/// let h = ubig!(b102 base 32);
/// assert_eq!(g, h);
/// let i = ubig!(_100ef base 32);
/// ```
#[macro_export]
macro_rules! ubig {
    ($val:ident) => {{
        let s = ::core::stringify!($val);
        let s = ::core::option::Option::unwrap_or(::core::primitive::str::strip_prefix(s, "_"), s);
        ::core::result::Result::expect(
            $crate::UBig::from_str_with_radix_prefix(s),
            "invalid number",
        )
    }};
    ($val:ident base $radix:literal) => {{
        let s = ::core::stringify!($val);
        let s = ::core::option::Option::unwrap_or(::core::primitive::str::strip_prefix(s, "_"), s);
        ::core::result::Result::expect($crate::UBig::from_str_radix(s, $radix), "invalid number")
    }};
    ($val:literal) => {{
        let val: ::core::primitive::u128 = $val;
        <$crate::UBig as ::core::convert::From<::core::primitive::u128>>::from(val)
    }};
    ($val:literal base $radix:literal) => {{
        let s = ::core::stringify!($val);
        let s = ::core::option::Option::unwrap_or(::core::primitive::str::strip_prefix(s, "_"), s);
        ::core::result::Result::expect($crate::UBig::from_str_radix(s, $radix), "invalid number")
    }};
}

/// Create an [IBig](crate::IBig) value.
///
/// Usually just pass use a numeric literal. This works for bases 2, 8, 10 or 16 using standard
/// prefixes:
/// ```
/// # use ibig::ibig;
/// let a = ibig!(100);
/// let b = ibig!(-0b101);
/// let c = ibig!(0o202);
/// let d = ibig!(-0x2ff);
/// ```
///
/// For an arbitrary base, add `base N`:
/// ```
/// # use ibig::ibig;
/// let e = ibig!(-a3gp1 base 32);
/// ```
///
/// If the sequence of digits is not a valid Rust literal or identifier, put an underscore before
/// the digits. This may be necessary when:
/// * There are a lot of digits. Rust will fail to compile without an underscore if the number
///   wouldn't fit in `u128`.
/// * The first digit is decimal, but not all digits are decimal.
/// ```
/// # use ibig::ibig;
/// let f = ibig!(-_314159265358979323846264338327950288419716939937);
/// let g = ibig!(_0b102 base 32);
/// let h = ibig!(b102 base 32);
/// assert_eq!(g, h);
/// let i = ibig!(-_100ef base 32);
/// ```
#[macro_export]
macro_rules! ibig {
    (- $val:ident) => {
        - <$crate::IBig as ::core::convert::From<$crate::UBig>>::from($crate::ubig!($val))
    };
    (- $val:ident base $radix:literal) => {
        - <$crate::IBig as ::core::convert::From<$crate::UBig>>::from(
            $crate::ubig!($val base $radix)
        )
    };
    (- $val:literal) => {
        - <$crate::IBig as ::core::convert::From<$crate::UBig>>::from($crate::ubig!($val))
    };
    (- $val:literal base $radix:literal) => {
        - <$crate::IBig as ::core::convert::From<$crate::UBig>>::from(
            $crate::ubig!($val base $radix)
        )
    };
    ($val:ident) => {
        <$crate::IBig as ::core::convert::From<$crate::UBig>>::from($crate::ubig!($val))
    };
    ($val:ident base $radix:literal) => {
        <$crate::IBig as ::core::convert::From<$crate::UBig>>::from(
            $crate::ubig!($val base $radix)
        )
    };
    ($val:literal) => {
        <$crate::IBig as ::core::convert::From<$crate::UBig>>::from($crate::ubig!($val))
    };
    ($val:literal base $radix:literal) => {
        <$crate::IBig as ::core::convert::From<$crate::UBig>>::from(
            $crate::ubig!($val base $radix)
        )
    };
}