DecodeBCD: use strings.Builder and optimize decoding [TO SQUASH]

Author: ligurio

decimal/bcd.go

@@ -63,7 +63,7 @@ var isNegative = map[byte]bool{
 
 // Calculate a number of digits in a buffer with decimal number.
 //
-// Plus, minus, point and leading zeros do not count.
+// Plus, minus, point and leading zeroes do not count.
 // Contains a quirk for a zero - returns 1.
 //
 // Examples (see more examples in tests):
@@ -125,7 +125,7 @@ func EncodeStringToBCD(buf string) ([]byte, error) {
 	scale := 0 // By default decimal number is integer.
 	var byteBuf []byte
 	for i, ch := range []byte(buf) {
-		// Skip leading zeros.
+		// Skip leading zeroes.
 		if (len(byteBuf) == 0) && ch == '0' {
 			continue
 		}
@@ -179,52 +179,77 @@ func EncodeStringToBCD(buf string) ([]byte, error) {
 // converted to a string. The BCD array is assumed full of digits, and must be
 // ended by a 4-bit sign nibble in the least significant four bits of the final
 // byte. The scale is used (negated) as the exponent of the decimal number.
-// Note that zeros may have a sign and/or a scale.
+// Note that zeroes may have a sign and/or a scale.
 func DecodeStringFromBCD(bcdBuf []byte) (string, error) {
-	const scaleIdx = 0 // Index of a byte with scale.
+	// Index of a byte with scale.
+	const scaleIdx = 0
 	scale := int(bcdBuf[scaleIdx])
-	// Get a BCD buffer without a byte with scale.
+
+	// Get a BCD buffer without scale.
 	bcdBuf = bcdBuf[scaleIdx+1:]
-	length := len(bcdBuf)
-	var digits []string
-	for i, bcdByte := range bcdBuf {
-		highNibble := bcdByte >> 4
-		digits = append(digits, string('0'+highNibble))
-		lowNibble := bcdByte & 0x0f
-		// lowNibble of last byte is ignored because it contains a
-		// sign.
-		if i != length-1 {
-			digits = append(digits, string('0'+lowNibble))
-		}
-	}
+	bufLen := len(bcdBuf)
 
-	// Add missing zeros when scale is less than current length.
-	l := len(digits)
-	if scale >= l {
-		var zeros []string
-		for i := 0; i <= scale-l; i++ {
-			zeros = append(zeros, "0")
-		}
-		digits = append(zeros, digits...)
+	// Every nibble contains a digit, and the last low nibble contains a
+	// sign.
+	ndigits := bufLen*2 - 1
+
+	// The first nibble contains 0 if the decimal number has an even number of
+	// digits. Decrease a number of digits if so.
+	if bcdBuf[0]&0xf0 == 0 {
+		ndigits -= 1
 	}
 
-	// Add a dot when number is fractional.
-	if scale != 0 {
-		idx := len(digits) - scale
-		digits = append(digits, "X")       // [1 2 3 X]
-		copy(digits[idx:], digits[idx-1:]) // [1 2 2 3]
-		digits[idx] = "."                  // [1 . 2 3]
+	// Reserve bytes for dot and sign.
+	numLen := ndigits + 2
+	// Reserve bytes for zeroes.
+	if scale >= ndigits {
+		numLen += scale - ndigits
 	}
 
+	var bld strings.Builder
+	bld.Grow(numLen)
+
 	// Add a sign, it is encoded in a low nibble of a last byte.
-	lastByte := bcdBuf[length-1]
+	lastByte := bcdBuf[bufLen-1]
 	sign := lastByte & 0x0f
 	if isNegative[sign] {
-		digits = append([]string{"-"}, digits...)
+		bld.WriteByte('-')
 	}
 
-	// Merge slice to a single string.
-	str := strings.Join(digits, "")
+	// Add missing zeroes to the left side when scale is bigger than a
+	// number of digits and a single missed zero to the right side when
+	// equal.
+	if scale > ndigits {
+		bld.WriteByte('0')
+		bld.WriteByte('.')
+		for diff := scale - ndigits; diff > 0; diff-- {
+			bld.WriteByte('0')
+		}
+	} else if scale == ndigits {
+		bld.WriteByte('0')
+	}
+
+	const MaxDigit = 0x09
+	// Builds a buffer with symbols of decimal number (digits, dot and sign).
+	processNibble := func(nibble byte) {
+		if nibble <= MaxDigit {
+			if ndigits == scale {
+				bld.WriteByte('.')
+			}
+			bld.WriteByte(nibble + '0')
+			ndigits--
+		}
+	}
+
+	for i, bcdByte := range bcdBuf {
+		highNibble := bcdByte >> 4
+		lowNibble := bcdByte & 0x0f
+		// Skip a first high nibble as no digit there.
+		if i != 0 || highNibble != 0 {
+			processNibble(highNibble)
+		}
+		processNibble(lowNibble)
+	}
 
-	return str, nil
+	return bld.String(), nil
 }