nsz Git - cparser/blob - win32/cygwin_math_ext.h

   1 /* Truncate argument to nearest integral value not larger than the argument.
   2    Copyright (C) 1997, 1999 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997 and
   5                   Jakub Jelinek <jj@ultra.linux.cz>, 1999.
   6
   7    The GNU C Library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Lesser General Public
   9    License as published by the Free Software Foundation; either
  10    version 2.1 of the License, or (at your option) any later version.
  11
  12    The GNU C Library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Lesser General Public License for more details.
  16
  17    You should have received a copy of the GNU Lesser General Public
  18    License along with the GNU C Library; if not, write to the Free
  19    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  20    02111-1307 USA.  */
  21
  22 #include <math.h>
  23
  24 /* On Cygwin it should be little endian. */
  25 #define __FLOAT_WORD_ORDER LITTLE_ENDIAN
  26
  27 /* A union which permits us to convert between a long double and
  28    four 32 bit ints or two 64 bit ints.  */
  29
  30 #if __FLOAT_WORD_ORDER == BIG_ENDIAN
  31
  32 typedef union
  33 {
  34         long double value;
  35         struct
  36         {
  37                 u_int64_t msw;
  38                 u_int64_t lsw;
  39         } parts64;
  40         struct
  41         {
  42                 u_int32_t w0, w1, w2, w3;
  43         } parts32;
  44 } ieee854_long_double_shape_type;
  45
  46 #endif
  47
  48 #if __FLOAT_WORD_ORDER == LITTLE_ENDIAN
  49
  50 typedef union
  51 {
  52         long double value;
  53         struct
  54         {
  55                 u_int64_t lsw;
  56                 u_int64_t msw;
  57         } parts64;
  58         struct
  59         {
  60                 u_int32_t w3, w2, w1, w0;
  61         } parts32;
  62 } ieee854_long_double_shape_type;
  63
  64 #endif
  65
  66 /* Get two 64 bit ints from a long double.  */
  67
  68 #define GET_LDOUBLE_WORDS64(ix0,ix1,d)                          \
  69 do {                                                            \
  70   ieee854_long_double_shape_type qw_u;                          \
  71   qw_u.value = (d);                                             \
  72   (ix0) = qw_u.parts64.msw;                                     \
  73   (ix1) = qw_u.parts64.lsw;                                     \
  74 } while (0)
  75
  76 /* Set a long double from two 64 bit ints.  */
  77
  78 #define SET_LDOUBLE_WORDS64(d,ix0,ix1)                          \
  79 do {                                                            \
  80   ieee854_long_double_shape_type qw_u;                          \
  81   qw_u.parts64.msw = (ix0);                                     \
  82   qw_u.parts64.lsw = (ix1);                                     \
  83   (d) = qw_u.value;                                             \
  84 } while (0)
  85
  86
  87 static long double truncl(long double x)
  88 {
  89         int32_t j0;
  90         u_int64_t i0, i1, sx;
  91
  92         GET_LDOUBLE_WORDS64 (i0, i1, x);
  93         sx = i0 & 0x8000000000000000ULL;
  94         j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
  95         if (j0 < 48)
  96         {
  97                 if (j0 < 0)
  98                         /* The magnitude of the number is < 1 so the result is +-0.  */
  99                         SET_LDOUBLE_WORDS64 (x, sx, 0);
 100                 else
 101                         SET_LDOUBLE_WORDS64 (x, i0 & ~(0x0000ffffffffffffLL >> j0), 0);
 102         }
 103         else if (j0 > 111)
 104         {
 105                 if (j0 == 0x4000)
 106                         /* x is inf or NaN.  */
 107                         return x + x;
 108         }
 109         else
 110         {
 111                 SET_LDOUBLE_WORDS64 (x, i0, i1 & ~(0xffffffffffffffffULL >> (j0 - 48)));
 112         }
 113
 114         return x;
 115 }