/*

  * ====================================================

  * Copyright (C) 1993 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.

  * ====================================================

  */

 /*

  * from: @(#)fdlibm.h 5.1 93/09/24

  * $Id$

  */

 #ifndef _MATH_PRIVATE_H_

 #define _MATH_PRIVATE_H_

 #include "SDL_endian.h"

 #define huge		really_big /* huge is a reserved keyword in VC++ 6.0 */

 #define int32_t 	math_int32_t

 #define u_int32_t	math_u_int32_t

 typedef Sint32 math_int32_t;

 typedef Uint32 math_u_int32_t;

 /* The original fdlibm 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.  */

 /* A union which permits us to convert between a double and two 32 bit

    ints.  */

 /*

  * Math on arm is special:

  * For FPA, float words are always big-endian.

  * For VFP, floats words follow the memory system mode.

  */

 #if (SDL_BYTEORDER == SDL_BIG_ENDIAN) || \

     (!defined(__VFP_FP__) && (defined(__arm__) || defined(__thumb__)))

 typedef union

 {

   double value;

   struct

   {

     u_int32_t msw;

     u_int32_t lsw;

   } parts;

 } ieee_double_shape_type;

 #else

 typedef union

 {

   double value;

   struct

   {

     u_int32_t lsw;

     u_int32_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.  */

 typedef union

 {

   float value;

   u_int32_t word;

 } ieee_float_shape_type;

 /* Get a 32 bit int from a float.  */

 #define GET_FLOAT_WORD(i,d)					\

 do {								\

   ieee_float_shape_type gf_u;					\

   gf_u.value = (d);						\

   (i) = gf_u.word;						\

 } while (0)

 /* Set a float from a 32 bit int.  */

 #define SET_FLOAT_WORD(d,i)					\

 do {								\

   ieee_float_shape_type sf_u;					\

   sf_u.word = (i);						\

   (d) = sf_u.value;						\

 } while (0)

 #ifdef __STDC__

 static const double

 #else

 static double

 #endif

 zero    =  0.0,

 one	=  1.0,

 two	=  2.0,

 two53	=  9007199254740992.0,	/* 0x43400000, 0x00000000 */

 two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */

 twom54  =  5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */

 huge   = 1.0e+300,

 tiny   = 1.0e-300;

 #endif /* _MATH_PRIVATE_H_ */