2008-11-17 13:34:03 -07:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package strconv
|
2008-11-18 18:12:07 -07:00
|
|
|
import "os"
|
|
|
|
|
2009-01-15 18:22:17 -07:00
|
|
|
func computeIntsize() uint {
|
2008-11-18 18:12:07 -07:00
|
|
|
siz := uint(8);
|
|
|
|
for 1<<siz != 0 {
|
|
|
|
siz *= 2
|
|
|
|
}
|
|
|
|
return siz
|
|
|
|
}
|
2009-01-15 18:22:17 -07:00
|
|
|
var intsize = computeIntsize();
|
2008-11-17 13:34:03 -07:00
|
|
|
|
2009-02-16 21:44:21 -07:00
|
|
|
// Return the first number n such that n*base >= 1<<64.
|
|
|
|
func cutoff64(base int) uint64 {
|
|
|
|
if base < 2 {
|
|
|
|
return 0;
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
2009-02-16 21:44:21 -07:00
|
|
|
return (1<<64 - 1) / uint64(base) + 1;
|
|
|
|
}
|
2008-11-17 13:34:03 -07:00
|
|
|
|
2009-03-05 16:29:04 -07:00
|
|
|
// Btoui64 interprets a string s in an arbitrary base b (2 to 36)
|
|
|
|
// and returns the corresponding value n.
|
|
|
|
//
|
|
|
|
// Btoui64 returns err == os.EINVAL if b is out of
|
|
|
|
// range or s is empty or contains invalid digits.
|
|
|
|
// It returns err == os.ERANGE if the value corresponding
|
|
|
|
// to s cannot be represented by a uint64.
|
|
|
|
func Btoui64(s string, b int) (n uint64, err *os.Error) {
|
|
|
|
if b < 2 || b > 36 || len(s) < 1 {
|
2009-02-16 21:44:21 -07:00
|
|
|
return 0, os.EINVAL;
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
2008-11-18 18:12:07 -07:00
|
|
|
|
2009-02-16 21:44:21 -07:00
|
|
|
n = 0;
|
2009-03-05 16:29:04 -07:00
|
|
|
cutoff := cutoff64(b);
|
2008-11-17 13:34:03 -07:00
|
|
|
|
|
|
|
for i := 0; i < len(s); i++ {
|
2009-02-16 21:44:21 -07:00
|
|
|
var v byte;
|
|
|
|
switch {
|
|
|
|
case '0' <= s[i] && s[i] <= '9':
|
|
|
|
v = s[i] - '0';
|
|
|
|
case 'a' <= s[i] && s[i] <= 'z':
|
|
|
|
v = s[i] - 'a' + 10;
|
|
|
|
case 'A' <= s[i] && s[i] <= 'Z':
|
|
|
|
v = s[i] - 'A' + 10;
|
|
|
|
default:
|
|
|
|
return 0, os.EINVAL;
|
2008-11-18 18:12:07 -07:00
|
|
|
}
|
2009-03-05 16:29:04 -07:00
|
|
|
if int(v) >= b {
|
2009-02-16 21:44:21 -07:00
|
|
|
return 0, os.EINVAL;
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
2009-02-16 21:44:21 -07:00
|
|
|
|
|
|
|
if n >= cutoff {
|
2009-03-05 16:29:04 -07:00
|
|
|
// n*b overflows
|
2009-02-16 21:44:21 -07:00
|
|
|
return 1<<64-1, os.ERANGE;
|
|
|
|
}
|
2009-03-05 16:29:04 -07:00
|
|
|
n *= uint64(b);
|
2009-02-16 21:44:21 -07:00
|
|
|
|
|
|
|
n1 := n+uint64(v);
|
|
|
|
if n1 < n {
|
|
|
|
// n+v overflows
|
|
|
|
return 1<<64-1, os.ERANGE;
|
2008-11-18 18:12:07 -07:00
|
|
|
}
|
2009-02-16 21:44:21 -07:00
|
|
|
n = n1;
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
2009-02-16 21:44:21 -07:00
|
|
|
|
|
|
|
return n, nil;
|
|
|
|
}
|
|
|
|
|
2009-03-05 16:29:04 -07:00
|
|
|
// Atoui64 interprets a string s as an unsigned decimal, octal, or
|
|
|
|
// hexadecimal number and returns the corresponding value n.
|
|
|
|
// The default base is decimal. Strings beginning with 0x are
|
|
|
|
// hexadecimal; strings beginning with 0 are octal.
|
|
|
|
//
|
|
|
|
// Atoui64 returns err == os.EINVAL if s is empty or contains invalid digits.
|
|
|
|
// It returns err == os.ERANGE if s cannot be represented by a uint64.
|
|
|
|
func Atoui64(s string) (n uint64, err *os.Error) {
|
2009-02-16 21:44:21 -07:00
|
|
|
// Empty string bad.
|
|
|
|
if len(s) == 0 {
|
|
|
|
return 0, os.EINVAL
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look for octal, hex prefix.
|
|
|
|
if s[0] == '0' && len(s) > 1 {
|
|
|
|
if s[1] == 'x' || s[1] == 'X' {
|
|
|
|
// hex
|
2009-03-05 16:29:04 -07:00
|
|
|
return Btoui64(s[2:len(s)], 16);
|
2009-02-16 21:44:21 -07:00
|
|
|
}
|
|
|
|
// octal
|
2009-03-05 16:29:04 -07:00
|
|
|
return Btoui64(s[1:len(s)], 8);
|
2009-02-16 21:44:21 -07:00
|
|
|
}
|
|
|
|
// decimal
|
2009-03-05 16:29:04 -07:00
|
|
|
return Btoui64(s, 10);
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
|
|
|
|
2009-03-05 16:29:04 -07:00
|
|
|
|
|
|
|
// Atoi64 is like Atoui64 but allows signed numbers and
|
|
|
|
// returns its result in an int64.
|
2009-01-20 15:40:40 -07:00
|
|
|
func Atoi64(s string) (i int64, err *os.Error) {
|
2009-02-16 21:44:21 -07:00
|
|
|
// Empty string bad.
|
2008-11-17 13:34:03 -07:00
|
|
|
if len(s) == 0 {
|
2008-11-18 18:12:07 -07:00
|
|
|
return 0, os.EINVAL
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
|
|
|
|
2009-02-16 21:44:21 -07:00
|
|
|
// Pick off leading sign.
|
2008-11-17 13:34:03 -07:00
|
|
|
neg := false;
|
|
|
|
if s[0] == '+' {
|
|
|
|
s = s[1:len(s)]
|
|
|
|
} else if s[0] == '-' {
|
|
|
|
neg = true;
|
|
|
|
s = s[1:len(s)]
|
|
|
|
}
|
|
|
|
|
2009-02-16 21:44:21 -07:00
|
|
|
// Convert unsigned and check range.
|
2008-11-17 13:34:03 -07:00
|
|
|
var un uint64;
|
2009-01-15 18:22:17 -07:00
|
|
|
un, err = Atoui64(s);
|
2008-11-18 18:12:07 -07:00
|
|
|
if err != nil && err != os.ERANGE {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
if !neg && un >= 1<<63 {
|
|
|
|
return 1<<63-1, os.ERANGE
|
|
|
|
}
|
|
|
|
if neg && un > 1<<63 {
|
|
|
|
return -1<<63, os.ERANGE
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
|
|
|
n := int64(un);
|
|
|
|
if neg {
|
|
|
|
n = -n
|
|
|
|
}
|
2008-11-18 18:12:07 -07:00
|
|
|
return n, nil
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
|
|
|
|
2009-03-05 16:29:04 -07:00
|
|
|
// Atoui is like Atoui64 but returns its result as a uint.
|
2009-01-20 15:40:40 -07:00
|
|
|
func Atoui(s string) (i uint, err *os.Error) {
|
2009-01-15 18:22:17 -07:00
|
|
|
i1, e1 := Atoui64(s);
|
2008-11-18 18:12:07 -07:00
|
|
|
if e1 != nil && e1 != os.ERANGE {
|
|
|
|
return 0, e1
|
|
|
|
}
|
|
|
|
i = uint(i1);
|
|
|
|
if uint64(i) != i1 {
|
|
|
|
// TODO: return uint(^0), os.ERANGE.
|
|
|
|
i1 = 1<<64-1;
|
|
|
|
return uint(i1), os.ERANGE
|
|
|
|
}
|
|
|
|
return i, nil
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
|
|
|
|
2009-03-05 16:29:04 -07:00
|
|
|
// Atoi is like Atoi64 but returns its result as an int.
|
2009-01-20 15:40:40 -07:00
|
|
|
func Atoi(s string) (i int, err *os.Error) {
|
2009-01-15 18:22:17 -07:00
|
|
|
i1, e1 := Atoi64(s);
|
2008-11-18 18:12:07 -07:00
|
|
|
if e1 != nil && e1 != os.ERANGE {
|
|
|
|
return 0, e1
|
|
|
|
}
|
|
|
|
i = int(i1);
|
|
|
|
if int64(i) != i1 {
|
|
|
|
if i1 < 0 {
|
|
|
|
return -1<<(intsize-1), os.ERANGE
|
|
|
|
}
|
|
|
|
return 1<<(intsize-1) - 1, os.ERANGE
|
|
|
|
}
|
|
|
|
return i, nil
|
2008-11-17 13:34:03 -07:00
|
|
|
}
|
2008-11-18 18:12:07 -07:00
|
|
|
|