Black Lives Matter. Support the Equal Justice Initiative.

# Source file src/strconv/itoa.go

## Documentation: strconv

```     1  // Copyright 2009 The Go Authors. All rights reserved.
2  // Use of this source code is governed by a BSD-style
4
5  package strconv
6
7  import "math/bits"
8
9  const fastSmalls = true // enable fast path for small integers
10
11  // FormatUint returns the string representation of i in the given base,
12  // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
13  // for digit values >= 10.
14  func FormatUint(i uint64, base int) string {
15  	if fastSmalls && i < nSmalls && base == 10 {
16  		return small(int(i))
17  	}
18  	_, s := formatBits(nil, i, base, false, false)
19  	return s
20  }
21
22  // FormatInt returns the string representation of i in the given base,
23  // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
24  // for digit values >= 10.
25  func FormatInt(i int64, base int) string {
26  	if fastSmalls && 0 <= i && i < nSmalls && base == 10 {
27  		return small(int(i))
28  	}
29  	_, s := formatBits(nil, uint64(i), base, i < 0, false)
30  	return s
31  }
32
33  // Itoa is equivalent to FormatInt(int64(i), 10).
34  func Itoa(i int) string {
35  	return FormatInt(int64(i), 10)
36  }
37
38  // AppendInt appends the string form of the integer i,
39  // as generated by FormatInt, to dst and returns the extended buffer.
40  func AppendInt(dst []byte, i int64, base int) []byte {
41  	if fastSmalls && 0 <= i && i < nSmalls && base == 10 {
42  		return append(dst, small(int(i))...)
43  	}
44  	dst, _ = formatBits(dst, uint64(i), base, i < 0, true)
45  	return dst
46  }
47
48  // AppendUint appends the string form of the unsigned integer i,
49  // as generated by FormatUint, to dst and returns the extended buffer.
50  func AppendUint(dst []byte, i uint64, base int) []byte {
51  	if fastSmalls && i < nSmalls && base == 10 {
52  		return append(dst, small(int(i))...)
53  	}
54  	dst, _ = formatBits(dst, i, base, false, true)
55  	return dst
56  }
57
58  // small returns the string for an i with 0 <= i < nSmalls.
59  func small(i int) string {
60  	if i < 10 {
61  		return digits[i : i+1]
62  	}
63  	return smallsString[i*2 : i*2+2]
64  }
65
66  const nSmalls = 100
67
68  const smallsString = "00010203040506070809" +
69  	"10111213141516171819" +
70  	"20212223242526272829" +
71  	"30313233343536373839" +
72  	"40414243444546474849" +
73  	"50515253545556575859" +
74  	"60616263646566676869" +
75  	"70717273747576777879" +
76  	"80818283848586878889" +
77  	"90919293949596979899"
78
79  const host32bit = ^uint(0)>>32 == 0
80
81  const digits = "0123456789abcdefghijklmnopqrstuvwxyz"
82
83  // formatBits computes the string representation of u in the given base.
84  // If neg is set, u is treated as negative int64 value. If append_ is
85  // set, the string is appended to dst and the resulting byte slice is
86  // returned as the first result value; otherwise the string is returned
87  // as the second result value.
88  //
89  func formatBits(dst []byte, u uint64, base int, neg, append_ bool) (d []byte, s string) {
90  	if base < 2 || base > len(digits) {
91  		panic("strconv: illegal AppendInt/FormatInt base")
92  	}
93  	// 2 <= base && base <= len(digits)
94
95  	var a [64 + 1]byte // +1 for sign of 64bit value in base 2
96  	i := len(a)
97
98  	if neg {
99  		u = -u
100  	}
101
102  	// convert bits
103  	// We use uint values where we can because those will
104  	// fit into a single register even on a 32bit machine.
105  	if base == 10 {
106  		// common case: use constants for / because
107  		// the compiler can optimize it into a multiply+shift
108
109  		if host32bit {
110  			// convert the lower digits using 32bit operations
111  			for u >= 1e9 {
112  				// Avoid using r = a%b in addition to q = a/b
113  				// since 64bit division and modulo operations
114  				// are calculated by runtime functions on 32bit machines.
115  				q := u / 1e9
116  				us := uint(u - q*1e9) // u % 1e9 fits into a uint
117  				for j := 4; j > 0; j-- {
118  					is := us % 100 * 2
119  					us /= 100
120  					i -= 2
121  					a[i+1] = smallsString[is+1]
122  					a[i+0] = smallsString[is+0]
123  				}
124
125  				// us < 10, since it contains the last digit
126  				// from the initial 9-digit us.
127  				i--
128  				a[i] = smallsString[us*2+1]
129
130  				u = q
131  			}
132  			// u < 1e9
133  		}
134
135  		// u guaranteed to fit into a uint
136  		us := uint(u)
137  		for us >= 100 {
138  			is := us % 100 * 2
139  			us /= 100
140  			i -= 2
141  			a[i+1] = smallsString[is+1]
142  			a[i+0] = smallsString[is+0]
143  		}
144
145  		// us < 100
146  		is := us * 2
147  		i--
148  		a[i] = smallsString[is+1]
149  		if us >= 10 {
150  			i--
151  			a[i] = smallsString[is]
152  		}
153
154  	} else if isPowerOfTwo(base) {
156  		// Base is a power of 2 and 2 <= base <= len(digits) where len(digits) is 36.
157  		// The largest power of 2 below or equal to 36 is 32, which is 1 << 5;
158  		// i.e., the largest possible shift count is 5. By &-ind that value with
159  		// the constant 7 we tell the compiler that the shift count is always
160  		// less than 8 which is smaller than any register width. This allows
161  		// the compiler to generate better code for the shift operation.
162  		shift := uint(bits.TrailingZeros(uint(base))) & 7
163  		b := uint64(base)
164  		m := uint(base) - 1 // == 1<<shift - 1
165  		for u >= b {
166  			i--
167  			a[i] = digits[uint(u)&m]
168  			u >>= shift
169  		}
170  		// u < base
171  		i--
172  		a[i] = digits[uint(u)]
173  	} else {
174  		// general case
175  		b := uint64(base)
176  		for u >= b {
177  			i--
178  			// Avoid using r = a%b in addition to q = a/b
179  			// since 64bit division and modulo operations
180  			// are calculated by runtime functions on 32bit machines.
181  			q := u / b
182  			a[i] = digits[uint(u-q*b)]
183  			u = q
184  		}
185  		// u < base
186  		i--
187  		a[i] = digits[uint(u)]
188  	}
189
190  	// add sign, if any
191  	if neg {
192  		i--
193  		a[i] = '-'
194  	}
195
196  	if append_ {
197  		d = append(dst, a[i:]...)
198  		return
199  	}
200  	s = string(a[i:])
201  	return
202  }
203
204  func isPowerOfTwo(x int) bool {
205  	return x&(x-1) == 0
206  }
207
```

View as plain text