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 // FormatUint returns the string representation of i in the given base.
   8 func FormatUint(i uint64, base int) string {
   9         _, s := formatBits(nil, i, base, false, false)
  10         return s
  11 }
  12
  13 // FormatInt returns the string representation of i in the given base.
  14 func FormatInt(i int64, base int) string {
  15         _, s := formatBits(nil, uint64(i), base, i < 0, false)
  16         return s
  17 }
  18
  19 // Itoa is shorthand for FormatInt(i, 10).
  20 func Itoa(i int) string {
  21         return FormatInt(int64(i), 10)
  22 }
  23
  24 // AppendInt appends the string form of the integer i,
  25 // as generated by FormatInt, to dst and returns the extended buffer.
  26 func AppendInt(dst []byte, i int64, base int) []byte {
  27         dst, _ = formatBits(dst, uint64(i), base, i < 0, true)
  28         return dst
  29 }
  30
  31 // AppendUint appends the string form of the unsigned integer i,
  32 // as generated by FormatUint, to dst and returns the extended buffer.
  33 func AppendUint(dst []byte, i uint64, base int) []byte {
  34         dst, _ = formatBits(dst, i, base, false, true)
  35         return dst
  36 }
  37
  38 const (
  39         digits   = "0123456789abcdefghijklmnopqrstuvwxyz"
  40         digits01 = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
  41         digits10 = "0000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999"
  42 )
  43
  44 var shifts = [len(digits) + 1]uint{
  45         1 << 1: 1,
  46         1 << 2: 2,
  47         1 << 3: 3,
  48         1 << 4: 4,
  49         1 << 5: 5,
  50 }
  51
  52 // formatBits computes the string representation of u in the given base.
  53 // If neg is set, u is treated as negative int64 value. If append_ is
  54 // set, the string is appended to dst and the resulting byte slice is
  55 // returned as the first result value; otherwise the string is returned
  56 // as the second result value.
  57 //
  58 func formatBits(dst []byte, u uint64, base int, neg, append_ bool) (d []byte, s string) {
  59         if base < 2 || base > len(digits) {
  60                 panic("strconv: illegal AppendInt/FormatInt base")
  61         }
  62         // 2 <= base && base <= len(digits)
  63
  64         var a [64 + 1]byte // +1 for sign of 64bit value in base 2
  65         i := len(a)
  66
  67         if neg {
  68                 u = -u
  69         }
  70
  71         // convert bits
  72         if base == 10 {
  73                 // common case: use constants for / and % because
  74                 // the compiler can optimize it into a multiply+shift,
  75                 // and unroll loop
  76                 for u >= 100 {
  77                         i -= 2
  78                         q := u / 100
  79                         j := uintptr(u - q*100)
  80                         a[i+1] = digits01[j]
  81                         a[i+0] = digits10[j]
  82                         u = q
  83                 }
  84                 if u >= 10 {
  85                         i--
  86                         q := u / 10
  87                         a[i] = digits[uintptr(u-q*10)]
  88                         u = q
  89                 }
  90
  91         } else if s := shifts[base]; s > 0 {
  92                 // base is power of 2: use shifts and masks instead of / and %
  93                 b := uint64(base)
  94                 m := uintptr(b) - 1 // == 1<<s - 1
  95                 for u >= b {
  96                         i--
  97                         a[i] = digits[uintptr(u)&m]
  98                         u >>= s
  99                 }
 100
 101         } else {
 102                 // general case
 103                 b := uint64(base)
 104                 for u >= b {
 105                         i--
 106                         a[i] = digits[uintptr(u%b)]
 107                         u /= b
 108                 }
 109         }
 110
 111         // u < base
 112         i--
 113         a[i] = digits[uintptr(u)]
 114
 115         // add sign, if any
 116         if neg {
 117                 i--
 118                 a[i] = '-'
 119         }
 120
 121         if append_ {
 122                 d = append(dst, a[i:]...)
 123                 return
 124         }
 125         s = string(a[i:])
 126         return
 127 }