...
Run Format

Source file src/strconv/itoa.go

Documentation: strconv

  // 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
  }
  

View as plain text