|
| 1 | +// Package decimal implements methods to encode and decode BCD. |
| 2 | +// |
| 3 | +// BCD (Binary-Coded Decimal) is a sequence of bytes representing decimal |
| 4 | +// digits of the encoded number (each byte has two decimal digits each encoded |
| 5 | +// using 4-bit nibbles), so byte >> 4 is the first digit and byte & 0x0f is the |
| 6 | +// second digit. The leftmost digit in the array is the most significant. The |
| 7 | +// rightmost digit in the array is the least significant. |
| 8 | +// |
| 9 | +// The first byte of the BCD array contains the first digit of the number, |
| 10 | +// represented as follows: |
| 11 | +// |
| 12 | +// | 4 bits | 4 bits | |
| 13 | +// = 0x = the 1st digit |
| 14 | +// |
| 15 | +// (The first nibble contains 0 if the decimal number has an even number of |
| 16 | +// digits). The last byte of the BCD array contains the last digit of the |
| 17 | +// number and the final nibble, represented as follows: |
| 18 | +// |
| 19 | +// | 4 bits | 4 bits | |
| 20 | +// = the last digit = nibble |
| 21 | +// |
| 22 | +// The final nibble represents the number's sign: 0x0a, 0x0c, 0x0e, 0x0f stand |
| 23 | +// for plus, 0x0b and 0x0d stand for minus. |
| 24 | +// |
| 25 | +// Examples: |
| 26 | +// |
| 27 | +// The decimal -12.34 will be encoded as 0xd6, 0x01, 0x02, 0x01, 0x23, 0x4d: |
| 28 | +// |
| 29 | +// |MP_EXT (fixext 4) | MP_DECIMAL | scale | 1 | 2,3 | 4 (minus) | |
| 30 | +// | 0xd6 | 0x01 | 0x02 | 0x01 | 0x23 | 0x4d | |
| 31 | +// |
| 32 | +// The decimal 0.000000000000000000000000000000000010 will be encoded as |
| 33 | +// 0xc7, 0x03, 0x01, 0x24, 0x01, 0x0c: |
| 34 | +// |
| 35 | +// | MP_EXT (ext 8) | length | MP_DECIMAL | scale | 1 | 0 (plus) | |
| 36 | +// | 0xc7 | 0x03 | 0x01 | 0x24 | 0x01 | 0x0c | |
| 37 | +// |
| 38 | +// See also: |
| 39 | +// |
| 40 | +// * MessagePack extensions https://www.tarantool.io/en/doc/latest/dev_guide/internals/msgpack_extensions/ |
| 41 | +// |
| 42 | +// * An implementation in C language https://github.com/tarantool/decNumber/blob/master/decPacked.c |
| 43 | +package decimal |
| 44 | + |
| 45 | +import ( |
| 46 | + "fmt" |
| 47 | + "strings" |
| 48 | +) |
| 49 | + |
| 50 | +const ( |
| 51 | + bytePlus = byte(0x0c) |
| 52 | + byteMinus = byte(0x0d) |
| 53 | +) |
| 54 | + |
| 55 | +var isNegative = map[byte]bool{ |
| 56 | + 0x0a: false, |
| 57 | + 0x0b: true, |
| 58 | + 0x0c: false, |
| 59 | + 0x0d: true, |
| 60 | + 0x0e: false, |
| 61 | + 0x0f: false, |
| 62 | +} |
| 63 | + |
| 64 | +// Calculate a number of digits in a buffer with decimal number. |
| 65 | +// |
| 66 | +// Plus, minus, point and leading zeros do not count. |
| 67 | +// Contains a quirk for a zero - returns 1. |
| 68 | +// |
| 69 | +// Examples (see more examples in tests): |
| 70 | +// |
| 71 | +// - 0.0000000000000001 - 1 digit |
| 72 | +// |
| 73 | +// - 00012.34 - 4 digits |
| 74 | +// |
| 75 | +// - 0.340 - 3 digits |
| 76 | +// |
| 77 | +// - 0 - 1 digit |
| 78 | +func GetNumberLength(buf string) int { |
| 79 | + n := 0 |
| 80 | + for _, ch := range []byte(buf) { |
| 81 | + if ch == '0' && n != 0 { |
| 82 | + n += 1 |
| 83 | + continue |
| 84 | + } |
| 85 | + if ch >= '1' && ch <= '9' { |
| 86 | + n += 1 |
| 87 | + } |
| 88 | + } |
| 89 | + |
| 90 | + // Fix a case with a single 0. |
| 91 | + if n == 0 { |
| 92 | + n = 1 |
| 93 | + } |
| 94 | + |
| 95 | + return n |
| 96 | +} |
| 97 | + |
| 98 | +// EncodeStringToBCD converts a string buffer to BCD Packed Decimal. |
| 99 | +// |
| 100 | +// The number is converted to a BCD packed decimal byte array, right aligned in |
| 101 | +// the BCD array, whose length is indicated by the second parameter. The final |
| 102 | +// 4-bit nibble in the array will be a sign nibble, 0x0c for "+" and 0x0d for |
| 103 | +// "-". Unused bytes and nibbles to the left of the number are set to 0. scale |
| 104 | +// is set to the scale of the number (this is the exponent, negated). |
| 105 | +func EncodeStringToBCD(buf string) ([]byte, error) { |
| 106 | + if len(buf) == 0 { |
| 107 | + return nil, fmt.Errorf("Length of number is zero") |
| 108 | + } |
| 109 | + signByte := bytePlus // By default number is positive. |
| 110 | + if buf[0] == '-' { |
| 111 | + signByte = byteMinus |
| 112 | + } |
| 113 | + |
| 114 | + // The first nibble should contain 0, if the decimal number has an even |
| 115 | + // number of digits. Therefore highNibble is false when decimal number |
| 116 | + // is even. |
| 117 | + highNibble := true |
| 118 | + l := GetNumberLength(buf) |
| 119 | + if l%2 == 0 { |
| 120 | + highNibble = false |
| 121 | + } |
| 122 | + scale := 0 // By default decimal number is integer. |
| 123 | + var byteBuf []byte |
| 124 | + for i, ch := range []byte(buf) { |
| 125 | + // Skip leading zeros. |
| 126 | + if (len(byteBuf) == 0) && ch == '0' { |
| 127 | + continue |
| 128 | + } |
| 129 | + if (i == 0) && (ch == '-' || ch == '+') { |
| 130 | + continue |
| 131 | + } |
| 132 | + if ch == '.' && scale != 0 { |
| 133 | + return nil, fmt.Errorf("Number contains more than one point") |
| 134 | + } |
| 135 | + // Calculate a number of digits after the decimal point. |
| 136 | + if ch == '.' { |
| 137 | + scale = len(buf) - i - 1 |
| 138 | + continue |
| 139 | + } |
| 140 | + |
| 141 | + if ch < '0' || ch > '9' { |
| 142 | + return nil, fmt.Errorf("Failed to convert symbol '%c' to a digit", ch) |
| 143 | + } |
| 144 | + digit := byte(ch - '0') |
| 145 | + if highNibble { |
| 146 | + // Add a digit to a high nibble. |
| 147 | + digit = digit << 4 |
| 148 | + byteBuf = append(byteBuf, digit) |
| 149 | + highNibble = false |
| 150 | + } else { |
| 151 | + if len(byteBuf) == 0 { |
| 152 | + byteBuf = make([]byte, 1) |
| 153 | + } |
| 154 | + // Add a digit to a low nibble. |
| 155 | + lowByteIdx := len(byteBuf) - 1 |
| 156 | + byteBuf[lowByteIdx] = byteBuf[lowByteIdx] | digit |
| 157 | + highNibble = true |
| 158 | + } |
| 159 | + } |
| 160 | + if highNibble { |
| 161 | + // Put a sign to a high nibble. |
| 162 | + byteBuf = append(byteBuf, signByte) |
| 163 | + } else { |
| 164 | + // Put a sign to a low nibble. |
| 165 | + lowByteIdx := len(byteBuf) - 1 |
| 166 | + byteBuf[lowByteIdx] = byteBuf[lowByteIdx] | signByte |
| 167 | + } |
| 168 | + byteBuf = append([]byte{byte(scale)}, byteBuf...) |
| 169 | + |
| 170 | + return byteBuf, nil |
| 171 | +} |
| 172 | + |
| 173 | +// DecodeStringFromBCD converts a BCD Packed Decimal to a string buffer. |
| 174 | +// |
| 175 | +// The BCD packed decimal byte array, together with an associated scale, is |
| 176 | +// converted to a string. The BCD array is assumed full of digits, and must be |
| 177 | +// ended by a 4-bit sign nibble in the least significant four bits of the final |
| 178 | +// byte. The scale is used (negated) as the exponent of the decimal number. |
| 179 | +// Note that zeros may have a sign and/or a scale. |
| 180 | +func DecodeStringFromBCD(bcdBuf []byte) (string, error) { |
| 181 | + const scaleIdx = 0 // Index of a byte with scale. |
| 182 | + scale := int(bcdBuf[scaleIdx]) |
| 183 | + // Get a BCD buffer without a byte with scale. |
| 184 | + bcdBuf = bcdBuf[scaleIdx+1:] |
| 185 | + length := len(bcdBuf) |
| 186 | + var digits []string |
| 187 | + for i, bcdByte := range bcdBuf { |
| 188 | + highNibble := bcdByte >> 4 |
| 189 | + digits = append(digits, string('0'+highNibble)) |
| 190 | + lowNibble := bcdByte & 0x0f |
| 191 | + // lowNibble of last byte is ignored because it contains a |
| 192 | + // sign. |
| 193 | + if i != length-1 { |
| 194 | + digits = append(digits, string('0'+lowNibble)) |
| 195 | + } |
| 196 | + } |
| 197 | + |
| 198 | + // Add missing zeros when scale is less than current length. |
| 199 | + l := len(digits) |
| 200 | + if scale >= l { |
| 201 | + var zeros []string |
| 202 | + for i := 0; i <= scale-l; i++ { |
| 203 | + zeros = append(zeros, "0") |
| 204 | + } |
| 205 | + digits = append(zeros, digits...) |
| 206 | + } |
| 207 | + |
| 208 | + // Add a dot when number is fractional. |
| 209 | + if scale != 0 { |
| 210 | + idx := len(digits) - scale |
| 211 | + digits = append(digits, "X") // [1 2 3 X] |
| 212 | + copy(digits[idx:], digits[idx-1:]) // [1 2 2 3] |
| 213 | + digits[idx] = "." // [1 . 2 3] |
| 214 | + } |
| 215 | + |
| 216 | + // Add a sign, it is encoded in a low nibble of a last byte. |
| 217 | + lastByte := bcdBuf[length-1] |
| 218 | + sign := lastByte & 0x0f |
| 219 | + if isNegative[sign] { |
| 220 | + digits = append([]string{"-"}, digits...) |
| 221 | + } |
| 222 | + |
| 223 | + // Merge slice to a single string. |
| 224 | + str := strings.Join(digits, "") |
| 225 | + |
| 226 | + return str, nil |
| 227 | +} |
0 commit comments