OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [libbid/] [bid64_to_int32.c] - Blame information for rev 734

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 734 jeremybenn 
/* Copyright (C) 2007, 2009  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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.