* src/fdlibm/s_finite.c,

src/fdlibm/fdlibm.h,
src/fdlibm/ieeefp.h,
src/fdlibm/e_fmod.c,
src/fdlibm/mprec.h,
src/fdlibm/w_fmod.c,
src/fdlibm/s_copysign.c: Updated from GNU Classpath.

diff --git a/src/fdlibm/e_fmod.c b/src/fdlibm/e_fmod.c
index 1cf099076668e48315f640403e520fea5ce22e36..e3dd4bf915d0ed1a63bbe46f51f4e4ddce0ac187 100644 (file)
--- a/src/fdlibm/e_fmod.c
+++ b/src/fdlibm/e_fmod.c
@@ -1,17 +1,17 @@
 
-/* @(#)e_fmod.c 5.1 93/09/24 */
+/* @(#)e_fmod.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
+ * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
-/*
+/* 
  * __ieee754_fmod(x,y)
  * Return x mod y in exact arithmetic
  * Method: shift and subtract
@@ -49,7 +49,7 @@ static double one = 1.0, Zero[] = {0.0, -0.0,};
            return (x*y)/(x*y);
        if(hx<=hy) {
            if((hx<hy)||(lx<ly)) return x;      /* |x|<|y| return x */
-           if(lx==ly)
+           if(lx==ly) 
                return Zero[(uint32_t)sx>>31];  /* |x|=|y| return x*0*/
        }
 
@@ -72,7 +72,7 @@ static double one = 1.0, Zero[] = {0.0, -0.0,};
        } else iy = (hy>>20)-1023;
 
     /* set up {hx,lx}, {hy,ly} and align y to x */
-       if(ix >= -1022)
+       if(ix >= -1022) 
            hx = 0x00100000|(0x000fffff&hx);
        else {          /* subnormal x, shift x to normal */
            n = -1022-ix;
@@ -84,7 +84,7 @@ static double one = 1.0, Zero[] = {0.0, -0.0,};
                lx = 0;
            }
        }
-       if(iy >= -1022)
+       if(iy >= -1022) 
            hy = 0x00100000|(0x000fffff&hy);
        else {          /* subnormal y, shift y to normal */
            n = -1022-iy;
@@ -113,7 +113,7 @@ static double one = 1.0, Zero[] = {0.0, -0.0,};
 
     /* convert back to floating value and restore the sign */
        if((hx|lx)==0)                  /* return sign(x)*0 */
-           return Zero[(uint32_t)sx>>31];
+           return Zero[(unsigned)sx>>31];      
        while(hx<0x00100000) {          /* normalize x */
            hx = hx+hx+(lx>>31); lx = lx+lx;
            iy -= 1;
@@ -136,5 +136,4 @@ static double one = 1.0, Zero[] = {0.0, -0.0,};
        }
        return x;               /* exact output */
 }
-
 #endif /* defined(_DOUBLE_IS_32BITS) */

diff --git a/src/fdlibm/fdlibm.h b/src/fdlibm/fdlibm.h
index 31ed8e42f1f129fcabbef89675b2c77a8a9dd7c5..c709601896126fdb09dddeb1f8b9edae1d722965 100644 (file)
--- a/src/fdlibm/fdlibm.h
+++ b/src/fdlibm/fdlibm.h
@@ -1,10 +1,9 @@
 
-/* @(#)fdlibm.h 5.1 93/09/24 */
+/* @(#)fdlibm.h 1.5 04/04/22 */
 /*
  * ====================================================
- * Copyright (C) 1993, 2000 by Sun Microsystems, Inc. All rights reserved.
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
  *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
@@ -24,6 +23,8 @@
 
 /* GCJ LOCAL: Include files.  */
 #include "ieeefp.h"
+/* CLASSPATH LOCAL: */
+/* #include "namespace.h" */
 
 #include "mprec.h"
 
@@ -34,15 +35,71 @@
 #undef __P
 #endif
 
+/* Sometimes it's necessary to define __LITTLE_ENDIAN explicitly
+   but these catch some common cases. */
+
+#if 0
+#if defined(i386) || defined(i486) || \
+       defined(intel) || defined(x86) || defined(i86pc) || \
+       defined(__alpha) || defined(__osf__)
+#define __LITTLE_ENDIAN
+#endif
+
+#ifdef __LITTLE_ENDIAN
+#define __HI(x) *(1+(int*)&x)
+#define __LO(x) *(int*)&x
+#define __HIp(x) *(1+(int*)x)
+#define __LOp(x) *(int*)x
+#else
+#define __HI(x) *(int*)&x
+#define __LO(x) *(1+(int*)&x)
+#define __HIp(x) *(int*)x
+#define __LOp(x) *(1+(int*)x)
+#endif
+#endif
+
 #ifdef __STDC__
 #define        __P(p)  p
 #else
 #define        __P(p)  ()
 #endif
 
-#ifndef HUGE
-#define        HUGE    ((float)3.40282346638528860e+38)
-#endif
+/*
+ * ANSI/POSIX
+ */
+
+extern int signgam;
+
+#define        MAXFLOAT        ((float)3.40282346638528860e+38)
+
+enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix};
+
+#define _LIB_VERSION_TYPE enum fdversion
+#define _LIB_VERSION _fdlib_version  
+
+/* if global variable _LIB_VERSION is not desirable, one may 
+ * change the following to be a constant by: 
+ *     #define _LIB_VERSION_TYPE const enum version
+ * In that case, after one initializes the value _LIB_VERSION (see
+ * s_lib_version.c) during compile time, it cannot be modified
+ * in the middle of a program
+ */ 
+extern  _LIB_VERSION_TYPE  _LIB_VERSION;
+
+#define _IEEE_  fdlibm_ieee
+#define _SVID_  fdlibm_svid
+#define _XOPEN_ fdlibm_xopen
+#define _POSIX_ fdlibm_posix
+
+struct exception {
+       int type;
+       char *name;
+       double arg1;
+       double arg2;
+       double retval;
+};
+
+#define        HUGE            MAXFLOAT
 
 /* 
  * set X_TLOSS = pi*2**52, which is possibly defined in <values.h>
@@ -51,6 +108,13 @@
 
 #define X_TLOSS                1.41484755040568800000e+16 
 
+#define        DOMAIN          1
+#define        SING            2
+#define        OVERFLOW        3
+#define        UNDERFLOW       4
+#define        TLOSS           5
+#define        PLOSS           6
+
 /* These typedefs are true for the targets running Java. */
 
 #define _IEEE_LIBM
@@ -62,123 +126,241 @@ extern "C" {
 /*
  * ANSI/POSIX
  */
-#if !defined(isnan) && !defined(HAVE_ISNAN)
+extern double acos __P((double));
+extern double asin __P((double));
+extern double atan __P((double));
+extern double atan2 __P((double, double));
+extern double cos __P((double));
+extern double sin __P((double));
+extern double tan __P((double));
+
+extern double cosh __P((double));
+extern double sinh __P((double));
+extern double tanh __P((double));
+
+extern double exp __P((double));
+extern double frexp __P((double, int *));
+extern double ldexp __P((double, int));
+extern double log __P((double));
+extern double log10 __P((double));
+extern double modf __P((double, double *));
+
+extern double pow __P((double, double));
+extern double sqrt __P((double));
+
+extern double ceil __P((double));
+extern double fabs __P((double));
+extern double floor __P((double));
+extern double fmod __P((double, double));
+
+extern double erf __P((double));
+extern double erfc __P((double));
+extern double gamma __P((double));
+extern double hypot __P((double, double));
+
+#if !defined(isnan)
 #define isnan(x) ((x) != (x))
 #endif
 
-/* ieee style elementary functions */
-extern double __ieee754_fmod __P((double,double));
+extern int finite __P((double));
+extern double j0 __P((double));
+extern double j1 __P((double));
+extern double jn __P((int, double));
+extern double lgamma __P((double));
+extern double y0 __P((double));
+extern double y1 __P((double));
+extern double yn __P((int, double));
+
+extern double acosh __P((double));
+extern double asinh __P((double));
+extern double atanh __P((double));
+extern double cbrt __P((double));
+extern double logb __P((double));
+extern double nextafter __P((double, double));
+extern double remainder __P((double, double));
+#ifdef _SCALB_INT
+extern double scalb __P((double, int));
+#else
+extern double scalb __P((double, double));
+#endif
+
+extern int matherr __P((struct exception *));
+
+/*
+ * IEEE Test Vector
+ */
+extern double significand __P((double));
 
 /*
  * Functions callable from C, intended to support IEEE arithmetic.
  */
 extern double copysign __P((double, double));
+extern int ilogb __P((double));
+extern double rint __P((double));
+extern double scalbn __P((double, int));
 
-/* The original code used statements like
-       n0 = ((*(int*)&one)>>29)^1;             * index of high word *
-       ix0 = *(n0+(int*)&x);                   * high word of x *
-       ix1 = *((1-n0)+(int*)&x);               * low word of x *
-   to dig two 32 bit words out of the 64 bit IEEE floating point
-   value.  That is non-ANSI, and, moreover, the gcc instruction
-   scheduler gets it wrong.  We instead use the following macros.
-   Unlike the original code, we determine the endianness at compile
-   time, not at run time; I don't see much benefit to selecting
-   endianness at run time.  */
-
-#ifndef __IEEE_BIG_ENDIAN
-#ifndef __IEEE_LITTLE_ENDIAN
- #error Must define endianness
-#endif
-#endif
-
-/* A union which permits us to convert between a double and two 32 bit
-   ints.  */
-
-#ifdef __IEEE_BIG_ENDIAN
-
-typedef union 
-{
-  double value;
-  struct 
-  {
-    uint32_t msw;
-    uint32_t lsw;
-  } parts;
-} ieee_double_shape_type;
-
-#endif
-
-#ifdef __IEEE_LITTLE_ENDIAN
+/*
+ * BSD math library entry points
+ */
+extern double expm1 __P((double));
+extern double log1p __P((double));
 
-typedef union 
-{
-  double value;
-  struct 
-  {
-    uint32_t lsw;
-    uint32_t msw;
-  } parts;
-} ieee_double_shape_type;
+/*
+ * Reentrant version of gamma & lgamma; passes signgam back by reference
+ * as the second argument; user must allocate space for signgam.
+ */
+#ifdef _REENTRANT
+extern double gamma_r __P((double, int *));
+extern double lgamma_r __P((double, int *));
+#endif /* _REENTRANT */
 
+/* ieee style elementary functions */
+extern double __ieee754_sqrt __P((double));                    
+extern double __ieee754_acos __P((double));                    
+extern double __ieee754_acosh __P((double));                   
+extern double __ieee754_log __P((double));                     
+extern double __ieee754_atanh __P((double));                   
+extern double __ieee754_asin __P((double));                    
+extern double __ieee754_atan2 __P((double,double));                    
+extern double __ieee754_exp __P((double));
+extern double __ieee754_cosh __P((double));
+extern double __ieee754_fmod __P((double,double));
+extern double __ieee754_pow __P((double,double));
+extern double __ieee754_lgamma_r __P((double,int *));
+extern double __ieee754_gamma_r __P((double,int *));
+extern double __ieee754_lgamma __P((double));
+extern double __ieee754_gamma __P((double));
+extern double __ieee754_log10 __P((double));
+extern double __ieee754_sinh __P((double));
+extern double __ieee754_hypot __P((double,double));
+extern double __ieee754_j0 __P((double));
+extern double __ieee754_j1 __P((double));
+extern double __ieee754_y0 __P((double));
+extern double __ieee754_y1 __P((double));
+extern double __ieee754_jn __P((int,double));
+extern double __ieee754_yn __P((int,double));
+extern double __ieee754_remainder __P((double,double));
+extern int32_t    __ieee754_rem_pio2 __P((double,double*));
+#ifdef _SCALB_INT
+extern double __ieee754_scalb __P((double,int));
+#else
+extern double __ieee754_scalb __P((double,double));
 #endif
 
-/* Get two 32 bit ints from a double.  */
-
-#define EXTRACT_WORDS(ix0,ix1,d)                               \
-do {                                                           \
-  ieee_double_shape_type ew_u;                                 \
-  ew_u.value = (d);                                            \
-  (ix0) = ew_u.parts.msw;                                      \
-  (ix1) = ew_u.parts.lsw;                                      \
-} while (0)
-
-/* Get the more significant 32 bit int from a double.  */
-
-#define GET_HIGH_WORD(i,d)                                     \
-do {                                                           \
-  ieee_double_shape_type gh_u;                                 \
-  gh_u.value = (d);                                            \
-  (i) = gh_u.parts.msw;                                                \
-} while (0)
-
-/* Get the less significant 32 bit int from a double.  */
-
-#define GET_LOW_WORD(i,d)                                      \
-do {                                                           \
-  ieee_double_shape_type gl_u;                                 \
-  gl_u.value = (d);                                            \
-  (i) = gl_u.parts.lsw;                                                \
-} while (0)
-
-/* Set a double from two 32 bit ints.  */
-
-#define INSERT_WORDS(d,ix0,ix1)                                        \
-do {                                                           \
-  ieee_double_shape_type iw_u;                                 \
-  iw_u.parts.msw = (ix0);                                      \
-  iw_u.parts.lsw = (ix1);                                      \
-  (d) = iw_u.value;                                            \
-} while (0)
-
-/* Set the more significant 32 bits of a double from an int.  */
-
-#define SET_HIGH_WORD(d,v)                                     \
-do {                                                           \
-  ieee_double_shape_type sh_u;                                 \
-  sh_u.value = (d);                                            \
-  sh_u.parts.msw = (v);                                                \
-  (d) = sh_u.value;                                            \
-} while (0)
-
-/* Set the less significant 32 bits of a double from an int.  */
-
-#define SET_LOW_WORD(d,v)                                      \
-do {                                                           \
-  ieee_double_shape_type sl_u;                                 \
-  sl_u.value = (d);                                            \
-  sl_u.parts.lsw = (v);                                                \
-  (d) = sl_u.value;                                            \
-} while (0)
+/* fdlibm kernel function */
+extern double __kernel_standard __P((double,double,int));      
+extern double __kernel_sin __P((double,double,int));
+extern double __kernel_cos __P((double,double));
+extern double __kernel_tan __P((double,double,int));
+extern int    __kernel_rem_pio2 __P((double*,double*,int,int,int,const int*));
+
+/* Classpath extensions */
+
+/* The original code used statements like  
+   n0 = ((*(int*)&one)>>29)^1;             * index of high word *  
+   ix0 = *(n0+(int*)&x);                   * high word of x *  
+   ix1 = *((1-n0)+(int*)&x);               * low word of x *  
+   to dig two 32 bit words out of the 64 bit IEEE floating point  
+   value.  That is non-ANSI, and, moreover, the gcc instruction  
+   scheduler gets it wrong.  We instead use the following macros.  
+   Unlike the original code, we determine the endianness at compile  
+   time, not at run time; I don't see much benefit to selecting  
+   endianness at run time.  */  
+   
+#ifndef __IEEE_BIG_ENDIAN  
+#ifndef __IEEE_LITTLE_ENDIAN  
+#error Must define endianness  
+#endif  
+#endif  
+   
+/* A union which permits us to convert between a double and two 32 bit  
+   ints.  */  
+   
+#ifdef __IEEE_BIG_ENDIAN  
+   
+  typedef union  
+  {  
+    double value;  
+    struct  
+    {  
+      uint32_t msw;  
+      uint32_t lsw;  
+    } parts;  
+  } ieee_double_shape_type;  
+   
+#endif  
+   
+#ifdef __IEEE_LITTLE_ENDIAN  
+   
+  typedef union  
+  {  
+    double value;  
+    struct  
+    {  
+      uint32_t lsw;  
+      uint32_t msw;  
+    } parts;  
+  } ieee_double_shape_type;  
+   
+#endif  
+   
+  /* Get two 32 bit ints from a double.  */  
+   
+#define EXTRACT_WORDS(ix0,ix1,d)                                  \
+  do {                                                            \
+    ieee_double_shape_type ew_u;                                  \
+    ew_u.value = (d);                                             \
+    (ix0) = ew_u.parts.msw;                                       \
+    (ix1) = ew_u.parts.lsw;                                       \
+  } while (0)  
+        
+/* Get the more significant 32 bit int from a double.  */  
+        
+#define GET_HIGH_WORD(i,d)                                      \
+  do {                                                            \
+    ieee_double_shape_type gh_u;                                  \
+    gh_u.value = (d);                                             \
+    (i) = gh_u.parts.msw;                                         \
+  } while (0)  
+        
+/* Get the less significant 32 bit int from a double.  */  
+        
+#define GET_LOW_WORD(i,d)                                       \
+  do {                                                            \
+    ieee_double_shape_type gl_u;                                  \
+    gl_u.value = (d);                                             \
+    (i) = gl_u.parts.lsw;                                         \
+  } while (0)  
+        
+/* Set a double from two 32 bit ints.  */  
+        
+#define INSERT_WORDS(d,ix0,ix1)                                 \
+  do {                                                            \
+    ieee_double_shape_type iw_u;                                  \
+    iw_u.parts.msw = (ix0);                                       \
+    iw_u.parts.lsw = (ix1);                                       \
+    (d) = iw_u.value;                                             \
+  } while (0)  
+        
+/* Set the more significant 32 bits of a double from an int.  */  
+        
+#define SET_HIGH_WORD(d,v)                                      \
+  do {                                                            \
+    ieee_double_shape_type sh_u;                                  \
+    sh_u.value = (d);                                             \
+    sh_u.parts.msw = (v);                                         \
+    (d) = sh_u.value;                                             \
+  } while (0)  
+        
+/* Set the less significant 32 bits of a double from an int.  */  
+        
+#define SET_LOW_WORD(d,v)                                       \
+  do {                                                            \
+    ieee_double_shape_type sl_u;                                  \
+    sl_u.value = (d);                                             \
+    sl_u.parts.lsw = (v);                                         \
+    (d) = sl_u.value;                                             \
+  } while (0)  
 
 /* A union which permits us to convert between a float and a 32 bit
    int.  */
@@ -212,3 +394,4 @@ do {                                                                \
 #endif
 
 #endif /* __CLASSPATH_FDLIBM_H__ */
+

diff --git a/src/fdlibm/ieeefp.h b/src/fdlibm/ieeefp.h
index 145a55b99a019778f864a50ecddf31babd20ce92..17ff86bff138c51a4f343156b8addb0a306903dd 100644 (file)
--- a/src/fdlibm/ieeefp.h
+++ b/src/fdlibm/ieeefp.h
@@ -123,9 +123,8 @@
 #define __IEEE_LITTLE_ENDIAN
 #endif
 
-#if defined (__PPC__) || defined (__ppc__) || defined (__ppc64__)
-#if (defined(_BIG_ENDIAN) && _BIG_ENDIAN) || (defined(_AIX) && _AIX) \
-    || defined (__APPLE__)
+#if defined (__PPC__) || defined (__ppc__) || defined (__powerpc__) || defined (__ppc64__) || defined (_POWER) || defined (_IBMR2)
+#if (defined(_BIG_ENDIAN) && _BIG_ENDIAN) || (defined(_AIX) && _AIX) || defined (__BIG_ENDIAN__)|| defined (__APPLE__)
 #define __IEEE_BIG_ENDIAN
 #else
 #if (defined(_LITTLE_ENDIAN) && _LITTLE_ENDIAN) || (defined(__sun__) && __sun__) || (defined(__WIN32__) && __WIN32__)

diff --git a/src/fdlibm/mprec.h b/src/fdlibm/mprec.h
index 9e1a106dad100755013e32093b033ac10874ac3a..a797890e8000cf8428257ef2a299e9ae5e7c083e 100644 (file)
--- a/src/fdlibm/mprec.h
+++ b/src/fdlibm/mprec.h
@@ -30,13 +30,11 @@
 #define __CLASSPATH_MPREC_H__
 
 #include <config.h>
-#include "ieeefp.h"
-
-#if defined HAVE_STDINT_H
+/* #include "config-int.h" */
 #include <stdint.h>
-#elif defined HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
+#include "ieeefp.h"
+/* CLASSPATH LOCAL */
+/* #include "namespace.h" */
 
 #if defined HAVE_SYS_TYPES_H
 #include <sys/types.h>
@@ -48,24 +46,6 @@
 
 #ifdef __cplusplus
 extern "C" {
-#endif
-
-/* ISO C99 int type declarations */
-
-#if !defined HAVE_INT32_DEFINED && defined HAVE_BSD_INT32_DEFINED
-typedef u_int32_t uint32_t;
-#endif
-
-#if !defined HAVE_BSD_INT32_DEFINED && !defined HAVE_INT32_DEFINED
-/* FIXME this could have problems with systems that don't define SI to be 4 */
-typedef int int32_t __attribute__((mode(SI)));
-
-/* This is a blatant hack: on Solaris 2.5, pthread.h defines uint32_t
-   in pthread.h, which we sometimes include.  We protect our
-   definition the same way Solaris 2.5 does, to avoid redefining it.  */
-#  ifndef _UINT32_T
-typedef unsigned int uint32_t __attribute__((mode(SI)));
-#  endif
 #endif
 
   /* These typedefs are true for the targets running Java. */
@@ -84,6 +64,7 @@ typedef unsigned int uint32_t __attribute__((mode(SI)));
 
 #ifdef DEBUG
 #include "stdio.h"
+#include <stdlib.h>
 #define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
 #endif
 
@@ -120,7 +101,7 @@ union double_union
  * An alternative that might be better on some machines is
  * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
  */
-#if defined(IEEE_8087) + defined(VAX)
+#if defined(__IEEE_BYTES_LITTLE_ENDIAN) + defined(IEEE_8087) + defined(VAX)
 #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
 ((unsigned short *)a)[0] = (unsigned short)c, a++)
 #else
@@ -275,9 +256,6 @@ extern double rnd_prod(double, double), rnd_quot(double, double);
 #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
 #define Big1 ((uint32_t)0xffffffffL)
 
-/* TWISTI to avoid bugs, we should use Just_16 on every platform */
-#define Just_16
-
 #ifndef Just_16
 /* When Pack_32 is not defined, we store 16 bits per 32-bit long.
  * This makes some inner loops simpler and sometimes saves work
@@ -294,15 +272,18 @@ extern double rnd_prod(double, double), rnd_quot(double, double);
 
 
 #define MAX_BIGNUMS 16
-/* TWISTI this does not work at least on alpha */
-/* #define MAX_BIGNUM_WDS 32 */
-#define MAX_BIGNUM_WDS 64
+#ifdef Pack_32
+#define MAX_BIGNUM_WDS 32
+#else
+  /* Note that this is a workaround for */
+#define MAX_BIGNUM_WDS 128
+#endif
 
 struct _Jv_Bigint
 {
   struct _Jv_Bigint *_next;
   int _k, _maxwds, _sign, _wds;
-  unsigned long _x[MAX_BIGNUM_WDS];
+  unsigned long _x[1];
 };
 
 
@@ -330,10 +311,8 @@ struct _Jv_reent
   int _result_k;
   struct _Jv_Bigint *_p5s;
 
-  struct _Jv_Bigint _freelist[MAX_BIGNUMS];
-  int _allocation_map;
-
-  int num;
+  struct _Jv_Bigint **_freelist;
+  int _max_k;
 };
 
 

diff --git a/src/fdlibm/s_copysign.c b/src/fdlibm/s_copysign.c
index 4804df130dc46d7d48abdea0ebe6a36f357077c2..38a9f6f7972435a9c7589057f905c2c7adea2361 100644 (file)
--- a/src/fdlibm/s_copysign.c
+++ b/src/fdlibm/s_copysign.c
@@ -1,60 +1,16 @@
 
-/* @(#)s_copysign.c 5.1 93/09/24 */
+/* @(#)s_copysign.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
+ * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
-/*
-FUNCTION
-<<copysign>>, <<copysignf>>---sign of <[y]>, magnitude of <[x]>
-
-INDEX
-       copysign
-INDEX
-       copysignf
-
-ANSI_SYNOPSIS
-       #include <math.h>
-       double copysign (double <[x]>, double <[y]>);
-       float copysignf (float <[x]>, float <[y]>);
-
-TRAD_SYNOPSIS
-       #include <math.h>
-       double copysign (<[x]>, <[y]>)
-       double <[x]>;
-       double <[y]>;
-
-       float copysignf (<[x]>, <[y]>)
-       float <[x]>;
-       float <[y]>;
-
-DESCRIPTION
-<<copysign>> constructs a number with the magnitude (absolute value)
-of its first argument, <[x]>, and the sign of its second argument,
-<[y]>.
-
-<<copysignf>> does the same thing; the two functions differ only in
-the type of their arguments and result.
-
-RETURNS
-<<copysign>> returns a <<double>> with the magnitude of
-<[x]> and the sign of <[y]>.
-<<copysignf>> returns a <<float>> with the magnitude of
-<[x]> and the sign of <[y]>.
-
-PORTABILITY
-<<copysign>> is not required by either ANSI C or the System V Interface
-Definition (Issue 2).
-
-*/
-
 /*
  * copysign(double x, double y)
  * copysign(x,y) returns a value with the magnitude of x and
@@ -72,11 +28,10 @@ Definition (Issue 2).
        double x,y;
 #endif
 {
-       uint32_t hx,hy;
-       GET_HIGH_WORD(hx,x);
-       GET_HIGH_WORD(hy,y);
-       SET_HIGH_WORD(x,(hx&0x7fffffff)|(hy&0x80000000));
+        uint32_t hx, hy;
+       GET_HIGH_WORD(hx, x);
+       GET_HIGH_WORD(hy, y);
+       SET_HIGH_WORD(x, (hx&0x7fffffff)|(hy&0x80000000));
         return x;
 }
-
 #endif /* _DOUBLE_IS_32BITS */

diff --git a/src/fdlibm/s_finite.c b/src/fdlibm/s_finite.c
index 3e6c8122b25e6bd1c7404ab4848887cf163f1904..e35b776a41944812f2e42fff9ef9d516b3f41c45 100644 (file)
--- a/src/fdlibm/s_finite.c
+++ b/src/fdlibm/s_finite.c
@@ -19,13 +19,13 @@
 #include "fdlibm.h"
 
 #ifdef __STDC__
-       int finite(double x)
+       int finite(double x)
 #else
-       int finite(x)
-       double x;
+       int finite(x)
+       double x;
 #endif
 {
-       uint32_t high; 
-       GET_HIGH_WORD(high,x);
-       return  (unsigned)((high&0x7fffffff)-0x7ff00000)>>31;
+       uint32_t hx;
+       GET_HIGH_WORD(hx,x);
+       return  (unsigned)((hx&0x7fffffff)-0x7ff00000)>>31;
 }

diff --git a/src/fdlibm/w_fmod.c b/src/fdlibm/w_fmod.c
index b6b36cb76ab93ea25d2fbc9802ac79f00ca89d3b..9d9f3a89e984dc74b6bf3f6d495d9f998600ce82 100644 (file)
--- a/src/fdlibm/w_fmod.c
+++ b/src/fdlibm/w_fmod.c
@@ -1,70 +1,22 @@
 
-/* @(#)w_fmod.c 5.1 93/09/24 */
+/* @(#)w_fmod.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
-/* 
-FUNCTION 
-<<fmod>>, <<fmodf>>---floating-point remainder (modulo)
-
-INDEX
-fmod
-INDEX
-fmodf
-
-ANSI_SYNOPSIS
-#include <math.h>
-double fmod(double <[x]>, double <[y]>)
-float fmodf(float <[x]>, float <[y]>)
-
-TRAD_SYNOPSIS
-#include <math.h>
-double fmod(<[x]>, <[y]>)
-double (<[x]>, <[y]>);
-
-float fmodf(<[x]>, <[y]>)
-float (<[x]>, <[y]>);
-
-DESCRIPTION
-The <<fmod>> and <<fmodf>> functions compute the floating-point
-remainder of <[x]>/<[y]> (<[x]> modulo <[y]>).
-
-RETURNS
-The <<fmod>> function returns the value 
-@ifinfo
-<[x]>-<[i]>*<[y]>, 
-@end ifinfo
-@tex
-$x-i\times y$,
-@end tex
-for the largest integer <[i]> such that, if <[y]> is nonzero, the
-result has the same sign as <[x]> and magnitude less than the
-magnitude of <[y]>. 
-
-<<fmod(<[x]>,0)>> returns NaN, and sets <<errno>> to <<EDOM>>.
-
-You can modify error treatment for these functions using <<matherr>>.
-
-PORTABILITY
-<<fmod>> is ANSI C. <<fmodf>> is an extension.
-*/
-
 /* 
  * wrapper fmod(x,y)
  */
 
 #include "fdlibm.h"
-#include <errno.h>
 
-#ifndef _DOUBLE_IS_32BITS
 
 #ifdef __STDC__
        double fmod(double x, double y) /* wrapper fmod */
@@ -77,31 +29,11 @@ PORTABILITY
        return __ieee754_fmod(x,y);
 #else
        double z;
-       struct exception exc;
        z = __ieee754_fmod(x,y);
        if(_LIB_VERSION == _IEEE_ ||isnan(y)||isnan(x)) return z;
        if(y==0.0) {
-            /* fmod(x,0) */
-            exc.type = DOMAIN;
-            exc.name = "fmod";
-           exc.arg1 = x;
-           exc.arg2 = y;
-           exc.err = 0;
-            if (_LIB_VERSION == _SVID_)
-               exc.retval = x;
-           else
-              exc.retval = 0.0/0.0;
-            if (_LIB_VERSION == _POSIX_)
-               errno = EDOM;
-            else if (!matherr(&exc)) {
-                  errno = EDOM;
-            }
-           if (exc.err != 0)
-              errno = exc.err;
-            return exc.retval; 
+               return __kernel_standard(x,y,27); /* fmod(x,0) */
        } else
            return z;
 #endif
 }
-
-#endif /* defined(_DOUBLE_IS_32BITS) */