Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /* Copyright (C) 2007-2015 Free Software Foundation, Inc.
  2.  
  3. This file is part of GCC.
  4.  
  5. GCC is free software; you can redistribute it and/or modify it under
  6. the terms of the GNU General Public License as published by the Free
  7. Software Foundation; either version 3, or (at your option) any later
  8. version.
  9.  
  10. GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13. for more details.
  14.  
  15. Under Section 7 of GPL version 3, you are granted additional
  16. permissions described in the GCC Runtime Library Exception, version
  17. 3.1, as published by the Free Software Foundation.
  18.  
  19. You should have received a copy of the GNU General Public License and
  20. a copy of the GCC Runtime Library Exception along with this program;
  21. see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22. <http://www.gnu.org/licenses/>.  */
  23.  
  24. #include "bid_internal.h"
  25.  
  26. /*****************************************************************************
  27.  *  BID64_to_int32_rnint
  28.  ****************************************************************************/
  29.  
  30. #if DECIMAL_CALL_BY_REFERENCE
  31. void
  32. bid64_to_int32_rnint (int *pres,
  33.                       UINT64 *
  34.                       px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  35.                       _EXC_INFO_PARAM) {
  36.   UINT64 x = *px;
  37. #else
  38. int
  39. bid64_to_int32_rnint (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  40.                       _EXC_INFO_PARAM) {
  41. #endif
  42.   int res;
  43.   UINT64 x_sign;
  44.   UINT64 x_exp;
  45.   int exp;                      // unbiased exponent
  46.   // Note: C1 represents x_significand (UINT64)
  47.   UINT64 tmp64;
  48.   BID_UI64DOUBLE tmp1;
  49.   unsigned int x_nr_bits;
  50.   int q, ind, shift;
  51.   UINT64 C1;
  52.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  53.   UINT128 fstar;
  54.   UINT128 P128;
  55.  
  56.   // check for NaN or Infinity
  57.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  58.     // set invalid flag
  59.     *pfpsf |= INVALID_EXCEPTION;
  60.     // return Integer Indefinite
  61.     res = 0x80000000;
  62.     BID_RETURN (res);
  63.   }
  64.   // unpack x
  65.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  66.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  67.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  68.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  69.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  70.     if (C1 > 9999999999999999ull) {     // non-canonical
  71.       x_exp = 0;
  72.       C1 = 0;
  73.     }
  74.   } else {
  75.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  76.     C1 = x & MASK_BINARY_SIG1;
  77.   }
  78.  
  79.   // check for zeros (possibly from non-canonical values)
  80.   if (C1 == 0x0ull) {
  81.     // x is 0
  82.     res = 0x00000000;
  83.     BID_RETURN (res);
  84.   }
  85.   // x is not special and is not zero
  86.  
  87.   // q = nr. of decimal digits in x (1 <= q <= 54)
  88.   //  determine first the nr. of bits in x
  89.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  90.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  91.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  92.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  93.       x_nr_bits =
  94.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  95.     } else {    // x < 2^32
  96.       tmp1.d = (double) C1;     // exact conversion
  97.       x_nr_bits =
  98.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  99.     }
  100.   } else {      // if x < 2^53
  101.     tmp1.d = (double) C1;       // exact conversion
  102.     x_nr_bits =
  103.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  104.   }
  105.   q = nr_digits[x_nr_bits - 1].digits;
  106.   if (q == 0) {
  107.     q = nr_digits[x_nr_bits - 1].digits1;
  108.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  109.       q++;
  110.   }
  111.   exp = x_exp - 398;    // unbiased exponent
  112.  
  113.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  114.     // set invalid flag
  115.     *pfpsf |= INVALID_EXCEPTION;
  116.     // return Integer Indefinite
  117.     res = 0x80000000;
  118.     BID_RETURN (res);
  119.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  120.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  121.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  122.     // the cases that do not fit are identified here; the ones that fit
  123.     // fall through and will be handled with other cases further,
  124.     // under '1 <= q + exp <= 10'
  125.     if (x_sign) {       // if n < 0 and q + exp = 10
  126.       // if n < -2^31 - 1/2 then n is too large
  127.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^31+1/2
  128.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x500000005, 1<=q<=16
  129.       // <=> C * 10^(11-q) > 0x500000005, 1<=q<=16
  130.       if (q <= 11) {
  131.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  132.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  133.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  134.         if (tmp64 > 0x500000005ull) {
  135.           // set invalid flag
  136.           *pfpsf |= INVALID_EXCEPTION;
  137.           // return Integer Indefinite
  138.           res = 0x80000000;
  139.           BID_RETURN (res);
  140.         }
  141.         // else cases that can be rounded to a 32-bit int fall through
  142.         // to '1 <= q + exp <= 10'
  143.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  144.         // C * 10^(11-q) > 0x500000005 <=>
  145.         // C > 0x500000005 * 10^(q-11) where 1 <= q - 11 <= 5
  146.         // (scale 2^31+1/2 up)
  147.         // Note: 0x500000005*10^(q-11) has q-1 or q digits, where q <= 16
  148.         tmp64 = 0x500000005ull * ten2k64[q - 11];
  149.         if (C1 > tmp64) {
  150.           // set invalid flag
  151.           *pfpsf |= INVALID_EXCEPTION;
  152.           // return Integer Indefinite
  153.           res = 0x80000000;
  154.           BID_RETURN (res);
  155.         }
  156.         // else cases that can be rounded to a 32-bit int fall through
  157.         // to '1 <= q + exp <= 10'
  158.       }
  159.     } else {    // if n > 0 and q + exp = 10
  160.       // if n >= 2^31 - 1/2 then n is too large
  161.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31-1/2
  162.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x4fffffffb, 1<=q<=16
  163.       // <=> C * 10^(11-q) >= 0x4fffffffb, 1<=q<=16
  164.       if (q <= 11) {
  165.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  166.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  167.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  168.         if (tmp64 >= 0x4fffffffbull) {
  169.           // set invalid flag
  170.           *pfpsf |= INVALID_EXCEPTION;
  171.           // return Integer Indefinite
  172.           res = 0x80000000;
  173.           BID_RETURN (res);
  174.         }
  175.         // else cases that can be rounded to a 32-bit int fall through
  176.         // to '1 <= q + exp <= 10'
  177.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  178.         // C * 10^(11-q) >= 0x4fffffffb <=>
  179.         // C >= 0x4fffffffb * 10^(q-11) where 1 <= q - 11 <= 5
  180.         // (scale 2^31-1/2 up)
  181.         // Note: 0x4fffffffb*10^(q-11) has q-1 or q digits, where q <= 16
  182.         tmp64 = 0x4fffffffbull * ten2k64[q - 11];
  183.         if (C1 >= tmp64) {
  184.           // set invalid flag
  185.           *pfpsf |= INVALID_EXCEPTION;
  186.           // return Integer Indefinite
  187.           res = 0x80000000;
  188.           BID_RETURN (res);
  189.         }
  190.         // else cases that can be rounded to a 32-bit int fall through
  191.         // to '1 <= q + exp <= 10'
  192.       }
  193.     }
  194.   }
  195.   // n is not too large to be converted to int32: -2^31 - 1/2 <= n < 2^31 - 1/2
  196.   // Note: some of the cases tested for above fall through to this point
  197.   if ((q + exp) < 0) {  // n = +/-0.0...c(0)c(1)...c(q-1)
  198.     // return 0
  199.     res = 0x00000000;
  200.     BID_RETURN (res);
  201.   } else if ((q + exp) == 0) {  // n = +/-0.c(0)c(1)...c(q-1)
  202.     // if 0.c(0)c(1)...c(q-1) <= 0.5 <=> c(0)c(1)...c(q-1) <= 5 * 10^(q-1)
  203.     //   res = 0
  204.     // else
  205.     //   res = +/-1
  206.     ind = q - 1;
  207.     if (C1 <= midpoint64[ind]) {
  208.       res = 0x00000000; // return 0
  209.     } else if (x_sign) {        // n < 0
  210.       res = 0xffffffff; // return -1
  211.     } else {    // n > 0
  212.       res = 0x00000001; // return +1
  213.     }
  214.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  215.     // -2^31-1/2 <= x <= -1 or 1 <= x < 2^31-1/2 so x can be rounded
  216.     // to nearest to a 32-bit signed integer
  217.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  218.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  219.       // chop off ind digits from the lower part of C1
  220.       // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 64 bits
  221.       C1 = C1 + midpoint64[ind - 1];
  222.       // calculate C* and f*
  223.       // C* is actually floor(C*) in this case
  224.       // C* and f* need shifting and masking, as shown by
  225.       // shiftright128[] and maskhigh128[]
  226.       // 1 <= x <= 15
  227.       // kx = 10^(-x) = ten2mk64[ind - 1]
  228.       // C* = (C1 + 1/2 * 10^x) * 10^(-x)
  229.       // the approximation of 10^(-x) was rounded up to 54 bits
  230.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  231.       Cstar = P128.w[1];
  232.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  233.       fstar.w[0] = P128.w[0];
  234.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  235.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  236.       // if (0 < f* < 10^(-x)) then the result is a midpoint
  237.       //   if floor(C*) is even then C* = floor(C*) - logical right
  238.       //       shift; C* has p decimal digits, correct by Prop. 1)
  239.       //   else if floor(C*) is odd C* = floor(C*)-1 (logical right
  240.       //       shift; C* has p decimal digits, correct by Pr. 1)
  241.       // else
  242.       //   C* = floor(C*) (logical right shift; C has p decimal digits,
  243.       //       correct by Property 1)
  244.       // n = C* * 10^(e+x)
  245.  
  246.       // shift right C* by Ex-64 = shiftright128[ind]
  247.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  248.       Cstar = Cstar >> shift;
  249.  
  250.       // if the result was a midpoint it was rounded away from zero, so
  251.       // it will need a correction
  252.       // check for midpoints
  253.       if ((fstar.w[1] == 0) && fstar.w[0]
  254.           && (fstar.w[0] <= ten2mk128trunc[ind - 1].w[1])) {
  255.         // ten2mk128trunc[ind -1].w[1] is identical to
  256.         // ten2mk128[ind -1].w[1]
  257.         // the result is a midpoint; round to nearest
  258.         if (Cstar & 0x01) {     // Cstar is odd; MP in [EVEN, ODD]
  259.           // if floor(C*) is odd C = floor(C*) - 1; the result >= 1
  260.           Cstar--;      // Cstar is now even
  261.         }       // else MP in [ODD, EVEN]
  262.       }
  263.       if (x_sign)
  264.         res = -Cstar;
  265.       else
  266.         res = Cstar;
  267.     } else if (exp == 0) {
  268.       // 1 <= q <= 10
  269.       // res = +/-C (exact)
  270.       if (x_sign)
  271.         res = -C1;
  272.       else
  273.         res = C1;
  274.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  275.       // res = +/-C * 10^exp (exact)
  276.       if (x_sign)
  277.         res = -C1 * ten2k64[exp];
  278.       else
  279.         res = C1 * ten2k64[exp];
  280.     }
  281.   }
  282.   BID_RETURN (res);
  283. }
  284.  
  285. /*****************************************************************************
  286.  *  BID64_to_int32_xrnint
  287.  ****************************************************************************/
  288.  
  289. #if DECIMAL_CALL_BY_REFERENCE
  290. void
  291. bid64_to_int32_xrnint (int *pres,
  292.                        UINT64 *
  293.                        px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  294.                        _EXC_INFO_PARAM) {
  295.   UINT64 x = *px;
  296. #else
  297. int
  298. bid64_to_int32_xrnint (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  299.                        _EXC_INFO_PARAM) {
  300. #endif
  301.   int res;
  302.   UINT64 x_sign;
  303.   UINT64 x_exp;
  304.   int exp;                      // unbiased exponent
  305.   // Note: C1 represents x_significand (UINT64)
  306.   UINT64 tmp64;
  307.   BID_UI64DOUBLE tmp1;
  308.   unsigned int x_nr_bits;
  309.   int q, ind, shift;
  310.   UINT64 C1;
  311.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  312.   UINT128 fstar;
  313.   UINT128 P128;
  314.  
  315.   // check for NaN or Infinity
  316.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  317.     // set invalid flag
  318.     *pfpsf |= INVALID_EXCEPTION;
  319.     // return Integer Indefinite
  320.     res = 0x80000000;
  321.     BID_RETURN (res);
  322.   }
  323.   // unpack x
  324.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  325.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  326.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  327.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  328.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  329.     if (C1 > 9999999999999999ull) {     // non-canonical
  330.       x_exp = 0;
  331.       C1 = 0;
  332.     }
  333.   } else {
  334.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  335.     C1 = x & MASK_BINARY_SIG1;
  336.   }
  337.  
  338.   // check for zeros (possibly from non-canonical values)
  339.   if (C1 == 0x0ull) {
  340.     // x is 0
  341.     res = 0x00000000;
  342.     BID_RETURN (res);
  343.   }
  344.   // x is not special and is not zero
  345.  
  346.   // q = nr. of decimal digits in x (1 <= q <= 54)
  347.   //  determine first the nr. of bits in x
  348.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  349.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  350.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  351.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  352.       x_nr_bits =
  353.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  354.     } else {    // x < 2^32
  355.       tmp1.d = (double) C1;     // exact conversion
  356.       x_nr_bits =
  357.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  358.     }
  359.   } else {      // if x < 2^53
  360.     tmp1.d = (double) C1;       // exact conversion
  361.     x_nr_bits =
  362.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  363.   }
  364.   q = nr_digits[x_nr_bits - 1].digits;
  365.   if (q == 0) {
  366.     q = nr_digits[x_nr_bits - 1].digits1;
  367.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  368.       q++;
  369.   }
  370.   exp = x_exp - 398;    // unbiased exponent
  371.  
  372.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  373.     // set invalid flag
  374.     *pfpsf |= INVALID_EXCEPTION;
  375.     // return Integer Indefinite
  376.     res = 0x80000000;
  377.     BID_RETURN (res);
  378.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  379.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  380.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  381.     // the cases that do not fit are identified here; the ones that fit
  382.     // fall through and will be handled with other cases further,
  383.     // under '1 <= q + exp <= 10'
  384.     if (x_sign) {       // if n < 0 and q + exp = 10
  385.       // if n < -2^31 - 1/2 then n is too large
  386.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^31+1/2
  387.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x500000005, 1<=q<=16
  388.       // <=> C * 10^(11-q) > 0x500000005, 1<=q<=16
  389.       if (q <= 11) {
  390.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  391.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  392.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  393.         if (tmp64 > 0x500000005ull) {
  394.           // set invalid flag
  395.           *pfpsf |= INVALID_EXCEPTION;
  396.           // return Integer Indefinite
  397.           res = 0x80000000;
  398.           BID_RETURN (res);
  399.         }
  400.         // else cases that can be rounded to a 32-bit int fall through
  401.         // to '1 <= q + exp <= 10'
  402.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  403.         // C * 10^(11-q) > 0x500000005 <=>
  404.         // C > 0x500000005 * 10^(q-11) where 1 <= q - 11 <= 5
  405.         // (scale 2^31+1/2 up)
  406.         // Note: 0x500000005*10^(q-11) has q-1 or q digits, where q <= 16
  407.         tmp64 = 0x500000005ull * ten2k64[q - 11];
  408.         if (C1 > tmp64) {
  409.           // set invalid flag
  410.           *pfpsf |= INVALID_EXCEPTION;
  411.           // return Integer Indefinite
  412.           res = 0x80000000;
  413.           BID_RETURN (res);
  414.         }
  415.         // else cases that can be rounded to a 32-bit int fall through
  416.         // to '1 <= q + exp <= 10'
  417.       }
  418.     } else {    // if n > 0 and q + exp = 10
  419.       // if n >= 2^31 - 1/2 then n is too large
  420.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31-1/2
  421.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x4fffffffb, 1<=q<=16
  422.       // <=> C * 10^(11-q) >= 0x4fffffffb, 1<=q<=16
  423.       if (q <= 11) {
  424.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  425.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  426.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  427.         if (tmp64 >= 0x4fffffffbull) {
  428.           // set invalid flag
  429.           *pfpsf |= INVALID_EXCEPTION;
  430.           // return Integer Indefinite
  431.           res = 0x80000000;
  432.           BID_RETURN (res);
  433.         }
  434.         // else cases that can be rounded to a 32-bit int fall through
  435.         // to '1 <= q + exp <= 10'
  436.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  437.         // C * 10^(11-q) >= 0x4fffffffb <=>
  438.         // C >= 0x4fffffffb * 10^(q-11) where 1 <= q - 11 <= 5
  439.         // (scale 2^31-1/2 up)
  440.         // Note: 0x4fffffffb*10^(q-11) has q-1 or q digits, where q <= 16
  441.         tmp64 = 0x4fffffffbull * ten2k64[q - 11];
  442.         if (C1 >= tmp64) {
  443.           // set invalid flag
  444.           *pfpsf |= INVALID_EXCEPTION;
  445.           // return Integer Indefinite
  446.           res = 0x80000000;
  447.           BID_RETURN (res);
  448.         }
  449.         // else cases that can be rounded to a 32-bit int fall through
  450.         // to '1 <= q + exp <= 10'
  451.       }
  452.     }
  453.   }
  454.   // n is not too large to be converted to int32: -2^31 - 1/2 < n < 2^31 - 1/2
  455.   // Note: some of the cases tested for above fall through to this point
  456.   if ((q + exp) < 0) {  // n = +/-0.0...c(0)c(1)...c(q-1)
  457.     // set inexact flag
  458.     *pfpsf |= INEXACT_EXCEPTION;
  459.     // return 0
  460.     res = 0x00000000;
  461.     BID_RETURN (res);
  462.   } else if ((q + exp) == 0) {  // n = +/-0.c(0)c(1)...c(q-1)
  463.     // if 0.c(0)c(1)...c(q-1) <= 0.5 <=> c(0)c(1)...c(q-1) <= 5 * 10^(q-1)
  464.     //   res = 0
  465.     // else
  466.     //   res = +/-1
  467.     ind = q - 1;
  468.     if (C1 <= midpoint64[ind]) {
  469.       res = 0x00000000; // return 0
  470.     } else if (x_sign) {        // n < 0
  471.       res = 0xffffffff; // return -1
  472.     } else {    // n > 0
  473.       res = 0x00000001; // return +1
  474.     }
  475.     // set inexact flag
  476.     *pfpsf |= INEXACT_EXCEPTION;
  477.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  478.     // -2^31-1/2 <= x <= -1 or 1 <= x < 2^31-1/2 so x can be rounded
  479.     // to nearest to a 32-bit signed integer
  480.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  481.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  482.       // chop off ind digits from the lower part of C1
  483.       // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 64 bits
  484.       C1 = C1 + midpoint64[ind - 1];
  485.       // calculate C* and f*
  486.       // C* is actually floor(C*) in this case
  487.       // C* and f* need shifting and masking, as shown by
  488.       // shiftright128[] and maskhigh128[]
  489.       // 1 <= x <= 15
  490.       // kx = 10^(-x) = ten2mk64[ind - 1]
  491.       // C* = (C1 + 1/2 * 10^x) * 10^(-x)
  492.       // the approximation of 10^(-x) was rounded up to 54 bits
  493.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  494.       Cstar = P128.w[1];
  495.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  496.       fstar.w[0] = P128.w[0];
  497.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  498.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  499.       // if (0 < f* < 10^(-x)) then the result is a midpoint
  500.       //   if floor(C*) is even then C* = floor(C*) - logical right
  501.       //       shift; C* has p decimal digits, correct by Prop. 1)
  502.       //   else if floor(C*) is odd C* = floor(C*)-1 (logical right
  503.       //       shift; C* has p decimal digits, correct by Pr. 1)
  504.       // else
  505.       //   C* = floor(C*) (logical right shift; C has p decimal digits,
  506.       //       correct by Property 1)
  507.       // n = C* * 10^(e+x)
  508.  
  509.       // shift right C* by Ex-64 = shiftright128[ind]
  510.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  511.       Cstar = Cstar >> shift;
  512.       // determine inexactness of the rounding of C*
  513.       // if (0 < f* - 1/2 < 10^(-x)) then
  514.       //   the result is exact
  515.       // else // if (f* - 1/2 > T*) then
  516.       //   the result is inexact
  517.       if (ind - 1 <= 2) {
  518.         if (fstar.w[0] > 0x8000000000000000ull) {
  519.           // f* > 1/2 and the result may be exact
  520.           tmp64 = fstar.w[0] - 0x8000000000000000ull;   // f* - 1/2
  521.           if ((tmp64 > ten2mk128trunc[ind - 1].w[1])) {
  522.             // ten2mk128trunc[ind -1].w[1] is identical to
  523.             // ten2mk128[ind -1].w[1]
  524.             // set the inexact flag
  525.             *pfpsf |= INEXACT_EXCEPTION;
  526.           }     // else the result is exact
  527.         } else {        // the result is inexact; f2* <= 1/2
  528.           // set the inexact flag
  529.           *pfpsf |= INEXACT_EXCEPTION;
  530.         }
  531.       } else {  // if 3 <= ind - 1 <= 14
  532.         if (fstar.w[1] > onehalf128[ind - 1] ||
  533.             (fstar.w[1] == onehalf128[ind - 1] && fstar.w[0])) {
  534.           // f2* > 1/2 and the result may be exact
  535.           // Calculate f2* - 1/2
  536.           tmp64 = fstar.w[1] - onehalf128[ind - 1];
  537.           if (tmp64 || fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  538.             // ten2mk128trunc[ind -1].w[1] is identical to
  539.             // ten2mk128[ind -1].w[1]
  540.             // set the inexact flag
  541.             *pfpsf |= INEXACT_EXCEPTION;
  542.           }     // else the result is exact
  543.         } else {        // the result is inexact; f2* <= 1/2
  544.           // set the inexact flag
  545.           *pfpsf |= INEXACT_EXCEPTION;
  546.         }
  547.       }
  548.  
  549.       // if the result was a midpoint it was rounded away from zero, so
  550.       // it will need a correction
  551.       // check for midpoints
  552.       if ((fstar.w[1] == 0) && fstar.w[0]
  553.           && (fstar.w[0] <= ten2mk128trunc[ind - 1].w[1])) {
  554.         // ten2mk128trunc[ind -1].w[1] is identical to
  555.         // ten2mk128[ind -1].w[1]
  556.         // the result is a midpoint; round to nearest
  557.         if (Cstar & 0x01) {     // Cstar is odd; MP in [EVEN, ODD]
  558.           // if floor(C*) is odd C = floor(C*) - 1; the result >= 1
  559.           Cstar--;      // Cstar is now even
  560.         }       // else MP in [ODD, EVEN]
  561.       }
  562.       if (x_sign)
  563.         res = -Cstar;
  564.       else
  565.         res = Cstar;
  566.     } else if (exp == 0) {
  567.       // 1 <= q <= 10
  568.       // res = +/-C (exact)
  569.       if (x_sign)
  570.         res = -C1;
  571.       else
  572.         res = C1;
  573.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  574.       // res = +/-C * 10^exp (exact)
  575.       if (x_sign)
  576.         res = -C1 * ten2k64[exp];
  577.       else
  578.         res = C1 * ten2k64[exp];
  579.     }
  580.   }
  581.   BID_RETURN (res);
  582. }
  583.  
  584. /*****************************************************************************
  585.  *  BID64_to_int32_floor
  586.  ****************************************************************************/
  587.  
  588. #if DECIMAL_CALL_BY_REFERENCE
  589. void
  590. bid64_to_int32_floor (int *pres,
  591.                       UINT64 *
  592.                       px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  593.                       _EXC_INFO_PARAM) {
  594.   UINT64 x = *px;
  595. #else
  596. int
  597. bid64_to_int32_floor (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  598.                       _EXC_INFO_PARAM) {
  599. #endif
  600.   int res;
  601.   UINT64 x_sign;
  602.   UINT64 x_exp;
  603.   int exp;                      // unbiased exponent
  604.   // Note: C1 represents x_significand (UINT64)
  605.   UINT64 tmp64;
  606.   BID_UI64DOUBLE tmp1;
  607.   unsigned int x_nr_bits;
  608.   int q, ind, shift;
  609.   UINT64 C1;
  610.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  611.   UINT128 fstar;
  612.   UINT128 P128;
  613.  
  614.   // check for NaN or Infinity
  615.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  616.     // set invalid flag
  617.     *pfpsf |= INVALID_EXCEPTION;
  618.     // return Integer Indefinite
  619.     res = 0x80000000;
  620.     BID_RETURN (res);
  621.   }
  622.   // unpack x
  623.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  624.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  625.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  626.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  627.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  628.     if (C1 > 9999999999999999ull) {     // non-canonical
  629.       x_exp = 0;
  630.       C1 = 0;
  631.     }
  632.   } else {
  633.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  634.     C1 = x & MASK_BINARY_SIG1;
  635.   }
  636.  
  637.   // check for zeros (possibly from non-canonical values)
  638.   if (C1 == 0x0ull) {
  639.     // x is 0
  640.     res = 0x00000000;
  641.     BID_RETURN (res);
  642.   }
  643.   // x is not special and is not zero
  644.  
  645.   // q = nr. of decimal digits in x (1 <= q <= 54)
  646.   //  determine first the nr. of bits in x
  647.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  648.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  649.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  650.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  651.       x_nr_bits =
  652.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  653.     } else {    // x < 2^32
  654.       tmp1.d = (double) C1;     // exact conversion
  655.       x_nr_bits =
  656.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  657.     }
  658.   } else {      // if x < 2^53
  659.     tmp1.d = (double) C1;       // exact conversion
  660.     x_nr_bits =
  661.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  662.   }
  663.   q = nr_digits[x_nr_bits - 1].digits;
  664.   if (q == 0) {
  665.     q = nr_digits[x_nr_bits - 1].digits1;
  666.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  667.       q++;
  668.   }
  669.   exp = x_exp - 398;    // unbiased exponent
  670.  
  671.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  672.     // set invalid flag
  673.     *pfpsf |= INVALID_EXCEPTION;
  674.     // return Integer Indefinite
  675.     res = 0x80000000;
  676.     BID_RETURN (res);
  677.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  678.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  679.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  680.     // the cases that do not fit are identified here; the ones that fit
  681.     // fall through and will be handled with other cases further,
  682.     // under '1 <= q + exp <= 10'
  683.     if (x_sign) {       // if n < 0 and q + exp = 10
  684.       // if n < -2^31 then n is too large
  685.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^31
  686.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x500000000, 1<=q<=16
  687.       // <=> C * 10^(11-q) >= 0x500000000, 1<=q<=16
  688.       if (q <= 11) {
  689.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000000 has 11 digits
  690.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  691.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  692.         if (tmp64 > 0x500000000ull) {
  693.           // set invalid flag
  694.           *pfpsf |= INVALID_EXCEPTION;
  695.           // return Integer Indefinite
  696.           res = 0x80000000;
  697.           BID_RETURN (res);
  698.         }
  699.         // else cases that can be rounded to a 32-bit int fall through
  700.         // to '1 <= q + exp <= 10'
  701.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  702.         // C * 10^(11-q) > 0x500000000 <=>
  703.         // C > 0x500000000 * 10^(q-11) where 1 <= q - 11 <= 5
  704.         // (scale 2^31+1 up)
  705.         // Note: 0x500000000*10^(q-11) has q-1 or q digits, where q <= 16
  706.         tmp64 = 0x500000000ull * ten2k64[q - 11];
  707.         if (C1 > tmp64) {
  708.           // set invalid flag
  709.           *pfpsf |= INVALID_EXCEPTION;
  710.           // return Integer Indefinite
  711.           res = 0x80000000;
  712.           BID_RETURN (res);
  713.         }
  714.         // else cases that can be rounded to a 32-bit int fall through
  715.         // to '1 <= q + exp <= 10'
  716.       }
  717.     } else {    // if n > 0 and q + exp = 10
  718.       // if n >= 2^31 then n is too large
  719.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31
  720.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x500000000, 1<=q<=16
  721.       // <=> C * 10^(11-q) >= 0x500000000, 1<=q<=16
  722.       if (q <= 11) {
  723.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000000 has 11 digits
  724.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  725.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  726.         if (tmp64 >= 0x500000000ull) {
  727.           // set invalid flag
  728.           *pfpsf |= INVALID_EXCEPTION;
  729.           // return Integer Indefinite
  730.           res = 0x80000000;
  731.           BID_RETURN (res);
  732.         }
  733.         // else cases that can be rounded to a 32-bit int fall through
  734.         // to '1 <= q + exp <= 10'
  735.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  736.         // C * 10^(11-q) >= 0x500000000 <=>
  737.         // C >= 0x500000000 * 10^(q-11) where 1 <= q - 11 <= 5
  738.         // (scale 2^31-1 up)
  739.         // Note: 0x500000000*10^(q-11) has q-1 or q digits, where q <= 16
  740.         tmp64 = 0x500000000ull * ten2k64[q - 11];
  741.         if (C1 >= tmp64) {
  742.           // set invalid flag
  743.           *pfpsf |= INVALID_EXCEPTION;
  744.           // return Integer Indefinite
  745.           res = 0x80000000;
  746.           BID_RETURN (res);
  747.         }
  748.         // else cases that can be rounded to a 32-bit int fall through
  749.         // to '1 <= q + exp <= 10'
  750.       }
  751.     }
  752.   }
  753.   // n is not too large to be converted to int32: -2^31 <= n < 2^31
  754.   // Note: some of the cases tested for above fall through to this point
  755.   if ((q + exp) <= 0) { // n = +/-0.[0...0]c(0)c(1)...c(q-1)
  756.     // return -1 or 0
  757.     if (x_sign)
  758.       res = 0xffffffff;
  759.     else
  760.       res = 0x00000000;
  761.     BID_RETURN (res);
  762.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  763.     // -2^31-1 < x <= -1 or 1 <= x < 2^31 so x can be rounded
  764.     // to nearest to a 32-bit signed integer
  765.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  766.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  767.       // chop off ind digits from the lower part of C1
  768.       // C1 fits in 64 bits
  769.       // calculate C* and f*
  770.       // C* is actually floor(C*) in this case
  771.       // C* and f* need shifting and masking, as shown by
  772.       // shiftright128[] and maskhigh128[]
  773.       // 1 <= x <= 15
  774.       // kx = 10^(-x) = ten2mk64[ind - 1]
  775.       // C* = C1 * 10^(-x)
  776.       // the approximation of 10^(-x) was rounded up to 54 bits
  777.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  778.       Cstar = P128.w[1];
  779.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  780.       fstar.w[0] = P128.w[0];
  781.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  782.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  783.       // C* = floor(C*) (logical right shift; C has p decimal digits,
  784.       //     correct by Property 1)
  785.       // n = C* * 10^(e+x)
  786.  
  787.       // shift right C* by Ex-64 = shiftright128[ind]
  788.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  789.       Cstar = Cstar >> shift;
  790.       // determine inexactness of the rounding of C*
  791.       // if (0 < f* < 10^(-x)) then
  792.       //   the result is exact
  793.       // else // if (f* > T*) then
  794.       //   the result is inexact
  795.       if (ind - 1 <= 2) {
  796.         if (fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  797.           // ten2mk128trunc[ind -1].w[1] is identical to
  798.           // ten2mk128[ind -1].w[1]
  799.           if (x_sign) { // negative and inexact
  800.             Cstar++;
  801.           }
  802.         }       // else the result is exact
  803.       } else {  // if 3 <= ind - 1 <= 14
  804.         if (fstar.w[1] || fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  805.           // ten2mk128trunc[ind -1].w[1] is identical to
  806.           // ten2mk128[ind -1].w[1]
  807.           if (x_sign) { // negative and inexact
  808.             Cstar++;
  809.           }
  810.         }       // else the result is exact
  811.       }
  812.  
  813.       if (x_sign)
  814.         res = -Cstar;
  815.       else
  816.         res = Cstar;
  817.     } else if (exp == 0) {
  818.       // 1 <= q <= 10
  819.       // res = +/-C (exact)
  820.       if (x_sign)
  821.         res = -C1;
  822.       else
  823.         res = C1;
  824.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  825.       // res = +/-C * 10^exp (exact)
  826.       if (x_sign)
  827.         res = -C1 * ten2k64[exp];
  828.       else
  829.         res = C1 * ten2k64[exp];
  830.     }
  831.   }
  832.   BID_RETURN (res);
  833. }
  834.  
  835. /*****************************************************************************
  836.  *  BID64_to_int32_xfloor
  837.  ****************************************************************************/
  838.  
  839. #if DECIMAL_CALL_BY_REFERENCE
  840. void
  841. bid64_to_int32_xfloor (int *pres,
  842.                        UINT64 *
  843.                        px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  844.                        _EXC_INFO_PARAM) {
  845.   UINT64 x = *px;
  846. #else
  847. int
  848. bid64_to_int32_xfloor (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  849.                        _EXC_INFO_PARAM) {
  850. #endif
  851.   int res;
  852.   UINT64 x_sign;
  853.   UINT64 x_exp;
  854.   int exp;                      // unbiased exponent
  855.   // Note: C1 represents x_significand (UINT64)
  856.   UINT64 tmp64;
  857.   BID_UI64DOUBLE tmp1;
  858.   unsigned int x_nr_bits;
  859.   int q, ind, shift;
  860.   UINT64 C1;
  861.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  862.   UINT128 fstar;
  863.   UINT128 P128;
  864.  
  865.   // check for NaN or Infinity
  866.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  867.     // set invalid flag
  868.     *pfpsf |= INVALID_EXCEPTION;
  869.     // return Integer Indefinite
  870.     res = 0x80000000;
  871.     BID_RETURN (res);
  872.   }
  873.   // unpack x
  874.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  875.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  876.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  877.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  878.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  879.     if (C1 > 9999999999999999ull) {     // non-canonical
  880.       x_exp = 0;
  881.       C1 = 0;
  882.     }
  883.   } else {
  884.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  885.     C1 = x & MASK_BINARY_SIG1;
  886.   }
  887.  
  888.   // check for zeros (possibly from non-canonical values)
  889.   if (C1 == 0x0ull) {
  890.     // x is 0
  891.     res = 0x00000000;
  892.     BID_RETURN (res);
  893.   }
  894.   // x is not special and is not zero
  895.  
  896.   // q = nr. of decimal digits in x (1 <= q <= 54)
  897.   //  determine first the nr. of bits in x
  898.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  899.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  900.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  901.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  902.       x_nr_bits =
  903.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  904.     } else {    // x < 2^32
  905.       tmp1.d = (double) C1;     // exact conversion
  906.       x_nr_bits =
  907.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  908.     }
  909.   } else {      // if x < 2^53
  910.     tmp1.d = (double) C1;       // exact conversion
  911.     x_nr_bits =
  912.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  913.   }
  914.   q = nr_digits[x_nr_bits - 1].digits;
  915.   if (q == 0) {
  916.     q = nr_digits[x_nr_bits - 1].digits1;
  917.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  918.       q++;
  919.   }
  920.   exp = x_exp - 398;    // unbiased exponent
  921.  
  922.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  923.     // set invalid flag
  924.     *pfpsf |= INVALID_EXCEPTION;
  925.     // return Integer Indefinite
  926.     res = 0x80000000;
  927.     BID_RETURN (res);
  928.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  929.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  930.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  931.     // the cases that do not fit are identified here; the ones that fit
  932.     // fall through and will be handled with other cases further,
  933.     // under '1 <= q + exp <= 10'
  934.     if (x_sign) {       // if n < 0 and q + exp = 10
  935.       // if n < -2^31 then n is too large
  936.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^31
  937.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x500000000, 1<=q<=16
  938.       // <=> C * 10^(11-q) >= 0x500000000, 1<=q<=16
  939.       if (q <= 11) {
  940.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000000 has 11 digits
  941.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  942.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  943.         if (tmp64 > 0x500000000ull) {
  944.           // set invalid flag
  945.           *pfpsf |= INVALID_EXCEPTION;
  946.           // return Integer Indefinite
  947.           res = 0x80000000;
  948.           BID_RETURN (res);
  949.         }
  950.         // else cases that can be rounded to a 32-bit int fall through
  951.         // to '1 <= q + exp <= 10'
  952.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  953.         // C * 10^(11-q) > 0x500000000 <=>
  954.         // C > 0x500000000 * 10^(q-11) where 1 <= q - 11 <= 5
  955.         // (scale 2^31+1 up)
  956.         // Note: 0x500000000*10^(q-11) has q-1 or q digits, where q <= 16
  957.         tmp64 = 0x500000000ull * ten2k64[q - 11];
  958.         if (C1 > tmp64) {
  959.           // set invalid flag
  960.           *pfpsf |= INVALID_EXCEPTION;
  961.           // return Integer Indefinite
  962.           res = 0x80000000;
  963.           BID_RETURN (res);
  964.         }
  965.         // else cases that can be rounded to a 32-bit int fall through
  966.         // to '1 <= q + exp <= 10'
  967.       }
  968.     } else {    // if n > 0 and q + exp = 10
  969.       // if n >= 2^31 then n is too large
  970.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31
  971.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x500000000, 1<=q<=16
  972.       // <=> C * 10^(11-q) >= 0x500000000, 1<=q<=16
  973.       if (q <= 11) {
  974.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000000 has 11 digits
  975.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  976.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  977.         if (tmp64 >= 0x500000000ull) {
  978.           // set invalid flag
  979.           *pfpsf |= INVALID_EXCEPTION;
  980.           // return Integer Indefinite
  981.           res = 0x80000000;
  982.           BID_RETURN (res);
  983.         }
  984.         // else cases that can be rounded to a 32-bit int fall through
  985.         // to '1 <= q + exp <= 10'
  986.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  987.         // C * 10^(11-q) >= 0x500000000 <=>
  988.         // C >= 0x500000000 * 10^(q-11) where 1 <= q - 11 <= 5
  989.         // (scale 2^31-1 up)
  990.         // Note: 0x500000000*10^(q-11) has q-1 or q digits, where q <= 16
  991.         tmp64 = 0x500000000ull * ten2k64[q - 11];
  992.         if (C1 >= tmp64) {
  993.           // set invalid flag
  994.           *pfpsf |= INVALID_EXCEPTION;
  995.           // return Integer Indefinite
  996.           res = 0x80000000;
  997.           BID_RETURN (res);
  998.         }
  999.         // else cases that can be rounded to a 32-bit int fall through
  1000.         // to '1 <= q + exp <= 10'
  1001.       }
  1002.     }
  1003.   }
  1004.   // n is not too large to be converted to int32: -2^31 <= n < 2^31
  1005.   // Note: some of the cases tested for above fall through to this point
  1006.   if ((q + exp) <= 0) { // n = +/-0.[0...0]c(0)c(1)...c(q-1)
  1007.     // set inexact flag
  1008.     *pfpsf |= INEXACT_EXCEPTION;
  1009.     // return -1 or 0
  1010.     if (x_sign)
  1011.       res = 0xffffffff;
  1012.     else
  1013.       res = 0x00000000;
  1014.     BID_RETURN (res);
  1015.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  1016.     // -2^31-1 < x <= -1 or 1 <= x < 2^31 so x can be rounded
  1017.     // to nearest to a 32-bit signed integer
  1018.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  1019.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  1020.       // chop off ind digits from the lower part of C1
  1021.       // C1 fits in 64 bits
  1022.       // calculate C* and f*
  1023.       // C* is actually floor(C*) in this case
  1024.       // C* and f* need shifting and masking, as shown by
  1025.       // shiftright128[] and maskhigh128[]
  1026.       // 1 <= x <= 15
  1027.       // kx = 10^(-x) = ten2mk64[ind - 1]
  1028.       // C* = C1 * 10^(-x)
  1029.       // the approximation of 10^(-x) was rounded up to 54 bits
  1030.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  1031.       Cstar = P128.w[1];
  1032.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  1033.       fstar.w[0] = P128.w[0];
  1034.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  1035.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  1036.       // C* = floor(C*) (logical right shift; C has p decimal digits,
  1037.       //     correct by Property 1)
  1038.       // n = C* * 10^(e+x)
  1039.  
  1040.       // shift right C* by Ex-64 = shiftright128[ind]
  1041.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  1042.       Cstar = Cstar >> shift;
  1043.       // determine inexactness of the rounding of C*
  1044.       // if (0 < f* < 10^(-x)) then
  1045.       //   the result is exact
  1046.       // else // if (f* > T*) then
  1047.       //   the result is inexact
  1048.       if (ind - 1 <= 2) {
  1049.         if (fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  1050.           // ten2mk128trunc[ind -1].w[1] is identical to
  1051.           // ten2mk128[ind -1].w[1]
  1052.           if (x_sign) { // negative and inexact
  1053.             Cstar++;
  1054.           }
  1055.           // set the inexact flag
  1056.           *pfpsf |= INEXACT_EXCEPTION;
  1057.         }       // else the result is exact
  1058.       } else {  // if 3 <= ind - 1 <= 14
  1059.         if (fstar.w[1] || fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  1060.           // ten2mk128trunc[ind -1].w[1] is identical to
  1061.           // ten2mk128[ind -1].w[1]
  1062.           if (x_sign) { // negative and inexact
  1063.             Cstar++;
  1064.           }
  1065.           // set the inexact flag
  1066.           *pfpsf |= INEXACT_EXCEPTION;
  1067.         }       // else the result is exact
  1068.       }
  1069.  
  1070.       if (x_sign)
  1071.         res = -Cstar;
  1072.       else
  1073.         res = Cstar;
  1074.     } else if (exp == 0) {
  1075.       // 1 <= q <= 10
  1076.       // res = +/-C (exact)
  1077.       if (x_sign)
  1078.         res = -C1;
  1079.       else
  1080.         res = C1;
  1081.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  1082.       // res = +/-C * 10^exp (exact)
  1083.       if (x_sign)
  1084.         res = -C1 * ten2k64[exp];
  1085.       else
  1086.         res = C1 * ten2k64[exp];
  1087.     }
  1088.   }
  1089.   BID_RETURN (res);
  1090. }
  1091.  
  1092. /*****************************************************************************
  1093.  *  BID64_to_int32_ceil
  1094.  ****************************************************************************/
  1095.  
  1096. #if DECIMAL_CALL_BY_REFERENCE
  1097. void
  1098. bid64_to_int32_ceil (int *pres,
  1099.                      UINT64 *
  1100.                      px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1101.                      _EXC_INFO_PARAM) {
  1102.   UINT64 x = *px;
  1103. #else
  1104. int
  1105. bid64_to_int32_ceil (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1106.                      _EXC_INFO_PARAM) {
  1107. #endif
  1108.   int res;
  1109.   UINT64 x_sign;
  1110.   UINT64 x_exp;
  1111.   int exp;                      // unbiased exponent
  1112.   // Note: C1 represents x_significand (UINT64)
  1113.   UINT64 tmp64;
  1114.   BID_UI64DOUBLE tmp1;
  1115.   unsigned int x_nr_bits;
  1116.   int q, ind, shift;
  1117.   UINT64 C1;
  1118.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  1119.   UINT128 fstar;
  1120.   UINT128 P128;
  1121.  
  1122.   // check for NaN or Infinity
  1123.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  1124.     // set invalid flag
  1125.     *pfpsf |= INVALID_EXCEPTION;
  1126.     // return Integer Indefinite
  1127.     res = 0x80000000;
  1128.     BID_RETURN (res);
  1129.   }
  1130.   // unpack x
  1131.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  1132.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  1133.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  1134.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  1135.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  1136.     if (C1 > 9999999999999999ull) {     // non-canonical
  1137.       x_exp = 0;
  1138.       C1 = 0;
  1139.     }
  1140.   } else {
  1141.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  1142.     C1 = x & MASK_BINARY_SIG1;
  1143.   }
  1144.  
  1145.   // check for zeros (possibly from non-canonical values)
  1146.   if (C1 == 0x0ull) {
  1147.     // x is 0
  1148.     res = 0x00000000;
  1149.     BID_RETURN (res);
  1150.   }
  1151.   // x is not special and is not zero
  1152.  
  1153.   // q = nr. of decimal digits in x (1 <= q <= 54)
  1154.   //  determine first the nr. of bits in x
  1155.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  1156.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  1157.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  1158.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  1159.       x_nr_bits =
  1160.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1161.     } else {    // x < 2^32
  1162.       tmp1.d = (double) C1;     // exact conversion
  1163.       x_nr_bits =
  1164.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1165.     }
  1166.   } else {      // if x < 2^53
  1167.     tmp1.d = (double) C1;       // exact conversion
  1168.     x_nr_bits =
  1169.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1170.   }
  1171.   q = nr_digits[x_nr_bits - 1].digits;
  1172.   if (q == 0) {
  1173.     q = nr_digits[x_nr_bits - 1].digits1;
  1174.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  1175.       q++;
  1176.   }
  1177.   exp = x_exp - 398;    // unbiased exponent
  1178.  
  1179.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  1180.     // set invalid flag
  1181.     *pfpsf |= INVALID_EXCEPTION;
  1182.     // return Integer Indefinite
  1183.     res = 0x80000000;
  1184.     BID_RETURN (res);
  1185.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  1186.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  1187.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  1188.     // the cases that do not fit are identified here; the ones that fit
  1189.     // fall through and will be handled with other cases further,
  1190.     // under '1 <= q + exp <= 10'
  1191.     if (x_sign) {       // if n < 0 and q + exp = 10
  1192.       // if n <= -2^31 - 1 then n is too large
  1193.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31+1
  1194.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x50000000a, 1<=q<=16
  1195.       // <=> C * 10^(11-q) >= 0x50000000a, 1<=q<=16
  1196.       if (q <= 11) {
  1197.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x50000000a has 11 digits
  1198.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1199.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1200.         if (tmp64 >= 0x50000000aull) {
  1201.           // set invalid flag
  1202.           *pfpsf |= INVALID_EXCEPTION;
  1203.           // return Integer Indefinite
  1204.           res = 0x80000000;
  1205.           BID_RETURN (res);
  1206.         }
  1207.         // else cases that can be rounded to a 32-bit int fall through
  1208.         // to '1 <= q + exp <= 10'
  1209.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1210.         // C * 10^(11-q) >= 0x50000000a <=>
  1211.         // C >= 0x50000000a * 10^(q-11) where 1 <= q - 11 <= 5
  1212.         // (scale 2^31+1 up)
  1213.         // Note: 0x50000000a*10^(q-11) has q-1 or q digits, where q <= 16
  1214.         tmp64 = 0x50000000aull * ten2k64[q - 11];
  1215.         if (C1 >= tmp64) {
  1216.           // set invalid flag
  1217.           *pfpsf |= INVALID_EXCEPTION;
  1218.           // return Integer Indefinite
  1219.           res = 0x80000000;
  1220.           BID_RETURN (res);
  1221.         }
  1222.         // else cases that can be rounded to a 32-bit int fall through
  1223.         // to '1 <= q + exp <= 10'
  1224.       }
  1225.     } else {    // if n > 0 and q + exp = 10
  1226.       // if n > 2^31 - 1 then n is too large
  1227.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^31 - 1
  1228.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x4fffffff6, 1<=q<=16
  1229.       // <=> C * 10^(11-q) > 0x4fffffff6, 1<=q<=16
  1230.       if (q <= 11) {
  1231.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x4fffffff6 has 11 digits
  1232.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1233.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1234.         if (tmp64 > 0x4fffffff6ull) {
  1235.           // set invalid flag
  1236.           *pfpsf |= INVALID_EXCEPTION;
  1237.           // return Integer Indefinite
  1238.           res = 0x80000000;
  1239.           BID_RETURN (res);
  1240.         }
  1241.         // else cases that can be rounded to a 32-bit int fall through
  1242.         // to '1 <= q + exp <= 10'
  1243.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1244.         // C * 10^(11-q) > 0x4fffffff6 <=>
  1245.         // C > 0x4fffffff6 * 10^(q-11) where 1 <= q - 11 <= 5
  1246.         // (scale 2^31-1 up)
  1247.         // Note: 0x4fffffff6*10^(q-11) has q-1 or q digits, where q <= 16
  1248.         tmp64 = 0x4fffffff6ull * ten2k64[q - 11];
  1249.         if (C1 > tmp64) {
  1250.           // set invalid flag
  1251.           *pfpsf |= INVALID_EXCEPTION;
  1252.           // return Integer Indefinite
  1253.           res = 0x80000000;
  1254.           BID_RETURN (res);
  1255.         }
  1256.         // else cases that can be rounded to a 32-bit int fall through
  1257.         // to '1 <= q + exp <= 10'
  1258.       }
  1259.     }
  1260.   }
  1261.   // n is not too large to be converted to int32: -2^31 - 1 < n <= 2^31 - 1
  1262.   // Note: some of the cases tested for above fall through to this point
  1263.   if ((q + exp) <= 0) { // n = +/-0.[0...0]c(0)c(1)...c(q-1)
  1264.     // return 0 or 1
  1265.     if (x_sign)
  1266.       res = 0x00000000;
  1267.     else
  1268.       res = 0x00000001;
  1269.     BID_RETURN (res);
  1270.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  1271.     // -2^31-1 < x <= -1 or 1 <= x <= 2^31-1 so x can be rounded
  1272.     // to nearest to a 32-bit signed integer
  1273.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  1274.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  1275.       // chop off ind digits from the lower part of C1
  1276.       // C1 fits in 64 bits
  1277.       // calculate C* and f*
  1278.       // C* is actually floor(C*) in this case
  1279.       // C* and f* need shifting and masking, as shown by
  1280.       // shiftright128[] and maskhigh128[]
  1281.       // 1 <= x <= 15
  1282.       // kx = 10^(-x) = ten2mk64[ind - 1]
  1283.       // C* = C1 * 10^(-x)
  1284.       // the approximation of 10^(-x) was rounded up to 54 bits
  1285.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  1286.       Cstar = P128.w[1];
  1287.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  1288.       fstar.w[0] = P128.w[0];
  1289.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  1290.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  1291.       // C* = floor(C*) (logical right shift; C has p decimal digits,
  1292.       //     correct by Property 1)
  1293.       // n = C* * 10^(e+x)
  1294.  
  1295.       // shift right C* by Ex-64 = shiftright128[ind]
  1296.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  1297.       Cstar = Cstar >> shift;
  1298.       // determine inexactness of the rounding of C*
  1299.       // if (0 < f* < 10^(-x)) then
  1300.       //   the result is exact
  1301.       // else // if (f* > T*) then
  1302.       //   the result is inexact
  1303.       if (ind - 1 <= 2) {
  1304.         if (fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  1305.           // ten2mk128trunc[ind -1].w[1] is identical to
  1306.           // ten2mk128[ind -1].w[1]
  1307.           if (!x_sign) {        // positive and inexact
  1308.             Cstar++;
  1309.           }
  1310.         }       // else the result is exact
  1311.       } else {  // if 3 <= ind - 1 <= 14
  1312.         if (fstar.w[1] || fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  1313.           // ten2mk128trunc[ind -1].w[1] is identical to
  1314.           // ten2mk128[ind -1].w[1]
  1315.           if (!x_sign) {        // positive and inexact
  1316.             Cstar++;
  1317.           }
  1318.         }       // else the result is exact
  1319.       }
  1320.  
  1321.       if (x_sign)
  1322.         res = -Cstar;
  1323.       else
  1324.         res = Cstar;
  1325.     } else if (exp == 0) {
  1326.       // 1 <= q <= 10
  1327.       // res = +/-C (exact)
  1328.       if (x_sign)
  1329.         res = -C1;
  1330.       else
  1331.         res = C1;
  1332.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  1333.       // res = +/-C * 10^exp (exact)
  1334.       if (x_sign)
  1335.         res = -C1 * ten2k64[exp];
  1336.       else
  1337.         res = C1 * ten2k64[exp];
  1338.     }
  1339.   }
  1340.   BID_RETURN (res);
  1341. }
  1342.  
  1343. /*****************************************************************************
  1344.  *  BID64_to_int32_xceil
  1345.  ****************************************************************************/
  1346.  
  1347. #if DECIMAL_CALL_BY_REFERENCE
  1348. void
  1349. bid64_to_int32_xceil (int *pres,
  1350.                       UINT64 *
  1351.                       px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1352.                       _EXC_INFO_PARAM) {
  1353.   UINT64 x = *px;
  1354. #else
  1355. int
  1356. bid64_to_int32_xceil (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1357.                       _EXC_INFO_PARAM) {
  1358. #endif
  1359.   int res;
  1360.   UINT64 x_sign;
  1361.   UINT64 x_exp;
  1362.   int exp;                      // unbiased exponent
  1363.   // Note: C1 represents x_significand (UINT64)
  1364.   UINT64 tmp64;
  1365.   BID_UI64DOUBLE tmp1;
  1366.   unsigned int x_nr_bits;
  1367.   int q, ind, shift;
  1368.   UINT64 C1;
  1369.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  1370.   UINT128 fstar;
  1371.   UINT128 P128;
  1372.  
  1373.   // check for NaN or Infinity
  1374.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  1375.     // set invalid flag
  1376.     *pfpsf |= INVALID_EXCEPTION;
  1377.     // return Integer Indefinite
  1378.     res = 0x80000000;
  1379.     BID_RETURN (res);
  1380.   }
  1381.   // unpack x
  1382.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  1383.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  1384.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  1385.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  1386.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  1387.     if (C1 > 9999999999999999ull) {     // non-canonical
  1388.       x_exp = 0;
  1389.       C1 = 0;
  1390.     }
  1391.   } else {
  1392.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  1393.     C1 = x & MASK_BINARY_SIG1;
  1394.   }
  1395.  
  1396.   // check for zeros (possibly from non-canonical values)
  1397.   if (C1 == 0x0ull) {
  1398.     // x is 0
  1399.     res = 0x00000000;
  1400.     BID_RETURN (res);
  1401.   }
  1402.   // x is not special and is not zero
  1403.  
  1404.   // q = nr. of decimal digits in x (1 <= q <= 54)
  1405.   //  determine first the nr. of bits in x
  1406.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  1407.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  1408.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  1409.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  1410.       x_nr_bits =
  1411.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1412.     } else {    // x < 2^32
  1413.       tmp1.d = (double) C1;     // exact conversion
  1414.       x_nr_bits =
  1415.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1416.     }
  1417.   } else {      // if x < 2^53
  1418.     tmp1.d = (double) C1;       // exact conversion
  1419.     x_nr_bits =
  1420.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1421.   }
  1422.   q = nr_digits[x_nr_bits - 1].digits;
  1423.   if (q == 0) {
  1424.     q = nr_digits[x_nr_bits - 1].digits1;
  1425.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  1426.       q++;
  1427.   }
  1428.   exp = x_exp - 398;    // unbiased exponent
  1429.  
  1430.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  1431.     // set invalid flag
  1432.     *pfpsf |= INVALID_EXCEPTION;
  1433.     // return Integer Indefinite
  1434.     res = 0x80000000;
  1435.     BID_RETURN (res);
  1436.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  1437.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  1438.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  1439.     // the cases that do not fit are identified here; the ones that fit
  1440.     // fall through and will be handled with other cases further,
  1441.     // under '1 <= q + exp <= 10'
  1442.     if (x_sign) {       // if n < 0 and q + exp = 10
  1443.       // if n <= -2^31 - 1 then n is too large
  1444.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31+1
  1445.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x50000000a, 1<=q<=16
  1446.       // <=> C * 10^(11-q) >= 0x50000000a, 1<=q<=16
  1447.       if (q <= 11) {
  1448.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x50000000a has 11 digits
  1449.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1450.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1451.         if (tmp64 >= 0x50000000aull) {
  1452.           // set invalid flag
  1453.           *pfpsf |= INVALID_EXCEPTION;
  1454.           // return Integer Indefinite
  1455.           res = 0x80000000;
  1456.           BID_RETURN (res);
  1457.         }
  1458.         // else cases that can be rounded to a 32-bit int fall through
  1459.         // to '1 <= q + exp <= 10'
  1460.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1461.         // C * 10^(11-q) >= 0x50000000a <=>
  1462.         // C >= 0x50000000a * 10^(q-11) where 1 <= q - 11 <= 5
  1463.         // (scale 2^31+1 up)
  1464.         // Note: 0x50000000a*10^(q-11) has q-1 or q digits, where q <= 16
  1465.         tmp64 = 0x50000000aull * ten2k64[q - 11];
  1466.         if (C1 >= tmp64) {
  1467.           // set invalid flag
  1468.           *pfpsf |= INVALID_EXCEPTION;
  1469.           // return Integer Indefinite
  1470.           res = 0x80000000;
  1471.           BID_RETURN (res);
  1472.         }
  1473.         // else cases that can be rounded to a 32-bit int fall through
  1474.         // to '1 <= q + exp <= 10'
  1475.       }
  1476.     } else {    // if n > 0 and q + exp = 10
  1477.       // if n > 2^31 - 1 then n is too large
  1478.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^31 - 1
  1479.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x4fffffff6, 1<=q<=16
  1480.       // <=> C * 10^(11-q) > 0x4fffffff6, 1<=q<=16
  1481.       if (q <= 11) {
  1482.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x4fffffff6 has 11 digits
  1483.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1484.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1485.         if (tmp64 > 0x4fffffff6ull) {
  1486.           // set invalid flag
  1487.           *pfpsf |= INVALID_EXCEPTION;
  1488.           // return Integer Indefinite
  1489.           res = 0x80000000;
  1490.           BID_RETURN (res);
  1491.         }
  1492.         // else cases that can be rounded to a 32-bit int fall through
  1493.         // to '1 <= q + exp <= 10'
  1494.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1495.         // C * 10^(11-q) > 0x4fffffff6 <=>
  1496.         // C > 0x4fffffff6 * 10^(q-11) where 1 <= q - 11 <= 5
  1497.         // (scale 2^31-1 up)
  1498.         // Note: 0x4fffffff6*10^(q-11) has q-1 or q digits, where q <= 16
  1499.         tmp64 = 0x4fffffff6ull * ten2k64[q - 11];
  1500.         if (C1 > tmp64) {
  1501.           // set invalid flag
  1502.           *pfpsf |= INVALID_EXCEPTION;
  1503.           // return Integer Indefinite
  1504.           res = 0x80000000;
  1505.           BID_RETURN (res);
  1506.         }
  1507.         // else cases that can be rounded to a 32-bit int fall through
  1508.         // to '1 <= q + exp <= 10'
  1509.       }
  1510.     }
  1511.   }
  1512.   // n is not too large to be converted to int32: -2^31 - 1 < n <= 2^31 - 1
  1513.   // Note: some of the cases tested for above fall through to this point
  1514.   if ((q + exp) <= 0) { // n = +/-0.[0...0]c(0)c(1)...c(q-1)
  1515.     // set inexact flag
  1516.     *pfpsf |= INEXACT_EXCEPTION;
  1517.     // return 0 or 1
  1518.     if (x_sign)
  1519.       res = 0x00000000;
  1520.     else
  1521.       res = 0x00000001;
  1522.     BID_RETURN (res);
  1523.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  1524.     // -2^31-1 < x <= -1 or 1 <= x <= 2^31-1 so x can be rounded
  1525.     // to nearest to a 32-bit signed integer
  1526.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  1527.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  1528.       // chop off ind digits from the lower part of C1
  1529.       // C1 fits in 64 bits
  1530.       // calculate C* and f*
  1531.       // C* is actually floor(C*) in this case
  1532.       // C* and f* need shifting and masking, as shown by
  1533.       // shiftright128[] and maskhigh128[]
  1534.       // 1 <= x <= 15
  1535.       // kx = 10^(-x) = ten2mk64[ind - 1]
  1536.       // C* = C1 * 10^(-x)
  1537.       // the approximation of 10^(-x) was rounded up to 54 bits
  1538.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  1539.       Cstar = P128.w[1];
  1540.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  1541.       fstar.w[0] = P128.w[0];
  1542.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  1543.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  1544.       // C* = floor(C*) (logical right shift; C has p decimal digits,
  1545.       //     correct by Property 1)
  1546.       // n = C* * 10^(e+x)
  1547.  
  1548.       // shift right C* by Ex-64 = shiftright128[ind]
  1549.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  1550.       Cstar = Cstar >> shift;
  1551.       // determine inexactness of the rounding of C*
  1552.       // if (0 < f* < 10^(-x)) then
  1553.       //   the result is exact
  1554.       // else // if (f* > T*) then
  1555.       //   the result is inexact
  1556.       if (ind - 1 <= 2) {
  1557.         if (fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  1558.           // ten2mk128trunc[ind -1].w[1] is identical to
  1559.           // ten2mk128[ind -1].w[1]
  1560.           if (!x_sign) {        // positive and inexact
  1561.             Cstar++;
  1562.           }
  1563.           // set the inexact flag
  1564.           *pfpsf |= INEXACT_EXCEPTION;
  1565.         }       // else the result is exact
  1566.       } else {  // if 3 <= ind - 1 <= 14
  1567.         if (fstar.w[1] || fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  1568.           // ten2mk128trunc[ind -1].w[1] is identical to
  1569.           // ten2mk128[ind -1].w[1]
  1570.           if (!x_sign) {        // positive and inexact
  1571.             Cstar++;
  1572.           }
  1573.           // set the inexact flag
  1574.           *pfpsf |= INEXACT_EXCEPTION;
  1575.         }       // else the result is exact
  1576.       }
  1577.  
  1578.       if (x_sign)
  1579.         res = -Cstar;
  1580.       else
  1581.         res = Cstar;
  1582.     } else if (exp == 0) {
  1583.       // 1 <= q <= 10
  1584.       // res = +/-C (exact)
  1585.       if (x_sign)
  1586.         res = -C1;
  1587.       else
  1588.         res = C1;
  1589.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  1590.       // res = +/-C * 10^exp (exact)
  1591.       if (x_sign)
  1592.         res = -C1 * ten2k64[exp];
  1593.       else
  1594.         res = C1 * ten2k64[exp];
  1595.     }
  1596.   }
  1597.   BID_RETURN (res);
  1598. }
  1599.  
  1600. /*****************************************************************************
  1601.  *  BID64_to_int32_int
  1602.  ****************************************************************************/
  1603.  
  1604. #if DECIMAL_CALL_BY_REFERENCE
  1605. void
  1606. bid64_to_int32_int (int *pres,
  1607.                     UINT64 *
  1608.                     px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1609.                     _EXC_INFO_PARAM) {
  1610.   UINT64 x = *px;
  1611. #else
  1612. int
  1613. bid64_to_int32_int (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1614.                     _EXC_INFO_PARAM) {
  1615. #endif
  1616.   int res;
  1617.   UINT64 x_sign;
  1618.   UINT64 x_exp;
  1619.   int exp;                      // unbiased exponent
  1620.   // Note: C1 represents x_significand (UINT64)
  1621.   UINT64 tmp64;
  1622.   BID_UI64DOUBLE tmp1;
  1623.   unsigned int x_nr_bits;
  1624.   int q, ind, shift;
  1625.   UINT64 C1;
  1626.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  1627.   UINT128 P128;
  1628.  
  1629.   // check for NaN or Infinity
  1630.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  1631.     // set invalid flag
  1632.     *pfpsf |= INVALID_EXCEPTION;
  1633.     // return Integer Indefinite
  1634.     res = 0x80000000;
  1635.     BID_RETURN (res);
  1636.   }
  1637.   // unpack x
  1638.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  1639.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  1640.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  1641.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  1642.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  1643.     if (C1 > 9999999999999999ull) {     // non-canonical
  1644.       x_exp = 0;
  1645.       C1 = 0;
  1646.     }
  1647.   } else {
  1648.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  1649.     C1 = x & MASK_BINARY_SIG1;
  1650.   }
  1651.  
  1652.   // check for zeros (possibly from non-canonical values)
  1653.   if (C1 == 0x0ull) {
  1654.     // x is 0
  1655.     res = 0x00000000;
  1656.     BID_RETURN (res);
  1657.   }
  1658.   // x is not special and is not zero
  1659.  
  1660.   // q = nr. of decimal digits in x (1 <= q <= 54)
  1661.   //  determine first the nr. of bits in x
  1662.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  1663.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  1664.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  1665.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  1666.       x_nr_bits =
  1667.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1668.     } else {    // x < 2^32
  1669.       tmp1.d = (double) C1;     // exact conversion
  1670.       x_nr_bits =
  1671.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1672.     }
  1673.   } else {      // if x < 2^53
  1674.     tmp1.d = (double) C1;       // exact conversion
  1675.     x_nr_bits =
  1676.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1677.   }
  1678.   q = nr_digits[x_nr_bits - 1].digits;
  1679.   if (q == 0) {
  1680.     q = nr_digits[x_nr_bits - 1].digits1;
  1681.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  1682.       q++;
  1683.   }
  1684.   exp = x_exp - 398;    // unbiased exponent
  1685.  
  1686.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  1687.     // set invalid flag
  1688.     *pfpsf |= INVALID_EXCEPTION;
  1689.     // return Integer Indefinite
  1690.     res = 0x80000000;
  1691.     BID_RETURN (res);
  1692.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  1693.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  1694.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  1695.     // the cases that do not fit are identified here; the ones that fit
  1696.     // fall through and will be handled with other cases further,
  1697.     // under '1 <= q + exp <= 10'
  1698.     if (x_sign) {       // if n < 0 and q + exp = 10
  1699.       // if n <= -2^31 - 1 then n is too large
  1700.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31+1
  1701.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x50000000a, 1<=q<=16
  1702.       // <=> C * 10^(11-q) >= 0x50000000a, 1<=q<=16
  1703.       if (q <= 11) {
  1704.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x50000000a has 11 digits
  1705.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1706.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1707.         if (tmp64 >= 0x50000000aull) {
  1708.           // set invalid flag
  1709.           *pfpsf |= INVALID_EXCEPTION;
  1710.           // return Integer Indefinite
  1711.           res = 0x80000000;
  1712.           BID_RETURN (res);
  1713.         }
  1714.         // else cases that can be rounded to a 32-bit int fall through
  1715.         // to '1 <= q + exp <= 10'
  1716.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1717.         // C * 10^(11-q) >= 0x50000000a <=>
  1718.         // C >= 0x50000000a * 10^(q-11) where 1 <= q - 11 <= 5
  1719.         // (scale 2^31+1 up)
  1720.         // Note: 0x50000000a*10^(q-11) has q-1 or q digits, where q <= 16
  1721.         tmp64 = 0x50000000aull * ten2k64[q - 11];
  1722.         if (C1 >= tmp64) {
  1723.           // set invalid flag
  1724.           *pfpsf |= INVALID_EXCEPTION;
  1725.           // return Integer Indefinite
  1726.           res = 0x80000000;
  1727.           BID_RETURN (res);
  1728.         }
  1729.         // else cases that can be rounded to a 32-bit int fall through
  1730.         // to '1 <= q + exp <= 10'
  1731.       }
  1732.     } else {    // if n > 0 and q + exp = 10
  1733.       // if n >= 2^31 then n is too large
  1734.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31
  1735.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x500000000, 1<=q<=16
  1736.       // <=> C * 10^(11-q) >= 0x500000000, 1<=q<=16
  1737.       if (q <= 11) {
  1738.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000000 has 11 digits
  1739.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1740.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1741.         if (tmp64 >= 0x500000000ull) {
  1742.           // set invalid flag
  1743.           *pfpsf |= INVALID_EXCEPTION;
  1744.           // return Integer Indefinite
  1745.           res = 0x80000000;
  1746.           BID_RETURN (res);
  1747.         }
  1748.         // else cases that can be rounded to a 32-bit int fall through
  1749.         // to '1 <= q + exp <= 10'
  1750.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1751.         // C * 10^(11-q) >= 0x500000000 <=>
  1752.         // C >= 0x500000000 * 10^(q-11) where 1 <= q - 11 <= 5
  1753.         // (scale 2^31-1 up)
  1754.         // Note: 0x500000000*10^(q-11) has q-1 or q digits, where q <= 16
  1755.         tmp64 = 0x500000000ull * ten2k64[q - 11];
  1756.         if (C1 >= tmp64) {
  1757.           // set invalid flag
  1758.           *pfpsf |= INVALID_EXCEPTION;
  1759.           // return Integer Indefinite
  1760.           res = 0x80000000;
  1761.           BID_RETURN (res);
  1762.         }
  1763.         // else cases that can be rounded to a 32-bit int fall through
  1764.         // to '1 <= q + exp <= 10'
  1765.       }
  1766.     }
  1767.   }
  1768.   // n is not too large to be converted to int32: -2^31 - 1 < n < 2^31
  1769.   // Note: some of the cases tested for above fall through to this point
  1770.   if ((q + exp) <= 0) { // n = +/-0.[0...0]c(0)c(1)...c(q-1)
  1771.     // return 0
  1772.     res = 0x00000000;
  1773.     BID_RETURN (res);
  1774.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  1775.     // -2^31-1 < x <= -1 or 1 <= x < 2^31 so x can be rounded
  1776.     // to nearest to a 32-bit signed integer
  1777.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  1778.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  1779.       // chop off ind digits from the lower part of C1
  1780.       // C1 fits in 64 bits
  1781.       // calculate C* and f*
  1782.       // C* is actually floor(C*) in this case
  1783.       // C* and f* need shifting and masking, as shown by
  1784.       // shiftright128[] and maskhigh128[]
  1785.       // 1 <= x <= 15
  1786.       // kx = 10^(-x) = ten2mk64[ind - 1]
  1787.       // C* = C1 * 10^(-x)
  1788.       // the approximation of 10^(-x) was rounded up to 54 bits
  1789.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  1790.       Cstar = P128.w[1];
  1791.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  1792.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  1793.       // C* = floor(C*) (logical right shift; C has p decimal digits,
  1794.       //     correct by Property 1)
  1795.       // n = C* * 10^(e+x)
  1796.  
  1797.       // shift right C* by Ex-64 = shiftright128[ind]
  1798.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  1799.       Cstar = Cstar >> shift;
  1800.       if (x_sign)
  1801.         res = -Cstar;
  1802.       else
  1803.         res = Cstar;
  1804.     } else if (exp == 0) {
  1805.       // 1 <= q <= 10
  1806.       // res = +/-C (exact)
  1807.       if (x_sign)
  1808.         res = -C1;
  1809.       else
  1810.         res = C1;
  1811.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  1812.       // res = +/-C * 10^exp (exact)
  1813.       if (x_sign)
  1814.         res = -C1 * ten2k64[exp];
  1815.       else
  1816.         res = C1 * ten2k64[exp];
  1817.     }
  1818.   }
  1819.   BID_RETURN (res);
  1820. }
  1821.  
  1822. /*****************************************************************************
  1823.  *  BID64_to_int32_xint
  1824.  ****************************************************************************/
  1825.  
  1826. #if DECIMAL_CALL_BY_REFERENCE
  1827. void
  1828. bid64_to_int32_xint (int *pres,
  1829.                      UINT64 *
  1830.                      px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1831.                      _EXC_INFO_PARAM) {
  1832.   UINT64 x = *px;
  1833. #else
  1834. int
  1835. bid64_to_int32_xint (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  1836.                      _EXC_INFO_PARAM) {
  1837. #endif
  1838.   int res;
  1839.   UINT64 x_sign;
  1840.   UINT64 x_exp;
  1841.   int exp;                      // unbiased exponent
  1842.   // Note: C1 represents x_significand (UINT64)
  1843.   UINT64 tmp64;
  1844.   BID_UI64DOUBLE tmp1;
  1845.   unsigned int x_nr_bits;
  1846.   int q, ind, shift;
  1847.   UINT64 C1;
  1848.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  1849.   UINT128 fstar;
  1850.   UINT128 P128;
  1851.  
  1852.   // check for NaN or Infinity
  1853.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  1854.     // set invalid flag
  1855.     *pfpsf |= INVALID_EXCEPTION;
  1856.     // return Integer Indefinite
  1857.     res = 0x80000000;
  1858.     BID_RETURN (res);
  1859.   }
  1860.   // unpack x
  1861.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  1862.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  1863.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  1864.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  1865.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  1866.     if (C1 > 9999999999999999ull) {     // non-canonical
  1867.       x_exp = 0;
  1868.       C1 = 0;
  1869.     }
  1870.   } else {
  1871.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  1872.     C1 = x & MASK_BINARY_SIG1;
  1873.   }
  1874.  
  1875.   // check for zeros (possibly from non-canonical values)
  1876.   if (C1 == 0x0ull) {
  1877.     // x is 0
  1878.     res = 0x00000000;
  1879.     BID_RETURN (res);
  1880.   }
  1881.   // x is not special and is not zero
  1882.  
  1883.   // q = nr. of decimal digits in x (1 <= q <= 54)
  1884.   //  determine first the nr. of bits in x
  1885.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  1886.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  1887.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  1888.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  1889.       x_nr_bits =
  1890.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1891.     } else {    // x < 2^32
  1892.       tmp1.d = (double) C1;     // exact conversion
  1893.       x_nr_bits =
  1894.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1895.     }
  1896.   } else {      // if x < 2^53
  1897.     tmp1.d = (double) C1;       // exact conversion
  1898.     x_nr_bits =
  1899.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  1900.   }
  1901.   q = nr_digits[x_nr_bits - 1].digits;
  1902.   if (q == 0) {
  1903.     q = nr_digits[x_nr_bits - 1].digits1;
  1904.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  1905.       q++;
  1906.   }
  1907.   exp = x_exp - 398;    // unbiased exponent
  1908.  
  1909.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  1910.     // set invalid flag
  1911.     *pfpsf |= INVALID_EXCEPTION;
  1912.     // return Integer Indefinite
  1913.     res = 0x80000000;
  1914.     BID_RETURN (res);
  1915.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  1916.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  1917.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  1918.     // the cases that do not fit are identified here; the ones that fit
  1919.     // fall through and will be handled with other cases further,
  1920.     // under '1 <= q + exp <= 10'
  1921.     if (x_sign) {       // if n < 0 and q + exp = 10
  1922.       // if n <= -2^31 - 1 then n is too large
  1923.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31+1
  1924.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x50000000a, 1<=q<=16
  1925.       // <=> C * 10^(11-q) >= 0x50000000a, 1<=q<=16
  1926.       if (q <= 11) {
  1927.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x50000000a has 11 digits
  1928.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1929.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1930.         if (tmp64 >= 0x50000000aull) {
  1931.           // set invalid flag
  1932.           *pfpsf |= INVALID_EXCEPTION;
  1933.           // return Integer Indefinite
  1934.           res = 0x80000000;
  1935.           BID_RETURN (res);
  1936.         }
  1937.         // else cases that can be rounded to a 32-bit int fall through
  1938.         // to '1 <= q + exp <= 10'
  1939.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1940.         // C * 10^(11-q) >= 0x50000000a <=>
  1941.         // C >= 0x50000000a * 10^(q-11) where 1 <= q - 11 <= 5
  1942.         // (scale 2^31+1 up)
  1943.         // Note: 0x50000000a*10^(q-11) has q-1 or q digits, where q <= 16
  1944.         tmp64 = 0x50000000aull * ten2k64[q - 11];
  1945.         if (C1 >= tmp64) {
  1946.           // set invalid flag
  1947.           *pfpsf |= INVALID_EXCEPTION;
  1948.           // return Integer Indefinite
  1949.           res = 0x80000000;
  1950.           BID_RETURN (res);
  1951.         }
  1952.         // else cases that can be rounded to a 32-bit int fall through
  1953.         // to '1 <= q + exp <= 10'
  1954.       }
  1955.     } else {    // if n > 0 and q + exp = 10
  1956.       // if n >= 2^31 then n is too large
  1957.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31
  1958.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x500000000, 1<=q<=16
  1959.       // <=> C * 10^(11-q) >= 0x500000000, 1<=q<=16
  1960.       if (q <= 11) {
  1961.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000000 has 11 digits
  1962.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  1963.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  1964.         if (tmp64 >= 0x500000000ull) {
  1965.           // set invalid flag
  1966.           *pfpsf |= INVALID_EXCEPTION;
  1967.           // return Integer Indefinite
  1968.           res = 0x80000000;
  1969.           BID_RETURN (res);
  1970.         }
  1971.         // else cases that can be rounded to a 32-bit int fall through
  1972.         // to '1 <= q + exp <= 10'
  1973.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  1974.         // C * 10^(11-q) >= 0x500000000 <=>
  1975.         // C >= 0x500000000 * 10^(q-11) where 1 <= q - 11 <= 5
  1976.         // (scale 2^31-1 up)
  1977.         // Note: 0x500000000*10^(q-11) has q-1 or q digits, where q <= 16
  1978.         tmp64 = 0x500000000ull * ten2k64[q - 11];
  1979.         if (C1 >= tmp64) {
  1980.           // set invalid flag
  1981.           *pfpsf |= INVALID_EXCEPTION;
  1982.           // return Integer Indefinite
  1983.           res = 0x80000000;
  1984.           BID_RETURN (res);
  1985.         }
  1986.         // else cases that can be rounded to a 32-bit int fall through
  1987.         // to '1 <= q + exp <= 10'
  1988.       }
  1989.     }
  1990.   }
  1991.   // n is not too large to be converted to int32: -2^31 - 1 < n < 2^31
  1992.   // Note: some of the cases tested for above fall through to this point
  1993.   if ((q + exp) <= 0) { // n = +/-0.[0...0]c(0)c(1)...c(q-1)
  1994.     // set inexact flag
  1995.     *pfpsf |= INEXACT_EXCEPTION;
  1996.     // return 0
  1997.     res = 0x00000000;
  1998.     BID_RETURN (res);
  1999.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  2000.     // -2^31-1 < x <= -1 or 1 <= x < 2^31 so x can be rounded
  2001.     // to nearest to a 32-bit signed integer
  2002.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  2003.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  2004.       // chop off ind digits from the lower part of C1
  2005.       // C1 fits in 64 bits
  2006.       // calculate C* and f*
  2007.       // C* is actually floor(C*) in this case
  2008.       // C* and f* need shifting and masking, as shown by
  2009.       // shiftright128[] and maskhigh128[]
  2010.       // 1 <= x <= 15
  2011.       // kx = 10^(-x) = ten2mk64[ind - 1]
  2012.       // C* = C1 * 10^(-x)
  2013.       // the approximation of 10^(-x) was rounded up to 54 bits
  2014.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  2015.       Cstar = P128.w[1];
  2016.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  2017.       fstar.w[0] = P128.w[0];
  2018.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  2019.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  2020.       // C* = floor(C*) (logical right shift; C has p decimal digits,
  2021.       //     correct by Property 1)
  2022.       // n = C* * 10^(e+x)
  2023.  
  2024.       // shift right C* by Ex-64 = shiftright128[ind]
  2025.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  2026.       Cstar = Cstar >> shift;
  2027.       // determine inexactness of the rounding of C*
  2028.       // if (0 < f* < 10^(-x)) then
  2029.       //   the result is exact
  2030.       // else // if (f* > T*) then
  2031.       //   the result is inexact
  2032.       if (ind - 1 <= 2) {
  2033.         if (fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  2034.           // ten2mk128trunc[ind -1].w[1] is identical to
  2035.           // ten2mk128[ind -1].w[1]
  2036.           // set the inexact flag
  2037.           *pfpsf |= INEXACT_EXCEPTION;
  2038.         }       // else the result is exact
  2039.       } else {  // if 3 <= ind - 1 <= 14
  2040.         if (fstar.w[1] || fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  2041.           // ten2mk128trunc[ind -1].w[1] is identical to
  2042.           // ten2mk128[ind -1].w[1]
  2043.           // set the inexact flag
  2044.           *pfpsf |= INEXACT_EXCEPTION;
  2045.         }       // else the result is exact
  2046.       }
  2047.  
  2048.       if (x_sign)
  2049.         res = -Cstar;
  2050.       else
  2051.         res = Cstar;
  2052.     } else if (exp == 0) {
  2053.       // 1 <= q <= 10
  2054.       // res = +/-C (exact)
  2055.       if (x_sign)
  2056.         res = -C1;
  2057.       else
  2058.         res = C1;
  2059.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  2060.       // res = +/-C * 10^exp (exact)
  2061.       if (x_sign)
  2062.         res = -C1 * ten2k64[exp];
  2063.       else
  2064.         res = C1 * ten2k64[exp];
  2065.     }
  2066.   }
  2067.   BID_RETURN (res);
  2068. }
  2069.  
  2070. /*****************************************************************************
  2071.  *  BID64_to_int32_rninta
  2072.  ****************************************************************************/
  2073.  
  2074. #if DECIMAL_CALL_BY_REFERENCE
  2075. void
  2076. bid64_to_int32_rninta (int *pres,
  2077.                        UINT64 *
  2078.                        px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  2079.                        _EXC_INFO_PARAM) {
  2080.   UINT64 x = *px;
  2081. #else
  2082. int
  2083. bid64_to_int32_rninta (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  2084.                        _EXC_INFO_PARAM) {
  2085. #endif
  2086.   int res;
  2087.   UINT64 x_sign;
  2088.   UINT64 x_exp;
  2089.   int exp;                      // unbiased exponent
  2090.   // Note: C1 represents x_significand (UINT64)
  2091.   UINT64 tmp64;
  2092.   BID_UI64DOUBLE tmp1;
  2093.   unsigned int x_nr_bits;
  2094.   int q, ind, shift;
  2095.   UINT64 C1;
  2096.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  2097.   UINT128 P128;
  2098.  
  2099.   // check for NaN or Infinity
  2100.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  2101.     // set invalid flag
  2102.     *pfpsf |= INVALID_EXCEPTION;
  2103.     // return Integer Indefinite
  2104.     res = 0x80000000;
  2105.     BID_RETURN (res);
  2106.   }
  2107.   // unpack x
  2108.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  2109.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  2110.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  2111.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  2112.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  2113.     if (C1 > 9999999999999999ull) {     // non-canonical
  2114.       x_exp = 0;
  2115.       C1 = 0;
  2116.     }
  2117.   } else {
  2118.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  2119.     C1 = x & MASK_BINARY_SIG1;
  2120.   }
  2121.  
  2122.   // check for zeros (possibly from non-canonical values)
  2123.   if (C1 == 0x0ull) {
  2124.     // x is 0
  2125.     res = 0x00000000;
  2126.     BID_RETURN (res);
  2127.   }
  2128.   // x is not special and is not zero
  2129.  
  2130.   // q = nr. of decimal digits in x (1 <= q <= 54)
  2131.   //  determine first the nr. of bits in x
  2132.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  2133.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  2134.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  2135.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  2136.       x_nr_bits =
  2137.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  2138.     } else {    // x < 2^32
  2139.       tmp1.d = (double) C1;     // exact conversion
  2140.       x_nr_bits =
  2141.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  2142.     }
  2143.   } else {      // if x < 2^53
  2144.     tmp1.d = (double) C1;       // exact conversion
  2145.     x_nr_bits =
  2146.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  2147.   }
  2148.   q = nr_digits[x_nr_bits - 1].digits;
  2149.   if (q == 0) {
  2150.     q = nr_digits[x_nr_bits - 1].digits1;
  2151.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  2152.       q++;
  2153.   }
  2154.   exp = x_exp - 398;    // unbiased exponent
  2155.  
  2156.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  2157.     // set invalid flag
  2158.     *pfpsf |= INVALID_EXCEPTION;
  2159.     // return Integer Indefinite
  2160.     res = 0x80000000;
  2161.     BID_RETURN (res);
  2162.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  2163.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  2164.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  2165.     // the cases that do not fit are identified here; the ones that fit
  2166.     // fall through and will be handled with other cases further,
  2167.     // under '1 <= q + exp <= 10'
  2168.     if (x_sign) {       // if n < 0 and q + exp = 10
  2169.       // if n <= -2^31 - 1/2 then n is too large
  2170.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31+1/2
  2171.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x500000005, 1<=q<=16
  2172.       // <=> C * 10^(11-q) >= 0x500000005, 1<=q<=16
  2173.       if (q <= 11) {
  2174.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  2175.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  2176.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  2177.         if (tmp64 >= 0x500000005ull) {
  2178.           // set invalid flag
  2179.           *pfpsf |= INVALID_EXCEPTION;
  2180.           // return Integer Indefinite
  2181.           res = 0x80000000;
  2182.           BID_RETURN (res);
  2183.         }
  2184.         // else cases that can be rounded to a 32-bit int fall through
  2185.         // to '1 <= q + exp <= 10'
  2186.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  2187.         // C * 10^(11-q) >= 0x500000005 <=>
  2188.         // C >= 0x500000005 * 10^(q-11) where 1 <= q - 11 <= 5
  2189.         // (scale 2^31+1/2 up)
  2190.         // Note: 0x500000005*10^(q-11) has q-1 or q digits, where q <= 16
  2191.         tmp64 = 0x500000005ull * ten2k64[q - 11];
  2192.         if (C1 >= tmp64) {
  2193.           // set invalid flag
  2194.           *pfpsf |= INVALID_EXCEPTION;
  2195.           // return Integer Indefinite
  2196.           res = 0x80000000;
  2197.           BID_RETURN (res);
  2198.         }
  2199.         // else cases that can be rounded to a 32-bit int fall through
  2200.         // to '1 <= q + exp <= 10'
  2201.       }
  2202.     } else {    // if n > 0 and q + exp = 10
  2203.       // if n >= 2^31 - 1/2 then n is too large
  2204.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31-1/2
  2205.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x4fffffffb, 1<=q<=16
  2206.       // <=> C * 10^(11-q) >= 0x4fffffffb, 1<=q<=16
  2207.       if (q <= 11) {
  2208.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  2209.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  2210.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  2211.         if (tmp64 >= 0x4fffffffbull) {
  2212.           // set invalid flag
  2213.           *pfpsf |= INVALID_EXCEPTION;
  2214.           // return Integer Indefinite
  2215.           res = 0x80000000;
  2216.           BID_RETURN (res);
  2217.         }
  2218.         // else cases that can be rounded to a 32-bit int fall through
  2219.         // to '1 <= q + exp <= 10'
  2220.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  2221.         // C * 10^(11-q) >= 0x4fffffffb <=>
  2222.         // C >= 0x4fffffffb * 10^(q-11) where 1 <= q - 11 <= 5
  2223.         // (scale 2^31-1/2 up)
  2224.         // Note: 0x4fffffffb*10^(q-11) has q-1 or q digits, where q <= 16
  2225.         tmp64 = 0x4fffffffbull * ten2k64[q - 11];
  2226.         if (C1 >= tmp64) {
  2227.           // set invalid flag
  2228.           *pfpsf |= INVALID_EXCEPTION;
  2229.           // return Integer Indefinite
  2230.           res = 0x80000000;
  2231.           BID_RETURN (res);
  2232.         }
  2233.         // else cases that can be rounded to a 32-bit int fall through
  2234.         // to '1 <= q + exp <= 10'
  2235.       }
  2236.     }
  2237.   }
  2238.   // n is not too large to be converted to int32: -2^31 - 1/2 < n < 2^31 - 1/2
  2239.   // Note: some of the cases tested for above fall through to this point
  2240.   if ((q + exp) < 0) {  // n = +/-0.0...c(0)c(1)...c(q-1)
  2241.     // return 0
  2242.     res = 0x00000000;
  2243.     BID_RETURN (res);
  2244.   } else if ((q + exp) == 0) {  // n = +/-0.c(0)c(1)...c(q-1)
  2245.     // if 0.c(0)c(1)...c(q-1) <= 0.5 <=> c(0)c(1)...c(q-1) <= 5 * 10^(q-1)
  2246.     //   res = 0
  2247.     // else
  2248.     //   res = +/-1
  2249.     ind = q - 1;
  2250.     if (C1 < midpoint64[ind]) {
  2251.       res = 0x00000000; // return 0
  2252.     } else if (x_sign) {        // n < 0
  2253.       res = 0xffffffff; // return -1
  2254.     } else {    // n > 0
  2255.       res = 0x00000001; // return +1
  2256.     }
  2257.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  2258.     // -2^31-1/2 <= x <= -1 or 1 <= x < 2^31-1/2 so x can be rounded
  2259.     // to nearest away to a 32-bit signed integer
  2260.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  2261.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  2262.       // chop off ind digits from the lower part of C1
  2263.       // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 64 bits
  2264.       C1 = C1 + midpoint64[ind - 1];
  2265.       // calculate C* and f*
  2266.       // C* is actually floor(C*) in this case
  2267.       // C* and f* need shifting and masking, as shown by
  2268.       // shiftright128[] and maskhigh128[]
  2269.       // 1 <= x <= 15
  2270.       // kx = 10^(-x) = ten2mk64[ind - 1]
  2271.       // C* = (C1 + 1/2 * 10^x) * 10^(-x)
  2272.       // the approximation of 10^(-x) was rounded up to 54 bits
  2273.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  2274.       Cstar = P128.w[1];
  2275.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  2276.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  2277.       // C* = floor(C*)-1 (logical right shift; C* has p decimal digits,
  2278.       // correct by Pr. 1)
  2279.       // n = C* * 10^(e+x)
  2280.  
  2281.       // shift right C* by Ex-64 = shiftright128[ind]
  2282.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  2283.       Cstar = Cstar >> shift;
  2284.  
  2285.       // if the result was a midpoint it was rounded away from zero
  2286.       if (x_sign)
  2287.         res = -Cstar;
  2288.       else
  2289.         res = Cstar;
  2290.     } else if (exp == 0) {
  2291.       // 1 <= q <= 10
  2292.       // res = +/-C (exact)
  2293.       if (x_sign)
  2294.         res = -C1;
  2295.       else
  2296.         res = C1;
  2297.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  2298.       // res = +/-C * 10^exp (exact)
  2299.       if (x_sign)
  2300.         res = -C1 * ten2k64[exp];
  2301.       else
  2302.         res = C1 * ten2k64[exp];
  2303.     }
  2304.   }
  2305.   BID_RETURN (res);
  2306. }
  2307.  
  2308. /*****************************************************************************
  2309.  *  BID64_to_int32_xrninta
  2310.  ****************************************************************************/
  2311.  
  2312. #if DECIMAL_CALL_BY_REFERENCE
  2313. void
  2314. bid64_to_int32_xrninta (int *pres,
  2315.                         UINT64 *
  2316.                         px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  2317.                         _EXC_INFO_PARAM) {
  2318.   UINT64 x = *px;
  2319. #else
  2320. int
  2321. bid64_to_int32_xrninta (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  2322.                         _EXC_INFO_PARAM) {
  2323. #endif
  2324.   int res;
  2325.   UINT64 x_sign;
  2326.   UINT64 x_exp;
  2327.   int exp;                      // unbiased exponent
  2328.   // Note: C1 represents x_significand (UINT64)
  2329.   UINT64 tmp64;
  2330.   BID_UI64DOUBLE tmp1;
  2331.   unsigned int x_nr_bits;
  2332.   int q, ind, shift;
  2333.   UINT64 C1;
  2334.   UINT64 Cstar;                 // C* represents up to 16 decimal digits ~ 54 bits
  2335.   UINT128 fstar;
  2336.   UINT128 P128;
  2337.  
  2338.   // check for NaN or Infinity
  2339.   if ((x & MASK_NAN) == MASK_NAN || (x & MASK_INF) == MASK_INF) {
  2340.     // set invalid flag
  2341.     *pfpsf |= INVALID_EXCEPTION;
  2342.     // return Integer Indefinite
  2343.     res = 0x80000000;
  2344.     BID_RETURN (res);
  2345.   }
  2346.   // unpack x
  2347.   x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative
  2348.   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  2349.   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  2350.     x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased
  2351.     C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  2352.     if (C1 > 9999999999999999ull) {     // non-canonical
  2353.       x_exp = 0;
  2354.       C1 = 0;
  2355.     }
  2356.   } else {
  2357.     x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased
  2358.     C1 = x & MASK_BINARY_SIG1;
  2359.   }
  2360.  
  2361.   // check for zeros (possibly from non-canonical values)
  2362.   if (C1 == 0x0ull) {
  2363.     // x is 0
  2364.     res = 0x00000000;
  2365.     BID_RETURN (res);
  2366.   }
  2367.   // x is not special and is not zero
  2368.  
  2369.   // q = nr. of decimal digits in x (1 <= q <= 54)
  2370.   //  determine first the nr. of bits in x
  2371.   if (C1 >= 0x0020000000000000ull) {    // x >= 2^53
  2372.     // split the 64-bit value in two 32-bit halves to avoid rounding errors
  2373.     if (C1 >= 0x0000000100000000ull) {  // x >= 2^32
  2374.       tmp1.d = (double) (C1 >> 32);     // exact conversion
  2375.       x_nr_bits =
  2376.         33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  2377.     } else {    // x < 2^32
  2378.       tmp1.d = (double) C1;     // exact conversion
  2379.       x_nr_bits =
  2380.         1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  2381.     }
  2382.   } else {      // if x < 2^53
  2383.     tmp1.d = (double) C1;       // exact conversion
  2384.     x_nr_bits =
  2385.       1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
  2386.   }
  2387.   q = nr_digits[x_nr_bits - 1].digits;
  2388.   if (q == 0) {
  2389.     q = nr_digits[x_nr_bits - 1].digits1;
  2390.     if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
  2391.       q++;
  2392.   }
  2393.   exp = x_exp - 398;    // unbiased exponent
  2394.  
  2395.   if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits)
  2396.     // set invalid flag
  2397.     *pfpsf |= INVALID_EXCEPTION;
  2398.     // return Integer Indefinite
  2399.     res = 0x80000000;
  2400.     BID_RETURN (res);
  2401.   } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1)
  2402.     // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2...
  2403.     // so x rounded to an integer may or may not fit in a signed 32-bit int
  2404.     // the cases that do not fit are identified here; the ones that fit
  2405.     // fall through and will be handled with other cases further,
  2406.     // under '1 <= q + exp <= 10'
  2407.     if (x_sign) {       // if n < 0 and q + exp = 10
  2408.       // if n <= -2^31 - 1/2 then n is too large
  2409.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31+1/2
  2410.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x500000005, 1<=q<=16
  2411.       // <=> C * 10^(11-q) >= 0x500000005, 1<=q<=16
  2412.       if (q <= 11) {
  2413.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  2414.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  2415.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  2416.         if (tmp64 >= 0x500000005ull) {
  2417.           // set invalid flag
  2418.           *pfpsf |= INVALID_EXCEPTION;
  2419.           // return Integer Indefinite
  2420.           res = 0x80000000;
  2421.           BID_RETURN (res);
  2422.         }
  2423.         // else cases that can be rounded to a 32-bit int fall through
  2424.         // to '1 <= q + exp <= 10'
  2425.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  2426.         // C * 10^(11-q) >= 0x500000005 <=>
  2427.         // C >= 0x500000005 * 10^(q-11) where 1 <= q - 11 <= 5
  2428.         // (scale 2^31+1/2 up)
  2429.         // Note: 0x500000005*10^(q-11) has q-1 or q digits, where q <= 16
  2430.         tmp64 = 0x500000005ull * ten2k64[q - 11];
  2431.         if (C1 >= tmp64) {
  2432.           // set invalid flag
  2433.           *pfpsf |= INVALID_EXCEPTION;
  2434.           // return Integer Indefinite
  2435.           res = 0x80000000;
  2436.           BID_RETURN (res);
  2437.         }
  2438.         // else cases that can be rounded to a 32-bit int fall through
  2439.         // to '1 <= q + exp <= 10'
  2440.       }
  2441.     } else {    // if n > 0 and q + exp = 10
  2442.       // if n >= 2^31 - 1/2 then n is too large
  2443.       // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^31-1/2
  2444.       // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x4fffffffb, 1<=q<=16
  2445.       // <=> C * 10^(11-q) >= 0x4fffffffb, 1<=q<=16
  2446.       if (q <= 11) {
  2447.         // Note: C * 10^(11-q) has 10 or 11 digits; 0x500000005 has 11 digits
  2448.         tmp64 = C1 * ten2k64[11 - q];   // C scaled up to 11-digit int
  2449.         // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits)
  2450.         if (tmp64 >= 0x4fffffffbull) {
  2451.           // set invalid flag
  2452.           *pfpsf |= INVALID_EXCEPTION;
  2453.           // return Integer Indefinite
  2454.           res = 0x80000000;
  2455.           BID_RETURN (res);
  2456.         }
  2457.         // else cases that can be rounded to a 32-bit int fall through
  2458.         // to '1 <= q + exp <= 10'
  2459.       } else {  // if (q > 11), i.e. 12 <= q <= 16 and so -15 <= exp <= -2
  2460.         // C * 10^(11-q) >= 0x4fffffffb <=>
  2461.         // C >= 0x4fffffffb * 10^(q-11) where 1 <= q - 11 <= 5
  2462.         // (scale 2^31-1/2 up)
  2463.         // Note: 0x4fffffffb*10^(q-11) has q-1 or q digits, where q <= 16
  2464.         tmp64 = 0x4fffffffbull * ten2k64[q - 11];
  2465.         if (C1 >= tmp64) {
  2466.           // set invalid flag
  2467.           *pfpsf |= INVALID_EXCEPTION;
  2468.           // return Integer Indefinite
  2469.           res = 0x80000000;
  2470.           BID_RETURN (res);
  2471.         }
  2472.         // else cases that can be rounded to a 32-bit int fall through
  2473.         // to '1 <= q + exp <= 10'
  2474.       }
  2475.     }
  2476.   }
  2477.   // n is not too large to be converted to int32: -2^31 - 1/2 < n < 2^31 - 1/2
  2478.   // Note: some of the cases tested for above fall through to this point
  2479.   if ((q + exp) < 0) {  // n = +/-0.0...c(0)c(1)...c(q-1)
  2480.     // set inexact flag
  2481.     *pfpsf |= INEXACT_EXCEPTION;
  2482.     // return 0
  2483.     res = 0x00000000;
  2484.     BID_RETURN (res);
  2485.   } else if ((q + exp) == 0) {  // n = +/-0.c(0)c(1)...c(q-1)
  2486.     // if 0.c(0)c(1)...c(q-1) <= 0.5 <=> c(0)c(1)...c(q-1) <= 5 * 10^(q-1)
  2487.     //   res = 0
  2488.     // else
  2489.     //   res = +/-1
  2490.     ind = q - 1;
  2491.     if (C1 < midpoint64[ind]) {
  2492.       res = 0x00000000; // return 0
  2493.     } else if (x_sign) {        // n < 0
  2494.       res = 0xffffffff; // return -1
  2495.     } else {    // n > 0
  2496.       res = 0x00000001; // return +1
  2497.     }
  2498.     // set inexact flag
  2499.     *pfpsf |= INEXACT_EXCEPTION;
  2500.   } else {      // if (1 <= q + exp <= 10, 1 <= q <= 16, -15 <= exp <= 9)
  2501.     // -2^31-1/2 <= x <= -1 or 1 <= x < 2^31-1/2 so x can be rounded
  2502.     // to nearest away to a 32-bit signed integer
  2503.     if (exp < 0) {      // 2 <= q <= 16, -15 <= exp <= -1, 1 <= q + exp <= 10
  2504.       ind = -exp;       // 1 <= ind <= 15; ind is a synonym for 'x'
  2505.       // chop off ind digits from the lower part of C1
  2506.       // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 64 bits
  2507.       C1 = C1 + midpoint64[ind - 1];
  2508.       // calculate C* and f*
  2509.       // C* is actually floor(C*) in this case
  2510.       // C* and f* need shifting and masking, as shown by
  2511.       // shiftright128[] and maskhigh128[]
  2512.       // 1 <= x <= 15
  2513.       // kx = 10^(-x) = ten2mk64[ind - 1]
  2514.       // C* = (C1 + 1/2 * 10^x) * 10^(-x)
  2515.       // the approximation of 10^(-x) was rounded up to 54 bits
  2516.       __mul_64x64_to_128MACH (P128, C1, ten2mk64[ind - 1]);
  2517.       Cstar = P128.w[1];
  2518.       fstar.w[1] = P128.w[1] & maskhigh128[ind - 1];
  2519.       fstar.w[0] = P128.w[0];
  2520.       // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind].w[0], e.g.
  2521.       // if x=1, T*=ten2mk128trunc[0].w[0]=0x1999999999999999
  2522.       // C* = floor(C*)-1 (logical right shift; C* has p decimal digits,
  2523.       // correct by Pr. 1)
  2524.       // n = C* * 10^(e+x)
  2525.  
  2526.       // shift right C* by Ex-64 = shiftright128[ind]
  2527.       shift = shiftright128[ind - 1];   // 0 <= shift <= 39
  2528.       Cstar = Cstar >> shift;
  2529.       // determine inexactness of the rounding of C*
  2530.       // if (0 < f* - 1/2 < 10^(-x)) then
  2531.       //   the result is exact
  2532.       // else // if (f* - 1/2 > T*) then
  2533.       //   the result is inexact
  2534.       if (ind - 1 <= 2) {
  2535.         if (fstar.w[0] > 0x8000000000000000ull) {
  2536.           // f* > 1/2 and the result may be exact
  2537.           tmp64 = fstar.w[0] - 0x8000000000000000ull;   // f* - 1/2
  2538.           if ((tmp64 > ten2mk128trunc[ind - 1].w[1])) {
  2539.             // ten2mk128trunc[ind -1].w[1] is identical to
  2540.             // ten2mk128[ind -1].w[1]
  2541.             // set the inexact flag
  2542.             *pfpsf |= INEXACT_EXCEPTION;
  2543.           }     // else the result is exact
  2544.         } else {        // the result is inexact; f2* <= 1/2
  2545.           // set the inexact flag
  2546.           *pfpsf |= INEXACT_EXCEPTION;
  2547.         }
  2548.       } else {  // if 3 <= ind - 1 <= 14
  2549.         if (fstar.w[1] > onehalf128[ind - 1] ||
  2550.             (fstar.w[1] == onehalf128[ind - 1] && fstar.w[0])) {
  2551.           // f2* > 1/2 and the result may be exact
  2552.           // Calculate f2* - 1/2
  2553.           tmp64 = fstar.w[1] - onehalf128[ind - 1];
  2554.           if (tmp64 || fstar.w[0] > ten2mk128trunc[ind - 1].w[1]) {
  2555.             // ten2mk128trunc[ind -1].w[1] is identical to
  2556.             // ten2mk128[ind -1].w[1]
  2557.             // set the inexact flag
  2558.             *pfpsf |= INEXACT_EXCEPTION;
  2559.           }     // else the result is exact
  2560.         } else {        // the result is inexact; f2* <= 1/2
  2561.           // set the inexact flag
  2562.           *pfpsf |= INEXACT_EXCEPTION;
  2563.         }
  2564.       }
  2565.  
  2566.       // if the result was a midpoint it was rounded away from zero
  2567.       if (x_sign)
  2568.         res = -Cstar;
  2569.       else
  2570.         res = Cstar;
  2571.     } else if (exp == 0) {
  2572.       // 1 <= q <= 10
  2573.       // res = +/-C (exact)
  2574.       if (x_sign)
  2575.         res = -C1;
  2576.       else
  2577.         res = C1;
  2578.     } else {    // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10
  2579.       // res = +/-C * 10^exp (exact)
  2580.       if (x_sign)
  2581.         res = -C1 * ten2k64[exp];
  2582.       else
  2583.         res = C1 * ten2k64[exp];
  2584.     }
  2585.   }
  2586.   BID_RETURN (res);
  2587. }
  2588.