Separate string->integer implementation in strconv

Author: brendanzab

src/librustc/metadata/decoder.rs

@@ -36,7 +36,7 @@ use std::io::extensions::u64_from_be_bytes;
 use std::io;
 use std::collections::hashmap::HashMap;
 use std::rc::Rc;
-use std::u64;
+use std::str;
 use rbml::reader;
 use rbml;
 use serialize::Decodable;
@@ -215,7 +215,9 @@ fn each_reexport(d: rbml::Doc, f: |rbml::Doc| -> bool) -> bool {
 
 fn variant_disr_val(d: rbml::Doc) -> Option<ty::Disr> {
     reader::maybe_get_doc(d, tag_disr_val).and_then(|val_doc| {
-        reader::with_doc_data(val_doc, |data| u64::parse_bytes(data, 10u))
+        reader::with_doc_data(val_doc, |data| {
+            str::from_utf8(data).and_then(from_str)
+        })
     })
 }
 

src/librustc/metadata/tydecode.rs

@@ -23,7 +23,6 @@ use middle::ty;
 use std::rc::Rc;
 use std::str;
 use std::string::String;
-use std::uint;
 use syntax::abi;
 use syntax::ast;
 use syntax::ast::*;
@@ -615,12 +614,12 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId {
     let crate_part = buf[0u..colon_idx];
     let def_part = buf[colon_idx + 1u..len];
 
-    let crate_num = match uint::parse_bytes(crate_part, 10u) {
+    let crate_num = match str::from_utf8(crate_part).and_then(from_str::<uint>) {
        Some(cn) => cn as ast::CrateNum,
        None => panic!("internal error: parse_def_id: crate number expected, found {}",
                      crate_part)
     };
-    let def_num = match uint::parse_bytes(def_part, 10u) {
+    let def_num = match str::from_utf8(def_part).and_then(from_str::<uint>) {
        Some(dn) => dn as ast::NodeId,
        None => panic!("internal error: parse_def_id: id expected, found {}",
                      def_part)

src/libstd/num/f32.rs

@@ -361,7 +361,7 @@ pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String {
 #[inline]
 pub fn from_str_hex(num: &str) -> Option<f32> {
     strconv::from_str_common(num, 16u, true, true, true,
-                             strconv::ExpBin, false, false)
+                             strconv::ExpBin, false)
 }
 
 impl FromStr for f32 {
@@ -393,7 +393,7 @@ impl FromStr for f32 {
     #[inline]
     fn from_str(val: &str) -> Option<f32> {
         strconv::from_str_common(val, 10u, true, true, true,
-                                 strconv::ExpDec, false, false)
+                                 strconv::ExpDec, false)
     }
 }
 
@@ -418,7 +418,7 @@ impl num::FromStrRadix for f32 {
     #[inline]
     fn from_str_radix(val: &str, rdx: uint) -> Option<f32> {
         strconv::from_str_common(val, rdx, true, true, false,
-                                 strconv::ExpNone, false, false)
+                                 strconv::ExpNone, false)
     }
 }
 

src/libstd/num/f64.rs

@@ -369,7 +369,7 @@ pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String {
 #[inline]
 pub fn from_str_hex(num: &str) -> Option<f64> {
     strconv::from_str_common(num, 16u, true, true, true,
-                             strconv::ExpBin, false, false)
+                             strconv::ExpBin, false)
 }
 
 impl FromStr for f64 {
@@ -401,7 +401,7 @@ impl FromStr for f64 {
     #[inline]
     fn from_str(val: &str) -> Option<f64> {
         strconv::from_str_common(val, 10u, true, true, true,
-                                 strconv::ExpDec, false, false)
+                                 strconv::ExpDec, false)
     }
 }
 
@@ -426,7 +426,7 @@ impl num::FromStrRadix for f64 {
     #[inline]
     fn from_str_radix(val: &str, rdx: uint) -> Option<f64> {
         strconv::from_str_common(val, rdx, true, true, false,
-                                 strconv::ExpNone, false, false)
+                                 strconv::ExpNone, false)
     }
 }
 

src/libstd/num/int_macros.rs

@@ -14,50 +14,26 @@
 
 macro_rules! int_module (($T:ty) => (
 
-// String conversion functions and impl str -> num
-
-/// Parse a byte slice as a number in the given base
-///
-/// Yields an `Option` because `buf` may or may not actually be parseable.
-///
-/// # Examples
-///
-/// ```
-/// let num = std::i64::parse_bytes([49,50,51,52,53,54,55,56,57], 10);
-/// assert!(num == Some(123456789));
-/// ```
-#[inline]
-#[experimental = "might need to return Result"]
-pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
-    strconv::from_str_bytes_common(buf, radix, true, false, false,
-                               strconv::ExpNone, false, false)
-}
-
 #[experimental = "might need to return Result"]
 impl FromStr for $T {
     #[inline]
     fn from_str(s: &str) -> Option<$T> {
-        strconv::from_str_common(s, 10u, true, false, false,
-                             strconv::ExpNone, false, false)
+        strconv::from_str_radix_int(s, 10)
     }
 }
 
 #[experimental = "might need to return Result"]
 impl FromStrRadix for $T {
     #[inline]
     fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
-        strconv::from_str_common(s, radix, true, false, false,
-                             strconv::ExpNone, false, false)
+        strconv::from_str_radix_int(s, radix)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use prelude::*;
-    use super::*;
-
-    use i32;
-    use str::StrSlice;
+    use num::FromStrRadix;
 
     #[test]
     fn test_from_str() {
@@ -73,33 +49,33 @@ mod tests {
         assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
         assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));
 
-        assert!(from_str::<$T>(" ").is_none());
-        assert!(from_str::<$T>("x").is_none());
+        assert_eq!(from_str::<$T>(""), None);
+        assert_eq!(from_str::<$T>(" "), None);
+        assert_eq!(from_str::<$T>("x"), None);
     }
 
     #[test]
-    fn test_parse_bytes() {
-        use str::StrSlice;
-        assert_eq!(parse_bytes("123".as_bytes(), 10u), Some(123 as $T));
-        assert_eq!(parse_bytes("1001".as_bytes(), 2u), Some(9 as $T));
-        assert_eq!(parse_bytes("123".as_bytes(), 8u), Some(83 as $T));
-        assert_eq!(i32::parse_bytes("123".as_bytes(), 16u), Some(291 as i32));
-        assert_eq!(i32::parse_bytes("ffff".as_bytes(), 16u), Some(65535 as i32));
-        assert_eq!(i32::parse_bytes("FFFF".as_bytes(), 16u), Some(65535 as i32));
-        assert_eq!(parse_bytes("z".as_bytes(), 36u), Some(35 as $T));
-        assert_eq!(parse_bytes("Z".as_bytes(), 36u), Some(35 as $T));
-
-        assert_eq!(parse_bytes("-123".as_bytes(), 10u), Some(-123 as $T));
-        assert_eq!(parse_bytes("-1001".as_bytes(), 2u), Some(-9 as $T));
-        assert_eq!(parse_bytes("-123".as_bytes(), 8u), Some(-83 as $T));
-        assert_eq!(i32::parse_bytes("-123".as_bytes(), 16u), Some(-291 as i32));
-        assert_eq!(i32::parse_bytes("-ffff".as_bytes(), 16u), Some(-65535 as i32));
-        assert_eq!(i32::parse_bytes("-FFFF".as_bytes(), 16u), Some(-65535 as i32));
-        assert_eq!(parse_bytes("-z".as_bytes(), 36u), Some(-35 as $T));
-        assert_eq!(parse_bytes("-Z".as_bytes(), 36u), Some(-35 as $T));
-
-        assert!(parse_bytes("Z".as_bytes(), 35u).is_none());
-        assert!(parse_bytes("-9".as_bytes(), 2u).is_none());
+    fn test_from_str_radix() {
+        assert_eq!(FromStrRadix::from_str_radix("123", 10), Some(123 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("1001", 2), Some(9 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("123", 8), Some(83 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("123", 16), Some(291 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("ffff", 16), Some(65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("FFFF", 16), Some(65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("z", 36), Some(35 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("Z", 36), Some(35 as $T));
+
+        assert_eq!(FromStrRadix::from_str_radix("-123", 10), Some(-123 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-1001", 2), Some(-9 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-123", 8), Some(-83 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-123", 16), Some(-291 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("-ffff", 16), Some(-65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("-FFFF", 16), Some(-65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("-z", 36), Some(-35 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-Z", 36), Some(-35 as $T));
+
+        assert_eq!(FromStrRadix::from_str_radix("Z", 35), None::<$T>);
+        assert_eq!(FromStrRadix::from_str_radix("-9", 2), None::<$T>);
     }
 
     #[test]
@@ -133,35 +109,35 @@ mod tests {
     fn test_int_from_str_overflow() {
         let mut i8_val: i8 = 127_i8;
         assert_eq!(from_str::<i8>("127"), Some(i8_val));
-        assert!(from_str::<i8>("128").is_none());
+        assert_eq!(from_str::<i8>("128"), None);
 
         i8_val += 1 as i8;
         assert_eq!(from_str::<i8>("-128"), Some(i8_val));
-        assert!(from_str::<i8>("-129").is_none());
+        assert_eq!(from_str::<i8>("-129"), None);
 
         let mut i16_val: i16 = 32_767_i16;
         assert_eq!(from_str::<i16>("32767"), Some(i16_val));
-        assert!(from_str::<i16>("32768").is_none());
+        assert_eq!(from_str::<i16>("32768"), None);
 
         i16_val += 1 as i16;
         assert_eq!(from_str::<i16>("-32768"), Some(i16_val));
-        assert!(from_str::<i16>("-32769").is_none());
+        assert_eq!(from_str::<i16>("-32769"), None);
 
         let mut i32_val: i32 = 2_147_483_647_i32;
         assert_eq!(from_str::<i32>("2147483647"), Some(i32_val));
-        assert!(from_str::<i32>("2147483648").is_none());
+        assert_eq!(from_str::<i32>("2147483648"), None);
 
         i32_val += 1 as i32;
         assert_eq!(from_str::<i32>("-2147483648"), Some(i32_val));
-        assert!(from_str::<i32>("-2147483649").is_none());
+        assert_eq!(from_str::<i32>("-2147483649"), None);
 
         let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
         assert_eq!(from_str::<i64>("9223372036854775807"), Some(i64_val));
-        assert!(from_str::<i64>("9223372036854775808").is_none());
+        assert_eq!(from_str::<i64>("9223372036854775808"), None);
 
         i64_val += 1 as i64;
         assert_eq!(from_str::<i64>("-9223372036854775808"), Some(i64_val));
-        assert!(from_str::<i64>("-9223372036854775809").is_none());
+        assert_eq!(from_str::<i64>("-9223372036854775809"), None);
     }
 }