diff options
Diffstat (limited to 'mysql/strings/decimal.c')
| -rw-r--r-- | mysql/strings/decimal.c | 2640 |
1 files changed, 0 insertions, 2640 deletions
diff --git a/mysql/strings/decimal.c b/mysql/strings/decimal.c deleted file mode 100644 index fc4e397..0000000 --- a/mysql/strings/decimal.c +++ /dev/null @@ -1,2640 +0,0 @@ -/* Copyright (c) 2004, 2016, Oracle and/or its affiliates. All rights reserved. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; version 2 of the License. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ - -/* -======================================================================= - NOTE: this library implements SQL standard "exact numeric" type - and is not at all generic, but rather intentinally crippled to - follow the standard :) -======================================================================= - Quoting the standard - (SQL:2003, Part 2 Foundations, aka ISO/IEC 9075-2:2003) - -4.4.2 Characteristics of numbers, page 27: - - An exact numeric type has a precision P and a scale S. P is a positive - integer that determines the number of significant digits in a - particular radix R, where R is either 2 or 10. S is a non-negative - integer. Every value of an exact numeric type of scale S is of the - form n*10^{-S}, where n is an integer such that -R^P <= n <= R^P. - - [...] - - If an assignment of some number would result in a loss of its most - significant digit, an exception condition is raised. If least - significant digits are lost, implementation-defined rounding or - truncating occurs, with no exception condition being raised. - - [...] - - Whenever an exact or approximate numeric value is assigned to an exact - numeric value site, an approximation of its value that preserves - leading significant digits after rounding or truncating is represented - in the declared type of the target. The value is converted to have the - precision and scale of the target. The choice of whether to truncate - or round is implementation-defined. - - [...] - - All numeric values between the smallest and the largest value, - inclusive, in a given exact numeric type have an approximation - obtained by rounding or truncation for that type; it is - implementation-defined which other numeric values have such - approximations. - -5.3 <literal>, page 143 - - <exact numeric literal> ::= - <unsigned integer> [ <period> [ <unsigned integer> ] ] - | <period> <unsigned integer> - -6.1 <data type>, page 165: - - 19) The <scale> of an <exact numeric type> shall not be greater than - the <precision> of the <exact numeric type>. - - 20) For the <exact numeric type>s DECIMAL and NUMERIC: - - a) The maximum value of <precision> is implementation-defined. - <precision> shall not be greater than this value. - b) The maximum value of <scale> is implementation-defined. <scale> - shall not be greater than this maximum value. - - 21) NUMERIC specifies the data type exact numeric, with the decimal - precision and scale specified by the <precision> and <scale>. - - 22) DECIMAL specifies the data type exact numeric, with the decimal - scale specified by the <scale> and the implementation-defined - decimal precision equal to or greater than the value of the - specified <precision>. - -6.26 <numeric value expression>, page 241: - - 1) If the declared type of both operands of a dyadic arithmetic - operator is exact numeric, then the declared type of the result is - an implementation-defined exact numeric type, with precision and - scale determined as follows: - - a) Let S1 and S2 be the scale of the first and second operands - respectively. - b) The precision of the result of addition and subtraction is - implementation-defined, and the scale is the maximum of S1 and S2. - c) The precision of the result of multiplication is - implementation-defined, and the scale is S1 + S2. - d) The precision and scale of the result of division are - implementation-defined. -*/ - -#include <my_global.h> -#include <m_ctype.h> -#include <myisampack.h> -#include <my_sys.h> /* for my_alloca */ -#include <m_string.h> -#include <decimal.h> - -/* - Internally decimal numbers are stored base 10^9 (see DIG_BASE below) - So one variable of type decimal_digit_t is limited: - - 0 < decimal_digit <= DIG_MAX < DIG_BASE - - in the struct st_decimal_t: - - intg is the number of *decimal* digits (NOT number of decimal_digit_t's !) - before the point - frac - number of decimal digits after the point - buf is an array of decimal_digit_t's - len is the length of buf (length of allocated space) in decimal_digit_t's, - not in bytes -*/ -typedef decimal_digit_t dec1; -typedef longlong dec2; - -#define DIG_PER_DEC1 9 -#define DIG_MASK 100000000 -#define DIG_BASE 1000000000 -#define DIG_MAX (DIG_BASE-1) -#define DIG_BASE2 ((dec2)DIG_BASE * (dec2)DIG_BASE) -#define ROUND_UP(X) (((X)+DIG_PER_DEC1-1)/DIG_PER_DEC1) -static const dec1 powers10[DIG_PER_DEC1+1]={ - 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000}; -static const int dig2bytes[DIG_PER_DEC1+1]={0, 1, 1, 2, 2, 3, 3, 4, 4, 4}; -static const dec1 frac_max[DIG_PER_DEC1-1]={ - 900000000, 990000000, 999000000, - 999900000, 999990000, 999999000, - 999999900, 999999990 }; - -#define sanity(d) DBUG_ASSERT((d)->len >0) - -#define FIX_INTG_FRAC_ERROR(len, intg1, frac1, error) \ - do \ - { \ - if (unlikely(intg1+frac1 > (len))) \ - { \ - if (unlikely(intg1 > (len))) \ - { \ - intg1=(len); \ - frac1=0; \ - error=E_DEC_OVERFLOW; \ - } \ - else \ - { \ - frac1=(len)-intg1; \ - error=E_DEC_TRUNCATED; \ - } \ - } \ - else \ - error=E_DEC_OK; \ - } while(0) - -#define ADD(to, from1, from2, carry) /* assume carry <= 1 */ \ - do \ - { \ - dec1 a=(from1)+(from2)+(carry); \ - DBUG_ASSERT((carry) <= 1); \ - if (((carry)= a >= DIG_BASE)) /* no division here! */ \ - a-=DIG_BASE; \ - (to)=a; \ - } while(0) - -#define ADD2(to, from1, from2, carry) \ - do \ - { \ - dec2 a=((dec2)(from1))+(from2)+(carry); \ - if (((carry)= a >= DIG_BASE)) \ - a-=DIG_BASE; \ - if (unlikely(a >= DIG_BASE)) \ - { \ - a-=DIG_BASE; \ - carry++; \ - } \ - (to)=(dec1) a; \ - } while(0) - -#define SUB(to, from1, from2, carry) /* to=from1-from2 */ \ - do \ - { \ - dec1 a=(from1)-(from2)-(carry); \ - if (((carry)= a < 0)) \ - a+=DIG_BASE; \ - (to)=a; \ - } while(0) - -#define SUB2(to, from1, from2, carry) /* to=from1-from2 */ \ - do \ - { \ - dec1 a=(from1)-(from2)-(carry); \ - if (((carry)= a < 0)) \ - a+=DIG_BASE; \ - if (unlikely(a < 0)) \ - { \ - a+=DIG_BASE; \ - carry++; \ - } \ - (to)=a; \ - } while(0) - - -/* - This is a direct loop unrolling of code that used to look like this: - for (; *buf_beg < powers10[i--]; start++) ; - - @param i start index - @param val value to compare against list of powers of 10 - - @retval Number of leading zeroes that can be removed from fraction. - - @note Why unroll? To get rid of lots of compiler warnings [-Warray-bounds] - Nice bonus: unrolled code is significantly faster. - */ -static inline int count_leading_zeroes(int i, dec1 val) -{ - int ret= 0; - switch (i) - { - /* @note Intentional fallthrough in all case labels */ - case 9: if (val >= 1000000000) break; ++ret; - case 8: if (val >= 100000000) break; ++ret; - case 7: if (val >= 10000000) break; ++ret; - case 6: if (val >= 1000000) break; ++ret; - case 5: if (val >= 100000) break; ++ret; - case 4: if (val >= 10000) break; ++ret; - case 3: if (val >= 1000) break; ++ret; - case 2: if (val >= 100) break; ++ret; - case 1: if (val >= 10) break; ++ret; - case 0: if (val >= 1) break; ++ret; - default: { DBUG_ASSERT(FALSE); } - } - return ret; -} - -/* - This is a direct loop unrolling of code that used to look like this: - for (; *buf_end % powers10[i++] == 0; stop--) ; - - @param i start index - @param val value to compare against list of powers of 10 - - @retval Number of trailing zeroes that can be removed from fraction. - - @note Why unroll? To get rid of lots of compiler warnings [-Warray-bounds] - Nice bonus: unrolled code is significantly faster. - */ -static inline int count_trailing_zeroes(int i, dec1 val) -{ - int ret= 0; - switch(i) - { - /* @note Intentional fallthrough in all case labels */ - case 0: if ((val % 1) != 0) break; ++ret; - case 1: if ((val % 10) != 0) break; ++ret; - case 2: if ((val % 100) != 0) break; ++ret; - case 3: if ((val % 1000) != 0) break; ++ret; - case 4: if ((val % 10000) != 0) break; ++ret; - case 5: if ((val % 100000) != 0) break; ++ret; - case 6: if ((val % 1000000) != 0) break; ++ret; - case 7: if ((val % 10000000) != 0) break; ++ret; - case 8: if ((val % 100000000) != 0) break; ++ret; - case 9: if ((val % 1000000000) != 0) break; ++ret; - default: { DBUG_ASSERT(FALSE); } - } - return ret; -} - - -/* - Get maximum value for given precision and scale - - SYNOPSIS - max_decimal() - precision/scale - see decimal_bin_size() below - to - decimal where where the result will be stored - to->buf and to->len must be set. -*/ - -void max_decimal(int precision, int frac, decimal_t *to) -{ - int intpart; - dec1 *buf= to->buf; - DBUG_ASSERT(precision && precision >= frac); - - to->sign= 0; - if ((intpart= to->intg= (precision - frac))) - { - int firstdigits= intpart % DIG_PER_DEC1; - if (firstdigits) - *buf++= powers10[firstdigits] - 1; /* get 9 99 999 ... */ - for(intpart/= DIG_PER_DEC1; intpart; intpart--) - *buf++= DIG_MAX; - } - - if ((to->frac= frac)) - { - int lastdigits= frac % DIG_PER_DEC1; - for(frac/= DIG_PER_DEC1; frac; frac--) - *buf++= DIG_MAX; - if (lastdigits) - *buf= frac_max[lastdigits - 1]; - } -} - - -static dec1 *remove_leading_zeroes(const decimal_t *from, int *intg_result) -{ - int intg= from->intg, i; - dec1 *buf0= from->buf; - i= ((intg - 1) % DIG_PER_DEC1) + 1; - while (intg > 0 && *buf0 == 0) - { - intg-= i; - i= DIG_PER_DEC1; - buf0++; - } - if (intg > 0) - { - intg-= count_leading_zeroes((intg - 1) % DIG_PER_DEC1, *buf0); - DBUG_ASSERT(intg > 0); - } - else - intg=0; - *intg_result= intg; - return buf0; -} - - -/* - Count actual length of fraction part (without ending zeroes) - - SYNOPSIS - decimal_actual_fraction() - from number for processing -*/ - -int decimal_actual_fraction(decimal_t *from) -{ - int frac= from->frac, i; - dec1 *buf0= from->buf + ROUND_UP(from->intg) + ROUND_UP(frac) - 1; - - if (frac == 0) - return 0; - - i= ((frac - 1) % DIG_PER_DEC1 + 1); - while (frac > 0 && *buf0 == 0) - { - frac-= i; - i= DIG_PER_DEC1; - buf0--; - } - if (frac > 0) - { - frac-= - count_trailing_zeroes(DIG_PER_DEC1 - ((frac - 1) % DIG_PER_DEC1), *buf0); - } - return frac; -} - - -/* - Convert decimal to its printable string representation - - SYNOPSIS - decimal2string() - from - value to convert - to - points to buffer where string representation - should be stored - *to_len - in: size of to buffer (incl. terminating '\0') - out: length of the actually written string (excl. '\0') - fixed_precision - 0 if representation can be variable length and - fixed_decimals will not be checked in this case. - Put number as with fixed point position with this - number of digits (sign counted and decimal point is - counted) - fixed_decimals - number digits after point. - filler - character to fill gaps in case of fixed_precision > 0 - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW -*/ - -int decimal2string(const decimal_t *from, char *to, int *to_len, - int fixed_precision, int fixed_decimals, - char filler) -{ - /* {intg_len, frac_len} output widths; {intg, frac} places in input */ - int len, intg, frac= from->frac, i, intg_len, frac_len, fill; - /* number digits before decimal point */ - int fixed_intg= (fixed_precision ? - (fixed_precision - fixed_decimals) : 0); - int error=E_DEC_OK; - char *s=to; - dec1 *buf, *buf0=from->buf, tmp; - - DBUG_ASSERT(*to_len >= 2+from->sign); - - /* removing leading zeroes */ - buf0= remove_leading_zeroes(from, &intg); - if (unlikely(intg+frac==0)) - { - intg=1; - tmp=0; - buf0=&tmp; - } - - if (!(intg_len= fixed_precision ? fixed_intg : intg)) - intg_len= 1; - frac_len= fixed_precision ? fixed_decimals : frac; - len= from->sign + intg_len + MY_TEST(frac) + frac_len; - if (fixed_precision) - { - if (frac > fixed_decimals) - { - error= E_DEC_TRUNCATED; - frac= fixed_decimals; - } - if (intg > fixed_intg) - { - error= E_DEC_OVERFLOW; - intg= fixed_intg; - } - } - else if (unlikely(len > --*to_len)) /* reserve one byte for \0 */ - { - int j= len - *to_len; /* excess printable chars */ - error= (frac && j <= frac + 1) ? E_DEC_TRUNCATED : E_DEC_OVERFLOW; - - /* - If we need to cut more places than frac is wide, we'll end up - dropping the decimal point as well. Account for this. - */ - if (frac && j >= frac + 1) - j--; - - if (j > frac) - { - intg_len= intg-= j-frac; - frac= 0; - } - else - frac-=j; - frac_len= frac; - len= from->sign + intg_len + MY_TEST(frac) + frac_len; - } - *to_len= len; - s[len]= 0; - - if (from->sign) - *s++='-'; - - if (frac) - { - char *s1= s + intg_len; - fill= frac_len - frac; - buf=buf0+ROUND_UP(intg); - *s1++='.'; - for (; frac>0; frac-=DIG_PER_DEC1) - { - dec1 x=*buf++; - for (i= MY_MIN(frac, DIG_PER_DEC1); i; i--) - { - dec1 y=x/DIG_MASK; - *s1++='0'+(uchar)y; - x-=y*DIG_MASK; - x*=10; - } - } - for(; fill > 0; fill--) - *s1++=filler; - } - - fill= intg_len - intg; - if (intg == 0) - fill--; /* symbol 0 before digital point */ - for(; fill > 0; fill--) - *s++=filler; - if (intg) - { - s+=intg; - for (buf=buf0+ROUND_UP(intg); intg>0; intg-=DIG_PER_DEC1) - { - dec1 x=*--buf; - for (i= MY_MIN(intg, DIG_PER_DEC1); i; i--) - { - dec1 y=x/10; - *--s='0'+(uchar)(x-y*10); - x=y; - } - } - } - else - *s= '0'; - - return error; -} - - -/* - Return bounds of decimal digits in the number - - SYNOPSIS - digits_bounds() - from - decimal number for processing - start_result - index (from 0 ) of first decimal digits will - be written by this address - end_result - index of position just after last decimal digit - be written by this address -*/ - -static void digits_bounds(decimal_t *from, int *start_result, int *end_result) -{ - int start, stop, i; - dec1 *buf_beg= from->buf; - dec1 *end= from->buf + ROUND_UP(from->intg) + ROUND_UP(from->frac); - dec1 *buf_end= end - 1; - - /* find non-zero digit from number begining */ - while (buf_beg < end && *buf_beg == 0) - buf_beg++; - - if (buf_beg >= end) - { - /* it is zero */ - *start_result= *end_result= 0; - return; - } - - /* find non-zero decimal digit from number begining */ - if (buf_beg == from->buf && from->intg) - { - start= DIG_PER_DEC1 - (i= ((from->intg-1) % DIG_PER_DEC1 + 1)); - i--; - } - else - { - i= DIG_PER_DEC1 - 1; - start= (int) ((buf_beg - from->buf) * DIG_PER_DEC1); - } - if (buf_beg < end) - start+= count_leading_zeroes(i, *buf_beg); - - *start_result= start; /* index of first decimal digit (from 0) */ - - /* find non-zero digit at the end */ - while (buf_end > buf_beg && *buf_end == 0) - buf_end--; - /* find non-zero decimal digit from the end */ - if (buf_end == end - 1 && from->frac) - { - stop= (int) (((buf_end - from->buf) * DIG_PER_DEC1 + - (i= ((from->frac - 1) % DIG_PER_DEC1 + 1)))); - i= DIG_PER_DEC1 - i + 1; - } - else - { - stop= (int) ((buf_end - from->buf + 1) * DIG_PER_DEC1); - i= 1; - } - stop-= count_trailing_zeroes(i, *buf_end); - *end_result= stop; /* index of position after last decimal digit (from 0) */ -} - - -/* - Left shift for alignment of data in buffer - - SYNOPSIS - do_mini_left_shift() - dec pointer to decimal number which have to be shifted - shift number of decimal digits on which it should be shifted - beg/end bounds of decimal digits (see digits_bounds()) - - NOTE - Result fitting in the buffer should be garanted. - 'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive) -*/ - -void do_mini_left_shift(decimal_t *dec, int shift, int beg, int last) -{ - dec1 *from= dec->buf + ROUND_UP(beg + 1) - 1; - dec1 *end= dec->buf + ROUND_UP(last) - 1; - int c_shift= DIG_PER_DEC1 - shift; - DBUG_ASSERT(from >= dec->buf); - DBUG_ASSERT(end < dec->buf + dec->len); - if (beg % DIG_PER_DEC1 < shift) - *(from - 1)= (*from) / powers10[c_shift]; - for(; from < end; from++) - *from= ((*from % powers10[c_shift]) * powers10[shift] + - (*(from + 1)) / powers10[c_shift]); - *from= (*from % powers10[c_shift]) * powers10[shift]; -} - - -/* - Right shift for alignment of data in buffer - - SYNOPSIS - do_mini_left_shift() - dec pointer to decimal number which have to be shifted - shift number of decimal digits on which it should be shifted - beg/end bounds of decimal digits (see digits_bounds()) - - NOTE - Result fitting in the buffer should be garanted. - 'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive) -*/ - -void do_mini_right_shift(decimal_t *dec, int shift, int beg, int last) -{ - dec1 *from= dec->buf + ROUND_UP(last) - 1; - dec1 *end= dec->buf + ROUND_UP(beg + 1) - 1; - int c_shift= DIG_PER_DEC1 - shift; - DBUG_ASSERT(from < dec->buf + dec->len); - DBUG_ASSERT(end >= dec->buf); - if (DIG_PER_DEC1 - ((last - 1) % DIG_PER_DEC1 + 1) < shift) - *(from + 1)= (*from % powers10[shift]) * powers10[c_shift]; - for(; from > end; from--) - *from= (*from / powers10[shift] + - (*(from - 1) % powers10[shift]) * powers10[c_shift]); - *from= *from / powers10[shift]; -} - - -/* - Shift of decimal digits in given number (with rounding if it need) - - SYNOPSIS - decimal_shift() - dec number to be shifted - shift number of decimal positions - shift > 0 means shift to left shift - shift < 0 meand right shift - NOTE - In fact it is multipling on 10^shift. - RETURN - E_DEC_OK OK - E_DEC_OVERFLOW operation lead to overflow, number is untoched - E_DEC_TRUNCATED number was rounded to fit into buffer -*/ - -int decimal_shift(decimal_t *dec, int shift) -{ - /* index of first non zero digit (all indexes from 0) */ - int beg; - /* index of position after last decimal digit */ - int end; - /* index of digit position just after point */ - int point= ROUND_UP(dec->intg) * DIG_PER_DEC1; - /* new point position */ - int new_point= point + shift; - /* number of digits in result */ - int digits_int, digits_frac; - /* length of result and new fraction in big digits*/ - int new_len, new_frac_len; - /* return code */ - int err= E_DEC_OK; - int new_front; - - if (shift == 0) - return E_DEC_OK; - - digits_bounds(dec, &beg, &end); - - if (beg == end) - { - decimal_make_zero(dec); - return E_DEC_OK; - } - - digits_int= new_point - beg; - set_if_bigger(digits_int, 0); - digits_frac= end - new_point; - set_if_bigger(digits_frac, 0); - - if ((new_len= ROUND_UP(digits_int) + (new_frac_len= ROUND_UP(digits_frac))) > - dec->len) - { - int lack= new_len - dec->len; - int diff; - - if (new_frac_len < lack) - return E_DEC_OVERFLOW; /* lack more then we have in fraction */ - - /* cat off fraction part to allow new number to fit in our buffer */ - err= E_DEC_TRUNCATED; - new_frac_len-= lack; - diff= digits_frac - (new_frac_len * DIG_PER_DEC1); - /* Make rounding method as parameter? */ - decimal_round(dec, dec, end - point - diff, HALF_UP); - end-= diff; - digits_frac= new_frac_len * DIG_PER_DEC1; - - if (end <= beg) - { - /* - we lost all digits (they will be shifted out of buffer), so we can - just return 0 - */ - decimal_make_zero(dec); - return E_DEC_TRUNCATED; - } - } - - if (shift % DIG_PER_DEC1) - { - int l_mini_shift, r_mini_shift, mini_shift; - int do_left; - /* - Calculate left/right shift to align decimal digits inside our bug - digits correctly - */ - if (shift > 0) - { - l_mini_shift= shift % DIG_PER_DEC1; - r_mini_shift= DIG_PER_DEC1 - l_mini_shift; - /* - It is left shift so prefer left shift, but if we have not place from - left, we have to have it from right, because we checked length of - result - */ - do_left= l_mini_shift <= beg; - DBUG_ASSERT(do_left || (dec->len * DIG_PER_DEC1 - end) >= r_mini_shift); - } - else - { - r_mini_shift= (-shift) % DIG_PER_DEC1; - l_mini_shift= DIG_PER_DEC1 - r_mini_shift; - /* see comment above */ - do_left= !((dec->len * DIG_PER_DEC1 - end) >= r_mini_shift); - DBUG_ASSERT(!do_left || l_mini_shift <= beg); - } - if (do_left) - { - do_mini_left_shift(dec, l_mini_shift, beg, end); - mini_shift= -l_mini_shift; - } - else - { - do_mini_right_shift(dec, r_mini_shift, beg, end); - mini_shift= r_mini_shift; - } - new_point+= mini_shift; - /* - If number is shifted and correctly aligned in buffer we can - finish - */ - if (!(shift+= mini_shift) && (new_point - digits_int) < DIG_PER_DEC1) - { - dec->intg= digits_int; - dec->frac= digits_frac; - return err; /* already shifted as it should be */ - } - beg+= mini_shift; - end+= mini_shift; - } - - /* if new 'decimal front' is in first digit, we do not need move digits */ - if ((new_front= (new_point - digits_int)) >= DIG_PER_DEC1 || - new_front < 0) - { - /* need to move digits */ - int d_shift; - dec1 *to, *barier; - if (new_front > 0) - { - /* move left */ - d_shift= new_front / DIG_PER_DEC1; - to= dec->buf + (ROUND_UP(beg + 1) - 1 - d_shift); - barier= dec->buf + (ROUND_UP(end) - 1 - d_shift); - DBUG_ASSERT(to >= dec->buf); - DBUG_ASSERT(barier + d_shift < dec->buf + dec->len); - for(; to <= barier; to++) - *to= *(to + d_shift); - for(barier+= d_shift; to <= barier; to++) - *to= 0; - d_shift= -d_shift; - } - else - { - /* move right */ - d_shift= (1 - new_front) / DIG_PER_DEC1; - to= dec->buf + ROUND_UP(end) - 1 + d_shift; - barier= dec->buf + ROUND_UP(beg + 1) - 1 + d_shift; - DBUG_ASSERT(to < dec->buf + dec->len); - DBUG_ASSERT(barier - d_shift >= dec->buf); - for(; to >= barier; to--) - *to= *(to - d_shift); - for(barier-= d_shift; to >= barier; to--) - *to= 0; - } - d_shift*= DIG_PER_DEC1; - beg+= d_shift; - end+= d_shift; - new_point+= d_shift; - } - - /* - If there are gaps then fill ren with 0. - - Only one of following 'for' loops will work becouse beg <= end - */ - beg= ROUND_UP(beg + 1) - 1; - end= ROUND_UP(end) - 1; - DBUG_ASSERT(new_point >= 0); - - /* We don't want negative new_point below */ - if (new_point != 0) - new_point= ROUND_UP(new_point) - 1; - - if (new_point > end) - { - do - { - dec->buf[new_point]=0; - } while (--new_point > end); - } - else - { - for (; new_point < beg; new_point++) - dec->buf[new_point]= 0; - } - dec->intg= digits_int; - dec->frac= digits_frac; - return err; -} - - -/* - Convert string to decimal - - SYNOPSIS - internal_str2decl() - from - value to convert. Doesn't have to be \0 terminated! - to - decimal where where the result will be stored - to->buf and to->len must be set. - end - Pointer to pointer to end of string. Will on return be - set to the char after the last used character - fixed - use to->intg, to->frac as limits for input number - - NOTE - to->intg and to->frac can be modified even when fixed=1 - (but only decreased, in this case) - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_BAD_NUM/E_DEC_OOM - In case of E_DEC_FATAL_ERROR *to is set to decimal zero - (to make error handling easier) -*/ - -int -internal_str2dec(const char *from, decimal_t *to, char **end, my_bool fixed) -{ - const char *s= from, *s1, *endp, *end_of_string= *end; - int i, intg, frac, error, intg1, frac1; - dec1 x,*buf; - sanity(to); - - error= E_DEC_BAD_NUM; /* In case of bad number */ - while (s < end_of_string && my_isspace(&my_charset_latin1, *s)) - s++; - if (s == end_of_string) - goto fatal_error; - - if ((to->sign= (*s == '-'))) - s++; - else if (*s == '+') - s++; - - s1=s; - while (s < end_of_string && my_isdigit(&my_charset_latin1, *s)) - s++; - intg= (int) (s-s1); - if (s < end_of_string && *s=='.') - { - endp= s+1; - while (endp < end_of_string && my_isdigit(&my_charset_latin1, *endp)) - endp++; - frac= (int) (endp - s - 1); - } - else - { - frac= 0; - endp= s; - } - - *end= (char*) endp; - - if (frac+intg == 0) - goto fatal_error; - - error= 0; - if (fixed) - { - if (frac > to->frac) - { - error=E_DEC_TRUNCATED; - frac=to->frac; - } - if (intg > to->intg) - { - error=E_DEC_OVERFLOW; - intg=to->intg; - } - intg1=ROUND_UP(intg); - frac1=ROUND_UP(frac); - if (intg1+frac1 > to->len) - { - error= E_DEC_OOM; - goto fatal_error; - } - } - else - { - intg1=ROUND_UP(intg); - frac1=ROUND_UP(frac); - FIX_INTG_FRAC_ERROR(to->len, intg1, frac1, error); - if (unlikely(error)) - { - frac=frac1*DIG_PER_DEC1; - if (error == E_DEC_OVERFLOW) - intg=intg1*DIG_PER_DEC1; - } - } - /* Error is guranteed to be set here */ - to->intg=intg; - to->frac=frac; - - buf=to->buf+intg1; - s1=s; - - for (x=0, i=0; intg; intg--) - { - x+= (*--s - '0')*powers10[i]; - - if (unlikely(++i == DIG_PER_DEC1)) - { - *--buf=x; - x=0; - i=0; - } - } - if (i) - *--buf=x; - - buf=to->buf+intg1; - for (x=0, i=0; frac; frac--) - { - x= (*++s1 - '0') + x*10; - - if (unlikely(++i == DIG_PER_DEC1)) - { - *buf++=x; - x=0; - i=0; - } - } - if (i) - *buf=x*powers10[DIG_PER_DEC1-i]; - - /* Handle exponent */ - if (endp+1 < end_of_string && (*endp == 'e' || *endp == 'E')) - { - int str_error; - longlong exponent= my_strtoll10(endp+1, (char**) &end_of_string, - &str_error); - - if (end_of_string != endp +1) /* If at least one digit */ - { - *end= (char*) end_of_string; - if (str_error > 0) - { - error= E_DEC_BAD_NUM; - goto fatal_error; - } - if (exponent > INT_MAX/2 || (str_error == 0 && exponent < 0)) - { - error= E_DEC_OVERFLOW; - goto fatal_error; - } - if (exponent < INT_MIN/2 && error != E_DEC_OVERFLOW) - { - error= E_DEC_TRUNCATED; - goto fatal_error; - } - if (error != E_DEC_OVERFLOW) - error= decimal_shift(to, (int) exponent); - } - } - /* Avoid returning negative zero, cfr. decimal_cmp() */ - if (to->sign && decimal_is_zero(to)) - to->sign= FALSE; - return error; - -fatal_error: - decimal_make_zero(to); - return error; -} - - -/* - Convert decimal to double - - SYNOPSIS - decimal2double() - from - value to convert - to - result will be stored there - - RETURN VALUE - E_DEC_OK/E_DEC_OVERFLOW/E_DEC_TRUNCATED -*/ - -int decimal2double(const decimal_t *from, double *to) -{ - char strbuf[FLOATING_POINT_BUFFER], *end; - int len= sizeof(strbuf); - int rc, error; - - rc = decimal2string(from, strbuf, &len, 0, 0, 0); - end= strbuf + len; - - DBUG_PRINT("info", ("interm.: %s", strbuf)); - - *to= my_strtod(strbuf, &end, &error); - - DBUG_PRINT("info", ("result: %f", *to)); - - return (rc != E_DEC_OK) ? rc : (error ? E_DEC_OVERFLOW : E_DEC_OK); -} - -/* - Convert double to decimal - - SYNOPSIS - double2decimal() - from - value to convert - to - result will be stored there - - RETURN VALUE - E_DEC_OK/E_DEC_OVERFLOW/E_DEC_TRUNCATED -*/ - -int double2decimal(double from, decimal_t *to) -{ - char buff[FLOATING_POINT_BUFFER], *end; - int res; - DBUG_ENTER("double2decimal"); - end= buff + my_gcvt(from, MY_GCVT_ARG_DOUBLE, (int)sizeof(buff) - 1, buff, NULL); - res= string2decimal(buff, to, &end); - DBUG_PRINT("exit", ("res: %d", res)); - DBUG_RETURN(res); -} - - -static int ull2dec(ulonglong from, decimal_t *to) -{ - int intg1; - int error= E_DEC_OK; - ulonglong x= from; - dec1 *buf; - - sanity(to); - - if (from == 0) - intg1= 1; - else - { - /* Count the number of decimal_digit_t's we need. */ - for (intg1= 0; from != 0; intg1++, from/= DIG_BASE) - ; - } - if (unlikely(intg1 > to->len)) - { - intg1= to->len; - error= E_DEC_OVERFLOW; - } - to->frac= 0; - to->intg= intg1 * DIG_PER_DEC1; - - for (buf= to->buf + intg1; intg1; intg1--) - { - ulonglong y= x / DIG_BASE; - *--buf=(dec1)(x - y * DIG_BASE); - x= y; - } - return error; -} - -int ulonglong2decimal(ulonglong from, decimal_t *to) -{ - to->sign=0; - return ull2dec(from, to); -} - -int longlong2decimal(longlong from, decimal_t *to) -{ - if ((to->sign= from < 0)) - return ull2dec(-from, to); - return ull2dec(from, to); -} - -int decimal2ulonglong(decimal_t *from, ulonglong *to) -{ - dec1 *buf=from->buf; - ulonglong x=0; - int intg, frac; - - if (from->sign) - { - *to=0ULL; - return E_DEC_OVERFLOW; - } - - for (intg=from->intg; intg > 0; intg-=DIG_PER_DEC1) - { - ulonglong y=x; - x=x*DIG_BASE + *buf++; - if (unlikely(y > ((ulonglong) ULLONG_MAX/DIG_BASE) || x < y)) - { - *to=ULLONG_MAX; - return E_DEC_OVERFLOW; - } - } - *to=x; - for (frac=from->frac; unlikely(frac > 0); frac-=DIG_PER_DEC1) - if (*buf++) - return E_DEC_TRUNCATED; - return E_DEC_OK; -} - -int decimal2longlong(decimal_t *from, longlong *to) -{ - dec1 *buf=from->buf; - longlong x=0; - int intg, frac; - - for (intg=from->intg; intg > 0; intg-=DIG_PER_DEC1) - { - longlong y=x; - /* - Attention: trick! - we're calculating -|from| instead of |from| here - because |LLONG_MIN| > LLONG_MAX - so we can convert -9223372036854775808 correctly - */ - x=x*DIG_BASE - *buf++; - if (unlikely(y < (LLONG_MIN/DIG_BASE) || x > y)) - { - /* - the decimal is bigger than any possible integer - return border integer depending on the sign - */ - *to= from->sign ? LLONG_MIN : LLONG_MAX; - return E_DEC_OVERFLOW; - } - } - /* boundary case: 9223372036854775808 */ - if (unlikely(from->sign==0 && x == LLONG_MIN)) - { - *to= LLONG_MAX; - return E_DEC_OVERFLOW; - } - - *to=from->sign ? x : -x; - for (frac=from->frac; unlikely(frac > 0); frac-=DIG_PER_DEC1) - if (*buf++) - return E_DEC_TRUNCATED; - return E_DEC_OK; -} - - -#define LLDIV_MIN -1000000000000000000LL -#define LLDIV_MAX 1000000000000000000LL - -/** - Convert decimal value to lldiv_t value. - @param from The decimal value to convert from. - @param OUT to The lldiv_t variable to convert to. - @return 0 on success, error code on error. -*/ -int decimal2lldiv_t(const decimal_t *from, lldiv_t *to) -{ - int int_part= ROUND_UP(from->intg); - int frac_part= ROUND_UP(from->frac); - if (int_part > 2) - { - to->rem= 0; - to->quot= from->sign ? LLDIV_MIN : LLDIV_MAX; - return E_DEC_OVERFLOW; - } - if (int_part == 2) - to->quot= ((longlong) from->buf[0]) * DIG_BASE + from->buf[1]; - else if (int_part == 1) - to->quot= from->buf[0]; - else - to->quot= 0; - to->rem= frac_part ? from->buf[int_part] : 0; - if (from->sign) - { - to->quot= -to->quot; - to->rem= -to->rem; - } - return 0; -} - - -/** - Convert double value to lldiv_t valie. - @param from The double value to convert from. - @param OUT to The lldit_t variable to convert to. - @return 0 on success, error code on error. - - Integer part goes into lld.quot. - Fractional part multiplied to 1000000000 (10^9) goes to lld.rem. - Typically used in datetime calculations to split seconds - and nanoseconds. -*/ -int double2lldiv_t(double nr, lldiv_t *lld) -{ - if (nr > LLDIV_MAX) - { - lld->quot= LLDIV_MAX; - lld->rem= 0; - return E_DEC_OVERFLOW; - } - else if (nr < LLDIV_MIN) - { - lld->quot= LLDIV_MIN; - lld->rem= 0; - return E_DEC_OVERFLOW; - } - /* Truncate fractional part toward zero and store into "quot" */ - lld->quot= (longlong) (nr > 0 ? floor(nr) : ceil(nr)); - /* Multiply reminder to 10^9 and store into "rem" */ - lld->rem= (longlong) rint((nr - (double) lld->quot) * 1000000000); - /* - Sometimes the expression "(double) 0.999999999xxx * (double) 10e9" - gives 1,000,000,000 instead of 999,999,999 due to lack of double precision. - The callers do not expect lld->rem to be greater than 999,999,999. - Let's catch this corner case and put the "nanounit" (e.g. nanosecond) - value in ldd->rem back into the valid range. - */ - if (lld->rem > 999999999LL) - lld->rem= 999999999LL; - else if (lld->rem < -999999999LL) - lld->rem= -999999999LL; - return E_DEC_OK; -} - - - -/* - Convert decimal to its binary fixed-length representation - two representations of the same length can be compared with memcmp - with the correct -1/0/+1 result - - SYNOPSIS - decimal2bin() - from - value to convert - to - points to buffer where string representation should be stored - precision/scale - see decimal_bin_size() below - - NOTE - the buffer is assumed to be of the size decimal_bin_size(precision, scale) - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW - - DESCRIPTION - for storage decimal numbers are converted to the "binary" format. - - This format has the following properties: - 1. length of the binary representation depends on the {precision, scale} - as provided by the caller and NOT on the intg/frac of the decimal to - convert. - 2. binary representations of the same {precision, scale} can be compared - with memcmp - with the same result as decimal_cmp() of the original - decimals (not taking into account possible precision loss during - conversion). - - This binary format is as follows: - 1. First the number is converted to have a requested precision and scale. - 2. Every full DIG_PER_DEC1 digits of intg part are stored in 4 bytes - as is - 3. The first intg % DIG_PER_DEC1 digits are stored in the reduced - number of bytes (enough bytes to store this number of digits - - see dig2bytes) - 4. same for frac - full decimal_digit_t's are stored as is, - the last frac % DIG_PER_DEC1 digits - in the reduced number of bytes. - 5. If the number is negative - every byte is inversed. - 5. The very first bit of the resulting byte array is inverted (because - memcmp compares unsigned bytes, see property 2 above) - - Example: - - 1234567890.1234 - - internally is represented as 3 decimal_digit_t's - - 1 234567890 123400000 - - (assuming we want a binary representation with precision=14, scale=4) - in hex it's - - 00-00-00-01 0D-FB-38-D2 07-5A-EF-40 - - now, middle decimal_digit_t is full - it stores 9 decimal digits. It goes - into binary representation as is: - - - ........... 0D-FB-38-D2 ............ - - First decimal_digit_t has only one decimal digit. We can store one digit in - one byte, no need to waste four: - - 01 0D-FB-38-D2 ............ - - now, last digit. It's 123400000. We can store 1234 in two bytes: - - 01 0D-FB-38-D2 04-D2 - - So, we've packed 12 bytes number in 7 bytes. - And now we invert the highest bit to get the final result: - - 81 0D FB 38 D2 04 D2 - - And for -1234567890.1234 it would be - - 7E F2 04 C7 2D FB 2D -*/ -int decimal2bin(decimal_t *from, uchar *to, int precision, int frac) -{ - dec1 mask=from->sign ? -1 : 0, *buf1=from->buf, *stop1; - int error=E_DEC_OK, intg=precision-frac, - isize1, intg1, intg1x, from_intg, - intg0=intg/DIG_PER_DEC1, - frac0=frac/DIG_PER_DEC1, - intg0x=intg-intg0*DIG_PER_DEC1, - frac0x=frac-frac0*DIG_PER_DEC1, - frac1=from->frac/DIG_PER_DEC1, - frac1x=from->frac-frac1*DIG_PER_DEC1, - isize0=intg0*sizeof(dec1)+dig2bytes[intg0x], - fsize0=frac0*sizeof(dec1)+dig2bytes[frac0x], - fsize1=frac1*sizeof(dec1)+dig2bytes[frac1x]; - const int orig_isize0= isize0; - const int orig_fsize0= fsize0; - uchar *orig_to= to; - - buf1= remove_leading_zeroes(from, &from_intg); - - if (unlikely(from_intg+fsize1==0)) - { - mask=0; /* just in case */ - intg=1; - buf1=&mask; - } - - intg1=from_intg/DIG_PER_DEC1; - intg1x=from_intg-intg1*DIG_PER_DEC1; - isize1=intg1*sizeof(dec1)+dig2bytes[intg1x]; - - if (intg < from_intg) - { - buf1+=intg1-intg0+(intg1x>0)-(intg0x>0); - intg1=intg0; intg1x=intg0x; - error=E_DEC_OVERFLOW; - } - else if (isize0 > isize1) - { - while (isize0-- > isize1) - *to++= (char)mask; - } - if (fsize0 < fsize1) - { - frac1=frac0; frac1x=frac0x; - error=E_DEC_TRUNCATED; - } - else if (fsize0 > fsize1 && frac1x) - { - if (frac0 == frac1) - { - frac1x=frac0x; - fsize0= fsize1; - } - else - { - frac1++; - frac1x=0; - } - } - - /* intg1x part */ - if (intg1x) - { - int i=dig2bytes[intg1x]; - dec1 x=(*buf1++ % powers10[intg1x]) ^ mask; - switch (i) - { - case 1: mi_int1store(to, x); break; - case 2: mi_int2store(to, x); break; - case 3: mi_int3store(to, x); break; - case 4: mi_int4store(to, x); break; - default: DBUG_ASSERT(0); - } - to+=i; - } - - /* intg1+frac1 part */ - for (stop1=buf1+intg1+frac1; buf1 < stop1; to+=sizeof(dec1)) - { - dec1 x=*buf1++ ^ mask; - DBUG_ASSERT(sizeof(dec1) == 4); - mi_int4store(to, x); - } - - /* frac1x part */ - if (frac1x) - { - dec1 x; - int i=dig2bytes[frac1x], - lim=(frac1 < frac0 ? DIG_PER_DEC1 : frac0x); - while (frac1x < lim && dig2bytes[frac1x] == i) - frac1x++; - x=(*buf1 / powers10[DIG_PER_DEC1 - frac1x]) ^ mask; - switch (i) - { - case 1: mi_int1store(to, x); break; - case 2: mi_int2store(to, x); break; - case 3: mi_int3store(to, x); break; - case 4: mi_int4store(to, x); break; - default: DBUG_ASSERT(0); - } - to+=i; - } - if (fsize0 > fsize1) - { - uchar *to_end= orig_to + orig_fsize0 + orig_isize0; - - while (fsize0-- > fsize1 && to < to_end) - *to++= (uchar)mask; - } - orig_to[0]^= 0x80; - - /* Check that we have written the whole decimal and nothing more */ - DBUG_ASSERT(to == orig_to + orig_fsize0 + orig_isize0); - return error; -} - -/* - Restores decimal from its binary fixed-length representation - - SYNOPSIS - bin2decimal() - from - value to convert - to - result - precision/scale - see decimal_bin_size() below - - NOTE - see decimal2bin() - the buffer is assumed to be of the size decimal_bin_size(precision, scale) - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW -*/ - -int bin2decimal(const uchar *from, decimal_t *to, int precision, int scale) -{ - int error=E_DEC_OK, intg=precision-scale, - intg0=intg/DIG_PER_DEC1, frac0=scale/DIG_PER_DEC1, - intg0x=intg-intg0*DIG_PER_DEC1, frac0x=scale-frac0*DIG_PER_DEC1, - intg1=intg0+(intg0x>0), frac1=frac0+(frac0x>0); - dec1 *buf=to->buf, mask=(*from & 0x80) ? 0 : -1; - const uchar *stop; - uchar *d_copy; - int bin_size= decimal_bin_size(precision, scale); - - sanity(to); - d_copy= (uchar*) my_alloca(bin_size); - memcpy(d_copy, from, bin_size); - d_copy[0]^= 0x80; - from= d_copy; - - FIX_INTG_FRAC_ERROR(to->len, intg1, frac1, error); - if (unlikely(error)) - { - if (intg1 < intg0+(intg0x>0)) - { - from+=dig2bytes[intg0x]+sizeof(dec1)*(intg0-intg1); - frac0=frac0x=intg0x=0; - intg0=intg1; - } - else - { - frac0x=0; - frac0=frac1; - } - } - - to->sign=(mask != 0); - to->intg=intg0*DIG_PER_DEC1+intg0x; - to->frac=frac0*DIG_PER_DEC1+frac0x; - - if (intg0x) - { - int i=dig2bytes[intg0x]; - dec1 x= 0; - switch (i) - { - case 1: x=mi_sint1korr(from); break; - case 2: x=mi_sint2korr(from); break; - case 3: x=mi_sint3korr(from); break; - case 4: x=mi_sint4korr(from); break; - default: DBUG_ASSERT(0); - } - from+=i; - *buf=x ^ mask; - if (((ulonglong)*buf) >= (ulonglong) powers10[intg0x+1]) - goto err; - if (buf > to->buf || *buf != 0) - buf++; - else - to->intg-=intg0x; - } - for (stop=from+intg0*sizeof(dec1); from < stop; from+=sizeof(dec1)) - { - DBUG_ASSERT(sizeof(dec1) == 4); - *buf=mi_sint4korr(from) ^ mask; - if (((uint32)*buf) > DIG_MAX) - goto err; - if (buf > to->buf || *buf != 0) - buf++; - else - to->intg-=DIG_PER_DEC1; - } - DBUG_ASSERT(to->intg >=0); - for (stop=from+frac0*sizeof(dec1); from < stop; from+=sizeof(dec1)) - { - DBUG_ASSERT(sizeof(dec1) == 4); - *buf=mi_sint4korr(from) ^ mask; - if (((uint32)*buf) > DIG_MAX) - goto err; - buf++; - } - if (frac0x) - { - int i=dig2bytes[frac0x]; - dec1 x= 0; - switch (i) - { - case 1: x=mi_sint1korr(from); break; - case 2: x=mi_sint2korr(from); break; - case 3: x=mi_sint3korr(from); break; - case 4: x=mi_sint4korr(from); break; - default: DBUG_ASSERT(0); - } - *buf=(x ^ mask) * powers10[DIG_PER_DEC1 - frac0x]; - if (((uint32)*buf) > DIG_MAX) - goto err; - buf++; - } - - /* - No digits? We have read the number zero, of unspecified precision. - Make it a proper zero, with non-zero precision. - */ - if (to->intg == 0 && to->frac == 0) - decimal_make_zero(to); - return error; - -err: - decimal_make_zero(to); - return(E_DEC_BAD_NUM); -} - -/* - Returns the size of array to hold a decimal with given precision and scale - - RETURN VALUE - size in dec1 - (multiply by sizeof(dec1) to get the size if bytes) -*/ - -int decimal_size(int precision, int scale) -{ - DBUG_ASSERT(scale >= 0 && precision > 0 && scale <= precision); - return ROUND_UP(precision-scale)+ROUND_UP(scale); -} - -/* - Returns the size of array to hold a binary representation of a decimal - - RETURN VALUE - size in bytes -*/ - -int decimal_bin_size(int precision, int scale) -{ - int intg=precision-scale, - intg0=intg/DIG_PER_DEC1, frac0=scale/DIG_PER_DEC1, - intg0x=intg-intg0*DIG_PER_DEC1, frac0x=scale-frac0*DIG_PER_DEC1; - - DBUG_ASSERT(scale >= 0 && precision > 0 && scale <= precision); - DBUG_ASSERT(intg0x >= 0); - DBUG_ASSERT(intg0x <= DIG_PER_DEC1); - DBUG_ASSERT(frac0x >= 0); - DBUG_ASSERT(frac0x <= DIG_PER_DEC1); - return intg0*sizeof(dec1)+dig2bytes[intg0x]+ - frac0*sizeof(dec1)+dig2bytes[frac0x]; -} - -/* - Rounds the decimal to "scale" digits - - SYNOPSIS - decimal_round() - from - decimal to round, - to - result buffer. from==to is allowed - scale - to what position to round. can be negative! - mode - round to nearest even or truncate - - NOTES - scale can be negative ! - one TRUNCATED error (line XXX below) isn't treated very logical :( - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED -*/ - -int -decimal_round(const decimal_t *from, decimal_t *to, int scale, - decimal_round_mode mode) -{ - int frac0=scale>0 ? ROUND_UP(scale) : (scale + 1)/DIG_PER_DEC1, - frac1=ROUND_UP(from->frac), round_digit= 0, - intg0=ROUND_UP(from->intg), error=E_DEC_OK, len=to->len; - - dec1 *buf0=from->buf, *buf1=to->buf, x, y, carry=0; - int first_dig; - - sanity(to); - - switch (mode) { - case HALF_UP: - case HALF_EVEN: round_digit=5; break; - case CEILING: round_digit= from->sign ? 10 : 0; break; - case FLOOR: round_digit= from->sign ? 0 : 10; break; - case TRUNCATE: round_digit=10; break; - default: DBUG_ASSERT(0); - } - - /* - For my_decimal we always use len == DECIMAL_BUFF_LENGTH == 9 - For internal testing here (ifdef MAIN) we always use len == 100/4 - */ - DBUG_ASSERT(from->len == to->len); - - if (unlikely(frac0+intg0 > len)) - { - frac0=len-intg0; - scale=frac0*DIG_PER_DEC1; - error=E_DEC_TRUNCATED; - } - - if (scale+from->intg < 0) - { - decimal_make_zero(to); - return E_DEC_OK; - } - - if (to != from) - { - dec1 *p0= buf0 + intg0 + MY_MAX(frac1, frac0); - dec1 *p1= buf1 + intg0 + MY_MAX(frac1, frac0); - - DBUG_ASSERT(p0 - buf0 <= len); - DBUG_ASSERT(p1 - buf1 <= len); - - while (buf0 < p0) - *(--p1) = *(--p0); - - buf0=to->buf; - buf1=to->buf; - to->sign=from->sign; - to->intg= MY_MIN(intg0, len) * DIG_PER_DEC1; - } - - if (frac0 > frac1) - { - buf1+=intg0+frac1; - while (frac0-- > frac1) - *buf1++=0; - goto done; - } - - if (scale >= from->frac) - goto done; /* nothing to do */ - - buf0+=intg0+frac0-1; - buf1+=intg0+frac0-1; - if (scale == frac0*DIG_PER_DEC1) - { - int do_inc= FALSE; - DBUG_ASSERT(frac0+intg0 >= 0); - switch (round_digit) { - case 0: - { - dec1 *p0= buf0 + (frac1-frac0); - for (; p0 > buf0; p0--) - { - if (*p0) - { - do_inc= TRUE; - break; - } - } - break; - } - case 5: - { - x= buf0[1]/DIG_MASK; - do_inc= (x>5) || ((x == 5) && - (mode == HALF_UP || (frac0+intg0 > 0 && *buf0 & 1))); - break; - } - default: - break; - } - if (do_inc) - { - if (frac0+intg0>0) - (*buf1)++; - else - *(++buf1)=DIG_BASE; - } - else if (frac0+intg0==0) - { - decimal_make_zero(to); - return E_DEC_OK; - } - } - else - { - /* TODO - fix this code as it won't work for CEILING mode */ - int pos=frac0*DIG_PER_DEC1-scale-1; - DBUG_ASSERT(frac0+intg0 > 0); - x=*buf1 / powers10[pos]; - y=x % 10; - if (y > round_digit || - (round_digit == 5 && y == 5 && (mode == HALF_UP || (x/10) & 1))) - x+=10; - *buf1=powers10[pos]*(x-y); - } - /* - In case we're rounding e.g. 1.5e9 to 2.0e9, the decimal_digit_t's inside - the buffer are as follows. - - Before <1, 5e8> - After <2, 5e8> - - Hence we need to set the 2nd field to 0. - The same holds if we round 1.5e-9 to 2e-9. - */ - if (frac0 < frac1) - { - dec1 *buf= to->buf + ((scale == 0 && intg0 == 0) ? 1 : intg0 + frac0); - dec1 *end= to->buf + len; - - while (buf < end) - *buf++=0; - } - if (*buf1 >= DIG_BASE) - { - carry=1; - *buf1-=DIG_BASE; - while (carry && --buf1 >= to->buf) - ADD(*buf1, *buf1, 0, carry); - if (unlikely(carry)) - { - /* shifting the number to create space for new digit */ - if (frac0+intg0 >= len) - { - frac0--; - scale=frac0*DIG_PER_DEC1; - error=E_DEC_TRUNCATED; /* XXX */ - } - for (buf1=to->buf + intg0 + MY_MAX(frac0, 0); buf1 > to->buf; buf1--) - { - /* Avoid out-of-bounds write. */ - if (buf1 < to->buf + len) - buf1[0]=buf1[-1]; - else - error= E_DEC_OVERFLOW; - } - *buf1=1; - /* We cannot have more than 9 * 9 = 81 digits. */ - if (to->intg < len * DIG_PER_DEC1) - to->intg++; - else - error= E_DEC_OVERFLOW; - } - } - else - { - for (;;) - { - if (likely(*buf1)) - break; - if (buf1-- == to->buf) - { - /* making 'zero' with the proper scale */ - dec1 *p0= to->buf + frac0 + 1; - to->intg=1; - to->frac= MY_MAX(scale, 0); - to->sign= 0; - for (buf1= to->buf; buf1<p0; buf1++) - *buf1= 0; - return E_DEC_OK; - } - } - } - - /* Here we check 999.9 -> 1000 case when we need to increase intg */ - first_dig= to->intg % DIG_PER_DEC1; - if (first_dig && (*buf1 >= powers10[first_dig])) - to->intg++; - - if (scale<0) - scale=0; - -done: - DBUG_ASSERT(to->intg <= (len * DIG_PER_DEC1)); - to->frac=scale; - return error; -} - -/* - Returns the size of the result of the operation - - SYNOPSIS - decimal_result_size() - from1 - operand of the unary operation or first operand of the - binary operation - from2 - second operand of the binary operation - op - operation. one char '+', '-', '*', '/' are allowed - others may be added later - param - extra param to the operation. unused for '+', '-', '*' - scale increment for '/' - - NOTE - returned valued may be larger than the actual buffer requred - in the operation, as decimal_result_size, by design, operates on - precision/scale values only and not on the actual decimal number - - RETURN VALUE - size of to->buf array in dec1 elements. to get size in bytes - multiply by sizeof(dec1) -*/ - -int decimal_result_size(decimal_t *from1, decimal_t *from2, char op, int param) -{ - switch (op) { - case '-': - return ROUND_UP(MY_MAX(from1->intg, from2->intg)) + - ROUND_UP(MY_MAX(from1->frac, from2->frac)); - case '+': - return ROUND_UP(MY_MAX(from1->intg, from2->intg)+1) + - ROUND_UP(MY_MAX(from1->frac, from2->frac)); - case '*': - return ROUND_UP(from1->intg+from2->intg)+ - ROUND_UP(from1->frac)+ROUND_UP(from2->frac); - case '/': - return ROUND_UP(from1->intg+from2->intg+1+from1->frac+from2->frac+param); - default: DBUG_ASSERT(0); - } - return -1; /* shut up the warning */ -} - -static int do_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to) -{ - int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg), - frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac), - frac0= MY_MAX(frac1, frac2), intg0= MY_MAX(intg1, intg2), error; - dec1 *buf1, *buf2, *buf0, *stop, *stop2, x, carry; - - sanity(to); - - /* is there a need for extra word because of carry ? */ - x=intg1 > intg2 ? from1->buf[0] : - intg2 > intg1 ? from2->buf[0] : - from1->buf[0] + from2->buf[0] ; - if (unlikely(x > DIG_MAX-1)) /* yes, there is */ - { - intg0++; - to->buf[0]=0; /* safety */ - } - - FIX_INTG_FRAC_ERROR(to->len, intg0, frac0, error); - if (unlikely(error == E_DEC_OVERFLOW)) - { - max_decimal(to->len * DIG_PER_DEC1, 0, to); - return error; - } - - buf0=to->buf+intg0+frac0; - - to->sign=from1->sign; - to->frac= MY_MAX(from1->frac, from2->frac); - to->intg=intg0*DIG_PER_DEC1; - if (unlikely(error)) - { - set_if_smaller(to->frac, frac0*DIG_PER_DEC1); - set_if_smaller(frac1, frac0); - set_if_smaller(frac2, frac0); - set_if_smaller(intg1, intg0); - set_if_smaller(intg2, intg0); - } - - /* part 1 - max(frac) ... min (frac) */ - if (frac1 > frac2) - { - buf1=from1->buf+intg1+frac1; - stop=from1->buf+intg1+frac2; - buf2=from2->buf+intg2+frac2; - stop2=from1->buf+(intg1 > intg2 ? intg1-intg2 : 0); - } - else - { - buf1=from2->buf+intg2+frac2; - stop=from2->buf+intg2+frac1; - buf2=from1->buf+intg1+frac1; - stop2=from2->buf+(intg2 > intg1 ? intg2-intg1 : 0); - } - while (buf1 > stop) - *--buf0=*--buf1; - - /* part 2 - min(frac) ... min(intg) */ - carry=0; - while (buf1 > stop2) - { - ADD(*--buf0, *--buf1, *--buf2, carry); - } - - /* part 3 - min(intg) ... max(intg) */ - buf1= intg1 > intg2 ? ((stop=from1->buf)+intg1-intg2) : - ((stop=from2->buf)+intg2-intg1) ; - while (buf1 > stop) - { - ADD(*--buf0, *--buf1, 0, carry); - } - - if (unlikely(carry)) - *--buf0=1; - DBUG_ASSERT(buf0 == to->buf || buf0 == to->buf+1); - - return error; -} - -/* to=from1-from2. - if to==0, return -1/0/+1 - the result of the comparison */ -static int do_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to) -{ - int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg), - frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac); - int frac0= MY_MAX(frac1, frac2), error; - dec1 *buf1, *buf2, *buf0, *stop1, *stop2, *start1, *start2, carry=0; - - /* let carry:=1 if from2 > from1 */ - start1=buf1=from1->buf; stop1=buf1+intg1; - start2=buf2=from2->buf; stop2=buf2+intg2; - if (unlikely(*buf1 == 0)) - { - while (buf1 < stop1 && *buf1 == 0) - buf1++; - start1=buf1; - intg1= (int) (stop1-buf1); - } - if (unlikely(*buf2 == 0)) - { - while (buf2 < stop2 && *buf2 == 0) - buf2++; - start2=buf2; - intg2= (int) (stop2-buf2); - } - if (intg2 > intg1) - carry=1; - else if (intg2 == intg1) - { - dec1 *end1= stop1 + (frac1 - 1); - dec1 *end2= stop2 + (frac2 - 1); - while (unlikely((buf1 <= end1) && (*end1 == 0))) - end1--; - while (unlikely((buf2 <= end2) && (*end2 == 0))) - end2--; - frac1= (int) (end1 - stop1) + 1; - frac2= (int) (end2 - stop2) + 1; - while (buf1 <=end1 && buf2 <= end2 && *buf1 == *buf2) - buf1++, buf2++; - if (buf1 <= end1) - { - if (buf2 <= end2) - carry= *buf2 > *buf1; - else - carry= 0; - } - else - { - if (buf2 <= end2) - carry=1; - else /* short-circuit everything: from1 == from2 */ - { - if (to == 0) /* decimal_cmp() */ - return 0; - decimal_make_zero(to); - return E_DEC_OK; - } - } - } - - if (to == 0) /* decimal_cmp() */ - return carry == from1->sign ? 1 : -1; - - sanity(to); - - to->sign=from1->sign; - - /* ensure that always from1 > from2 (and intg1 >= intg2) */ - if (carry) - { - swap_variables(const decimal_t *, from1, from2); - swap_variables(dec1 *,start1, start2); - swap_variables(int,intg1,intg2); - swap_variables(int,frac1,frac2); - to->sign= 1 - to->sign; - } - - FIX_INTG_FRAC_ERROR(to->len, intg1, frac0, error); - buf0=to->buf+intg1+frac0; - - to->frac= MY_MAX(from1->frac, from2->frac); - to->intg=intg1*DIG_PER_DEC1; - if (unlikely(error)) - { - set_if_smaller(to->frac, frac0*DIG_PER_DEC1); - set_if_smaller(frac1, frac0); - set_if_smaller(frac2, frac0); - set_if_smaller(intg2, intg1); - } - carry=0; - - /* part 1 - max(frac) ... min (frac) */ - if (frac1 > frac2) - { - buf1=start1+intg1+frac1; - stop1=start1+intg1+frac2; - buf2=start2+intg2+frac2; - while (frac0-- > frac1) - *--buf0=0; - while (buf1 > stop1) - *--buf0=*--buf1; - } - else - { - buf1=start1+intg1+frac1; - buf2=start2+intg2+frac2; - stop2=start2+intg2+frac1; - while (frac0-- > frac2) - *--buf0=0; - while (buf2 > stop2) - { - SUB(*--buf0, 0, *--buf2, carry); - } - } - - /* part 2 - min(frac) ... intg2 */ - while (buf2 > start2) - { - SUB(*--buf0, *--buf1, *--buf2, carry); - } - - /* part 3 - intg2 ... intg1 */ - while (carry && buf1 > start1) - { - SUB(*--buf0, *--buf1, 0, carry); - } - - while (buf1 > start1) - *--buf0=*--buf1; - - while (buf0 > to->buf) - *--buf0=0; - - return error; -} - -int decimal_intg(const decimal_t *from) -{ - int res; - remove_leading_zeroes(from, &res); - return res; -} - -int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to) -{ - if (likely(from1->sign == from2->sign)) - return do_add(from1, from2, to); - return do_sub(from1, from2, to); -} - -int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to) -{ - if (likely(from1->sign == from2->sign)) - return do_sub(from1, from2, to); - return do_add(from1, from2, to); -} - -int decimal_cmp(const decimal_t *from1, const decimal_t *from2) -{ - if (likely(from1->sign == from2->sign)) - return do_sub(from1, from2, 0); - - // Reject negative zero, cfr. internal_str2dec() - DBUG_ASSERT(!(decimal_is_zero(from1) && from1->sign)); - DBUG_ASSERT(!(decimal_is_zero(from2) && from2->sign)); - - return from1->sign > from2->sign ? -1 : 1; -} - -int decimal_is_zero(const decimal_t *from) -{ - dec1 *buf1=from->buf, - *end=buf1+ROUND_UP(from->intg)+ROUND_UP(from->frac); - while (buf1 < end) - if (*buf1++) - return 0; - return 1; -} - -/* - multiply two decimals - - SYNOPSIS - decimal_mul() - from1, from2 - factors - to - product - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW; - - NOTES - in this implementation, with sizeof(dec1)=4 we have DIG_PER_DEC1=9, - and 63-digit number will take only 7 dec1 words (basically a 7-digit - "base 999999999" number). Thus there's no need in fast multiplication - algorithms, 7-digit numbers can be multiplied with a naive O(n*n) - method. - - XXX if this library is to be used with huge numbers of thousands of - digits, fast multiplication must be implemented. -*/ -int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to) -{ - int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg), - frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac), - intg0=ROUND_UP(from1->intg+from2->intg), - frac0=frac1+frac2, error, iii, jjj, d_to_move; - dec1 *buf1=from1->buf+intg1, *buf2=from2->buf+intg2, *buf0, - *start2, *stop2, *stop1, *start0, carry; - - sanity(to); - - iii= intg0; /* save 'ideal' values */ - jjj= frac0; - FIX_INTG_FRAC_ERROR(to->len, intg0, frac0, error); /* bound size */ - to->sign= from1->sign != from2->sign; - to->frac= from1->frac + from2->frac; /* store size in digits */ - set_if_smaller(to->frac, NOT_FIXED_DEC); - to->intg=intg0*DIG_PER_DEC1; - - if (unlikely(error)) - { - set_if_smaller(to->frac, frac0*DIG_PER_DEC1); - set_if_smaller(to->intg, intg0*DIG_PER_DEC1); - if (unlikely(iii > intg0)) /* bounded integer-part */ - { - iii-=intg0; - jjj= iii >> 1; - intg1-= jjj; - intg2-=iii-jjj; - frac1=frac2=0; /* frac0 is already 0 here */ - } - else /* bounded fract part */ - { - jjj-=frac0; - iii=jjj >> 1; - if (frac1 <= frac2) - { - frac1-= iii; - frac2-=jjj-iii; - } - else - { - frac2-= iii; - frac1-=jjj-iii; - } - } - } - start0=to->buf+intg0+frac0-1; - start2=buf2+frac2-1; - stop1=buf1-intg1; - stop2=buf2-intg2; - - memset(to->buf, 0, (intg0+frac0)*sizeof(dec1)); - - for (buf1+=frac1-1; buf1 >= stop1; buf1--, start0--) - { - carry=0; - for (buf0=start0, buf2=start2; buf2 >= stop2; buf2--, buf0--) - { - dec1 hi, lo; - dec2 p= ((dec2)*buf1) * ((dec2)*buf2); - hi=(dec1)(p/DIG_BASE); - lo=(dec1)(p-((dec2)hi)*DIG_BASE); - ADD2(*buf0, *buf0, lo, carry); - carry+=hi; - } - if (carry) - { - if (buf0 < to->buf) - return E_DEC_OVERFLOW; - ADD2(*buf0, *buf0, 0, carry); - } - for (buf0--; carry; buf0--) - { - if (buf0 < to->buf) - return E_DEC_OVERFLOW; - ADD(*buf0, *buf0, 0, carry); - } - } - - /* Now we have to check for -0.000 case */ - if (to->sign) - { - dec1 *buf= to->buf; - dec1 *end= to->buf + intg0 + frac0; - DBUG_ASSERT(buf != end); - for (;;) - { - if (*buf) - break; - if (++buf == end) - { - /* We got decimal zero */ - decimal_make_zero(to); - break; - } - } - } - buf1= to->buf; - d_to_move= intg0 + ROUND_UP(to->frac); - while (!*buf1 && (to->intg > DIG_PER_DEC1)) - { - buf1++; - to->intg-= DIG_PER_DEC1; - d_to_move--; - } - if (to->buf < buf1) - { - dec1 *cur_d= to->buf; - for (; d_to_move--; cur_d++, buf1++) - *cur_d= *buf1; - } - return error; -} - -/* - naive division algorithm (Knuth's Algorithm D in 4.3.1) - - it's ok for short numbers - also we're using alloca() to allocate a temporary buffer - - XXX if this library is to be used with huge numbers of thousands of - digits, fast division must be implemented and alloca should be - changed to malloc (or at least fallback to malloc if alloca() fails) - but then, decimal_mul() should be rewritten too :( -*/ -static int do_div_mod(const decimal_t *from1, const decimal_t *from2, - decimal_t *to, decimal_t *mod, int scale_incr) -{ - - /* - frac* - number of digits in fractional part of the number - prec* - precision of the number - intg* - number of digits in the integer part - buf* - buffer having the actual number - All variables ending with 0 - like frac0, intg0 etc are - for the final result. Similarly frac1, intg1 etc are for - the first number and frac2, intg2 etc are for the second number - */ - int frac1=ROUND_UP(from1->frac)*DIG_PER_DEC1, prec1=from1->intg+frac1, - frac2=ROUND_UP(from2->frac)*DIG_PER_DEC1, prec2=from2->intg+frac2, - error= 0, i, intg0, frac0, len1, len2, - dintg, /* Holds the estimate of number of integer digits in final result */ - div_mod=(!mod) /*true if this is division */; - dec1 *buf0, *buf1=from1->buf, *buf2=from2->buf, *start1, *stop1, - *start2, *stop2, *stop0 ,norm2, carry, dcarry, *tmp1; - dec2 norm_factor, x, guess, y; - - if (mod) - to=mod; - - sanity(to); - - /* - removing all the leading zeroes in the second number. Leading zeroes are - added later to the result. - */ - i= ((prec2 - 1) % DIG_PER_DEC1) + 1; - while (prec2 > 0 && *buf2 == 0) - { - prec2-= i; - i= DIG_PER_DEC1; - buf2++; - } - if (prec2 <= 0) /* short-circuit everything: from2 == 0 */ - return E_DEC_DIV_ZERO; - - /* - Remove the remanining zeroes . For ex: for 0.000000000001 - the above while loop removes 9 zeroes and the result will have 0.0001 - these remaining zeroes are removed here - */ - prec2-= count_leading_zeroes((prec2 - 1) % DIG_PER_DEC1, *buf2); - DBUG_ASSERT(prec2 > 0); - - /* - Do the same for the first number. Remove the leading zeroes. - Check if the number is actually 0. Then remove the remaining zeroes. - */ - - i=((prec1-1) % DIG_PER_DEC1)+1; - while (prec1 > 0 && *buf1 == 0) - { - prec1-=i; - i=DIG_PER_DEC1; - buf1++; - } - if (prec1 <= 0) - { /* short-circuit everything: from1 == 0 */ - decimal_make_zero(to); - return E_DEC_OK; - } - prec1-= count_leading_zeroes((prec1-1) % DIG_PER_DEC1, *buf1); - DBUG_ASSERT(prec1 > 0); - - /* let's fix scale_incr, taking into account frac1,frac2 increase */ - if ((scale_incr-= frac1 - from1->frac + frac2 - from2->frac) < 0) - scale_incr=0; - - /* Calculate the integer digits in final result */ - dintg=(prec1-frac1)-(prec2-frac2)+(*buf1 >= *buf2); - if (dintg < 0) - { - dintg/=DIG_PER_DEC1; - intg0=0; - } - else - intg0=ROUND_UP(dintg); - if (mod) - { - /* we're calculating N1 % N2. - The result will have - frac=max(frac1, frac2), as for subtraction - intg=intg2 - */ - to->sign=from1->sign; - to->frac= MY_MAX(from1->frac, from2->frac); - frac0=0; - } - else - { - /* - we're calculating N1/N2. N1 is in the buf1, has prec1 digits - N2 is in the buf2, has prec2 digits. Scales are frac1 and - frac2 accordingly. - Thus, the result will have - frac = ROUND_UP(frac1+frac2+scale_incr) - and - intg = (prec1-frac1) - (prec2-frac2) + 1 - prec = intg+frac - */ - frac0=ROUND_UP(frac1+frac2+scale_incr); - FIX_INTG_FRAC_ERROR(to->len, intg0, frac0, error); - to->sign=from1->sign != from2->sign; - to->intg=intg0*DIG_PER_DEC1; - to->frac=frac0*DIG_PER_DEC1; - } - buf0=to->buf; - stop0=buf0+intg0+frac0; - if (likely(div_mod)) - while (dintg++ < 0 && buf0 < &to->buf[to->len]) - { - *buf0++=0; - } - - len1=(i=ROUND_UP(prec1))+ROUND_UP(2*frac2+scale_incr+1) + 1; - set_if_bigger(len1, 3); - if (!(tmp1=(dec1 *)my_alloca(len1*sizeof(dec1)))) - return E_DEC_OOM; - memcpy(tmp1, buf1, i*sizeof(dec1)); - memset(tmp1+i, 0, (len1-i)*sizeof(dec1)); - - start1=tmp1; - stop1=start1+len1; - start2=buf2; - stop2=buf2+ROUND_UP(prec2)-1; - - /* removing end zeroes */ - while (*stop2 == 0 && stop2 >= start2) - stop2--; - len2= (int) (stop2++ - start2); - - /* - calculating norm2 (normalized *start2) - we need *start2 to be large - (at least > DIG_BASE/2), but unlike Knuth's Alg. D we don't want to - normalize input numbers (as we don't make a copy of the divisor). - Thus we normalize first dec1 of buf2 only, and we'll normalize *start1 - on the fly for the purpose of guesstimation only. - It's also faster, as we're saving on normalization of buf2 - */ - norm_factor=DIG_BASE/(*start2+1); - norm2=(dec1)(norm_factor*start2[0]); - if (likely(len2>0)) - norm2+=(dec1)(norm_factor*start2[1]/DIG_BASE); - - if (*start1 < *start2) - dcarry=*start1++; - else - dcarry=0; - - /* main loop */ - for (; buf0 < stop0; buf0++) - { - /* short-circuit, if possible */ - if (unlikely(dcarry == 0 && *start1 < *start2)) - guess=0; - else - { - /* D3: make a guess */ - x=start1[0]+((dec2)dcarry)*DIG_BASE; - y=start1[1]; - guess=(norm_factor*x+norm_factor*y/DIG_BASE)/norm2; - if (unlikely(guess >= DIG_BASE)) - guess=DIG_BASE-1; - if (likely(len2>0)) - { - /* hmm, this is a suspicious trick - I removed normalization here */ - if (start2[1]*guess > (x-guess*start2[0])*DIG_BASE+y) - guess--; - if (unlikely(start2[1]*guess > (x-guess*start2[0])*DIG_BASE+y)) - guess--; - DBUG_ASSERT(start2[1]*guess <= (x-guess*start2[0])*DIG_BASE+y); - } - - /* D4: multiply and subtract */ - buf2=stop2; - buf1=start1+len2; - DBUG_ASSERT(buf1 < stop1); - for (carry=0; buf2 > start2; buf1--) - { - dec1 hi, lo; - x=guess * (*--buf2); - hi=(dec1)(x/DIG_BASE); - lo=(dec1)(x-((dec2)hi)*DIG_BASE); - SUB2(*buf1, *buf1, lo, carry); - carry+=hi; - } - carry= dcarry < carry; - - /* D5: check the remainder */ - if (unlikely(carry)) - { - /* D6: correct the guess */ - guess--; - buf2=stop2; - buf1=start1+len2; - for (carry=0; buf2 > start2; buf1--) - { - ADD(*buf1, *buf1, *--buf2, carry); - } - } - } - if (likely(div_mod)) - { - DBUG_ASSERT(buf0 < to->buf + to->len); - *buf0=(dec1)guess; - } - dcarry= *start1; - start1++; - } - if (mod) - { - /* - now the result is in tmp1, it has - intg=prec1-frac1 if there were no leading zeroes. - If leading zeroes were present, they have been removed - earlier. We need to now add them back to the result. - frac=max(frac1, frac2)=to->frac - */ - if (dcarry) - *--start1=dcarry; - buf0=to->buf; - /* Calculate the final result's integer digits */ - dintg= (prec1 - frac1) - ((start1 - tmp1) * DIG_PER_DEC1); - if (dintg < 0) - { - /* If leading zeroes in the fractional part were earlier stripped */ - intg0= dintg / DIG_PER_DEC1; - } - else - intg0= ROUND_UP(dintg); - frac0=ROUND_UP(to->frac); - error=E_DEC_OK; - if (unlikely(frac0==0 && intg0==0)) - { - decimal_make_zero(to); - goto done; - } - if (intg0<=0) - { - /* Add back the leading zeroes that were earlier stripped */ - if (unlikely(-intg0 >= to->len)) - { - decimal_make_zero(to); - error=E_DEC_TRUNCATED; - goto done; - } - stop1= start1 + frac0 + intg0; - frac0+=intg0; - to->intg=0; - while (intg0++ < 0) - *buf0++=0; - } - else - { - if (unlikely(intg0 > to->len)) - { - frac0=0; - intg0=to->len; - error=E_DEC_OVERFLOW; - goto done; - } - DBUG_ASSERT(intg0 <= ROUND_UP(from2->intg)); - stop1=start1+frac0+intg0; - to->intg= MY_MIN(intg0 * DIG_PER_DEC1, from2->intg); - } - if (unlikely(intg0+frac0 > to->len)) - { - stop1-=frac0+intg0-to->len; - frac0=to->len-intg0; - to->frac=frac0*DIG_PER_DEC1; - error=E_DEC_TRUNCATED; - } - DBUG_ASSERT(buf0 + (stop1 - start1) <= to->buf + to->len); - while (start1 < stop1) - *buf0++=*start1++; - } -done: - tmp1= remove_leading_zeroes(to, &to->intg); - if(to->buf != tmp1) - memmove(to->buf, tmp1, - (ROUND_UP(to->intg) + ROUND_UP(to->frac)) * sizeof(dec1)); - return error; -} - -/* - division of two decimals - - SYNOPSIS - decimal_div() - from1 - dividend - from2 - divisor - to - quotient - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_DIV_ZERO; - - NOTES - see do_div_mod() -*/ - -int -decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to, - int scale_incr) -{ - return do_div_mod(from1, from2, to, 0, scale_incr); -} - -/* - modulus - - SYNOPSIS - decimal_mod() - from1 - dividend - from2 - divisor - to - modulus - - RETURN VALUE - E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_DIV_ZERO; - - NOTES - see do_div_mod() - - DESCRIPTION - the modulus R in R = M mod N - - is defined as - - 0 <= |R| < |M| - sign R == sign M - R = M - k*N, where k is integer - - thus, there's no requirement for M or N to be integers -*/ - -int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to) -{ - return do_div_mod(from1, from2, 0, to, 0); -} - -#ifdef MAIN -/* - The main() program has been converted into a unit test. - */ -#endif |