← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/strconv/atoi.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/strconv/atoi.go
20
20
}
21
21
 
22
22
func (e *NumError) Error() string {
23
 
        return "strconv." + e.Func + ": " + `parsing "` + e.Num + `": ` + e.Err.Error()
 
23
        return "strconv." + e.Func + ": " + "parsing " + Quote(e.Num) + ": " + e.Err.Error()
24
24
}
25
25
 
26
26
func syntaxError(fn, str string) *NumError {
44
44
}
45
45
 
46
46
// ParseUint is like ParseInt but for unsigned numbers.
47
 
func ParseUint(s string, b int, bitSize int) (n uint64, err error) {
 
47
func ParseUint(s string, base int, bitSize int) (n uint64, err error) {
48
48
        var cutoff, maxVal uint64
49
49
 
50
50
        if bitSize == 0 {
57
57
                err = ErrSyntax
58
58
                goto Error
59
59
 
60
 
        case 2 <= b && b <= 36:
 
60
        case 2 <= base && base <= 36:
61
61
                // valid base; nothing to do
62
62
 
63
 
        case b == 0:
 
63
        case base == 0:
64
64
                // Look for octal, hex prefix.
65
65
                switch {
66
66
                case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'):
67
 
                        b = 16
 
67
                        base = 16
68
68
                        s = s[2:]
69
69
                        if len(s) < 1 {
70
70
                                err = ErrSyntax
71
71
                                goto Error
72
72
                        }
73
73
                case s[0] == '0':
74
 
                        b = 8
 
74
                        base = 8
75
75
                default:
76
 
                        b = 10
 
76
                        base = 10
77
77
                }
78
78
 
79
79
        default:
80
 
                err = errors.New("invalid base " + Itoa(b))
 
80
                err = errors.New("invalid base " + Itoa(base))
81
81
                goto Error
82
82
        }
83
83
 
84
84
        n = 0
85
 
        cutoff = cutoff64(b)
 
85
        cutoff = cutoff64(base)
86
86
        maxVal = 1<<uint(bitSize) - 1
87
87
 
88
88
        for i := 0; i < len(s); i++ {
100
100
                        err = ErrSyntax
101
101
                        goto Error
102
102
                }
103
 
                if int(v) >= b {
 
103
                if int(v) >= base {
104
104
                        n = 0
105
105
                        err = ErrSyntax
106
106
                        goto Error
107
107
                }
108
108
 
109
109
                if n >= cutoff {
110
 
                        // n*b overflows
 
110
                        // n*base overflows
111
111
                        n = 1<<64 - 1
112
112
                        err = ErrRange
113
113
                        goto Error
114
114
                }
115
 
                n *= uint64(b)
 
115
                n *= uint64(base)
116
116
 
117
117
                n1 := n + uint64(v)
118
118
                if n1 < n || n1 > maxVal {