| /* Packed decimal conversion module for the decNumber C Library. |
| Copyright (C) 2007-2021 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 3, or (at your option) any later |
| version. |
| |
| 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. |
| |
| Under Section 7 of GPL version 3, you are granted additional |
| permissions described in the GCC Runtime Library Exception, version |
| 3.1, as published by the Free Software Foundation. |
| |
| You should have received a copy of the GNU General Public License and |
| a copy of the GCC Runtime Library Exception along with this program; |
| see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| /* ------------------------------------------------------------------ */ |
| /* Packed Decimal conversion module */ |
| /* ------------------------------------------------------------------ */ |
| /* This module comprises the routines for Packed Decimal format */ |
| /* numbers. Conversions are supplied to and from decNumber, which in */ |
| /* turn supports: */ |
| /* conversions to and from string */ |
| /* arithmetic routines */ |
| /* utilities. */ |
| /* Conversions from decNumber to and from densely packed decimal */ |
| /* formats are provided by the decimal32 through decimal128 modules. */ |
| /* ------------------------------------------------------------------ */ |
| |
| #include <string.h> /* for NULL */ |
| #include "decNumber.h" /* base number library */ |
| #include "decPacked.h" /* packed decimal */ |
| #include "decNumberLocal.h" /* decNumber local types, etc. */ |
| |
| /* ------------------------------------------------------------------ */ |
| /* decPackedFromNumber -- convert decNumber to BCD Packed Decimal */ |
| /* */ |
| /* bcd is the BCD bytes */ |
| /* length is the length of the BCD array */ |
| /* scale is the scale result */ |
| /* dn is the decNumber */ |
| /* returns bcd, or NULL if error */ |
| /* */ |
| /* The number is converted to a BCD packed decimal byte array, */ |
| /* right aligned in the bcd array, whose length is indicated by the */ |
| /* second parameter. The final 4-bit nibble in the array will be a */ |
| /* sign nibble, C (1100) for + and D (1101) for -. Unused bytes and */ |
| /* nibbles to the left of the number are set to 0. */ |
| /* */ |
| /* scale is set to the scale of the number (this is the exponent, */ |
| /* negated). To force the number to a specified scale, first use the */ |
| /* decNumberRescale routine, which will round and change the exponent */ |
| /* as necessary. */ |
| /* */ |
| /* If there is an error (that is, the decNumber has too many digits */ |
| /* to fit in length bytes, or it is a NaN or Infinity), NULL is */ |
| /* returned and the bcd and scale results are unchanged. Otherwise */ |
| /* bcd is returned. */ |
| /* ------------------------------------------------------------------ */ |
| uByte * decPackedFromNumber(uByte *bcd, Int length, Int *scale, |
| const decNumber *dn) { |
| const Unit *up=dn->lsu; /* Unit array pointer */ |
| uByte obyte, *out; /* current output byte, and where it goes */ |
| Int indigs=dn->digits; /* digits processed */ |
| uInt cut=DECDPUN; /* downcounter per Unit */ |
| uInt u=*up; /* work */ |
| uInt nib; /* .. */ |
| #if DECDPUN<=4 |
| uInt temp; /* .. */ |
| #endif |
| |
| if (dn->digits>length*2-1 /* too long .. */ |
| ||(dn->bits & DECSPECIAL)) return NULL; /* .. or special -- hopeless */ |
| |
| if (dn->bits&DECNEG) obyte=DECPMINUS; /* set the sign .. */ |
| else obyte=DECPPLUS; |
| *scale=-dn->exponent; /* .. and scale */ |
| |
| /* loop from lowest (rightmost) byte */ |
| out=bcd+length-1; /* -> final byte */ |
| for (; out>=bcd; out--) { |
| if (indigs>0) { |
| if (cut==0) { |
| up++; |
| u=*up; |
| cut=DECDPUN; |
| } |
| #if DECDPUN<=4 |
| temp=(u*6554)>>16; /* fast /10 */ |
| nib=u-X10(temp); |
| u=temp; |
| #else |
| nib=u%10; /* cannot use *6554 trick :-( */ |
| u=u/10; |
| #endif |
| obyte|=(nib<<4); |
| indigs--; |
| cut--; |
| } |
| *out=obyte; |
| obyte=0; /* assume 0 */ |
| if (indigs>0) { |
| if (cut==0) { |
| up++; |
| u=*up; |
| cut=DECDPUN; |
| } |
| #if DECDPUN<=4 |
| temp=(u*6554)>>16; /* as above */ |
| obyte=(uByte)(u-X10(temp)); |
| u=temp; |
| #else |
| obyte=(uByte)(u%10); |
| u=u/10; |
| #endif |
| indigs--; |
| cut--; |
| } |
| } /* loop */ |
| |
| return bcd; |
| } /* decPackedFromNumber */ |
| |
| /* ------------------------------------------------------------------ */ |
| /* decPackedToNumber -- convert BCD Packed Decimal to a decNumber */ |
| /* */ |
| /* bcd is the BCD bytes */ |
| /* length is the length of the BCD array */ |
| /* scale is the scale associated with the BCD integer */ |
| /* dn is the decNumber [with space for length*2 digits] */ |
| /* returns dn, or NULL if error */ |
| /* */ |
| /* The BCD packed decimal byte array, together with an associated */ |
| /* scale, is converted to a decNumber. 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 decNumber. */ |
| /* Note that zeros may have a sign and/or a scale. */ |
| /* */ |
| /* The decNumber structure is assumed to have sufficient space to */ |
| /* hold the converted number (that is, up to length*2-1 digits), so */ |
| /* no error is possible unless the adjusted exponent is out of range, */ |
| /* no sign nibble was found, or a sign nibble was found before the */ |
| /* final nibble. In these error cases, NULL is returned and the */ |
| /* decNumber will be 0. */ |
| /* ------------------------------------------------------------------ */ |
| decNumber * decPackedToNumber(const uByte *bcd, Int length, |
| const Int *scale, decNumber *dn) { |
| const uByte *last=bcd+length-1; /* -> last byte */ |
| const uByte *first; /* -> first non-zero byte */ |
| uInt nib; /* work nibble */ |
| Unit *up=dn->lsu; /* output pointer */ |
| Int digits; /* digits count */ |
| Int cut=0; /* phase of output */ |
| |
| decNumberZero(dn); /* default result */ |
| last=&bcd[length-1]; |
| nib=*last & 0x0f; /* get the sign */ |
| if (nib==DECPMINUS || nib==DECPMINUSALT) dn->bits=DECNEG; |
| else if (nib<=9) return NULL; /* not a sign nibble */ |
| |
| /* skip leading zero bytes [final byte is always non-zero, due to sign] */ |
| for (first=bcd; *first==0;) first++; |
| digits=(last-first)*2+1; /* calculate digits .. */ |
| if ((*first & 0xf0)==0) digits--; /* adjust for leading zero nibble */ |
| if (digits!=0) dn->digits=digits; /* count of actual digits [if 0, */ |
| /* leave as 1] */ |
| |
| /* check the adjusted exponent; note that scale could be unbounded */ |
| dn->exponent=-*scale; /* set the exponent */ |
| if (*scale>=0) { /* usual case */ |
| if ((dn->digits-*scale-1)<-DECNUMMAXE) { /* underflow */ |
| decNumberZero(dn); |
| return NULL;} |
| } |
| else { /* -ve scale; +ve exponent */ |
| /* need to be careful to avoid wrap, here, also BADINT case */ |
| if ((*scale<-DECNUMMAXE) /* overflow even without digits */ |
| || ((dn->digits-*scale-1)>DECNUMMAXE)) { /* overflow */ |
| decNumberZero(dn); |
| return NULL;} |
| } |
| if (digits==0) return dn; /* result was zero */ |
| |
| /* copy the digits to the number's units, starting at the lsu */ |
| /* [unrolled] */ |
| for (;;) { /* forever */ |
| /* left nibble first */ |
| nib=(unsigned)(*last & 0xf0)>>4; |
| /* got a digit, in nib */ |
| if (nib>9) {decNumberZero(dn); return NULL;} |
| |
| if (cut==0) *up=(Unit)nib; |
| else *up=(Unit)(*up+nib*DECPOWERS[cut]); |
| digits--; |
| if (digits==0) break; /* got them all */ |
| cut++; |
| if (cut==DECDPUN) { |
| up++; |
| cut=0; |
| } |
| last--; /* ready for next */ |
| nib=*last & 0x0f; /* get right nibble */ |
| if (nib>9) {decNumberZero(dn); return NULL;} |
| |
| /* got a digit, in nib */ |
| if (cut==0) *up=(Unit)nib; |
| else *up=(Unit)(*up+nib*DECPOWERS[cut]); |
| digits--; |
| if (digits==0) break; /* got them all */ |
| cut++; |
| if (cut==DECDPUN) { |
| up++; |
| cut=0; |
| } |
| } /* forever */ |
| |
| return dn; |
| } /* decPackedToNumber */ |
| |
