/* 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;
}