stdlib: add strconv package

Author: douyixuan

pkg/strconv/itoa.cell

@@ -0,0 +1,189 @@
+
+package strconv
+
+import (
+	// "math/bits"
+	"strings"
+)
+
+const nSmalls = 100
+const fastSmalls = true // enable fast path for small integers
+const digits = "0123456789abcdefghijklmnopqrstuvwxyz"
+const h32bit = -1^uint64(0)>>32
+const host32bit = h32bit == 0
+const smallsString = strings.Join([]string{"00010203040506070809",
+	"10111213141516171819",
+	"20212223242526272829",
+	"30313233343536373839",
+	"40414243444546474849",
+	"50515253545556575859",
+	"60616263646566676869",
+	"70717273747576777879",
+	"80818283848586878889",
+	"90919293949596979899"})
+
+func isPowerOfTwo(x int) bool {
+	ret := x&(x-1)
+	return ret == 0
+}
+
+// small returns the string for an i with 0 <= i < nSmalls.
+func small(i int) string {
+	if i < 10 {
+		return digits[i : i+1]
+	}
+	return smallsString[i*2 : i*2+2]
+}
+
+func formatBits(dst []byte, u uint64, base uint64, neg bool, append_ bool) ([]byte, string) {
+	var d []byte
+	var s string
+	// 2 <= base && base <= len(digits)
+	if base > len(digits) {
+		// panic("strconv: illegal AppendInt/FormatInt base")
+	}
+	if base < 2 {
+		// panic
+	}
+
+	var a [65]byte // 64 + 1, +1 for sign of 64bit value in base 2
+	i := uint64(len(a))
+
+	num := u
+	if neg {
+		num = -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 i ; num >= 1000000000 ; 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 := num / 1000000000
+				us := num - q*1000000000 // num % 1e9 fits into a uint
+				for j := 4; j > 0; j-- {
+					is := us % 100 * 2
+					us = us / 100
+					i = i - 2
+					str := "sdakj"
+					a[i+1] = str[is+uint64(1)]//smallsString[is+1]
+					a[i+0] = smallsString[is+uint64(0)]
+				}
+				// us < 10, since it contains the last digit
+				// from the initial 9-digit us.
+				idx := us*2+1
+				a[i-1] = smallsString[idx]
+				num = q
+			}
+			return d, s
+			// u < 1e9
+		}
+
+		// u guaranteed to fit into a uint
+		us := num
+		for us ;us >= 100; us = us / 100 {
+			is := us % 100 * 2
+			i = i - 2
+			a[i+1] = smallsString[is+uint64(1)]
+			a[i+0] = smallsString[is+uint64(0)]
+		}
+
+		// us < 100
+		is := us * 2
+		i--
+		a[i] = smallsString[is+uint64(1)]
+		if us >= 10 {
+			i--
+			a[i] = smallsString[is]
+		}
+	}  else if isPowerOfTwo(base) {
+		// Use shifts and masks instead of / and %.
+		// Base is a power of 2 and 2 <= base <= len(digits) where len(digits) is 36.
+		// The largest power of 2 below or equal to 36 is 32, which is 1 << 5;
+		// i.e., the largest possible shift count is 5. By &-ind that value with
+		// the constant 7 we tell the compiler that the shift count is always
+		// less than 8 which is smaller than any register width. This allows
+		// the compiler to generate better code for the shift operation.
+		shift := 1 //uint64(bits.TrailingZeros(uint(base))) & 7
+		b := base
+		m := base - 1 // == 1<<shift - 1
+		for num := u; num >= b; num = num >> shift {
+			i--
+			a[i] = digits[num&m]
+		}
+		// u < base
+		i--
+		a[i] = digits[num]
+	} else {
+		// general case
+		b := base
+		num := u
+		for num; num >= 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 - 1] = digits[num-q*b]
+			num = q
+		}
+		// u < base
+		i--
+		a[i] = digits[num]
+	}
+
+	// add sign, if any
+	if neg {
+		i--
+		a[i] = '-'
+	}
+
+	if append_ {
+		// d = append(dst, a[i:])
+		for j := uint32(0); j < len(a); j++ {
+			d = append(dst, a[j])
+		}
+		return d, s
+	}
+	// s = string(a[i:])
+	return d, s
+}
+
+// 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 int64) string {
+	ok := fastSmalls && i < nSmalls
+	ok = ok && base == int64(10)
+	if ok {
+		return small(int64(i))
+	}
+	_, s := formatBits([]byte{}, 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 int64) string {
+	ok := fastSmalls && 0 <= i
+	ok = ok && i < nSmalls
+	ok = ok && base == 10
+	if ok {
+		return small(int64(i))
+	}
+	_, s := formatBits([]byte{}, uint64(i), base, i < 0, false)
+	return s
+}
+
+// // Itoa is equivalent to FormatInt(int64(i), 10).
+// func Itoa(i int) string {
+// 	return FormatInt(int64(i), 10)
+// }