| // 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 |
| |
| const fastSmalls = true // enable fast path for small integers |
| |
| // FormatUint returns the string representation of i in the given base, |
| // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' |
| // for digit values >= 10. |
| func FormatUint(i uint64, base int) string { |
| if fastSmalls && i < nSmalls && base == 10 { |
| return small(int(i)) |
| } |
| _, s := formatBits(nil, i, base, false, false) |
| return s |
| } |
| |
| // FormatInt returns the string representation of i in the given base, |
| // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' |
| // for digit values >= 10. |
| func FormatInt(i int64, base int) string { |
| if fastSmalls && 0 <= i && i < nSmalls && base == 10 { |
| return small(int(i)) |
| } |
| _, s := formatBits(nil, uint64(i), base, i < 0, false) |
| return s |
| } |
| |
| // Itoa is shorthand for FormatInt(int64(i), 10). |
| func Itoa(i int) string { |
| return FormatInt(int64(i), 10) |
| } |
| |
| // AppendInt appends the string form of the integer i, |
| // as generated by FormatInt, to dst and returns the extended buffer. |
| func AppendInt(dst []byte, i int64, base int) []byte { |
| if fastSmalls && 0 <= i && i < nSmalls && base == 10 { |
| return append(dst, small(int(i))...) |
| } |
| dst, _ = formatBits(dst, uint64(i), base, i < 0, true) |
| return dst |
| } |
| |
| // AppendUint appends the string form of the unsigned integer i, |
| // as generated by FormatUint, to dst and returns the extended buffer. |
| func AppendUint(dst []byte, i uint64, base int) []byte { |
| if fastSmalls && i < nSmalls && base == 10 { |
| return append(dst, small(int(i))...) |
| } |
| dst, _ = formatBits(dst, i, base, false, true) |
| return dst |
| } |
| |
| // small returns the string for an i with 0 <= i < nSmalls. |
| func small(i int) string { |
| off := 0 |
| if i < 10 { |
| off = 1 |
| } |
| return smallsString[i*2+off : i*2+2] |
| } |
| |
| const nSmalls = 100 |
| |
| const smallsString = "00010203040506070809" + |
| "10111213141516171819" + |
| "20212223242526272829" + |
| "30313233343536373839" + |
| "40414243444546474849" + |
| "50515253545556575859" + |
| "60616263646566676869" + |
| "70717273747576777879" + |
| "80818283848586878889" + |
| "90919293949596979899" |
| |
| const host32bit = ^uint(0)>>32 == 0 |
| |
| const digits = "0123456789abcdefghijklmnopqrstuvwxyz" |
| |
| var shifts = [len(digits) + 1]uint{ |
| 1 << 1: 1, |
| 1 << 2: 2, |
| 1 << 3: 3, |
| 1 << 4: 4, |
| 1 << 5: 5, |
| } |
| |
| // formatBits computes the string representation of u in the given base. |
| // If neg is set, u is treated as negative int64 value. If append_ is |
| // set, the string is appended to dst and the resulting byte slice is |
| // returned as the first result value; otherwise the string is returned |
| // as the second result value. |
| // |
| func formatBits(dst []byte, u uint64, base int, neg, append_ bool) (d []byte, s string) { |
| if base < 2 || base > len(digits) { |
| panic("strconv: illegal AppendInt/FormatInt base") |
| } |
| // 2 <= base && base <= len(digits) |
| |
| var a [64 + 1]byte // +1 for sign of 64bit value in base 2 |
| i := len(a) |
| |
| if neg { |
| u = -u |
| } |
| |
| // convert bits |
| // We use uint values where we can because those will |
| // fit into a single register even on a 32bit machine. |
| if base == 10 { |
| // common case: use constants for / because |
| // the compiler can optimize it into a multiply+shift |
| |
| if host32bit { |
| // convert the lower digits using 32bit operations |
| for u >= 1e9 { |
| // Avoid using r = a%b in addition to q = a/b |
| // since 64bit division and modulo operations |
| // are calculated by runtime functions on 32bit machines. |
| q := u / 1e9 |
| us := uint(u - q*1e9) // u % 1e9 fits into a uint |
| for j := 4; j > 0; j-- { |
| is := us % 100 * 2 |
| us /= 100 |
| i -= 2 |
| a[i+1] = smallsString[is+1] |
| a[i+0] = smallsString[is+0] |
| } |
| |
| // us < 10, since it contains the last digit |
| // from the initial 9-digit us. |
| i-- |
| a[i] = smallsString[us*2+1] |
| |
| u = q |
| } |
| // u < 1e9 |
| } |
| |
| // u guaranteed to fit into a uint |
| us := uint(u) |
| for us >= 100 { |
| is := us % 100 * 2 |
| us /= 100 |
| i -= 2 |
| a[i+1] = smallsString[is+1] |
| a[i+0] = smallsString[is+0] |
| } |
| |
| // us < 100 |
| is := us * 2 |
| i-- |
| a[i] = smallsString[is+1] |
| if us >= 10 { |
| i-- |
| a[i] = smallsString[is] |
| } |
| |
| } else if s := shifts[base]; s > 0 { |
| // base is power of 2: use shifts and masks instead of / and % |
| b := uint64(base) |
| m := uint(base) - 1 // == 1<<s - 1 |
| for u >= b { |
| i-- |
| a[i] = digits[uint(u)&m] |
| u >>= s |
| } |
| // u < base |
| i-- |
| a[i] = digits[uint(u)] |
| } else { |
| // general case |
| b := uint64(base) |
| for u >= b { |
| i-- |
| // Avoid using r = a%b in addition to q = a/b |
| // since 64bit division and modulo operations |
| // are calculated by runtime functions on 32bit machines. |
| q := u / b |
| a[i] = digits[uint(u-q*b)] |
| u = q |
| } |
| // u < base |
| i-- |
| a[i] = digits[uint(u)] |
| } |
| |
| // add sign, if any |
| if neg { |
| i-- |
| a[i] = '-' |
| } |
| |
| if append_ { |
| d = append(dst, a[i:]...) |
| return |
| } |
| s = string(a[i:]) |
| return |
| } |