core: Generalize uint-string conversions to all uint types

Issue #2239

src/libcore/core.rc

@@ -95,10 +95,10 @@ mod i64 {
 mod uint {
     import inst::{
         div_ceil, div_round, div_floor, hash, iterate,
-        next_power_of_two, parse_buf, from_str, to_str, str
+        next_power_of_two
     };
     export div_ceil, div_round, div_floor, hash, iterate,
-    next_power_of_two, parse_buf, from_str, to_str, str;
+    next_power_of_two;
 
     #[path = "uint.rs"]
     mod inst;
@@ -131,9 +131,6 @@ mod u32 {
 #[doc = "Operations and constants for `u64`"]
 #[path = "uint-template"]
 mod u64 {
-    import inst::{ to_str, str, from_str };
-    export to_str, str, from_str;
-
     #[path = "u64.rs"]
     mod inst;
 }

src/libcore/uint-template.rs

@@ -8,6 +8,7 @@ export is_positive, is_negative;
 export is_nonpositive, is_nonnegative;
 export range;
 export compl;
+export to_str, from_str, from_str_radix, str, parse_buf;
 
 const min_value: T = 0 as T;
 const max_value: T = 0 as T - 1 as T;
@@ -43,3 +44,118 @@ fn range(lo: T, hi: T, it: fn(T)) {
 pure fn compl(i: T) -> T {
     max_value ^ i
 }
+
+#[doc = "
+Parse a buffer of bytes
+
+# Arguments
+
+* buf - A byte buffer
+* radix - The base of the number
+
+# Failure
+
+`buf` must not be empty
+"]
+fn parse_buf(buf: [u8], radix: uint) -> option<T> {
+    if vec::len(buf) == 0u { ret none; }
+    let mut i = vec::len(buf) - 1u;
+    let mut power = 1u as T;
+    let mut n = 0u as T;
+    loop {
+        alt char::to_digit(buf[i] as char, radix) {
+          some(d) { n += d as T * power; }
+          none { ret none; }
+        }
+        power *= radix as T;
+        if i == 0u { ret some(n); }
+        i -= 1u;
+    };
+}
+
+#[doc = "Parse a string to an int"]
+fn from_str(s: str) -> option<T> { parse_buf(str::bytes(s), 10u) }
+
+#[doc = "Parse a string as an unsigned integer."]
+fn from_str_radix(buf: str, radix: u64) -> option<u64> {
+    if str::len(buf) == 0u { ret none; }
+    let mut i = str::len(buf) - 1u;
+    let mut power = 1u64, n = 0u64;
+    loop {
+        alt char::to_digit(buf[i] as char, radix as uint) {
+          some(d) { n += d as u64 * power; }
+          none { ret none; }
+        }
+        power *= radix;
+        if i == 0u { ret some(n); }
+        i -= 1u;
+    };
+}
+
+#[doc = "Convert to a string in a given base"]
+fn to_str(num: T, radix: uint) -> str {
+    assert (0u < radix && radix <= 16u);
+    let mut n = num;
+    let radix = radix as T;
+    fn digit(n: T) -> char {
+        ret alt n {
+              0u as T { '0' }
+              1u as T { '1' }
+              2u as T { '2' }
+              3u as T { '3' }
+              4u as T { '4' }
+              5u as T { '5' }
+              6u as T { '6' }
+              7u as T { '7' }
+              8u as T { '8' }
+              9u as T { '9' }
+              10u as T { 'a' }
+              11u as T { 'b' }
+              12u as T { 'c' }
+              13u as T { 'd' }
+              14u as T { 'e' }
+              15u as T { 'f' }
+              _ { fail }
+            };
+    }
+    if n == 0u as T { ret "0"; }
+    let mut s: str = "";
+    while n != 0u as T {
+        s += str::from_byte(digit(n % radix) as u8);
+        n /= radix;
+    }
+    let mut s1: str = "";
+    let mut len: uint = str::len(s);
+    while len != 0u { len -= 1u; s1 += str::from_byte(s[len]); }
+    ret s1;
+}
+
+#[doc = "Convert to a string"]
+fn str(i: T) -> str { ret to_str(i, 10u); }
+
+#[test]
+fn test_from_str() {
+    assert from_str("0") == some(0u as T);
+    assert from_str("3") == some(3u as T);
+    assert from_str("10") == some(10u as T);
+    assert from_str("123456789") == some(123456789u as T);
+    assert from_str("00100") == some(100u as T);
+
+    assert from_str("") == none;
+    assert from_str(" ") == none;
+    assert from_str("x") == none;
+}
+
+#[test]
+fn test_parse_buf() {
+    import str::bytes;
+    assert parse_buf(bytes("123"), 10u) == some(123u as T);
+    assert parse_buf(bytes("1001"), 2u) == some(9u as T);
+    assert parse_buf(bytes("123"), 8u) == some(83u as T);
+    assert parse_buf(bytes("123"), 16u) == some(291u as T);
+    assert parse_buf(bytes("ffff"), 16u) == some(65535u as T);
+    assert parse_buf(bytes("z"), 36u) == some(35u as T);
+
+    assert parse_buf(str::bytes("Z"), 10u) == none;
+    assert parse_buf(str::bytes("_"), 2u) == none;
+}

src/libcore/uint-template/u64.rs

@@ -1,62 +1 @@
 type T = u64;
-
-// Type-specific functions here. These must be reexported by the
-// parent module so that they appear in core::u8 and not core::u8::u8;
-
-
-// FIXME: Surely we can generalize this to apply to all uint types
-#[doc = "Convert to a string in a given base"]
-fn to_str(n: u64, radix: uint) -> str {
-    assert (0u < radix && radix <= 16u);
-
-    let r64 = radix as u64;
-
-    fn digit(n: u64) -> str {
-        ret alt n {
-              0u64 { "0" }
-              1u64 { "1" }
-              2u64 { "2" }
-              3u64 { "3" }
-              4u64 { "4" }
-              5u64 { "5" }
-              6u64 { "6" }
-              7u64 { "7" }
-              8u64 { "8" }
-              9u64 { "9" }
-              10u64 { "a" }
-              11u64 { "b" }
-              12u64 { "c" }
-              13u64 { "d" }
-              14u64 { "e" }
-              15u64 { "f" }
-              _ { fail }
-            };
-    }
-
-    if n == 0u64 { ret "0"; }
-
-    let mut s = "";
-
-    let mut n = n;
-    while n > 0u64 { s = digit(n % r64) + s; n /= r64; }
-    ret s;
-}
-
-#[doc = "Convert to a string"]
-fn str(n: u64) -> str { ret to_str(n, 10u); }
-
-#[doc = "Parse a string as an unsigned integer."]
-fn from_str(buf: str, radix: u64) -> option<u64> {
-    if str::len(buf) == 0u { ret none; }
-    let mut i = str::len(buf) - 1u;
-    let mut power = 1u64, n = 0u64;
-    loop {
-        alt char::to_digit(buf[i] as char, radix as uint) {
-          some(d) { n += d as u64 * power; }
-          none { ret none; }
-        }
-        power *= radix;
-        if i == 0u { ret some(n); }
-        i -= 1u;
-    };
-}

src/libcore/uint-template/uint.rs

@@ -89,104 +89,6 @@ fn next_power_of_two(n: uint) -> uint {
     ret tmp + 1u;
 }
 
-#[doc = "
-Parse a buffer of bytes
-
-# Arguments
-
-* buf - A byte buffer
-* radix - The base of the number
-
-# Failure
-
-`buf` must not be empty
-"]
-fn parse_buf(buf: [u8], radix: uint) -> option<uint> {
-    if vec::len(buf) == 0u { ret none; }
-    let mut i = vec::len(buf) - 1u;
-    let mut power = 1u;
-    let mut n = 0u;
-    loop {
-        alt char::to_digit(buf[i] as char, radix) {
-          some(d) { n += d * power; }
-          none { ret none; }
-        }
-        power *= radix;
-        if i == 0u { ret some(n); }
-        i -= 1u;
-    };
-}
-
-#[doc = "Parse a string to an int"]
-fn from_str(s: str) -> option<uint> { parse_buf(str::bytes(s), 10u) }
-
-#[doc = "Convert to a string in a given base"]
-fn to_str(num: uint, radix: uint) -> str {
-    let mut n = num;
-    assert (0u < radix && radix <= 16u);
-    fn digit(n: uint) -> char {
-        ret alt n {
-              0u { '0' }
-              1u { '1' }
-              2u { '2' }
-              3u { '3' }
-              4u { '4' }
-              5u { '5' }
-              6u { '6' }
-              7u { '7' }
-              8u { '8' }
-              9u { '9' }
-              10u { 'a' }
-              11u { 'b' }
-              12u { 'c' }
-              13u { 'd' }
-              14u { 'e' }
-              15u { 'f' }
-              _ { fail }
-            };
-    }
-    if n == 0u { ret "0"; }
-    let mut s: str = "";
-    while n != 0u {
-        s += str::from_byte(digit(n % radix) as u8);
-        n /= radix;
-    }
-    let mut s1: str = "";
-    let mut len: uint = str::len(s);
-    while len != 0u { len -= 1u; s1 += str::from_byte(s[len]); }
-    ret s1;
-}
-
-#[doc = "Convert to a string"]
-fn str(i: uint) -> str { ret to_str(i, 10u); }
-
-#[test]
-fn test_from_str() {
-    assert uint::from_str("0") == some(0u);
-    assert uint::from_str("3") == some(3u);
-    assert uint::from_str("10") == some(10u);
-    assert uint::from_str("123456789") == some(123456789u);
-    assert uint::from_str("00100") == some(100u);
-
-    assert uint::from_str("") == none;
-    assert uint::from_str(" ") == none;
-    assert uint::from_str("x") == none;
-}
-
-#[Test]
-fn test_parse_buf() {
-    import str::bytes;
-    assert uint::parse_buf(bytes("123"), 10u) == some(123u);
-    assert uint::parse_buf(bytes("1001"), 2u) == some(9u);
-    assert uint::parse_buf(bytes("123"), 8u) == some(83u);
-    assert uint::parse_buf(bytes("123"), 16u) == some(291u);
-    assert uint::parse_buf(bytes("ffff"), 16u) == some(65535u);
-    assert uint::parse_buf(bytes("z"), 36u) == some(35u);
-
-    assert uint::parse_buf(str::bytes("Z"), 10u) == none;
-    assert uint::parse_buf(str::bytes("_"), 2u) == none;
-}
-
 #[test]
 fn test_next_power_of_two() {
     assert (uint::next_power_of_two(0u) == 0u);

src/librustsyntax/parse/lexer.rs

@@ -223,7 +223,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
         if str::len(num_str) == 0u {
             rdr.fatal("no valid digits found for number");
         }
-        let parsed = option::get(u64::from_str(num_str, base as u64));
+        let parsed = option::get(u64::from_str_radix(num_str, base as u64));
         alt tp {
           either::left(t) { ret token::LIT_INT(parsed as i64, t); }
           either::right(t) { ret token::LIT_UINT(parsed, t); }
@@ -271,7 +271,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
         if str::len(num_str) == 0u {
             rdr.fatal("no valid digits found for number");
         }
-        let parsed = option::get(u64::from_str(num_str, base as u64));
+        let parsed = option::get(u64::from_str_radix(num_str, base as u64));
         ret token::LIT_INT(parsed as i64, ast::ty_i);
     }
 }