| /* Utility functions for decimal floating point support via decNumber. |
| Copyright (C) 2005 Free Software Foundation, Inc. |
| Contributed by IBM Corporation. Author Mike Cowlishaw. |
| |
| This file is part of GCC. |
| |
| GCC 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; either version 2, or (at your option) any later |
| version. |
| |
| In addition to the permissions in the GNU General Public License, |
| the Free Software Foundation gives you unlimited permission to link |
| the compiled version of this file into combinations with other |
| programs, and to distribute those combinations without any |
| restriction coming from the use of this file. (The General Public |
| License restrictions do apply in other respects; for example, they |
| cover modification of the file, and distribution when not linked |
| into a combine executable.) |
| |
| GCC 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 GCC; see the file COPYING. If not, write to the Free |
| Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301, USA. */ |
| |
| #include "config.h" |
| #include "decNumber.h" /* base number library */ |
| #include "decNumberLocal.h" /* decNumber local types, etc. */ |
| #include "decUtility.h" /* utility routines */ |
| |
| /* ================================================================== */ |
| /* Shared utility routines */ |
| /* ================================================================== */ |
| |
| /* define and include the conversion tables to use */ |
| #define DEC_BIN2DPD 1 /* used for all sizes */ |
| #if DECDPUN==3 |
| #define DEC_DPD2BIN 1 |
| #else |
| #define DEC_DPD2BCD 1 |
| #endif |
| #include "decDPD.h" /* lookup tables */ |
| |
| /* The maximum number of decNumberUnits we need for a working copy of */ |
| /* the units array is the ceiling of digits/DECDPUN, where digits is */ |
| /* the maximum number of digits in any of the formats for which this */ |
| /* is used. We do not want to include decimal128.h, so, as a very */ |
| /* special case, that number is defined here. */ |
| #define DECMAX754 34 |
| #define DECMAXUNITS ((DECMAX754+DECDPUN-1)/DECDPUN) |
| |
| /* ------------------------------------------------------------------ */ |
| /* decDensePackCoeff -- densely pack coefficient into DPD form */ |
| /* */ |
| /* dn is the source number (assumed valid, max DECMAX754 digits) */ |
| /* bytes is the target's byte array */ |
| /* len is length of target format's byte array */ |
| /* shift is the number of 0 digits to add on the right (normally 0) */ |
| /* */ |
| /* The coefficient must be known small enough to fit, and is filled */ |
| /* in from the right (least significant first). Note that the full */ |
| /* coefficient is copied, including the leading 'odd' digit. This */ |
| /* digit is retrieved and packed into the combination field by the */ |
| /* caller. */ |
| /* */ |
| /* shift is used for 'fold-down' padding. */ |
| /* */ |
| /* No error is possible. */ |
| /* ------------------------------------------------------------------ */ |
| void |
| decDensePackCoeff (const decNumber * dn, uByte * bytes, Int len, Int shift) |
| { |
| Int cut; /* work */ |
| Int n; /* output bunch counter */ |
| Int digits = dn->digits; /* digit countdown */ |
| uInt dpd; /* densely packed decimal value */ |
| uInt bin; /* binary value 0-999 */ |
| uByte *bout; /* -> current output byte */ |
| const Unit *inu = dn->lsu; /* -> current input unit */ |
| Unit uar[DECMAXUNITS]; /* working copy of units, iff shifted */ |
| #if DECDPUN!=3 /* not fast path */ |
| Unit in; /* current input unit */ |
| #endif |
| |
| if (shift != 0) |
| { /* shift towards most significant required */ |
| /* shift the units array to the left by pad digits and copy */ |
| /* [this code is a special case of decShiftToMost, which could */ |
| /* be used instead if exposed and the array were copied first] */ |
| Unit *target, *first; /* work */ |
| const Unit *source; /* work */ |
| uInt next = 0; /* work */ |
| |
| source = dn->lsu + D2U (digits) - 1; /* where msu comes from */ |
| first = uar + D2U (digits + shift) - 1; /* where msu will end up */ |
| target = uar + D2U (digits) - 1 + D2U (shift); /* where upper part of first cut goes */ |
| |
| cut = (DECDPUN - shift % DECDPUN) % DECDPUN; |
| for (; source >= dn->lsu; source--, target--) |
| { |
| /* split the source Unit and accumulate remainder for next */ |
| uInt rem = *source % powers[cut]; |
| next += *source / powers[cut]; |
| if (target <= first) |
| *target = (Unit) next; /* write to target iff valid */ |
| next = rem * powers[DECDPUN - cut]; /* save remainder for next Unit */ |
| } |
| /* propagate remainder to one below and clear the rest */ |
| for (; target >= uar; target--) |
| { |
| *target = (Unit) next; |
| next = 0; |
| } |
| digits += shift; /* add count (shift) of zeros added */ |
| inu = uar; /* use units in working array */ |
| } |
| |
| /* densely pack the coefficient into the byte array, starting from |
| the right (optionally padded) */ |
| bout = &bytes[len - 1]; /* rightmost result byte for phase */ |
| |
| #if DECDPUN!=3 /* not fast path */ |
| in = *inu; /* prime */ |
| cut = 0; /* at lowest digit */ |
| bin = 0; /* [keep compiler quiet] */ |
| #endif |
| |
| for (n = 0; digits > 0; n++) |
| { /* each output bunch */ |
| #if DECDPUN==3 /* fast path, 3-at-a-time */ |
| bin = *inu; /* 3 ready for convert */ |
| digits -= 3; /* [may go negative] */ |
| inu++; /* may need another */ |
| |
| #else /* must collect digit-by-digit */ |
| Unit dig; /* current digit */ |
| Int j; /* digit-in-bunch count */ |
| for (j = 0; j < 3; j++) |
| { |
| #if DECDPUN<=4 |
| Unit temp = (Unit) ((uInt) (in * 6554) >> 16); |
| dig = (Unit) (in - X10 (temp)); |
| in = temp; |
| #else |
| dig = in % 10; |
| in = in / 10; |
| #endif |
| |
| if (j == 0) |
| bin = dig; |
| else if (j == 1) |
| bin += X10 (dig); |
| else /* j==2 */ |
| bin += X100 (dig); |
| |
| digits--; |
| if (digits == 0) |
| break; /* [also protects *inu below] */ |
| cut++; |
| if (cut == DECDPUN) |
| { |
| inu++; |
| in = *inu; |
| cut = 0; |
| } |
| } |
| #endif |
| /* here we have 3 digits in bin, or have used all input digits */ |
| |
| dpd = BIN2DPD[bin]; |
| |
| /* write bunch (bcd) to byte array */ |
| switch (n & 0x03) |
| { /* phase 0-3 */ |
| case 0: |
| *bout = (uByte) dpd; /* [top 2 bits truncated] */ |
| bout--; |
| *bout = (uByte) (dpd >> 8); |
| break; |
| case 1: |
| *bout |= (uByte) (dpd << 2); |
| bout--; |
| *bout = (uByte) (dpd >> 6); |
| break; |
| case 2: |
| *bout |= (uByte) (dpd << 4); |
| bout--; |
| *bout = (uByte) (dpd >> 4); |
| break; |
| case 3: |
| *bout |= (uByte) (dpd << 6); |
| bout--; |
| *bout = (uByte) (dpd >> 2); |
| bout--; |
| break; |
| } /* switch */ |
| } /* n bunches */ |
| return; |
| } |
| |
| /* ------------------------------------------------------------------ */ |
| /* decDenseUnpackCoeff -- unpack a format's coefficient */ |
| /* */ |
| /* byte is the source's byte array */ |
| /* len is length of the source's byte array */ |
| /* dn is the target number, with 7, 16, or 34-digit space. */ |
| /* bunches is the count of DPD groups in the decNumber (2, 5, or 11)*/ |
| /* odd is 1 if there is a non-zero leading 10-bit group containing */ |
| /* a single digit, 0 otherwise */ |
| /* */ |
| /* (This routine works on a copy of the number, if necessary, where */ |
| /* an extra 10-bit group is prefixed to the coefficient continuation */ |
| /* to hold the most significant digit if the latter is non-0.) */ |
| /* */ |
| /* dn->digits is set, but not the sign or exponent. */ |
| /* No error is possible [the redundant 888 codes are allowed]. */ |
| /* ------------------------------------------------------------------ */ |
| void |
| decDenseUnpackCoeff (const uByte * bytes, Int len, decNumber * dn, |
| Int bunches, Int odd) |
| { |
| uInt dpd = 0; /* collector for 10 bits */ |
| Int n; /* counter */ |
| const uByte *bin; /* -> current input byte */ |
| Unit *uout = dn->lsu; /* -> current output unit */ |
| Unit out = 0; /* accumulator */ |
| Int cut = 0; /* power of ten in current unit */ |
| Unit *last = uout; /* will be unit containing msd */ |
| #if DECDPUN!=3 |
| uInt bcd; /* BCD result */ |
| uInt nibble; /* work */ |
| #endif |
| |
| /* Expand the densely-packed integer, right to left */ |
| bin = &bytes[len - 1]; /* next input byte to use */ |
| for (n = 0; n < bunches + odd; n++) |
| { /* N bunches of 10 bits */ |
| /* assemble the 10 bits */ |
| switch (n & 0x03) |
| { /* phase 0-3 */ |
| case 0: |
| dpd = *bin; |
| bin--; |
| dpd |= (*bin & 0x03) << 8; |
| break; |
| case 1: |
| dpd = (unsigned) *bin >> 2; |
| bin--; |
| dpd |= (*bin & 0x0F) << 6; |
| break; |
| case 2: |
| dpd = (unsigned) *bin >> 4; |
| bin--; |
| dpd |= (*bin & 0x3F) << 4; |
| break; |
| case 3: |
| dpd = (unsigned) *bin >> 6; |
| bin--; |
| dpd |= (*bin) << 2; |
| bin--; |
| break; |
| } /*switch */ |
| |
| #if DECDPUN==3 |
| if (dpd == 0) |
| *uout = 0; |
| else |
| { |
| *uout = DPD2BIN[dpd]; /* convert 10 bits to binary 0-999 */ |
| last = uout; /* record most significant unit */ |
| } |
| uout++; |
| |
| #else /* DECDPUN!=3 */ |
| if (dpd == 0) |
| { /* fastpath [e.g., leading zeros] */ |
| cut += 3; |
| for (; cut >= DECDPUN;) |
| { |
| cut -= DECDPUN; |
| *uout = out; |
| uout++; |
| out = 0; |
| } |
| continue; |
| } |
| bcd = DPD2BCD[dpd]; /* convert 10 bits to 12 bits BCD */ |
| /* now split the 3 BCD nibbles into bytes, and accumulate into units */ |
| /* If this is the last bunch and it is an odd one, we only have one */ |
| /* nibble to handle [extras could overflow a Unit] */ |
| nibble = bcd & 0x000f; |
| if (nibble) |
| { |
| last = uout; |
| out = (Unit) (out + nibble * powers[cut]); |
| } |
| cut++; |
| if (cut == DECDPUN) |
| { |
| *uout = out; |
| uout++; |
| cut = 0; |
| out = 0; |
| } |
| if (n < bunches) |
| { |
| nibble = bcd & 0x00f0; |
| if (nibble) |
| { |
| nibble >>= 4; |
| last = uout; |
| out = (Unit) (out + nibble * powers[cut]); |
| } |
| cut++; |
| if (cut == DECDPUN) |
| { |
| *uout = out; |
| uout++; |
| cut = 0; |
| out = 0; |
| } |
| nibble = bcd & 0x0f00; |
| if (nibble) |
| { |
| nibble >>= 8; |
| last = uout; |
| out = (Unit) (out + nibble * powers[cut]); |
| } |
| cut++; |
| if (cut == DECDPUN) |
| { |
| *uout = out; |
| uout++; |
| cut = 0; |
| out = 0; |
| } |
| } |
| #endif |
| } /* n */ |
| if (cut != 0) |
| *uout = out; /* write out final unit */ |
| |
| /* here, last points to the most significant unit with digits */ |
| /* we need to inspect it to get final digits count */ |
| dn->digits = (last - dn->lsu) * DECDPUN; /* floor of digits */ |
| for (cut = 0; cut < DECDPUN; cut++) |
| { |
| if (*last < powers[cut]) |
| break; |
| dn->digits++; |
| } |
| if (dn->digits == 0) |
| dn->digits++; /* zero has one digit */ |
| return; |
| } |