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
126
127
128
129
130
131
132
133

//! This crate implements 256-bit integer types.
//!
//! The implementation tries to follow as closely as possible to primitive
//! integer types, and should implement all the common methods and traits as the
//! primitive integer types.

#![deny(missing_docs)]
#![no_std]

#[cfg(test)]
extern crate alloc;

#[macro_use]
mod macros {
    #[macro_use]
    pub mod cmp;
    #[macro_use]
    pub mod fmt;
    #[macro_use]
    pub mod iter;
    #[macro_use]
    pub mod ops;
    #[macro_use]
    pub mod parse;
}

mod error;
mod fmt;
mod int;
pub mod intrinsics;
mod parse;
#[cfg(feature = "serde")]
pub mod serde;
mod uint;

/// Macro for 256-bit signed integer literal.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// # use ethnum::{int, I256};
/// assert_eq!(
///     int!(
///         "-57896044618658097711785492504343953926634992332820282019728792003956564819968"
///     ),
///     I256::MIN,
/// );
/// ```
///
/// Additionally, this macro accepts `0b` for binary, `0o` for octal, and `0x`
/// for hexadecimal literals. Using `_` for spacing is also permitted.
///
/// ```
/// # use ethnum::{int, I256};
/// assert_eq!(
///     int!(
///         "0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff
///            ffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff"
///     ),
///     I256::MAX,
/// );
/// assert_eq!(int!("0b101010"), 42);
/// assert_eq!(int!("-0o52"), -42);
/// ```
#[macro_export]
macro_rules! int {
    ($integer:literal) => {{
        const VALUE: $crate::I256 = $crate::I256::const_from_str_prefixed($integer);
        VALUE
    }};
}

/// Macro for 256-bit unsigned integer literal.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// # use ethnum::{uint, U256};
/// assert_eq!(
///     uint!(
///         "115792089237316195423570985008687907852837564279074904382605163141518161494337"
///     ),
///     U256::from_words(
///         0xfffffffffffffffffffffffffffffffe,
///         0xbaaedce6af48a03bbfd25e8cd0364141,
///     ),
/// );
/// ```
///
/// Additionally, this macro accepts `0b` for binary, `0o` for octal, and `0x`
/// for hexadecimal literals. Using `_` for spacing is also permitted.
///
/// ```
/// # use ethnum::{uint, U256};
/// assert_eq!(
///     uint!(
///         "0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff
///            ffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff"
///     ),
///     U256::MAX,
/// );
/// assert_eq!(uint!("0b101010"), 42);
/// assert_eq!(uint!("0o52"), 42);
/// ```
#[macro_export]
macro_rules! uint {
    ($integer:literal) => {{
        const VALUE: $crate::U256 = $crate::U256::const_from_str_prefixed($integer);
        VALUE
    }};
}

/// Convenience re-export of 256-integer types and as- conversion traits.
pub mod prelude {
    pub use crate::{AsI256, AsU256, I256, U256};
}

pub use crate::{
    int::{AsI256, I256},
    uint::{AsU256, U256},
};

/// A 256-bit signed integer type.
#[allow(non_camel_case_types)]
pub type i256 = I256;

/// A 256-bit unsigned integer type.
#[allow(non_camel_case_types)]
pub type u256 = U256;