dlls/msvcrt/math.c

   1 /*
   2  * msvcrt.dll math functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include "config.h"
  21
  22 #include <stdio.h>
  23 #define __USE_ISOC9X 1
  24 #define __USE_ISOC99 1
  25 #include <math.h>
  26 #ifdef HAVE_IEEEFP_H
  27 #include <ieeefp.h>
  28 #endif
  29
  30 #include "msvcrt.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  35
  36 #ifndef HAVE_FINITE
  37 #ifndef finite /* Could be a macro */
  38 #ifdef isfinite
  39 #define finite(x) isfinite(x)
  40 #else
  41 #define finite(x) (!isnan(x)) /* At least catch some cases */
  42 #endif
  43 #endif
  44 #endif
  45
  46 #ifndef signbit
  47 #define signbit(x) 0
  48 #endif
  49
  50 typedef int (*MSVCRT_matherr_func)(struct MSVCRT__exception *);
  51
  52 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
  53
  54 /*********************************************************************
  55  *              MSVCRT_acos (MSVCRT.@)
  56  */
  57 double CDECL MSVCRT_acos( double x )
  58 {
  59   if (x < -1.0 || x > 1.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
  60   /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
  61    * asin() uses a similar construction. This is bad because as x gets nearer to
  62    * 1 the error in the expression "1 - x^2" can get relatively large due to
  63    * cancellation. The sqrt() makes things worse. A safer way to calculate
  64    * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
  65   return atan2(sqrt((1 - x) * (1 + x)), x);
  66 }
  67
  68 /*********************************************************************
  69  *              MSVCRT_asin (MSVCRT.@)
  70  */
  71 double CDECL MSVCRT_asin( double x )
  72 {
  73   if (x < -1.0 || x > 1.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
  74   return atan2(x, sqrt((1 - x) * (1 + x)));
  75 }
  76
  77 /*********************************************************************
  78  *              MSVCRT_atan (MSVCRT.@)
  79  */
  80 double CDECL MSVCRT_atan( double x )
  81 {
  82   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
  83   return atan(x);
  84 }
  85
  86 /*********************************************************************
  87  *              MSVCRT_atan2 (MSVCRT.@)
  88  */
  89 double CDECL MSVCRT_atan2( double x, double y )
  90 {
  91   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
  92   return atan2(x,y);
  93 }
  94
  95 /*********************************************************************
  96  *              MSVCRT_cos (MSVCRT.@)
  97  */
  98 double CDECL MSVCRT_cos( double x )
  99 {
 100   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 101   return cos(x);
 102 }
 103
 104 /*********************************************************************
 105  *              MSVCRT_cosh (MSVCRT.@)
 106  */
 107 double CDECL MSVCRT_cosh( double x )
 108 {
 109   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 110   return cosh(x);
 111 }
 112
 113 /*********************************************************************
 114  *              MSVCRT_exp (MSVCRT.@)
 115  */
 116 double CDECL MSVCRT_exp( double x )
 117 {
 118   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 119   return exp(x);
 120 }
 121
 122 /*********************************************************************
 123  *              MSVCRT_fmod (MSVCRT.@)
 124  */
 125 double CDECL MSVCRT_fmod( double x, double y )
 126 {
 127   if (!finite(x) || !finite(y)) *MSVCRT__errno() = MSVCRT_EDOM;
 128   return fmod(x,y);
 129 }
 130
 131 /*********************************************************************
 132  *              MSVCRT_log (MSVCRT.@)
 133  */
 134 double CDECL MSVCRT_log( double x)
 135 {
 136   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 137   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 138   return log(x);
 139 }
 140
 141 /*********************************************************************
 142  *              MSVCRT_log10 (MSVCRT.@)
 143  */
 144 double CDECL MSVCRT_log10( double x )
 145 {
 146   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 147   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 148   return log10(x);
 149 }
 150
 151 /*********************************************************************
 152  *              MSVCRT_pow (MSVCRT.@)
 153  */
 154 double CDECL MSVCRT_pow( double x, double y )
 155 {
 156   /* FIXME: If x < 0 and y is not integral, set EDOM */
 157   double z = pow(x,y);
 158   if (!finite(z)) *MSVCRT__errno() = MSVCRT_EDOM;
 159   return z;
 160 }
 161
 162 /*********************************************************************
 163  *              MSVCRT_sin (MSVCRT.@)
 164  */
 165 double CDECL MSVCRT_sin( double x )
 166 {
 167   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 168   return sin(x);
 169 }
 170
 171 /*********************************************************************
 172  *              MSVCRT_sinh (MSVCRT.@)
 173  */
 174 double CDECL MSVCRT_sinh( double x )
 175 {
 176   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 177   return sinh(x);
 178 }
 179
 180 /*********************************************************************
 181  *              MSVCRT_sqrt (MSVCRT.@)
 182  */
 183 double CDECL MSVCRT_sqrt( double x )
 184 {
 185   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 186   return sqrt(x);
 187 }
 188
 189 /*********************************************************************
 190  *              MSVCRT_tan (MSVCRT.@)
 191  */
 192 double CDECL MSVCRT_tan( double x )
 193 {
 194   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 195   return tan(x);
 196 }
 197
 198 /*********************************************************************
 199  *              MSVCRT_tanh (MSVCRT.@)
 200  */
 201 double CDECL MSVCRT_tanh( double x )
 202 {
 203   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 204   return tanh(x);
 205 }
 206
 207
 208 #if defined(__GNUC__) && defined(__i386__)
 209
 210 #define FPU_DOUBLE(var) double var; \
 211   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 212 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 213   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 214   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 215
 216 /*********************************************************************
 217  *              _CIacos (MSVCRT.@)
 218  */
 219 double CDECL _CIacos(void)
 220 {
 221   FPU_DOUBLE(x);
 222   return MSVCRT_acos(x);
 223 }
 224
 225 /*********************************************************************
 226  *              _CIasin (MSVCRT.@)
 227  */
 228 double CDECL _CIasin(void)
 229 {
 230   FPU_DOUBLE(x);
 231   return MSVCRT_asin(x);
 232 }
 233
 234 /*********************************************************************
 235  *              _CIatan (MSVCRT.@)
 236  */
 237 double CDECL _CIatan(void)
 238 {
 239   FPU_DOUBLE(x);
 240   return MSVCRT_atan(x);
 241 }
 242
 243 /*********************************************************************
 244  *              _CIatan2 (MSVCRT.@)
 245  */
 246 double CDECL _CIatan2(void)
 247 {
 248   FPU_DOUBLES(x,y);
 249   return MSVCRT_atan2(x,y);
 250 }
 251
 252 /*********************************************************************
 253  *              _CIcos (MSVCRT.@)
 254  */
 255 double CDECL _CIcos(void)
 256 {
 257   FPU_DOUBLE(x);
 258   return MSVCRT_cos(x);
 259 }
 260
 261 /*********************************************************************
 262  *              _CIcosh (MSVCRT.@)
 263  */
 264 double CDECL _CIcosh(void)
 265 {
 266   FPU_DOUBLE(x);
 267   return MSVCRT_cosh(x);
 268 }
 269
 270 /*********************************************************************
 271  *              _CIexp (MSVCRT.@)
 272  */
 273 double CDECL _CIexp(void)
 274 {
 275   FPU_DOUBLE(x);
 276   return MSVCRT_exp(x);
 277 }
 278
 279 /*********************************************************************
 280  *              _CIfmod (MSVCRT.@)
 281  */
 282 double CDECL _CIfmod(void)
 283 {
 284   FPU_DOUBLES(x,y);
 285   return MSVCRT_fmod(x,y);
 286 }
 287
 288 /*********************************************************************
 289  *              _CIlog (MSVCRT.@)
 290  */
 291 double CDECL _CIlog(void)
 292 {
 293   FPU_DOUBLE(x);
 294   return MSVCRT_log(x);
 295 }
 296
 297 /*********************************************************************
 298  *              _CIlog10 (MSVCRT.@)
 299  */
 300 double CDECL _CIlog10(void)
 301 {
 302   FPU_DOUBLE(x);
 303   return MSVCRT_log10(x);
 304 }
 305
 306 /*********************************************************************
 307  *              _CIpow (MSVCRT.@)
 308  */
 309 double CDECL _CIpow(void)
 310 {
 311   FPU_DOUBLES(x,y);
 312   return MSVCRT_pow(x,y);
 313 }
 314
 315 /*********************************************************************
 316  *              _CIsin (MSVCRT.@)
 317  */
 318 double CDECL _CIsin(void)
 319 {
 320   FPU_DOUBLE(x);
 321   return MSVCRT_sin(x);
 322 }
 323
 324 /*********************************************************************
 325  *              _CIsinh (MSVCRT.@)
 326  */
 327 double CDECL _CIsinh(void)
 328 {
 329   FPU_DOUBLE(x);
 330   return MSVCRT_sinh(x);
 331 }
 332
 333 /*********************************************************************
 334  *              _CIsqrt (MSVCRT.@)
 335  */
 336 double CDECL _CIsqrt(void)
 337 {
 338   FPU_DOUBLE(x);
 339   return MSVCRT_sqrt(x);
 340 }
 341
 342 /*********************************************************************
 343  *              _CItan (MSVCRT.@)
 344  */
 345 double CDECL _CItan(void)
 346 {
 347   FPU_DOUBLE(x);
 348   return MSVCRT_tan(x);
 349 }
 350
 351 /*********************************************************************
 352  *              _CItanh (MSVCRT.@)
 353  */
 354 double CDECL _CItanh(void)
 355 {
 356   FPU_DOUBLE(x);
 357   return MSVCRT_tanh(x);
 358 }
 359
 360 #endif /* defined(__GNUC__) && defined(__i386__) */
 361
 362 /*********************************************************************
 363  *              _fpclass (MSVCRT.@)
 364  */
 365 int CDECL _fpclass(double num)
 366 {
 367 #if defined(HAVE_FPCLASS) || defined(fpclass)
 368   switch (fpclass( num ))
 369   {
 370 #ifdef FP_SNAN
 371   case FP_SNAN:  return MSVCRT__FPCLASS_SNAN;
 372 #endif
 373 #ifdef FP_QNAN
 374   case FP_QNAN:  return MSVCRT__FPCLASS_QNAN;
 375 #endif
 376 #ifdef FP_NINF
 377   case FP_NINF:  return MSVCRT__FPCLASS_NINF;
 378 #endif
 379 #ifdef FP_PINF
 380   case FP_PINF:  return MSVCRT__FPCLASS_PINF;
 381 #endif
 382 #ifdef FP_NDENORM
 383   case FP_NDENORM: return MSVCRT__FPCLASS_ND;
 384 #endif
 385 #ifdef FP_PDENORM
 386   case FP_PDENORM: return MSVCRT__FPCLASS_PD;
 387 #endif
 388 #ifdef FP_NZERO
 389   case FP_NZERO: return MSVCRT__FPCLASS_NZ;
 390 #endif
 391 #ifdef FP_PZERO
 392   case FP_PZERO: return MSVCRT__FPCLASS_PZ;
 393 #endif
 394 #ifdef FP_NNORM
 395   case FP_NNORM: return MSVCRT__FPCLASS_NN;
 396 #endif
 397 #ifdef FP_PNORM
 398   case FP_PNORM: return MSVCRT__FPCLASS_PN;
 399 #endif
 400   default: return MSVCRT__FPCLASS_PN;
 401   }
 402 #elif defined (fpclassify)
 403   switch (fpclassify( num ))
 404   {
 405   case FP_NAN: return MSVCRT__FPCLASS_QNAN;
 406   case FP_INFINITE: return signbit(num) ? MSVCRT__FPCLASS_NINF : MSVCRT__FPCLASS_PINF;
 407   case FP_SUBNORMAL: return signbit(num) ?MSVCRT__FPCLASS_ND : MSVCRT__FPCLASS_PD;
 408   case FP_ZERO: return signbit(num) ? MSVCRT__FPCLASS_NZ : MSVCRT__FPCLASS_PZ;
 409   }
 410   return signbit(num) ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN;
 411 #else
 412   if (!finite(num))
 413     return MSVCRT__FPCLASS_QNAN;
 414   return num == 0.0 ? MSVCRT__FPCLASS_PZ : (num < 0 ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN);
 415 #endif
 416 }
 417
 418 /*********************************************************************
 419  *              _rotl (MSVCRT.@)
 420  */
 421 unsigned int CDECL _rotl(unsigned int num, int shift)
 422 {
 423   shift &= 31;
 424   return (num << shift) | (num >> (32-shift));
 425 }
 426
 427 /*********************************************************************
 428  *              _logb (MSVCRT.@)
 429  */
 430 double CDECL _logb(double num)
 431 {
 432   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 433   return logb(num);
 434 }
 435
 436 /*********************************************************************
 437  *              _lrotl (MSVCRT.@)
 438  */
 439 MSVCRT_ulong CDECL MSVCRT__lrotl(MSVCRT_ulong num, int shift)
 440 {
 441   shift &= 0x1f;
 442   return (num << shift) | (num >> (32-shift));
 443 }
 444
 445 /*********************************************************************
 446  *              _lrotr (MSVCRT.@)
 447  */
 448 MSVCRT_ulong CDECL MSVCRT__lrotr(MSVCRT_ulong num, int shift)
 449 {
 450   shift &= 0x1f;
 451   return (num >> shift) | (num << (32-shift));
 452 }
 453
 454 /*********************************************************************
 455  *              _rotr (MSVCRT.@)
 456  */
 457 unsigned int CDECL _rotr(unsigned int num, int shift)
 458 {
 459     shift &= 0x1f;
 460     return (num >> shift) | (num << (32-shift));
 461 }
 462
 463 /*********************************************************************
 464  *              _scalb (MSVCRT.@)
 465  */
 466 double CDECL MSVCRT__scalb(double num, MSVCRT_long power)
 467 {
 468   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 469   return ldexp(num, power);
 470 }
 471
 472 /*********************************************************************
 473  *              _hypot (MSVCRT.@)
 474  */
 475 double CDECL _hypot(double x, double y)
 476 {
 477   /* FIXME: errno handling */
 478   return hypot( x, y );
 479 }
 480
 481 /*********************************************************************
 482  *              ceil (MSVCRT.@)
 483  */
 484 double CDECL MSVCRT_ceil( double x )
 485 {
 486   return ceil(x);
 487 }
 488
 489 /*********************************************************************
 490  *              floor (MSVCRT.@)
 491  */
 492 double CDECL MSVCRT_floor( double x )
 493 {
 494   return floor(x);
 495 }
 496
 497 /*********************************************************************
 498  *              fabs (MSVCRT.@)
 499  */
 500 double CDECL MSVCRT_fabs( double x )
 501 {
 502   return fabs(x);
 503 }
 504
 505 /*********************************************************************
 506  *              frexp (MSVCRT.@)
 507  */
 508 double CDECL MSVCRT_frexp( double x, int *exp )
 509 {
 510   return frexp( x, exp );
 511 }
 512
 513 /*********************************************************************
 514  *              modf (MSVCRT.@)
 515  */
 516 double CDECL MSVCRT_modf( double x, double *iptr )
 517 {
 518   return modf( x, iptr );
 519 }
 520
 521 /*********************************************************************
 522  *              _matherr (MSVCRT.@)
 523  */
 524 int CDECL MSVCRT__matherr(struct MSVCRT__exception *e)
 525 {
 526   if (e)
 527     TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
 528           e->retval);
 529   else
 530     TRACE("(null)\n");
 531   if (MSVCRT_default_matherr_func)
 532     return MSVCRT_default_matherr_func(e);
 533   ERR(":Unhandled math error!\n");
 534   return 0;
 535 }
 536
 537 /*********************************************************************
 538  *              __setusermatherr (MSVCRT.@)
 539  */
 540 void CDECL MSVCRT___setusermatherr(MSVCRT_matherr_func func)
 541 {
 542   MSVCRT_default_matherr_func = func;
 543   TRACE(":new matherr handler %p\n", func);
 544 }
 545
 546 /**********************************************************************
 547  *              _statusfp (MSVCRT.@)
 548  */
 549 unsigned int CDECL _statusfp(void)
 550 {
 551    unsigned int retVal = 0;
 552 #if defined(__GNUC__) && defined(__i386__)
 553   unsigned int fpword;
 554
 555   __asm__ __volatile__( "fstsw %0" : "=m" (fpword) : );
 556   if (fpword & 0x1)  retVal |= MSVCRT__SW_INVALID;
 557   if (fpword & 0x2)  retVal |= MSVCRT__SW_DENORMAL;
 558   if (fpword & 0x4)  retVal |= MSVCRT__SW_ZERODIVIDE;
 559   if (fpword & 0x8)  retVal |= MSVCRT__SW_OVERFLOW;
 560   if (fpword & 0x10) retVal |= MSVCRT__SW_UNDERFLOW;
 561   if (fpword & 0x20) retVal |= MSVCRT__SW_INEXACT;
 562 #else
 563   FIXME(":Not implemented!\n");
 564 #endif
 565   return retVal;
 566 }
 567
 568 /*********************************************************************
 569  *              _clearfp (MSVCRT.@)
 570  */
 571 unsigned int CDECL _clearfp(void)
 572 {
 573   unsigned int retVal = _statusfp();
 574 #if defined(__GNUC__) && defined(__i386__)
 575   __asm__ __volatile__( "fnclex" );
 576 #else
 577   FIXME(":Not Implemented\n");
 578 #endif
 579   return retVal;
 580 }
 581
 582 /*********************************************************************
 583  *              __fpecode (MSVCRT.@)
 584  */
 585 int * CDECL __fpecode(void)
 586 {
 587     return &msvcrt_get_thread_data()->fpecode;
 588 }
 589
 590 /*********************************************************************
 591  *              ldexp (MSVCRT.@)
 592  */
 593 double CDECL MSVCRT_ldexp(double num, MSVCRT_long exp)
 594 {
 595   double z = ldexp(num,exp);
 596
 597   if (!finite(z))
 598     *MSVCRT__errno() = MSVCRT_ERANGE;
 599   else if (z == 0 && signbit(z))
 600     z = 0.0; /* Convert -0 -> +0 */
 601   return z;
 602 }
 603
 604 /*********************************************************************
 605  *              _cabs (MSVCRT.@)
 606  */
 607 double CDECL MSVCRT__cabs(struct MSVCRT__complex num)
 608 {
 609   return sqrt(num.x * num.x + num.y * num.y);
 610 }
 611
 612 /*********************************************************************
 613  *              _chgsign (MSVCRT.@)
 614  */
 615 double CDECL _chgsign(double num)
 616 {
 617   /* FIXME: +-infinity,Nan not tested */
 618   return -num;
 619 }
 620
 621 /*********************************************************************
 622  *              _control87 (MSVCRT.@)
 623  */
 624 unsigned int CDECL _control87(unsigned int newval, unsigned int mask)
 625 {
 626 #if defined(__GNUC__) && defined(__i386__)
 627   unsigned int fpword = 0;
 628   unsigned int flags = 0;
 629
 630   TRACE("(%08x, %08x): Called\n", newval, mask);
 631
 632   /* Get fp control word */
 633   __asm__ __volatile__( "fstcw %0" : "=m" (fpword) : );
 634
 635   TRACE("Control word before : %08x\n", fpword);
 636
 637   /* Convert into mask constants */
 638   if (fpword & 0x1)  flags |= MSVCRT__EM_INVALID;
 639   if (fpword & 0x2)  flags |= MSVCRT__EM_DENORMAL;
 640   if (fpword & 0x4)  flags |= MSVCRT__EM_ZERODIVIDE;
 641   if (fpword & 0x8)  flags |= MSVCRT__EM_OVERFLOW;
 642   if (fpword & 0x10) flags |= MSVCRT__EM_UNDERFLOW;
 643   if (fpword & 0x20) flags |= MSVCRT__EM_INEXACT;
 644   switch(fpword & 0xC00) {
 645   case 0xC00: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
 646   case 0x800: flags |= MSVCRT__RC_UP; break;
 647   case 0x400: flags |= MSVCRT__RC_DOWN; break;
 648   }
 649   switch(fpword & 0x300) {
 650   case 0x0:   flags |= MSVCRT__PC_24; break;
 651   case 0x200: flags |= MSVCRT__PC_53; break;
 652   case 0x300: flags |= MSVCRT__PC_64; break;
 653   }
 654   if (fpword & 0x1000) flags |= MSVCRT__IC_AFFINE;
 655
 656   /* Mask with parameters */
 657   flags = (flags & ~mask) | (newval & mask);
 658
 659   /* Convert (masked) value back to fp word */
 660   fpword = 0;
 661   if (flags & MSVCRT__EM_INVALID)    fpword |= 0x1;
 662   if (flags & MSVCRT__EM_DENORMAL)   fpword |= 0x2;
 663   if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x4;
 664   if (flags & MSVCRT__EM_OVERFLOW)   fpword |= 0x8;
 665   if (flags & MSVCRT__EM_UNDERFLOW)  fpword |= 0x10;
 666   if (flags & MSVCRT__EM_INEXACT)    fpword |= 0x20;
 667   switch(flags & (MSVCRT__RC_UP | MSVCRT__RC_DOWN)) {
 668   case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0xC00; break;
 669   case MSVCRT__RC_UP:          fpword |= 0x800; break;
 670   case MSVCRT__RC_DOWN:        fpword |= 0x400; break;
 671   }
 672   switch (flags & (MSVCRT__PC_24 | MSVCRT__PC_53)) {
 673   case MSVCRT__PC_64: fpword |= 0x300; break;
 674   case MSVCRT__PC_53: fpword |= 0x200; break;
 675   case MSVCRT__PC_24: fpword |= 0x0; break;
 676   }
 677   if (flags & MSVCRT__IC_AFFINE) fpword |= 0x1000;
 678
 679   TRACE("Control word after  : %08x\n", fpword);
 680
 681   /* Put fp control word */
 682   __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
 683
 684   return flags;
 685 #else
 686   FIXME(":Not Implemented!\n");
 687   return 0;
 688 #endif
 689 }
 690
 691 /*********************************************************************
 692  *              _controlfp (MSVCRT.@)
 693  */
 694 unsigned int CDECL _controlfp(unsigned int newval, unsigned int mask)
 695 {
 696 #ifdef __i386__
 697   return _control87( newval, mask & ~MSVCRT__EM_DENORMAL );
 698 #else
 699   FIXME(":Not Implemented!\n");
 700   return 0;
 701 #endif
 702 }
 703
 704 /*********************************************************************
 705  *              _controlfp_s (MSVCRT.@)
 706  */
 707 int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
 708 {
 709 #ifdef __i386__
 710     unsigned int flags;
 711
 712     FIXME("(%p %u %u) semi-stub\n", cur, newval, mask);
 713
 714     flags = _control87( newval, mask & ~MSVCRT__EM_DENORMAL );
 715
 716     if(cur)
 717         *cur = flags;
 718
 719     return 0;
 720 #else
 721     FIXME(":Not Implemented!\n");
 722     return 0;
 723 #endif
 724 }
 725
 726 /*********************************************************************
 727  *              _copysign (MSVCRT.@)
 728  */
 729 double CDECL _copysign(double num, double sign)
 730 {
 731   /* FIXME: Behaviour for Nan/Inf? */
 732   if (sign < 0.0)
 733     return num < 0.0 ? num : -num;
 734   return num < 0.0 ? -num : num;
 735 }
 736
 737 /*********************************************************************
 738  *              _finite (MSVCRT.@)
 739  */
 740 int CDECL _finite(double num)
 741 {
 742   return (finite(num)?1:0); /* See comment for _isnan() */
 743 }
 744
 745 /*********************************************************************
 746  *              _fpreset (MSVCRT.@)
 747  */
 748 void CDECL _fpreset(void)
 749 {
 750 #if defined(__GNUC__) && defined(__i386__)
 751   __asm__ __volatile__( "fninit" );
 752 #else
 753   FIXME(":Not Implemented!\n");
 754 #endif
 755 }
 756
 757 /*********************************************************************
 758  *              _isnan (MSVCRT.@)
 759  */
 760 INT CDECL _isnan(double num)
 761 {
 762   /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
 763    * Do the same, as the result may be used in calculations
 764    */
 765   return isnan(num) ? 1 : 0;
 766 }
 767
 768 /*********************************************************************
 769  *              _j0 (MSVCRT.@)
 770  */
 771 double CDECL _j0(double num)
 772 {
 773   /* FIXME: errno handling */
 774   return j0(num);
 775 }
 776
 777 /*********************************************************************
 778  *              _j1 (MSVCRT.@)
 779  */
 780 double CDECL _j1(double num)
 781 {
 782   /* FIXME: errno handling */
 783   return j1(num);
 784 }
 785
 786 /*********************************************************************
 787  *              jn (MSVCRT.@)
 788  */
 789 double CDECL _jn(int n, double num)
 790 {
 791   /* FIXME: errno handling */
 792   return jn(n, num);
 793 }
 794
 795 /*********************************************************************
 796  *              _y0 (MSVCRT.@)
 797  */
 798 double CDECL _y0(double num)
 799 {
 800   double retval;
 801   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 802   retval  = y0(num);
 803   if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
 804   {
 805     *MSVCRT__errno() = MSVCRT_EDOM;
 806     retval = sqrt(-1);
 807   }
 808   return retval;
 809 }
 810
 811 /*********************************************************************
 812  *              _y1 (MSVCRT.@)
 813  */
 814 double CDECL _y1(double num)
 815 {
 816   double retval;
 817   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 818   retval  = y1(num);
 819   if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
 820   {
 821     *MSVCRT__errno() = MSVCRT_EDOM;
 822     retval = sqrt(-1);
 823   }
 824   return retval;
 825 }
 826
 827 /*********************************************************************
 828  *              _yn (MSVCRT.@)
 829  */
 830 double CDECL _yn(int order, double num)
 831 {
 832   double retval;
 833   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 834   retval  = yn(order,num);
 835   if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
 836   {
 837     *MSVCRT__errno() = MSVCRT_EDOM;
 838     retval = sqrt(-1);
 839   }
 840   return retval;
 841 }
 842
 843 /*********************************************************************
 844  *              _nextafter (MSVCRT.@)
 845  */
 846 double CDECL _nextafter(double num, double next)
 847 {
 848   double retval;
 849   if (!finite(num) || !finite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
 850   retval = nextafter(num,next);
 851   return retval;
 852 }
 853
 854 /*********************************************************************
 855  *              _ecvt (MSVCRT.@)
 856  */
 857 char * CDECL _ecvt( double number, int ndigits, int *decpt, int *sign )
 858 {
 859     int prec, len;
 860     thread_data_t *data = msvcrt_get_thread_data();
 861     /* FIXME: check better for overflow (native supports over 300 chars's) */
 862     ndigits = min( ndigits, 80 - 7); /* 7 : space for dec point, 1 for "e",
 863                                       * 4 for exponent and one for
 864                                       * terminating '\0' */
 865     if (!data->efcvt_buffer)
 866         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
 867
 868     if( number < 0) {
 869         *sign = TRUE;
 870         number = -number;
 871     } else
 872         *sign = FALSE;
 873     /* handle cases with zero ndigits or less */
 874     prec = ndigits;
 875     if( prec < 1) prec = 2;
 876     len = snprintf(data->efcvt_buffer, 80, "%.*le", prec - 1, number);
 877     /* take the decimal "point away */
 878     if( prec != 1)
 879         memmove( data->efcvt_buffer + 1, data->efcvt_buffer + 2, len - 1 );
 880     /* take the exponential "e" out */
 881     data->efcvt_buffer[ prec] = '\0';
 882     /* read the exponent */
 883     sscanf( data->efcvt_buffer + prec + 1, "%d", decpt);
 884     (*decpt)++;
 885     /* adjust for some border cases */
 886     if( data->efcvt_buffer[0] == '0')/* value is zero */
 887         *decpt = 0;
 888     /* handle cases with zero ndigits or less */
 889     if( ndigits < 1){
 890         if( data->efcvt_buffer[ 0] >= '5')
 891             (*decpt)++;
 892         data->efcvt_buffer[ 0] = '\0';
 893     }
 894     TRACE("out=\"%s\"\n",data->efcvt_buffer);
 895     return data->efcvt_buffer;
 896 }
 897
 898 /***********************************************************************
 899  *              _fcvt  (MSVCRT.@)
 900  */
 901 char * CDECL _fcvt( double number, int ndigits, int *decpt, int *sign )
 902 {
 903     thread_data_t *data = msvcrt_get_thread_data();
 904     int stop, dec1, dec2;
 905     char *ptr1, *ptr2, *first;
 906     char buf[80]; /* ought to be enough */
 907
 908     if (!data->efcvt_buffer)
 909         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
 910
 911     if (number < 0)
 912     {
 913         *sign = 1;
 914         number = -number;
 915     } else *sign = 0;
 916
 917     snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
 918     ptr1 = buf;
 919     ptr2 = data->efcvt_buffer;
 920     first = NULL;
 921     dec1 = 0;
 922     dec2 = 0;
 923
 924     /* For numbers below the requested resolution, work out where
 925        the decimal point will be rather than finding it in the string */
 926     if (number < 1.0 && number > 0.0) {
 927         dec2 = log10(number + 1e-10);
 928         if (-dec2 <= ndigits) dec2 = 0;
 929     }
 930
 931     /* If requested digits is zero or less, we will need to truncate
 932      * the returned string */
 933     if (ndigits < 1) {
 934         stop = strlen(buf) + ndigits;
 935     } else {
 936         stop = strlen(buf);
 937     }
 938
 939     while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
 940     while (*ptr1 != '\0' && *ptr1 != '.') {
 941         if (!first) first = ptr2;
 942         if ((ptr1 - buf) < stop) {
 943             *ptr2++ = *ptr1++;
 944         } else {
 945             ptr1++;
 946         }
 947         dec1++;
 948     }
 949
 950     if (ndigits > 0) {
 951         ptr1++;
 952         if (!first) {
 953             while (*ptr1 == '0') { /* Process leading zeroes */
 954                 *ptr2++ = *ptr1++;
 955                 dec1--;
 956             }
 957         }
 958         while (*ptr1 != '\0') {
 959             if (!first) first = ptr2;
 960             *ptr2++ = *ptr1++;
 961         }
 962     }
 963
 964     *ptr2 = '\0';
 965
 966     /* We never found a non-zero digit, then our number is either
 967      * smaller than the requested precision, or 0.0 */
 968     if (!first) {
 969         if (number > 0.0) {
 970             first = ptr2;
 971         } else {
 972             first = data->efcvt_buffer;
 973             dec1 = 0;
 974         }
 975     }
 976
 977     *decpt = dec2 ? dec2 : dec1;
 978     return first;
 979 }
 980
 981 /***********************************************************************
 982  *              _gcvt  (MSVCRT.@)
 983  *
 984  * FIXME: uses both E and F.
 985  */
 986 char * CDECL _gcvt( double number, int ndigit, char *buff )
 987 {
 988     sprintf(buff, "%.*E", ndigit, number);
 989     return buff;
 990 }
 991
 992 #include <stdlib.h> /* div_t, ldiv_t */
 993
 994 /*********************************************************************
 995  *              div (MSVCRT.@)
 996  * VERSION
 997  *      [i386] Windows binary compatible - returns the struct in eax/edx.
 998  */
 999 #ifdef __i386__
1000 unsigned __int64 CDECL MSVCRT_div(int num, int denom)
1001 {
1002   div_t dt = div(num,denom);
1003   return ((unsigned __int64)dt.rem << 32) | (unsigned int)dt.quot;
1004 }
1005 #else
1006 /*********************************************************************
1007  *              div (MSVCRT.@)
1008  * VERSION
1009  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1010  */
1011 MSVCRT_div_t CDECL MSVCRT_div(int num, int denom)
1012 {
1013   div_t dt = div(num,denom);
1014   MSVCRT_div_t     ret;
1015   ret.quot = dt.quot;
1016   ret.rem = dt.rem;
1017
1018   return ret;
1019
1020 }
1021 #endif /* ifdef __i386__ */
1022
1023
1024 /*********************************************************************
1025  *              ldiv (MSVCRT.@)
1026  * VERSION
1027  *      [i386] Windows binary compatible - returns the struct in eax/edx.
1028  */
1029 #ifdef __i386__
1030 unsigned __int64 CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1031 {
1032   ldiv_t ldt = ldiv(num,denom);
1033   return ((unsigned __int64)ldt.rem << 32) | (MSVCRT_ulong)ldt.quot;
1034 }
1035 #else
1036 /*********************************************************************
1037  *              ldiv (MSVCRT.@)
1038  * VERSION
1039  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1040  */
1041 MSVCRT_ldiv_t CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1042 {
1043   ldiv_t result = ldiv(num,denom);
1044
1045   MSVCRT_ldiv_t ret;
1046   ret.quot = result.quot;
1047   ret.rem = result.rem;
1048
1049   return ret;
1050 }
1051 #endif /* ifdef __i386__ */
1052
1053 #ifdef __i386__
1054
1055 /*********************************************************************
1056  *              _adjust_fdiv (MSVCRT.@)
1057  * Used by the MSVC compiler to work around the Pentium FDIV bug.
1058  */
1059 int MSVCRT__adjust_fdiv = 0;
1060
1061 /***********************************************************************
1062  *              _adj_fdiv_m16i (MSVCRT.@)
1063  *
1064  * NOTE
1065  *    I _think_ this function is intended to work around the Pentium
1066  *    fdiv bug.
1067  */
1068 void __stdcall _adj_fdiv_m16i( short arg )
1069 {
1070   TRACE("(): stub\n");
1071 }
1072
1073 /***********************************************************************
1074  *              _adj_fdiv_m32 (MSVCRT.@)
1075  *
1076  * NOTE
1077  *    I _think_ this function is intended to work around the Pentium
1078  *    fdiv bug.
1079  */
1080 void __stdcall _adj_fdiv_m32( unsigned int arg )
1081 {
1082   TRACE("(): stub\n");
1083 }
1084
1085 /***********************************************************************
1086  *              _adj_fdiv_m32i (MSVCRT.@)
1087  *
1088  * NOTE
1089  *    I _think_ this function is intended to work around the Pentium
1090  *    fdiv bug.
1091  */
1092 void __stdcall _adj_fdiv_m32i( int arg )
1093 {
1094   TRACE("(): stub\n");
1095 }
1096
1097 /***********************************************************************
1098  *              _adj_fdiv_m64 (MSVCRT.@)
1099  *
1100  * NOTE
1101  *    I _think_ this function is intended to work around the Pentium
1102  *    fdiv bug.
1103  */
1104 void __stdcall _adj_fdiv_m64( unsigned __int64 arg )
1105 {
1106   TRACE("(): stub\n");
1107 }
1108
1109 /***********************************************************************
1110  *              _adj_fdiv_r (MSVCRT.@)
1111  * FIXME
1112  *    This function is likely to have the wrong number of arguments.
1113  *
1114  * NOTE
1115  *    I _think_ this function is intended to work around the Pentium
1116  *    fdiv bug.
1117  */
1118 void _adj_fdiv_r(void)
1119 {
1120   TRACE("(): stub\n");
1121 }
1122
1123 /***********************************************************************
1124  *              _adj_fdivr_m16i (MSVCRT.@)
1125  *
1126  * NOTE
1127  *    I _think_ this function is intended to work around the Pentium
1128  *    fdiv bug.
1129  */
1130 void __stdcall _adj_fdivr_m16i( short arg )
1131 {
1132   TRACE("(): stub\n");
1133 }
1134
1135 /***********************************************************************
1136  *              _adj_fdivr_m32 (MSVCRT.@)
1137  *
1138  * NOTE
1139  *    I _think_ this function is intended to work around the Pentium
1140  *    fdiv bug.
1141  */
1142 void __stdcall _adj_fdivr_m32( unsigned int arg )
1143 {
1144   TRACE("(): stub\n");
1145 }
1146
1147 /***********************************************************************
1148  *              _adj_fdivr_m32i (MSVCRT.@)
1149  *
1150  * NOTE
1151  *    I _think_ this function is intended to work around the Pentium
1152  *    fdiv bug.
1153  */
1154 void __stdcall _adj_fdivr_m32i( int arg )
1155 {
1156   TRACE("(): stub\n");
1157 }
1158
1159 /***********************************************************************
1160  *              _adj_fdivr_m64 (MSVCRT.@)
1161  *
1162  * NOTE
1163  *    I _think_ this function is intended to work around the Pentium
1164  *    fdiv bug.
1165  */
1166 void __stdcall _adj_fdivr_m64( unsigned __int64 arg )
1167 {
1168   TRACE("(): stub\n");
1169 }
1170
1171 /***********************************************************************
1172  *              _adj_fpatan (MSVCRT.@)
1173  * FIXME
1174  *    This function is likely to have the wrong number of arguments.
1175  *
1176  * NOTE
1177  *    I _think_ this function is intended to work around the Pentium
1178  *    fdiv bug.
1179  */
1180 void _adj_fpatan(void)
1181 {
1182   TRACE("(): stub\n");
1183 }
1184
1185 /***********************************************************************
1186  *              _adj_fprem (MSVCRT.@)
1187  * FIXME
1188  *    This function is likely to have the wrong number of arguments.
1189  *
1190  * NOTE
1191  *    I _think_ this function is intended to work around the Pentium
1192  *    fdiv bug.
1193  */
1194 void _adj_fprem(void)
1195 {
1196   TRACE("(): stub\n");
1197 }
1198
1199 /***********************************************************************
1200  *              _adj_fprem1 (MSVCRT.@)
1201  * FIXME
1202  *    This function is likely to have the wrong number of arguments.
1203  *
1204  * NOTE
1205  *    I _think_ this function is intended to work around the Pentium
1206  *    fdiv bug.
1207  */
1208 void _adj_fprem1(void)
1209 {
1210   TRACE("(): stub\n");
1211 }
1212
1213 /***********************************************************************
1214  *              _adj_fptan (MSVCRT.@)
1215  * FIXME
1216  *    This function is likely to have the wrong number of arguments.
1217  *
1218  * NOTE
1219  *    I _think_ this function is intended to work around the Pentium
1220  *    fdiv bug.
1221  */
1222 void _adj_fptan(void)
1223 {
1224   TRACE("(): stub\n");
1225 }
1226
1227 /***********************************************************************
1228  *              _safe_fdiv (MSVCRT.@)
1229  * FIXME
1230  *    This function is likely to have the wrong number of arguments.
1231  *
1232  * NOTE
1233  *    I _think_ this function is intended to work around the Pentium
1234  *    fdiv bug.
1235  */
1236 void _safe_fdiv(void)
1237 {
1238   TRACE("(): stub\n");
1239 }
1240
1241 /***********************************************************************
1242  *              _safe_fdivr (MSVCRT.@)
1243  * FIXME
1244  *    This function is likely to have the wrong number of arguments.
1245  *
1246  * NOTE
1247  *    I _think_ this function is intended to work around the Pentium
1248  *    fdiv bug.
1249  */
1250 void _safe_fdivr(void)
1251 {
1252   TRACE("(): stub\n");
1253 }
1254
1255 /***********************************************************************
1256  *              _safe_fprem (MSVCRT.@)
1257  * FIXME
1258  *    This function is likely to have the wrong number of arguments.
1259  *
1260  * NOTE
1261  *    I _think_ this function is intended to work around the Pentium
1262  *    fdiv bug.
1263  */
1264 void _safe_fprem(void)
1265 {
1266   TRACE("(): stub\n");
1267 }
1268
1269 /***********************************************************************
1270  *              _safe_fprem1 (MSVCRT.@)
1271  *
1272  * FIXME
1273  *    This function is likely to have the wrong number of arguments.
1274  *
1275  * NOTE
1276  *    I _think_ this function is intended to work around the Pentium
1277  *    fdiv bug.
1278  */
1279 void _safe_fprem1(void)
1280 {
1281   TRACE("(): stub\n");
1282 }
1283
1284 #endif  /* __i386__ */