libgo/go/strconv/itoa.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   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 shorthand for 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) {
 155                 // It is known that base is a power of two and
 156                 // 2 <= base <= len(digits).
 157                 // Use shifts and masks instead of / and %.
 158                 shift := uint(bits.TrailingZeros(uint(base))) & 31
 159                 b := uint64(base)
 160                 m := uint(base) - 1 // == 1<<shift - 1
 161                 for u >= b {
 162                         i--
 163                         a[i] = digits[uint(u)&m]
 164                         u >>= shift
 165                 }
 166                 // u < base
 167                 i--
 168                 a[i] = digits[uint(u)]
 169         } else {
 170                 // general case
 171                 b := uint64(base)
 172                 for u >= b {
 173                         i--
 174                         // Avoid using r = a%b in addition to q = a/b
 175                         // since 64bit division and modulo operations
 176                         // are calculated by runtime functions on 32bit machines.
 177                         q := u / b
 178                         a[i] = digits[uint(u-q*b)]
 179                         u = q
 180                 }
 181                 // u < base
 182                 i--
 183                 a[i] = digits[uint(u)]
 184         }
 185
 186         // add sign, if any
 187         if neg {
 188                 i--
 189                 a[i] = '-'
 190         }
 191
 192         if append_ {
 193                 d = append(dst, a[i:]...)
 194                 return
 195         }
 196         s = string(a[i:])
 197         return
 198 }
 199
 200 func isPowerOfTwo(x int) bool {
 201         return x&(x-1) == 0
 202 }