URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libdecnumber/] [decPacked.c] - Rev 387
Go to most recent revision | Compare with Previous | Blame | View Log
/* Packed decimal conversion module for the decNumber C Library. Copyright (C) 2007, 2009 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 */
Go to most recent revision | Compare with Previous | Blame | View Log