[thirdparty/binutils-gdb.git] / libdecnumber / dpd / decimal32.c

/* Decimal 32-bit format module for the decNumber C Library.
   Copyright (C) 2005-2018 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/>.  */

/* ------------------------------------------------------------------ */
/* Decimal 32-bit format module 				      */
/* ------------------------------------------------------------------ */
/* This module comprises the routines for decimal32 format numbers.   */
/* Conversions are supplied to and from decNumber and String.	      */
/*								      */
/* This is used when decNumber provides operations, either for all    */
/* operations or as a proxy between decNumber and decSingle.	      */
/*								      */
/* Error handling is the same as decNumber (qv.).		      */
/* ------------------------------------------------------------------ */
#include <string.h>	      /* [for memset/memcpy] */
#include <stdio.h>	      /* [for printf] */

#include "dconfig.h"          /* GCC definitions */
#define  DECNUMDIGITS  7      /* make decNumbers with space for 7 */
#include "decNumber.h"	      /* base number library */
#include "decNumberLocal.h"   /* decNumber local types, etc. */
#include "decimal32.h"	      /* our primary include */

/* Utility tables and routines [in decimal64.c] */
extern const uInt   COMBEXP[32], COMBMSD[32];
extern const uShort DPD2BIN[1024];
extern const uShort BIN2DPD[1000];
extern const uByte  BIN2CHAR[4001];

extern void decDigitsToDPD(const decNumber *, uInt *, Int);
extern void decDigitsFromDPD(decNumber *, const uInt *, Int);

#if DECTRACE || DECCHECK
void decimal32Show(const decimal32 *);		  /* for debug */
extern void decNumberShow(const decNumber *);	  /* .. */
#endif

/* Useful macro */
/* Clear a structure (e.g., a decNumber) */
#define DEC_clear(d) memset(d, 0, sizeof(*d))

/* ------------------------------------------------------------------ */
/* decimal32FromNumber -- convert decNumber to decimal32	      */
/*								      */
/*   ds is the target decimal32 				      */
/*   dn is the source number (assumed valid)			      */
/*   set is the context, used only for reporting errors 	      */
/*								      */
/* The set argument is used only for status reporting and for the     */
/* rounding mode (used if the coefficient is more than DECIMAL32_Pmax */
/* digits or an overflow is detected).	If the exponent is out of the */
/* valid range then Overflow or Underflow will be raised.	      */
/* After Underflow a subnormal result is possible.		      */
/*								      */
/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
/* by reducing its exponent and multiplying the coefficient by a      */
/* power of ten, or if the exponent on a zero had to be clamped.      */
/* ------------------------------------------------------------------ */
decimal32 * decimal32FromNumber(decimal32 *d32, const decNumber *dn,
			      decContext *set) {
  uInt status=0;		   /* status accumulator */
  Int ae;			   /* adjusted exponent */
  decNumber  dw;		   /* work */
  decContext dc;		   /* .. */
  uInt comb, exp;		   /* .. */
  uInt uiwork;			   /* for macros */
  uInt targ=0;			   /* target 32-bit */

  /* If the number has too many digits, or the exponent could be */
  /* out of range then reduce the number under the appropriate */
  /* constraints.  This could push the number to Infinity or zero, */
  /* so this check and rounding must be done before generating the */
  /* decimal32] */
  ae=dn->exponent+dn->digits-1; 	     /* [0 if special] */
  if (dn->digits>DECIMAL32_Pmax 	     /* too many digits */
   || ae>DECIMAL32_Emax 		     /* likely overflow */
   || ae<DECIMAL32_Emin) {		     /* likely underflow */
    decContextDefault(&dc, DEC_INIT_DECIMAL32); /* [no traps] */
    dc.round=set->round;		     /* use supplied rounding */
    decNumberPlus(&dw, dn, &dc);	     /* (round and check) */
    /* [this changes -0 to 0, so enforce the sign...] */
    dw.bits|=dn->bits&DECNEG;
    status=dc.status;			     /* save status */
    dn=&dw;				     /* use the work number */
    } /* maybe out of range */

  if (dn->bits&DECSPECIAL) {			  /* a special value */
    if (dn->bits&DECINF) targ=DECIMAL_Inf<<24;
     else {					  /* sNaN or qNaN */
      if ((*dn->lsu!=0 || dn->digits>1) 	  /* non-zero coefficient */
       && (dn->digits<DECIMAL32_Pmax)) {	  /* coefficient fits */
	decDigitsToDPD(dn, &targ, 0);
	}
      if (dn->bits&DECNAN) targ|=DECIMAL_NaN<<24;
       else targ|=DECIMAL_sNaN<<24;
      } /* a NaN */
    } /* special */

   else { /* is finite */
    if (decNumberIsZero(dn)) {		     /* is a zero */
      /* set and clamp exponent */
      if (dn->exponent<-DECIMAL32_Bias) {
	exp=0;				     /* low clamp */
	status|=DEC_Clamped;
	}
       else {
	exp=dn->exponent+DECIMAL32_Bias;     /* bias exponent */
	if (exp>DECIMAL32_Ehigh) {	     /* top clamp */
	  exp=DECIMAL32_Ehigh;
	  status|=DEC_Clamped;
	  }
	}
      comb=(exp>>3) & 0x18;		/* msd=0, exp top 2 bits .. */
      }
     else {				/* non-zero finite number */
      uInt msd; 			/* work */
      Int pad=0;			/* coefficient pad digits */

      /* the dn is known to fit, but it may need to be padded */
      exp=(uInt)(dn->exponent+DECIMAL32_Bias);	  /* bias exponent */
      if (exp>DECIMAL32_Ehigh) {		  /* fold-down case */
	pad=exp-DECIMAL32_Ehigh;
	exp=DECIMAL32_Ehigh;			  /* [to maximum] */
	status|=DEC_Clamped;
	}

      /* fastpath common case */
      if (DECDPUN==3 && pad==0) {
	targ=BIN2DPD[dn->lsu[0]];
	if (dn->digits>3) targ|=(uInt)(BIN2DPD[dn->lsu[1]])<<10;
	msd=(dn->digits==7 ? dn->lsu[2] : 0);
	}
       else { /* general case */
	decDigitsToDPD(dn, &targ, pad);
	/* save and clear the top digit */
	msd=targ>>20;
	targ&=0x000fffff;
	}

      /* create the combination field */
      if (msd>=8) comb=0x18 | ((exp>>5) & 0x06) | (msd & 0x01);
	     else comb=((exp>>3) & 0x18) | msd;
      }
    targ|=comb<<26;		   /* add combination field .. */
    targ|=(exp&0x3f)<<20;	   /* .. and exponent continuation */
    } /* finite */

  if (dn->bits&DECNEG) targ|=0x80000000;  /* add sign bit */

  /* now write to storage; this is endian */
  UBFROMUI(d32->bytes, targ);	   /* directly store the int */

  if (status!=0) decContextSetStatus(set, status); /* pass on status */
  /* decimal32Show(d32); */
  return d32;
  } /* decimal32FromNumber */

/* ------------------------------------------------------------------ */
/* decimal32ToNumber -- convert decimal32 to decNumber		      */
/*   d32 is the source decimal32				      */
/*   dn is the target number, with appropriate space		      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
decNumber * decimal32ToNumber(const decimal32 *d32, decNumber *dn) {
  uInt msd;			   /* coefficient MSD */
  uInt exp;			   /* exponent top two bits */
  uInt comb;			   /* combination field */
  uInt sour;			   /* source 32-bit */
  uInt uiwork;			   /* for macros */

  /* load source from storage; this is endian */
  sour=UBTOUI(d32->bytes);	   /* directly load the int */

  comb=(sour>>26)&0x1f; 	   /* combination field */

  decNumberZero(dn);		   /* clean number */
  if (sour&0x80000000) dn->bits=DECNEG; /* set sign if negative */

  msd=COMBMSD[comb];		   /* decode the combination field */
  exp=COMBEXP[comb];		   /* .. */

  if (exp==3) { 		   /* is a special */
    if (msd==0) {
      dn->bits|=DECINF;
      return dn;		   /* no coefficient needed */
      }
    else if (sour&0x02000000) dn->bits|=DECSNAN;
    else dn->bits|=DECNAN;
    msd=0;			   /* no top digit */
    }
   else {			   /* is a finite number */
    dn->exponent=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; /* unbiased */
    }

  /* get the coefficient */
  sour&=0x000fffff;		   /* clean coefficient continuation */
  if (msd) {			   /* non-zero msd */
    sour|=msd<<20;		   /* prefix to coefficient */
    decDigitsFromDPD(dn, &sour, 3); /* process 3 declets */
    return dn;
    }
  /* msd=0 */
  if (!sour) return dn; 	   /* easy: coefficient is 0 */
  if (sour&0x000ffc00)		   /* need 2 declets? */
    decDigitsFromDPD(dn, &sour, 2); /* process 2 declets */
   else
    decDigitsFromDPD(dn, &sour, 1); /* process 1 declet */
  return dn;
  } /* decimal32ToNumber */

/* ------------------------------------------------------------------ */
/* to-scientific-string -- conversion to numeric string 	      */
/* to-engineering-string -- conversion to numeric string	      */
/*								      */
/*   decimal32ToString(d32, string);				      */
/*   decimal32ToEngString(d32, string); 			      */
/*								      */
/*  d32 is the decimal32 format number to convert		      */
/*  string is the string where the result will be laid out	      */
/*								      */
/*  string must be at least 24 characters			      */
/*								      */
/*  No error is possible, and no status can be set.		      */
/* ------------------------------------------------------------------ */
char * decimal32ToEngString(const decimal32 *d32, char *string){
  decNumber dn; 			/* work */
  decimal32ToNumber(d32, &dn);
  decNumberToEngString(&dn, string);
  return string;
  } /* decimal32ToEngString */

char * decimal32ToString(const decimal32 *d32, char *string){
  uInt msd;			   /* coefficient MSD */
  Int  exp;			   /* exponent top two bits or full */
  uInt comb;			   /* combination field */
  char *cstart; 		   /* coefficient start */
  char *c;			   /* output pointer in string */
  const uByte *u;		   /* work */
  char *s, *t;			   /* .. (source, target) */
  Int  dpd;			   /* .. */
  Int  pre, e;			   /* .. */
  uInt uiwork;			   /* for macros */
  uInt sour;			   /* source 32-bit */

  /* load source from storage; this is endian */
  sour=UBTOUI(d32->bytes);	   /* directly load the int */

  c=string;			   /* where result will go */
  if (((Int)sour)<0) *c++='-';	   /* handle sign */

  comb=(sour>>26)&0x1f; 	   /* combination field */
  msd=COMBMSD[comb];		   /* decode the combination field */
  exp=COMBEXP[comb];		   /* .. */

  if (exp==3) {
    if (msd==0) {		   /* infinity */
      strcpy(c,   "Inf");
      strcpy(c+3, "inity");
      return string;		   /* easy */
      }
    if (sour&0x02000000) *c++='s'; /* sNaN */
    strcpy(c, "NaN");		   /* complete word */
    c+=3;			   /* step past */
    if ((sour&0x000fffff)==0) return string; /* zero payload */
    /* otherwise drop through to add integer; set correct exp */
    exp=0; msd=0;		   /* setup for following code */
    }
   else exp=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; /* unbiased */

  /* convert 7 digits of significand to characters */
  cstart=c;			   /* save start of coefficient */
  if (msd) *c++='0'+(char)msd;	   /* non-zero most significant digit */

  /* Now decode the declets.  After extracting each one, it is */
  /* decoded to binary and then to a 4-char sequence by table lookup; */
  /* the 4-chars are a 1-char length (significant digits, except 000 */
  /* has length 0).  This allows us to left-align the first declet */
  /* with non-zero content, then remaining ones are full 3-char */
  /* length.  We use fixed-length memcpys because variable-length */
  /* causes a subroutine call in GCC.  (These are length 4 for speed */
  /* and are safe because the array has an extra terminator byte.) */
  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; 		  \
		   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}	  \
		    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}

  dpd=(sour>>10)&0x3ff; 	   /* declet 1 */
  dpd2char;
  dpd=(sour)&0x3ff;		   /* declet 2 */
  dpd2char;

  if (c==cstart) *c++='0';	   /* all zeros -- make 0 */

  if (exp==0) { 		   /* integer or NaN case -- easy */
    *c='\0';			   /* terminate */
    return string;
    }

  /* non-0 exponent */
  e=0;				   /* assume no E */
  pre=c-cstart+exp;
  /* [here, pre-exp is the digits count (==1 for zero)] */
  if (exp>0 || pre<-5) {	   /* need exponential form */
    e=pre-1;			   /* calculate E value */
    pre=1;			   /* assume one digit before '.' */
    } /* exponential form */

  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
  s=c-1;			   /* source (LSD) */
  if (pre>0) {			   /* ddd.ddd (plain), perhaps with E */
    char *dotat=cstart+pre;
    if (dotat<c) {		   /* if embedded dot needed... */
      t=c;				/* target */
      for (; s>=dotat; s--, t--) *t=*s; /* open the gap; leave t at gap */
      *t='.';				/* insert the dot */
      c++;				/* length increased by one */
      }

    /* finally add the E-part, if needed; it will never be 0, and has */
    /* a maximum length of 3 digits (E-101 case) */
    if (e!=0) {
      *c++='E'; 		   /* starts with E */
      *c++='+'; 		   /* assume positive */
      if (e<0) {
	*(c-1)='-';		   /* oops, need '-' */
	e=-e;			   /* uInt, please */
	}
      u=&BIN2CHAR[e*4]; 	   /* -> length byte */
      memcpy(c, u+4-*u, 4);	   /* copy fixed 4 characters [is safe] */
      c+=*u;			   /* bump pointer appropriately */
      }
    *c='\0';			   /* add terminator */
    /*printf("res %s\n", string); */
    return string;
    } /* pre>0 */

  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
  t=c+1-pre;
  *(t+1)='\0';				/* can add terminator now */
  for (; s>=cstart; s--, t--) *t=*s;	/* shift whole coefficient right */
  c=cstart;
  *c++='0';				/* always starts with 0. */
  *c++='.';
  for (; pre<0; pre++) *c++='0';	/* add any 0's after '.' */
  /*printf("res %s\n", string); */
  return string;
  } /* decimal32ToString */

/* ------------------------------------------------------------------ */
/* to-number -- conversion from numeric string			      */
/*								      */
/*   decimal32FromString(result, string, set);			      */
/*								      */
/*  result  is the decimal32 format number which gets the result of   */
/*	    the conversion					      */
/*  *string is the character string which should contain a valid      */
/*	    number (which may be a special value)		      */
/*  set     is the context					      */
/*								      */
/* The context is supplied to this routine is used for error handling */
/* (setting of status and traps) and for the rounding mode, only.     */
/* If an error occurs, the result will be a valid decimal32 NaN.      */
/* ------------------------------------------------------------------ */
decimal32 * decimal32FromString(decimal32 *result, const char *string,
				decContext *set) {
  decContext dc;			     /* work */
  decNumber dn; 			     /* .. */

  decContextDefault(&dc, DEC_INIT_DECIMAL32); /* no traps, please */
  dc.round=set->round;			      /* use supplied rounding */

  decNumberFromString(&dn, string, &dc);     /* will round if needed */
  decimal32FromNumber(result, &dn, &dc);
  if (dc.status!=0) {			     /* something happened */
    decContextSetStatus(set, dc.status);     /* .. pass it on */
    }
  return result;
  } /* decimal32FromString */

/* ------------------------------------------------------------------ */
/* decimal32IsCanonical -- test whether encoding is canonical	      */
/*   d32 is the source decimal32				      */
/*   returns 1 if the encoding of d32 is canonical, 0 otherwise       */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
uInt decimal32IsCanonical(const decimal32 *d32) {
  decNumber dn; 			/* work */
  decimal32 canon;			/* .. */
  decContext dc;			/* .. */
  decContextDefault(&dc, DEC_INIT_DECIMAL32);
  decimal32ToNumber(d32, &dn);
  decimal32FromNumber(&canon, &dn, &dc);/* canon will now be canonical */
  return memcmp(d32, &canon, DECIMAL32_Bytes)==0;
  } /* decimal32IsCanonical */

/* ------------------------------------------------------------------ */
/* decimal32Canonical -- copy an encoding, ensuring it is canonical   */
/*   d32 is the source decimal32				      */
/*   result is the target (may be the same decimal32)		      */
/*   returns result						      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
decimal32 * decimal32Canonical(decimal32 *result, const decimal32 *d32) {
  decNumber dn; 			/* work */
  decContext dc;			/* .. */
  decContextDefault(&dc, DEC_INIT_DECIMAL32);
  decimal32ToNumber(d32, &dn);
  decimal32FromNumber(result, &dn, &dc);/* result will now be canonical */
  return result;
  } /* decimal32Canonical */

#if DECTRACE || DECCHECK
/* Macros for accessing decimal32 fields.  These assume the argument
   is a reference (pointer) to the decimal32 structure, and the
   decimal32 is in network byte order (big-endian) */
/* Get sign */
#define decimal32Sign(d)       ((unsigned)(d)->bytes[0]>>7)

/* Get combination field */
#define decimal32Comb(d)       (((d)->bytes[0] & 0x7c)>>2)

/* Get exponent continuation [does not remove bias] */
#define decimal32ExpCon(d)     ((((d)->bytes[0] & 0x03)<<4)	      \
			     | ((unsigned)(d)->bytes[1]>>4))

/* Set sign [this assumes sign previously 0] */
#define decimal32SetSign(d, b) {				      \
  (d)->bytes[0]|=((unsigned)(b)<<7);}

/* Set exponent continuation [does not apply bias] */
/* This assumes range has been checked and exponent previously 0; */
/* type of exponent must be unsigned */
#define decimal32SetExpCon(d, e) {				      \
  (d)->bytes[0]|=(uByte)((e)>>4);				      \
  (d)->bytes[1]|=(uByte)(((e)&0x0F)<<4);}

/* ------------------------------------------------------------------ */
/* decimal32Show -- display a decimal32 in hexadecimal [debug aid]    */
/*   d32 -- the number to show					      */
/* ------------------------------------------------------------------ */
/* Also shows sign/cob/expconfields extracted - valid bigendian only */
void decimal32Show(const decimal32 *d32) {
  char buf[DECIMAL32_Bytes*2+1];
  Int i, j=0;

  if (DECLITEND) {
    for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
      sprintf(&buf[j], "%02x", d32->bytes[3-i]);
      }
    printf(" D32> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
	   d32->bytes[3]>>7, (d32->bytes[3]>>2)&0x1f,
	   ((d32->bytes[3]&0x3)<<4)| (d32->bytes[2]>>4));
    }
   else {
    for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
      sprintf(&buf[j], "%02x", d32->bytes[i]);
      }
    printf(" D32> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
	   decimal32Sign(d32), decimal32Comb(d32), decimal32ExpCon(d32));
    }
  } /* decimal32Show */
#endif
Commit	Line	Data
f5bc1778	1	/* Decimal 32-bit format module for the decNumber C Library.
f57a3bca	2	Copyright (C) 2005-2018 Free Software Foundation, Inc.
f5bc1778 DJ	3	Contributed by IBM Corporation. Author Mike Cowlishaw.
	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
168a2f77	9	Software Foundation; either version 3, or (at your option) any later
f5bc1778 DJ	10	version.
f5bc1778 DJ	11
f5bc1778 DJ	12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
168a2f77 DD	17	Under Section 7 of GPL version 3, you are granted additional
	18	permissions described in the GCC Runtime Library Exception, version
	19	3.1, as published by the Free Software Foundation.
	20
	21	You should have received a copy of the GNU General Public License and
	22	a copy of the GCC Runtime Library Exception along with this program;
	23	see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	24	<http://www.gnu.org/licenses/>. */
f5bc1778 DJ	25
f5bc1778 DJ	26	/* ------------------------------------------------------------------ */
87d32bb7	27	/* Decimal 32-bit format module */
f5bc1778 DJ	28	/* ------------------------------------------------------------------ */
	29	/* This module comprises the routines for decimal32 format numbers. */
	30	/* Conversions are supplied to and from decNumber and String. */
	31	/* */
	32	/* This is used when decNumber provides operations, either for all */
	33	/* operations or as a proxy between decNumber and decSingle. */
	34	/* */
	35	/* Error handling is the same as decNumber (qv.). */
	36	/* ------------------------------------------------------------------ */
	37	#include <string.h> /* [for memset/memcpy] */
	38	#include <stdio.h> /* [for printf] */
	39
87d32bb7 DD	40	#include "dconfig.h" /* GCC definitions */
87d32bb7 DD	41	#define DECNUMDIGITS 7 /* make decNumbers with space for 7 */
f5bc1778 DJ	42	#include "decNumber.h" /* base number library */
	43	#include "decNumberLocal.h" /* decNumber local types, etc. */
	44	#include "decimal32.h" /* our primary include */
	45
	46	/* Utility tables and routines [in decimal64.c] */
f5bc1778 DJ	47	extern const uInt COMBEXP[32], COMBMSD[32];
	48	extern const uShort DPD2BIN[1024];
	49	extern const uShort BIN2DPD[1000];
	50	extern const uByte BIN2CHAR[4001];
	51
	52	extern void decDigitsToDPD(const decNumber , uInt , Int);
	53	extern void decDigitsFromDPD(decNumber , const uInt , Int);
	54
	55	#if DECTRACE \|\| DECCHECK
	56	void decimal32Show(const decimal32 ); / for debug */
	57	extern void decNumberShow(const decNumber ); / .. */
	58	#endif
	59
	60	/* Useful macro */
	61	/* Clear a structure (e.g., a decNumber) */
	62	#define DEC_clear(d) memset(d, 0, sizeof(*d))
	63
	64	/* ------------------------------------------------------------------ */
	65	/* decimal32FromNumber -- convert decNumber to decimal32 */
	66	/* */
87d32bb7	67	/* ds is the target decimal32 */
f5bc1778	68	/* dn is the source number (assumed valid) */
87d32bb7	69	/* set is the context, used only for reporting errors */
f5bc1778 DJ	70	/* */
	71	/* The set argument is used only for status reporting and for the */
	72	/* rounding mode (used if the coefficient is more than DECIMAL32_Pmax */
	73	/* digits or an overflow is detected). If the exponent is out of the */
	74	/* valid range then Overflow or Underflow will be raised. */
	75	/* After Underflow a subnormal result is possible. */
	76	/* */
	77	/* DEC_Clamped is set if the number has to be 'folded down' to fit, */
	78	/* by reducing its exponent and multiplying the coefficient by a */
	79	/* power of ten, or if the exponent on a zero had to be clamped. */
	80	/* ------------------------------------------------------------------ */
	81	decimal32 * decimal32FromNumber(decimal32 d32, const decNumber dn,
	82	decContext *set) {
	83	uInt status=0; /* status accumulator */
	84	Int ae; /* adjusted exponent */
	85	decNumber dw; /* work */
	86	decContext dc; /* .. */
f5bc1778	87	uInt comb, exp; /* .. */
87d32bb7	88	uInt uiwork; /* for macros */
f5bc1778 DJ	89	uInt targ=0; /* target 32-bit */
	90
	91	/* If the number has too many digits, or the exponent could be */
	92	/* out of range then reduce the number under the appropriate */
	93	/* constraints. This could push the number to Infinity or zero, */
	94	/* so this check and rounding must be done before generating the */
	95	/* decimal32] */
87d32bb7 DD	96	ae=dn->exponent+dn->digits-1; /* [0 if special] */
	97	if (dn->digits>DECIMAL32_Pmax /* too many digits */
	98	\|\| ae>DECIMAL32_Emax /* likely overflow */
f5bc1778 DJ	99	\|\| ae<DECIMAL32_Emin) { /* likely underflow */
	100	decContextDefault(&dc, DEC_INIT_DECIMAL32); /* [no traps] */
	101	dc.round=set->round; /* use supplied rounding */
	102	decNumberPlus(&dw, dn, &dc); /* (round and check) */
	103	/* [this changes -0 to 0, so enforce the sign...] */
	104	dw.bits\|=dn->bits&DECNEG;
	105	status=dc.status; /* save status */
	106	dn=&dw; /* use the work number */
	107	} /* maybe out of range */
	108
	109	if (dn->bits&DECSPECIAL) { /* a special value */
	110	if (dn->bits&DECINF) targ=DECIMAL_Inf<<24;
	111	else { /* sNaN or qNaN */
87d32bb7	112	if ((dn->lsu!=0 \|\| dn->digits>1) / non-zero coefficient */
f5bc1778 DJ	113	&& (dn->digits<DECIMAL32_Pmax)) { /* coefficient fits */
	114	decDigitsToDPD(dn, &targ, 0);
	115	}
	116	if (dn->bits&DECNAN) targ\|=DECIMAL_NaN<<24;
	117	else targ\|=DECIMAL_sNaN<<24;
	118	} /* a NaN */
	119	} /* special */
	120
	121	else { /* is finite */
	122	if (decNumberIsZero(dn)) { /* is a zero */
	123	/* set and clamp exponent */
	124	if (dn->exponent<-DECIMAL32_Bias) {
	125	exp=0; /* low clamp */
	126	status\|=DEC_Clamped;
	127	}
	128	else {
	129	exp=dn->exponent+DECIMAL32_Bias; /* bias exponent */
	130	if (exp>DECIMAL32_Ehigh) { /* top clamp */
	131	exp=DECIMAL32_Ehigh;
	132	status\|=DEC_Clamped;
	133	}
	134	}
	135	comb=(exp>>3) & 0x18; /* msd=0, exp top 2 bits .. */
	136	}
	137	else { /* non-zero finite number */
87d32bb7	138	uInt msd; /* work */
f5bc1778 DJ	139	Int pad=0; /* coefficient pad digits */
	140
	141	/* the dn is known to fit, but it may need to be padded */
	142	exp=(uInt)(dn->exponent+DECIMAL32_Bias); /* bias exponent */
	143	if (exp>DECIMAL32_Ehigh) { /* fold-down case */
	144	pad=exp-DECIMAL32_Ehigh;
	145	exp=DECIMAL32_Ehigh; /* [to maximum] */
	146	status\|=DEC_Clamped;
	147	}
	148
	149	/* fastpath common case */
	150	if (DECDPUN==3 && pad==0) {
	151	targ=BIN2DPD[dn->lsu[0]];
	152	if (dn->digits>3) targ\|=(uInt)(BIN2DPD[dn->lsu[1]])<<10;
	153	msd=(dn->digits==7 ? dn->lsu[2] : 0);
	154	}
	155	else { /* general case */
	156	decDigitsToDPD(dn, &targ, pad);
	157	/* save and clear the top digit */
	158	msd=targ>>20;
	159	targ&=0x000fffff;
	160	}
	161
	162	/* create the combination field */
	163	if (msd>=8) comb=0x18 \| ((exp>>5) & 0x06) \| (msd & 0x01);
	164	else comb=((exp>>3) & 0x18) \| msd;
	165	}
	166	targ\|=comb<<26; /* add combination field .. */
	167	targ\|=(exp&0x3f)<<20; /* .. and exponent continuation */
	168	} /* finite */
	169
	170	if (dn->bits&DECNEG) targ\|=0x80000000; /* add sign bit */
	171
	172	/* now write to storage; this is endian */
87d32bb7	173	UBFROMUI(d32->bytes, targ); /* directly store the int */
f5bc1778 DJ	174
	175	if (status!=0) decContextSetStatus(set, status); /* pass on status */
	176	/* decimal32Show(d32); */
	177	return d32;
	178	} /* decimal32FromNumber */
	179
	180	/* ------------------------------------------------------------------ */
	181	/* decimal32ToNumber -- convert decimal32 to decNumber */
	182	/* d32 is the source decimal32 */
	183	/* dn is the target number, with appropriate space */
	184	/* No error is possible. */
	185	/* ------------------------------------------------------------------ */
	186	decNumber * decimal32ToNumber(const decimal32 d32, decNumber dn) {
	187	uInt msd; /* coefficient MSD */
	188	uInt exp; /* exponent top two bits */
	189	uInt comb; /* combination field */
	190	uInt sour; /* source 32-bit */
87d32bb7	191	uInt uiwork; /* for macros */
f5bc1778 DJ	192
f5bc1778 DJ	193	/* load source from storage; this is endian */
87d32bb7	194	sour=UBTOUI(d32->bytes); /* directly load the int */
f5bc1778	195
87d32bb7	196	comb=(sour>>26)&0x1f; /* combination field */
f5bc1778 DJ	197
	198	decNumberZero(dn); /* clean number */
	199	if (sour&0x80000000) dn->bits=DECNEG; /* set sign if negative */
	200
	201	msd=COMBMSD[comb]; /* decode the combination field */
	202	exp=COMBEXP[comb]; /* .. */
	203
87d32bb7	204	if (exp==3) { /* is a special */
f5bc1778 DJ	205	if (msd==0) {
	206	dn->bits\|=DECINF;
	207	return dn; /* no coefficient needed */
	208	}
	209	else if (sour&0x02000000) dn->bits\|=DECSNAN;
	210	else dn->bits\|=DECNAN;
	211	msd=0; /* no top digit */
	212	}
	213	else { /* is a finite number */
	214	dn->exponent=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; /* unbiased */
	215	}
	216
	217	/* get the coefficient */
	218	sour&=0x000fffff; /* clean coefficient continuation */
	219	if (msd) { /* non-zero msd */
	220	sour\|=msd<<20; /* prefix to coefficient */
	221	decDigitsFromDPD(dn, &sour, 3); /* process 3 declets */
	222	return dn;
	223	}
	224	/* msd=0 */
87d32bb7	225	if (!sour) return dn; /* easy: coefficient is 0 */
f5bc1778 DJ	226	if (sour&0x000ffc00) /* need 2 declets? */
	227	decDigitsFromDPD(dn, &sour, 2); /* process 2 declets */
	228	else
	229	decDigitsFromDPD(dn, &sour, 1); /* process 1 declet */
	230	return dn;
	231	} /* decimal32ToNumber */
	232
	233	/* ------------------------------------------------------------------ */
87d32bb7	234	/* to-scientific-string -- conversion to numeric string */
f5bc1778 DJ	235	/* to-engineering-string -- conversion to numeric string */
	236	/* */
	237	/* decimal32ToString(d32, string); */
87d32bb7	238	/* decimal32ToEngString(d32, string); */
f5bc1778 DJ	239	/* */
	240	/* d32 is the decimal32 format number to convert */
	241	/* string is the string where the result will be laid out */
	242	/* */
	243	/* string must be at least 24 characters */
	244	/* */
	245	/* No error is possible, and no status can be set. */
	246	/* ------------------------------------------------------------------ */
	247	char * decimal32ToEngString(const decimal32 d32, char string){
87d32bb7	248	decNumber dn; /* work */
f5bc1778 DJ	249	decimal32ToNumber(d32, &dn);
	250	decNumberToEngString(&dn, string);
	251	return string;
	252	} /* decimal32ToEngString */
	253
	254	char * decimal32ToString(const decimal32 d32, char string){
	255	uInt msd; /* coefficient MSD */
	256	Int exp; /* exponent top two bits or full */
	257	uInt comb; /* combination field */
87d32bb7	258	char cstart; / coefficient start */
f5bc1778	259	char c; / output pointer in string */
87d32bb7	260	const uByte u; / work */
f5bc1778 DJ	261	char s, t; /* .. (source, target) */
	262	Int dpd; /* .. */
	263	Int pre, e; /* .. */
87d32bb7	264	uInt uiwork; /* for macros */
f5bc1778 DJ	265	uInt sour; /* source 32-bit */
	266
	267	/* load source from storage; this is endian */
87d32bb7	268	sour=UBTOUI(d32->bytes); /* directly load the int */
f5bc1778 DJ	269
	270	c=string; /* where result will go */
	271	if (((Int)sour)<0) c++='-'; / handle sign */
	272
87d32bb7	273	comb=(sour>>26)&0x1f; /* combination field */
f5bc1778 DJ	274	msd=COMBMSD[comb]; /* decode the combination field */
	275	exp=COMBEXP[comb]; /* .. */
	276
	277	if (exp==3) {
	278	if (msd==0) { /* infinity */
87d32bb7	279	strcpy(c, "Inf");
f5bc1778 DJ	280	strcpy(c+3, "inity");
	281	return string; /* easy */
	282	}
	283	if (sour&0x02000000) c++='s'; / sNaN */
	284	strcpy(c, "NaN"); /* complete word */
	285	c+=3; /* step past */
	286	if ((sour&0x000fffff)==0) return string; /* zero payload */
	287	/* otherwise drop through to add integer; set correct exp */
	288	exp=0; msd=0; /* setup for following code */
	289	}
	290	else exp=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; /* unbiased */
	291
	292	/* convert 7 digits of significand to characters */
	293	cstart=c; /* save start of coefficient */
	294	if (msd) c++='0'+(char)msd; / non-zero most significant digit */
	295
	296	/* Now decode the declets. After extracting each one, it is */
	297	/* decoded to binary and then to a 4-char sequence by table lookup; */
	298	/* the 4-chars are a 1-char length (significant digits, except 000 */
	299	/* has length 0). This allows us to left-align the first declet */
	300	/* with non-zero content, then remaining ones are full 3-char */
	301	/* length. We use fixed-length memcpys because variable-length */
	302	/* causes a subroutine call in GCC. (These are length 4 for speed */
	303	/* and are safe because the array has an extra terminator byte.) */
87d32bb7	304	#define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; \
f5bc1778 DJ	305	if (c!=cstart) {memcpy(c, u+1, 4); c+=3;} \
	306	else if (u) {memcpy(c, u+4-u, 4); c+=*u;}
	307
87d32bb7	308	dpd=(sour>>10)&0x3ff; /* declet 1 */
f5bc1778 DJ	309	dpd2char;
	310	dpd=(sour)&0x3ff; /* declet 2 */
	311	dpd2char;
	312
	313	if (c==cstart) c++='0'; / all zeros -- make 0 */
	314
87d32bb7	315	if (exp==0) { /* integer or NaN case -- easy */
f5bc1778 DJ	316	c='\0'; / terminate */
	317	return string;
	318	}
	319
	320	/* non-0 exponent */
	321	e=0; /* assume no E */
	322	pre=c-cstart+exp;
	323	/* [here, pre-exp is the digits count (==1 for zero)] */
	324	if (exp>0 \|\| pre<-5) { /* need exponential form */
	325	e=pre-1; /* calculate E value */
	326	pre=1; /* assume one digit before '.' */
	327	} /* exponential form */
	328
	329	/* modify the coefficient, adding 0s, '.', and E+nn as needed */
	330	s=c-1; /* source (LSD) */
	331	if (pre>0) { /* ddd.ddd (plain), perhaps with E */
	332	char *dotat=cstart+pre;
	333	if (dotat<c) { /* if embedded dot needed... */
	334	t=c; /* target */
	335	for (; s>=dotat; s--, t--) t=s; /* open the gap; leave t at gap */
	336	t='.'; / insert the dot */
	337	c++; /* length increased by one */
	338	}
	339
	340	/* finally add the E-part, if needed; it will never be 0, and has */
	341	/* a maximum length of 3 digits (E-101 case) */
	342	if (e!=0) {
87d32bb7 DD	343	c++='E'; / starts with E */
87d32bb7 DD	344	c++='+'; / assume positive */
f5bc1778 DJ	345	if (e<0) {
	346	(c-1)='-'; / oops, need '-' */
	347	e=-e; /* uInt, please */
	348	}
87d32bb7	349	u=&BIN2CHAR[e4]; / -> length byte */
f5bc1778 DJ	350	memcpy(c, u+4-u, 4); / copy fixed 4 characters [is safe] */
	351	c+=u; / bump pointer appropriately */
	352	}
	353	c='\0'; / add terminator */
	354	/printf("res %s\n", string); /
	355	return string;
	356	} /* pre>0 */
	357
	358	/* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
	359	t=c+1-pre;
	360	(t+1)='\0'; / can add terminator now */
	361	for (; s>=cstart; s--, t--) t=s; /* shift whole coefficient right */
	362	c=cstart;
	363	c++='0'; / always starts with 0. */
	364	*c++='.';
	365	for (; pre<0; pre++) c++='0'; / add any 0's after '.' */
	366	/printf("res %s\n", string); /
	367	return string;
	368	} /* decimal32ToString */
	369
	370	/* ------------------------------------------------------------------ */
	371	/* to-number -- conversion from numeric string */
	372	/* */
	373	/* decimal32FromString(result, string, set); */
	374	/* */
	375	/* result is the decimal32 format number which gets the result of */
	376	/* the conversion */
	377	/* string is the character string which should contain a valid /
	378	/* number (which may be a special value) */
87d32bb7	379	/* set is the context */
f5bc1778 DJ	380	/* */
	381	/* The context is supplied to this routine is used for error handling */
	382	/* (setting of status and traps) and for the rounding mode, only. */
	383	/* If an error occurs, the result will be a valid decimal32 NaN. */
	384	/* ------------------------------------------------------------------ */
	385	decimal32 * decimal32FromString(decimal32 result, const char string,
	386	decContext *set) {
	387	decContext dc; /* work */
87d32bb7	388	decNumber dn; /* .. */
f5bc1778 DJ	389
	390	decContextDefault(&dc, DEC_INIT_DECIMAL32); /* no traps, please */
	391	dc.round=set->round; /* use supplied rounding */
	392
	393	decNumberFromString(&dn, string, &dc); /* will round if needed */
	394	decimal32FromNumber(result, &dn, &dc);
	395	if (dc.status!=0) { /* something happened */
	396	decContextSetStatus(set, dc.status); /* .. pass it on */
	397	}
	398	return result;
	399	} /* decimal32FromString */
	400
	401	/* ------------------------------------------------------------------ */
	402	/* decimal32IsCanonical -- test whether encoding is canonical */
	403	/* d32 is the source decimal32 */
87d32bb7	404	/* returns 1 if the encoding of d32 is canonical, 0 otherwise */
f5bc1778 DJ	405	/* No error is possible. */
f5bc1778 DJ	406	/* ------------------------------------------------------------------ */
87d32bb7 DD	407	uInt decimal32IsCanonical(const decimal32 *d32) {
87d32bb7 DD	408	decNumber dn; /* work */
f5bc1778 DJ	409	decimal32 canon; /* .. */
	410	decContext dc; /* .. */
	411	decContextDefault(&dc, DEC_INIT_DECIMAL32);
	412	decimal32ToNumber(d32, &dn);
	413	decimal32FromNumber(&canon, &dn, &dc);/* canon will now be canonical */
	414	return memcmp(d32, &canon, DECIMAL32_Bytes)==0;
	415	} /* decimal32IsCanonical */
	416
	417	/* ------------------------------------------------------------------ */
	418	/* decimal32Canonical -- copy an encoding, ensuring it is canonical */
	419	/* d32 is the source decimal32 */
	420	/* result is the target (may be the same decimal32) */
	421	/* returns result */
	422	/* No error is possible. */
	423	/* ------------------------------------------------------------------ */
	424	decimal32 * decimal32Canonical(decimal32 result, const decimal32 d32) {
87d32bb7	425	decNumber dn; /* work */
f5bc1778 DJ	426	decContext dc; /* .. */
	427	decContextDefault(&dc, DEC_INIT_DECIMAL32);
	428	decimal32ToNumber(d32, &dn);
	429	decimal32FromNumber(result, &dn, &dc);/* result will now be canonical */
	430	return result;
	431	} /* decimal32Canonical */
	432
	433	#if DECTRACE \|\| DECCHECK
	434	/* Macros for accessing decimal32 fields. These assume the argument
	435	is a reference (pointer) to the decimal32 structure, and the
	436	decimal32 is in network byte order (big-endian) */
	437	/* Get sign */
	438	#define decimal32Sign(d) ((unsigned)(d)->bytes[0]>>7)
	439
	440	/* Get combination field */
	441	#define decimal32Comb(d) (((d)->bytes[0] & 0x7c)>>2)
	442
	443	/* Get exponent continuation [does not remove bias] */
	444	#define decimal32ExpCon(d) ((((d)->bytes[0] & 0x03)<<4) \
	445	\| ((unsigned)(d)->bytes[1]>>4))
	446
	447	/* Set sign [this assumes sign previously 0] */
	448	#define decimal32SetSign(d, b) { \
	449	(d)->bytes[0]\|=((unsigned)(b)<<7);}
	450
	451	/* Set exponent continuation [does not apply bias] */
	452	/* This assumes range has been checked and exponent previously 0; */
	453	/* type of exponent must be unsigned */
	454	#define decimal32SetExpCon(d, e) { \
87d32bb7 DD	455	(d)->bytes[0]\|=(uByte)((e)>>4); \
87d32bb7 DD	456	(d)->bytes[1]\|=(uByte)(((e)&0x0F)<<4);}
f5bc1778 DJ	457
	458	/* ------------------------------------------------------------------ */
	459	/* decimal32Show -- display a decimal32 in hexadecimal [debug aid] */
	460	/* d32 -- the number to show */
	461	/* ------------------------------------------------------------------ */
	462	/* Also shows sign/cob/expconfields extracted - valid bigendian only */
	463	void decimal32Show(const decimal32 *d32) {
	464	char buf[DECIMAL32_Bytes*2+1];
	465	Int i, j=0;
	466
	467	if (DECLITEND) {
	468	for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
	469	sprintf(&buf[j], "%02x", d32->bytes[3-i]);
	470	}
	471	printf(" D32> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
	472	d32->bytes[3]>>7, (d32->bytes[3]>>2)&0x1f,
	473	((d32->bytes[3]&0x3)<<4)\| (d32->bytes[2]>>4));
	474	}
	475	else {
	476	for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
	477	sprintf(&buf[j], "%02x", d32->bytes[i]);
	478	}
	479	printf(" D32> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
	480	decimal32Sign(d32), decimal32Comb(d32), decimal32ExpCon(d32));
	481	}
	482	} /* decimal32Show */
	483	#endif