blob: f7b8456725bfa2e447f390cf484dfce369587a05 [file] [log] [blame]
// 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
import "os"
type NumError struct {
Num string
Error os.Error
}
func (e *NumError) String() string { return `parsing "` + e.Num + `": ` + e.Error.String() }
func computeIntsize() uint {
siz := uint(8)
for 1<<siz != 0 {
siz *= 2
}
return siz
}
var IntSize = computeIntsize()
// Return the first number n such that n*base >= 1<<64.
func cutoff64(base int) uint64 {
if base < 2 {
return 0
}
return (1<<64-1)/uint64(base) + 1
}
// Btoui64 interprets a string s in an arbitrary base b (2 to 36)
// and returns the corresponding value n. If b == 0, the base
// is taken from the string prefix: base 16 for "0x", base 8 for "0",
// and base 10 otherwise.
//
// The errors that Btoui64 returns have concrete type *NumError
// and include err.Num = s. If s is empty or contains invalid
// digits, err.Error = os.EINVAL; if the value corresponding
// to s cannot be represented by a uint64, err.Error = os.ERANGE.
func Btoui64(s string, b int) (n uint64, err os.Error) {
s0 := s
switch {
case len(s) < 1:
err = os.EINVAL
goto Error
case 2 <= b && b <= 36:
// valid base; nothing to do
case b == 0:
// Look for octal, hex prefix.
switch {
case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'):
b = 16
s = s[2:]
if len(s) < 1 {
err = os.EINVAL
goto Error
}
case s[0] == '0':
b = 8
default:
b = 10
}
default:
err = os.ErrorString("invalid base " + Itoa(b))
goto Error
}
n = 0
cutoff := cutoff64(b)
for i := 0; i < len(s); i++ {
var v byte
d := s[i]
switch {
case '0' <= d && d <= '9':
v = d - '0'
case 'a' <= d && d <= 'z':
v = d - 'a' + 10
case 'A' <= d && d <= 'Z':
v = d - 'A' + 10
default:
n = 0
err = os.EINVAL
goto Error
}
if int(v) >= b {
n = 0
err = os.EINVAL
goto Error
}
if n >= cutoff {
// n*b overflows
n = 1<<64 - 1
err = os.ERANGE
goto Error
}
n *= uint64(b)
n1 := n + uint64(v)
if n1 < n {
// n+v overflows
n = 1<<64 - 1
err = os.ERANGE
goto Error
}
n = n1
}
return n, nil
Error:
return n, &NumError{s0, err}
}
// Atoui64 interprets a string s as a decimal number and
// returns the corresponding value n.
//
// 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) {
return Btoui64(s, 10)
}
// Btoi64 is like Btoui64 but allows signed numbers and
// returns its result in an int64.
func Btoi64(s string, base int) (i int64, err os.Error) {
// Empty string bad.
if len(s) == 0 {
return 0, &NumError{s, os.EINVAL}
}
// Pick off leading sign.
s0 := s
neg := false
if s[0] == '+' {
s = s[1:]
} else if s[0] == '-' {
neg = true
s = s[1:]
}
// Convert unsigned and check range.
var un uint64
un, err = Btoui64(s, base)
if err != nil && err.(*NumError).Error != os.ERANGE {
err.(*NumError).Num = s0
return 0, err
}
if !neg && un >= 1<<63 {
return 1<<63 - 1, &NumError{s0, os.ERANGE}
}
if neg && un > 1<<63 {
return -1 << 63, &NumError{s0, os.ERANGE}
}
n := int64(un)
if neg {
n = -n
}
return n, nil
}
// Atoi64 is like Atoui64 but allows signed numbers and
// returns its result in an int64.
func Atoi64(s string) (i int64, err os.Error) { return Btoi64(s, 10) }
// Atoui is like Atoui64 but returns its result as a uint.
func Atoui(s string) (i uint, err os.Error) {
i1, e1 := Atoui64(s)
if e1 != nil && e1.(*NumError).Error != os.ERANGE {
return 0, e1
}
i = uint(i1)
if uint64(i) != i1 {
return ^uint(0), &NumError{s, os.ERANGE}
}
return i, nil
}
// Atoi is like Atoi64 but returns its result as an int.
func Atoi(s string) (i int, err os.Error) {
i1, e1 := Atoi64(s)
if e1 != nil && e1.(*NumError).Error != os.ERANGE {
return 0, e1
}
i = int(i1)
if int64(i) != i1 {
if i1 < 0 {
return -1 << (IntSize - 1), &NumError{s, os.ERANGE}
}
return 1<<(IntSize-1) - 1, &NumError{s, os.ERANGE}
}
return i, nil
}