1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 #![macro_escape]
12 #![doc(hidden)]
13
14 macro_rules! int_module (($T:ty) => (
15
16 // String conversion functions and impl str -> num
17
18 /// Parse a byte slice as a number in the given base
19 ///
20 /// Yields an `Option` because `buf` may or may not actually be parseable.
21 ///
22 /// # Examples
23 ///
24 /// ```
25 /// let num = std::i64::parse_bytes([49,50,51,52,53,54,55,56,57], 10);
26 /// assert!(num == Some(123456789));
27 /// ```
28 #[inline]
29 pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
30 strconv::from_str_bytes_common(buf, radix, true, false, false,
31 strconv::ExpNone, false, false)
32 }
33
34 impl FromStr for $T {
35 #[inline]
36 fn from_str(s: &str) -> Option<$T> {
37 strconv::from_str_common(s, 10u, true, false, false,
38 strconv::ExpNone, false, false)
39 }
40 }
41
42 impl FromStrRadix for $T {
43 #[inline]
44 fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
45 strconv::from_str_common(s, radix, true, false, false,
46 strconv::ExpNone, false, false)
47 }
48 }
49
50 // String conversion functions and impl num -> str
51
52 /// Convert to a string as a byte slice in a given base.
53 ///
54 /// Use in place of x.to_str() when you do not need to store the string permanently
55 ///
56 /// # Examples
57 ///
58 /// ```
59 /// std::int::to_str_bytes(123, 10, |v| {
60 /// assert!(v == "123".as_bytes());
61 /// });
62 /// ```
63 #[inline]
64 pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
65 // The radix can be as low as 2, so we need at least 64 characters for a
66 // base 2 number, and then we need another for a possible '-' character.
67 let mut buf = [0u8, ..65];
68 let mut cur = 0;
69 strconv::int_to_str_bytes_common(n, radix, strconv::SignNeg, |i| {
70 buf[cur] = i;
71 cur += 1;
72 });
73 f(buf.slice(0, cur))
74 }
75
76 impl ToStrRadix for $T {
77 /// Convert to a string in a given base.
78 #[inline]
79 fn to_str_radix(&self, radix: uint) -> ~str {
80 use slice::Vector;
81 use str::StrAllocating;
82
83 let mut buf = ::vec::Vec::new();
84 strconv::int_to_str_bytes_common(*self, radix, strconv::SignNeg, |i| {
85 buf.push(i);
86 });
87 // We know we generated valid utf-8, so we don't need to go through that
88 // check.
89 unsafe { str::raw::from_utf8(buf.as_slice()).to_owned() }
90 }
91 }
92
93 #[cfg(test)]
94 mod tests {
95 use prelude::*;
96 use super::*;
97
98 use i32;
99 use num::ToStrRadix;
100 use str::StrSlice;
101
102 #[test]
103 fn test_from_str() {
104 assert_eq!(from_str::<$T>("0"), Some(0 as $T));
105 assert_eq!(from_str::<$T>("3"), Some(3 as $T));
106 assert_eq!(from_str::<$T>("10"), Some(10 as $T));
107 assert_eq!(from_str::<i32>("123456789"), Some(123456789 as i32));
108 assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
109
110 assert_eq!(from_str::<$T>("-1"), Some(-1 as $T));
111 assert_eq!(from_str::<$T>("-3"), Some(-3 as $T));
112 assert_eq!(from_str::<$T>("-10"), Some(-10 as $T));
113 assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
114 assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));
115
116 assert!(from_str::<$T>(" ").is_none());
117 assert!(from_str::<$T>("x").is_none());
118 }
119
120 #[test]
121 fn test_parse_bytes() {
122 use str::StrSlice;
123 assert_eq!(parse_bytes("123".as_bytes(), 10u), Some(123 as $T));
124 assert_eq!(parse_bytes("1001".as_bytes(), 2u), Some(9 as $T));
125 assert_eq!(parse_bytes("123".as_bytes(), 8u), Some(83 as $T));
126 assert_eq!(i32::parse_bytes("123".as_bytes(), 16u), Some(291 as i32));
127 assert_eq!(i32::parse_bytes("ffff".as_bytes(), 16u), Some(65535 as i32));
128 assert_eq!(i32::parse_bytes("FFFF".as_bytes(), 16u), Some(65535 as i32));
129 assert_eq!(parse_bytes("z".as_bytes(), 36u), Some(35 as $T));
130 assert_eq!(parse_bytes("Z".as_bytes(), 36u), Some(35 as $T));
131
132 assert_eq!(parse_bytes("-123".as_bytes(), 10u), Some(-123 as $T));
133 assert_eq!(parse_bytes("-1001".as_bytes(), 2u), Some(-9 as $T));
134 assert_eq!(parse_bytes("-123".as_bytes(), 8u), Some(-83 as $T));
135 assert_eq!(i32::parse_bytes("-123".as_bytes(), 16u), Some(-291 as i32));
136 assert_eq!(i32::parse_bytes("-ffff".as_bytes(), 16u), Some(-65535 as i32));
137 assert_eq!(i32::parse_bytes("-FFFF".as_bytes(), 16u), Some(-65535 as i32));
138 assert_eq!(parse_bytes("-z".as_bytes(), 36u), Some(-35 as $T));
139 assert_eq!(parse_bytes("-Z".as_bytes(), 36u), Some(-35 as $T));
140
141 assert!(parse_bytes("Z".as_bytes(), 35u).is_none());
142 assert!(parse_bytes("-9".as_bytes(), 2u).is_none());
143 }
144
145 #[test]
146 fn test_to_str() {
147 assert_eq!((0 as $T).to_str_radix(10u), "0".to_owned());
148 assert_eq!((1 as $T).to_str_radix(10u), "1".to_owned());
149 assert_eq!((-1 as $T).to_str_radix(10u), "-1".to_owned());
150 assert_eq!((127 as $T).to_str_radix(16u), "7f".to_owned());
151 assert_eq!((100 as $T).to_str_radix(10u), "100".to_owned());
152
153 }
154
155 #[test]
156 fn test_int_to_str_overflow() {
157 let mut i8_val: i8 = 127_i8;
158 assert_eq!(i8_val.to_str(), "127".to_owned());
159
160 i8_val += 1 as i8;
161 assert_eq!(i8_val.to_str(), "-128".to_owned());
162
163 let mut i16_val: i16 = 32_767_i16;
164 assert_eq!(i16_val.to_str(), "32767".to_owned());
165
166 i16_val += 1 as i16;
167 assert_eq!(i16_val.to_str(), "-32768".to_owned());
168
169 let mut i32_val: i32 = 2_147_483_647_i32;
170 assert_eq!(i32_val.to_str(), "2147483647".to_owned());
171
172 i32_val += 1 as i32;
173 assert_eq!(i32_val.to_str(), "-2147483648".to_owned());
174
175 let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
176 assert_eq!(i64_val.to_str(), "9223372036854775807".to_owned());
177
178 i64_val += 1 as i64;
179 assert_eq!(i64_val.to_str(), "-9223372036854775808".to_owned());
180 }
181
182 #[test]
183 fn test_int_from_str_overflow() {
184 let mut i8_val: i8 = 127_i8;
185 assert_eq!(from_str::<i8>("127"), Some(i8_val));
186 assert!(from_str::<i8>("128").is_none());
187
188 i8_val += 1 as i8;
189 assert_eq!(from_str::<i8>("-128"), Some(i8_val));
190 assert!(from_str::<i8>("-129").is_none());
191
192 let mut i16_val: i16 = 32_767_i16;
193 assert_eq!(from_str::<i16>("32767"), Some(i16_val));
194 assert!(from_str::<i16>("32768").is_none());
195
196 i16_val += 1 as i16;
197 assert_eq!(from_str::<i16>("-32768"), Some(i16_val));
198 assert!(from_str::<i16>("-32769").is_none());
199
200 let mut i32_val: i32 = 2_147_483_647_i32;
201 assert_eq!(from_str::<i32>("2147483647"), Some(i32_val));
202 assert!(from_str::<i32>("2147483648").is_none());
203
204 i32_val += 1 as i32;
205 assert_eq!(from_str::<i32>("-2147483648"), Some(i32_val));
206 assert!(from_str::<i32>("-2147483649").is_none());
207
208 let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
209 assert_eq!(from_str::<i64>("9223372036854775807"), Some(i64_val));
210 assert!(from_str::<i64>("9223372036854775808").is_none());
211
212 i64_val += 1 as i64;
213 assert_eq!(from_str::<i64>("-9223372036854775808"), Some(i64_val));
214 assert!(from_str::<i64>("-9223372036854775809").is_none());
215 }
216 }
217
218 ))