1 --- stdcxx-4.2.1/etc/config/src/INFINITY.cpp	2008-04-24 20:25:44.000000000 -0400

     2 +++ stdcxx-4.2.1/etc/config/src/INFINITY.cpp	2011-01-14 11:17:58.611690181 -0500

     3 @@ -24,6 +24,7 @@

     4  

     5  #include <stdio.h>    // for printf()

     6  #include <string.h>   // for memset()

     7 +#include <sys/types.h> // for size_t

     8  

     9  #include "config.h"

    10  #include "float_defs.h"  // for FLT_MIN, DBL_MIN, LDBL_MIN

    11 @@ -83,17 +84,17 @@

    12  /**************************************************************************/

    13  

    14  // print out `size' bytes starting at data prefixed by `text'

    15 -static void print (const char *text, const void *data, unsigned size)

    16 +static void print (const char *text, const void *data, size_t size)

    17  {

    18      printf ("%s { ", text);

    19  

    20      const unsigned char *p = (const unsigned char*)data;

    21  

    22 -    for (unsigned i = 0; i != size; ++i) {

    23 +    for (size_t i = 0; i != size; ++i) {

    24          if (p[i])

    25              printf ("'\\x%x'", p[i]);

    26          else

    27 -            printf ("%d", p[i]);

    28 +            printf ("'\\%d'", p[i]);

    29          if (i < size - 1)

    30              printf (", ");

    31      }

    32 @@ -105,10 +106,10 @@

    33  

    34  union flt_bits

    35  {

    36 -    char bits [sizeof (float)];

    37      float val;

    38 +    unsigned char bits [sizeof (float)];

    39      

    40 -    flt_bits () { memset (bits, 0, sizeof (bits)); }

    41 +    flt_bits () { memset (bits, '\0', sizeof (bits)); }

    42  };

    43  

    44  static float flt_zero ()

    45 @@ -287,10 +288,10 @@

    46  

    47  union dbl_bits

    48  {

    49 -    char bits [sizeof (double)];

    50      double val;

    51 +    unsigned char bits [sizeof (double)];

    52      

    53 -    dbl_bits () { memset (bits, 0, sizeof (bits)); }

    54 +    dbl_bits () { memset (bits, '\0', sizeof (bits)); }

    55  };

    56  

    57  static float dbl_zero ()

    58 @@ -503,10 +504,10 @@

    59  

    60  union ldbl_bits

    61  {

    62 -    char bits [sizeof (long double)];

    63      long double val;

    64 +    unsigned char bits [sizeof (long double)];

    65      

    66 -    ldbl_bits () { memset (bits, 0, sizeof (bits)); }

    67 +    ldbl_bits () { memset (bits, '\0', sizeof (bits)); }

    68  };

    69  

    70  static long double ldbl_zero ()

    71 @@ -554,6 +555,43 @@

    72          val.bits [15] = '\0';

    73      }

    74      else {

    75 +#if defined(__SUNPRO_CC)

    76 +#if defined(i386) || defined(__i386) || defined(__i386__) && !defined(__amd64) && !defined(__x86_64__)

    77 +		val.bits [ 0] = '\0';

    78 +		val.bits [ 1] = '\0';

    79 +		val.bits [ 2] = '\0';

    80 +		val.bits [ 3] = '\0';

    81 +		val.bits [ 4] = '\0';

    82 +		val.bits [ 5] = '\0';

    83 +		val.bits [ 6] = '\0';

    84 +		val.bits [ 7] = '\x80';

    85 +		val.bits [ 8] = '\xff';

    86 +		val.bits [ 9] = '\x7f';

    87 +		val.bits [10] = '\xfa';

    88 +		val.bits [11] = '\xfe'; // long double is 12 bytes on 32-bit Intel

    89 +		val.bits [12] = '\0';	// last 4 bytes will be ignored

    90 +		val.bits [13] = '\0';

    91 +		val.bits [14] = '\0';

    92 +		val.bits [15] = '\0';

    93 +#elif defined(__amd64) || defined(__x86__64__)

    94 +		val.bits [ 0] = '\0';

    95 +		val.bits [ 1] = '\0';

    96 +		val.bits [ 2] = '\0';

    97 +		val.bits [ 3] = '\0';

    98 +		val.bits [ 4] = '\0';

    99 +		val.bits [ 5] = '\0';

   100 +		val.bits [ 6] = '\0';

   101 +		val.bits [ 7] = '\x80';

   102 +		val.bits [ 8] = '\xff';

   103 +		val.bits [ 9] = '\x7f';

   104 +		val.bits [10] = '\0';

   105 +		val.bits [11] = '\0';

   106 +		val.bits [12] = '\0';

   107 +		val.bits [13] = '\0';

   108 +		val.bits [14] = '\0';

   109 +		val.bits [15] = '\0';

   110 +#endif

   111 +#else // not __SUNPRO_CC

   112          val.bits [ 0] = '\0';

   113          val.bits [ 1] = '\0';

   114          val.bits [ 2] = '\0';

   115 @@ -570,6 +608,7 @@

   116          val.bits [13] = '\0';

   117          val.bits [14] = '\xff';

   118          val.bits [15] = '\x7f';

   119 +#endif

   120      }

   121  

   122  #endif   // _RWSTD_NO_DBL_TRAPS

   123 @@ -594,6 +633,24 @@

   124      // assume IEEE 754 floating point format

   125  

   126      if (e == big_endian) {

   127 +#if defined(__SUNPRO_CC) && defined(sun) || defined(__sun) || defined(__sun__)

   128 +		val.bits [ 0] = '\x7f';

   129 +		val.bits [ 1] = '\xff';

   130 +		val.bits [ 2] = '\xff';

   131 +		val.bits [ 3] = '\xff';

   132 +		val.bits [ 4] = '\xff';

   133 +		val.bits [ 5] = '\xff';

   134 +		val.bits [ 6] = '\xff';

   135 +		val.bits [ 7] = '\xff';

   136 +		val.bits [ 8] = '\xff';

   137 +		val.bits [ 9] = '\xff';

   138 +		val.bits [10] = '\xff';

   139 +		val.bits [11] = '\xff';

   140 +		val.bits [12] = '\xff';

   141 +		val.bits [13] = '\xff';

   142 +		val.bits [14] = '\xff';

   143 +		val.bits [15] = '\xff';

   144 +#else // not __SUNPRO_CC

   145          val.bits [ 0] = '\xff';

   146          val.bits [ 1] = '\xff';

   147          val.bits [ 2] = '\x80';

   148 @@ -610,8 +667,84 @@

   149          val.bits [13] = '\0';

   150          val.bits [14] = '\0';

   151          val.bits [15] = '\0';

   152 +#endif // __SUNPRO_CC

   153      }

   154      else {

   155 +#if defined(__SUNPRO_CC)

   156 +#if defined(i386) || defined(__i386) || defined(__i386) && (!defined(__amd64) && !defined(__x86_64__))

   157 +#if defined(sun) || defined(__sun) || defined(__sun__)

   158 +		val.bits [ 0] = '\xff';

   159 +		val.bits [ 1] = '\xff';

   160 +		val.bits [ 2] = '\xff';

   161 +		val.bits [ 3] = '\xff';

   162 +		val.bits [ 4] = '\xff';

   163 +		val.bits [ 5] = '\xff';

   164 +		val.bits [ 6] = '\xff';

   165 +		val.bits [ 7] = '\xff';

   166 +		val.bits [ 8] = '\xff';

   167 +		val.bits [ 9] = '\x7f';

   168 +		val.bits [10] = '\x4';

   169 +		val.bits [11] = '\x8';

   170 +		val.bits [12] = '\0'; // long double is 12 bytes on 32-bit Intel

   171 +		val.bits [13] = '\0'; // last 4 bytes will be ignored

   172 +		val.bits [14] = '\0';

   173 +		val.bits [15] = '\0';

   174 +#elif defined(linux) || defined(__linux) || defined(__linux__)

   175 +		val.bits [ 0] = '\x7f';

   176 +		val.bits [ 1] = '\xff'; 

   177 +		val.bits [ 2] = '\xff';

   178 +		val.bits [ 3] = '\xff';

   179 +		val.bits [ 4] = '\xff';

   180 +		val.bits [ 5] = '\xff';

   181 +		val.bits [ 6] = '\xff';

   182 +		val.bits [ 7] = '\xff';

   183 +		val.bits [ 8] = '\xff';

   184 +		val.bits [ 9] = '\x7f';

   185 +		val.bits [10] = '\xfa';

   186 +		val.bits [11] = '\xfe';

   187 +		val.bits [12] = '\0'; // long double is 12 bytes on 32-bit Intel

   188 +		val.bits [13] = '\0'; // last 4 bytes will be ignored

   189 +		val.bits [14] = '\0';

   190 +		val.bits [15] = '\0';

   191 +#endif // __sun || __linux__

   192 +#elif defined(__amd64) || defined(__x86_64__)

   193 +#if defined(sun) || defined(__sun) || defined(__sun__)

   194 +		val.bits [ 0] = '\xff';

   195 +		val.bits [ 1] = '\xff';

   196 +		val.bits [ 2] = '\xff';

   197 +		val.bits [ 3] = '\xff';

   198 +		val.bits [ 4] = '\xff';

   199 +		val.bits [ 5] = '\xff';

   200 +		val.bits [ 6] = '\xff';

   201 +		val.bits [ 7] = '\xff';

   202 +		val.bits [ 8] = '\xff';

   203 +		val.bits [ 9] = '\x7f';

   204 +		val.bits [10] = '\0';

   205 +		val.bits [11] = '\0';

   206 +		val.bits [12] = '\0';

   207 +		val.bits [13] = '\0';

   208 +		val.bits [14] = '\0';

   209 +		val.bits [15] = '\0';

   210 +#elif defined(linux) || defined(__linux) || defined(__linux__)

   211 +		val.bits [ 0] = '\x7f';

   212 +		val.bits [ 1] = '\xff'; 

   213 +		val.bits [ 2] = '\xff';

   214 +		val.bits [ 3] = '\xff';

   215 +		val.bits [ 4] = '\xff';

   216 +		val.bits [ 5] = '\xff';

   217 +		val.bits [ 6] = '\xff';

   218 +		val.bits [ 7] = '\xff';

   219 +		val.bits [ 8] = '\xff';

   220 +		val.bits [ 9] = '\x7f';

   221 +		val.bits [10] = '\0';

   222 +		val.bits [11] = '\0';

   223 +		val.bits [12] = '\0';

   224 +		val.bits [13] = '\0';

   225 +		val.bits [14] = '\0';

   226 +		val.bits [15] = '\0';

   227 +#endif // __sun || __linux__

   228 +#endif

   229 +#else // not __SUNPRO_CC

   230          val.bits [ 0] = '\0';

   231          val.bits [ 1] = '\0';

   232          val.bits [ 2] = '\0';

   233 @@ -628,6 +761,7 @@

   234          val.bits [13] = '\x80';

   235          val.bits [14] = '\xff';

   236          val.bits [15] = '\xff';

   237 +#endif // __SUNPRO_CC

   238      }

   239  

   240  #endif   // _RWSTD_NO_DBL_TRAPS

   241 @@ -694,6 +828,81 @@

   242          val.bits [15] = '\x01';

   243      }

   244      else {

   245 +#if defined(__SUNPRO_CC)

   246 +#if defined(i386) || defined(__i386) || defined(__i386__) && (!defined(__amd64) && !defined(__x86_64__))

   247 +#if defined(sun) || defined(__sun) || defined(__sun__)

   248 +		val.bits [ 0] = '\x1';

   249 +		val.bits [ 1] = '\0';

   250 +		val.bits [ 2] = '\0';

   251 +		val.bits [ 3] = '\0';

   252 +		val.bits [ 4] = '\0';

   253 +		val.bits [ 5] = '\0';

   254 +		val.bits [ 6] = '\0';

   255 +		val.bits [ 7] = '\x80';

   256 +		val.bits [ 8] = '\xff';

   257 +		val.bits [ 9] = '\x7f';

   258 +		val.bits [10] = '\xfa';

   259 +		val.bits [11] = '\xfe';

   260 +		val.bits [12] = '\0'; // long double is 12 bytes on 32-bit Intel

   261 +		val.bits [13] = '\0'; // last 4 bytes will be ignored

   262 +		val.bits [14] = '\0';

   263 +		val.bits [15] = '\0';

   264 +#elif defined(linux) || defined(__linux) || defined(__linux__)

   265 +		val.bits [ 0] = '\xff';

   266 +		val.bits [ 1] = '\xff';

   267 +		val.bits [ 2] = '\xff';

   268 +		val.bits [ 3] = '\xff';

   269 +		val.bits [ 4] = '\xff';

   270 +		val.bits [ 5] = '\xff';

   271 +		val.bits [ 6] = '\xff';

   272 +		val.bits [ 7] = '\xff';

   273 +		val.bits [ 8] = '\xff';

   274 +		val.bits [ 9] = '\x7f';

   275 +		val.bits [10] = '\xfa';

   276 +		val.bits [11] = '\xfe';

   277 +		val.bits [12] = '\0'; // long double is 12 bytes on 32-bit Intel

   278 +		val.bits [13] = '\0'; // last 4 bytes will be ignored

   279 +		val.bits [14] = '\0';

   280 +		val.bits [15] = '\0';

   281 +#endif

   282 +#elif defined(__amd64) || defined(__x86_64__)

   283 +#if defined(sun) || defined(__sun) || defined(__sun__)

   284 +		val.bits [ 0] = '\x1';

   285 +		val.bits [ 1] = '\0';

   286 +		val.bits [ 2] = '\0';

   287 +		val.bits [ 3] = '\0';

   288 +		val.bits [ 4] = '\0';

   289 +		val.bits [ 5] = '\0';

   290 +		val.bits [ 6] = '\0';

   291 +		val.bits [ 7] = '\x80';

   292 +		val.bits [ 8] = '\xff';

   293 +		val.bits [ 9] = '\x7f';

   294 +		val.bits [10] = '\0';

   295 +		val.bits [11] = '\0';

   296 +		val.bits [12] = '\0';

   297 +		val.bits [13] = '\0';

   298 +		val.bits [14] = '\0';

   299 +		val.bits [15] = '\0';

   300 +#elif defined(linux) || defined(__linux) || defined(__linux__)

   301 +		val.bits [ 0] = '\xff';

   302 +		val.bits [ 1] = '\xff';

   303 +		val.bits [ 2] = '\xff';

   304 +		val.bits [ 3] = '\xff';

   305 +		val.bits [ 4] = '\xff';

   306 +		val.bits [ 5] = '\xff';

   307 +		val.bits [ 6] = '\xff';

   308 +		val.bits [ 7] = '\xff';

   309 +		val.bits [ 8] = '\xff';

   310 +		val.bits [ 9] = '\x7f';

   311 +		val.bits [10] = '\0';

   312 +		val.bits [11] = '\0'; 

   313 +		val.bits [12] = '\0';

   314 +		val.bits [13] = '\0';

   315 +		val.bits [14] = '\0';

   316 +		val.bits [15] = '\0';

   317 +#endif

   318 +#endif

   319 +#else // not __SUNPRO_CC

   320          val.bits [ 0] = '\x01';

   321          val.bits [ 1] = '\0';

   322          val.bits [ 2] = '\0';

   323 @@ -710,6 +919,7 @@

   324          val.bits [13] = '\0';

   325          val.bits [14] = '\xff';

   326          val.bits [15] = '\x7f';

   327 +#endif // __SUNPRO_CC

   328      }

   329  

   330  #endif   // _RWSTD_NO_DBL_TRAPS

   331 @@ -822,32 +1032,38 @@

   332              "// (values not computed due to floating exception trapping)\n",

   333              e == big_endian ? "big" : "little");

   334  

   335 +#if defined(__SUNPRO_CC)

   336 +    const int flt_has_denorm  = 1;

   337 +    const int dbl_has_denorm  = 1;

   338 +    const int ldbl_has_denorm = 1;

   339 +#else

   340      const int flt_has_denorm  = 1;

   341      const int dbl_has_denorm  = 1;

   342      const int ldbl_has_denorm = 1;

   343 +#endif

   344  

   345  #endif   // _RWSTD_NO_DBL_TRAPS

   346  

   347 -    print ("#define _RWSTD_FLT_INF_BITS ", &f_inf, sizeof f_inf);

   348 -    print ("#define _RWSTD_FLT_QNAN_BITS ", &f_qnan, sizeof f_qnan);

   349 -    print ("#define _RWSTD_FLT_SNAN_BITS ", &f_snan, sizeof f_snan);

   350 -    print ("#define _RWSTD_FLT_DENORM_MIN_BITS ", &f_den, sizeof f_den);

   351 +    print ("#define _RWSTD_FLT_INF_BITS ", &f_inf, sizeof(float));

   352 +    print ("#define _RWSTD_FLT_QNAN_BITS ", &f_qnan, sizeof(float));

   353 +    print ("#define _RWSTD_FLT_SNAN_BITS ", &f_snan, sizeof(float));

   354 +    print ("#define _RWSTD_FLT_DENORM_MIN_BITS ", &f_den, sizeof(float));

   355  

   356      printf ("#define _RWSTD_FLT_HAS_DENORM  %d\n", flt_has_denorm);

   357  

   358 -    print ("#define _RWSTD_DBL_INF_BITS ", &d_inf, sizeof d_inf);

   359 -    print ("#define _RWSTD_DBL_QNAN_BITS ", &d_qnan, sizeof d_qnan);

   360 -    print ("#define _RWSTD_DBL_SNAN_BITS ", &d_snan, sizeof d_snan);

   361 -    print ("#define _RWSTD_DBL_DENORM_MIN_BITS ", &d_den, sizeof d_den);

   362 +    print ("#define _RWSTD_DBL_INF_BITS ", &d_inf, sizeof(double));

   363 +    print ("#define _RWSTD_DBL_QNAN_BITS ", &d_qnan, sizeof(double));

   364 +    print ("#define _RWSTD_DBL_SNAN_BITS ", &d_snan, sizeof(double));

   365 +    print ("#define _RWSTD_DBL_DENORM_MIN_BITS ", &d_den, sizeof(double));

   366  

   367      printf ("#define _RWSTD_DBL_HAS_DENORM  %d\n", dbl_has_denorm);

   368  

   369  #ifndef _RWSTD_NO_LONG_DOUBLE

   370  

   371 -    print ("#define _RWSTD_LDBL_INF_BITS ", &l_inf, sizeof l_inf);

   372 -    print ("#define _RWSTD_LDBL_QNAN_BITS ", &l_qnan, sizeof l_qnan);

   373 -    print ("#define _RWSTD_LDBL_SNAN_BITS ", &l_snan, sizeof l_snan);

   374 -    print ("#define _RWSTD_LDBL_DENORM_MIN_BITS ", &l_den, sizeof l_den);

   375 +    print ("#define _RWSTD_LDBL_INF_BITS ", &l_inf, sizeof(long double));

   376 +    print ("#define _RWSTD_LDBL_QNAN_BITS ", &l_qnan, sizeof(long double));

   377 +    print ("#define _RWSTD_LDBL_SNAN_BITS ", &l_snan, sizeof(long double));

   378 +    print ("#define _RWSTD_LDBL_DENORM_MIN_BITS ", &l_den, sizeof(long double));

   379  

   380      printf ("#define _RWSTD_LDBL_HAS_DENORM  %d\n", ldbl_has_denorm);

   381