7a9389330e
gcc/: * gcc.c (default_compilers): Add entry for ".go". * common.opt: Add -static-libgo as a driver option. * doc/install.texi (Configuration): Mention libgo as an option for --enable-shared. Mention go as an option for --enable-languages. * doc/invoke.texi (Overall Options): Mention .go as a file name suffix. Mention go as a -x option. * doc/frontends.texi (G++ and GCC): Mention Go as a supported language. * doc/sourcebuild.texi (Top Level): Mention libgo. * doc/standards.texi (Standards): Add section on Go language. Move references for other languages into their own section. * doc/contrib.texi (Contributors): Mention that I contributed the Go frontend. gcc/testsuite/: * lib/go.exp: New file. * lib/go-dg.exp: New file. * lib/go-torture.exp: New file. * lib/target-supports.exp (check_compile): Match // Go. From-SVN: r167407
203 lines
4.1 KiB
Go
203 lines
4.1 KiB
Go
// 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
|
|
}
|