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 (CDECL *MSVCRT_matherr_func)(struct MSVCRT__exception *);
  51
  52 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
  53
  54 static BOOL sse2_supported;
  55 static BOOL sse2_enabled;
  56
  57 void msvcrt_init_math(void)
  58 {
  59     sse2_supported = sse2_enabled = IsProcessorFeaturePresent( PF_XMMI64_INSTRUCTIONS_AVAILABLE );
  60 }
  61
  62 /*********************************************************************
  63  *      _set_SSE2_enable (MSVCRT.@)
  64  */
  65 int CDECL MSVCRT__set_SSE2_enable(int flag)
  66 {
  67     sse2_enabled = flag && sse2_supported;
  68     return sse2_enabled;
  69 }
  70
  71 #ifdef __x86_64__
  72
  73 /*********************************************************************
  74  *      MSVCRT_acosf (MSVCRT.@)
  75  */
  76 float CDECL MSVCRT_acosf( float x )
  77 {
  78   if (x < -1.0 || x > 1.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
  79   /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
  80    * asin() uses a similar construction. This is bad because as x gets nearer to
  81    * 1 the error in the expression "1 - x^2" can get relatively large due to
  82    * cancellation. The sqrt() makes things worse. A safer way to calculate
  83    * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
  84   return atan2f(sqrtf((1 - x) * (1 + x)), x);
  85 }
  86
  87 /*********************************************************************
  88  *      MSVCRT_asinf (MSVCRT.@)
  89  */
  90 float CDECL MSVCRT_asinf( float x )
  91 {
  92   if (x < -1.0 || x > 1.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
  93   return atan2f(x, sqrtf((1 - x) * (1 + x)));
  94 }
  95
  96 /*********************************************************************
  97  *      MSVCRT_atanf (MSVCRT.@)
  98  */
  99 float CDECL MSVCRT_atanf( float x )
 100 {
 101   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 102   return atanf(x);
 103 }
 104
 105 /*********************************************************************
 106  *              MSVCRT_atan2f (MSVCRT.@)
 107  */
 108 float CDECL MSVCRT_atan2f( float x, float y )
 109 {
 110   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 111   return atan2f(x,y);
 112 }
 113
 114 /*********************************************************************
 115  *      MSVCRT_cosf (MSVCRT.@)
 116  */
 117 float CDECL MSVCRT_cosf( float x )
 118 {
 119   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 120   return cosf(x);
 121 }
 122
 123 /*********************************************************************
 124  *      MSVCRT_coshf (MSVCRT.@)
 125  */
 126 float CDECL MSVCRT_coshf( float x )
 127 {
 128   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 129   return coshf(x);
 130 }
 131
 132 /*********************************************************************
 133  *      MSVCRT_expf (MSVCRT.@)
 134  */
 135 float CDECL MSVCRT_expf( float x )
 136 {
 137   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 138   return expf(x);
 139 }
 140
 141 /*********************************************************************
 142  *      MSVCRT_fmodf (MSVCRT.@)
 143  */
 144 float CDECL MSVCRT_fmodf( float x, float y )
 145 {
 146   if (!finitef(x) || !finitef(y)) *MSVCRT__errno() = MSVCRT_EDOM;
 147   return fmodf(x,y);
 148 }
 149
 150 /*********************************************************************
 151  *      MSVCRT_logf (MSVCRT.@)
 152  */
 153 float CDECL MSVCRT_logf( float x)
 154 {
 155   if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 156   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 157   return logf(x);
 158 }
 159
 160 /*********************************************************************
 161  *      MSVCRT_log10f (MSVCRT.@)
 162  */
 163 float CDECL MSVCRT_log10f( float x )
 164 {
 165   if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 166   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 167   return log10f(x);
 168 }
 169
 170 /*********************************************************************
 171  *      MSVCRT_powf (MSVCRT.@)
 172  */
 173 float CDECL MSVCRT_powf( float x, float y )
 174 {
 175   /* FIXME: If x < 0 and y is not integral, set EDOM */
 176   float z = powf(x,y);
 177   if (!finitef(z)) *MSVCRT__errno() = MSVCRT_EDOM;
 178   return z;
 179 }
 180
 181 /*********************************************************************
 182  *      MSVCRT_sinf (MSVCRT.@)
 183  */
 184 float CDECL MSVCRT_sinf( float x )
 185 {
 186   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 187   return sinf(x);
 188 }
 189
 190 /*********************************************************************
 191  *      MSVCRT_sinhf (MSVCRT.@)
 192  */
 193 float CDECL MSVCRT_sinhf( float x )
 194 {
 195   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 196   return sinhf(x);
 197 }
 198
 199 /*********************************************************************
 200  *      MSVCRT_sqrtf (MSVCRT.@)
 201  */
 202 float CDECL MSVCRT_sqrtf( float x )
 203 {
 204   if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 205   return sqrtf(x);
 206 }
 207
 208 /*********************************************************************
 209  *      MSVCRT_tanf (MSVCRT.@)
 210  */
 211 float CDECL MSVCRT_tanf( float x )
 212 {
 213   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 214   return tanf(x);
 215 }
 216
 217 /*********************************************************************
 218  *      MSVCRT_tanhf (MSVCRT.@)
 219  */
 220 float CDECL MSVCRT_tanhf( float x )
 221 {
 222   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 223   return tanhf(x);
 224 }
 225
 226 /*********************************************************************
 227  *      ceilf (MSVCRT.@)
 228  */
 229 float CDECL MSVCRT_ceilf( float x )
 230 {
 231   return ceilf(x);
 232 }
 233
 234 /*********************************************************************
 235  *      floorf (MSVCRT.@)
 236  */
 237 float CDECL MSVCRT_floorf( float x )
 238 {
 239   return floorf(x);
 240 }
 241
 242 /*********************************************************************
 243  *      frexpf (MSVCRT.@)
 244  */
 245 float CDECL MSVCRT_frexpf( float x, int *exp )
 246 {
 247   return frexpf( x, exp );
 248 }
 249
 250 /*********************************************************************
 251  *      _scalbf (MSVCRT.@)
 252  */
 253 float CDECL MSVCRT__scalbf(float num, MSVCRT_long power)
 254 {
 255   if (!finitef(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 256   return ldexpf(num, power);
 257 }
 258
 259 /*********************************************************************
 260  *      modff (MSVCRT.@)
 261  */
 262 double CDECL MSVCRT_modff( float x, float *iptr )
 263 {
 264   return modff( x, iptr );
 265 }
 266
 267 #endif
 268
 269 /*********************************************************************
 270  *              MSVCRT_acos (MSVCRT.@)
 271  */
 272 double CDECL MSVCRT_acos( double x )
 273 {
 274   if (x < -1.0 || x > 1.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 275   /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
 276    * asin() uses a similar construction. This is bad because as x gets nearer to
 277    * 1 the error in the expression "1 - x^2" can get relatively large due to
 278    * cancellation. The sqrt() makes things worse. A safer way to calculate
 279    * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
 280   return atan2(sqrt((1 - x) * (1 + x)), x);
 281 }
 282
 283 /*********************************************************************
 284  *              MSVCRT_asin (MSVCRT.@)
 285  */
 286 double CDECL MSVCRT_asin( double x )
 287 {
 288   if (x < -1.0 || x > 1.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 289   return atan2(x, sqrt((1 - x) * (1 + x)));
 290 }
 291
 292 /*********************************************************************
 293  *              MSVCRT_atan (MSVCRT.@)
 294  */
 295 double CDECL MSVCRT_atan( double x )
 296 {
 297   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 298   return atan(x);
 299 }
 300
 301 /*********************************************************************
 302  *              MSVCRT_atan2 (MSVCRT.@)
 303  */
 304 double CDECL MSVCRT_atan2( double x, double y )
 305 {
 306   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 307   return atan2(x,y);
 308 }
 309
 310 /*********************************************************************
 311  *              MSVCRT_cos (MSVCRT.@)
 312  */
 313 double CDECL MSVCRT_cos( double x )
 314 {
 315   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 316   return cos(x);
 317 }
 318
 319 /*********************************************************************
 320  *              MSVCRT_cosh (MSVCRT.@)
 321  */
 322 double CDECL MSVCRT_cosh( double x )
 323 {
 324   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 325   return cosh(x);
 326 }
 327
 328 /*********************************************************************
 329  *              MSVCRT_exp (MSVCRT.@)
 330  */
 331 double CDECL MSVCRT_exp( double x )
 332 {
 333   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 334   return exp(x);
 335 }
 336
 337 /*********************************************************************
 338  *              MSVCRT_fmod (MSVCRT.@)
 339  */
 340 double CDECL MSVCRT_fmod( double x, double y )
 341 {
 342   if (!finite(x) || !finite(y)) *MSVCRT__errno() = MSVCRT_EDOM;
 343   return fmod(x,y);
 344 }
 345
 346 /*********************************************************************
 347  *              MSVCRT_log (MSVCRT.@)
 348  */
 349 double CDECL MSVCRT_log( double x)
 350 {
 351   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 352   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 353   return log(x);
 354 }
 355
 356 /*********************************************************************
 357  *              MSVCRT_log10 (MSVCRT.@)
 358  */
 359 double CDECL MSVCRT_log10( double x )
 360 {
 361   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 362   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 363   return log10(x);
 364 }
 365
 366 /*********************************************************************
 367  *              MSVCRT_pow (MSVCRT.@)
 368  */
 369 double CDECL MSVCRT_pow( double x, double y )
 370 {
 371   /* FIXME: If x < 0 and y is not integral, set EDOM */
 372   double z = pow(x,y);
 373   if (!finite(z)) *MSVCRT__errno() = MSVCRT_EDOM;
 374   return z;
 375 }
 376
 377 /*********************************************************************
 378  *              MSVCRT_sin (MSVCRT.@)
 379  */
 380 double CDECL MSVCRT_sin( double x )
 381 {
 382   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 383   return sin(x);
 384 }
 385
 386 /*********************************************************************
 387  *              MSVCRT_sinh (MSVCRT.@)
 388  */
 389 double CDECL MSVCRT_sinh( double x )
 390 {
 391   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 392   return sinh(x);
 393 }
 394
 395 /*********************************************************************
 396  *              MSVCRT_sqrt (MSVCRT.@)
 397  */
 398 double CDECL MSVCRT_sqrt( double x )
 399 {
 400   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 401   return sqrt(x);
 402 }
 403
 404 /*********************************************************************
 405  *              MSVCRT_tan (MSVCRT.@)
 406  */
 407 double CDECL MSVCRT_tan( double x )
 408 {
 409   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 410   return tan(x);
 411 }
 412
 413 /*********************************************************************
 414  *              MSVCRT_tanh (MSVCRT.@)
 415  */
 416 double CDECL MSVCRT_tanh( double x )
 417 {
 418   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 419   return tanh(x);
 420 }
 421
 422
 423 #if defined(__GNUC__) && defined(__i386__)
 424
 425 #define FPU_DOUBLE(var) double var; \
 426   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 427 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 428   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 429   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 430
 431 /*********************************************************************
 432  *              _CIacos (MSVCRT.@)
 433  */
 434 double CDECL _CIacos(void)
 435 {
 436   FPU_DOUBLE(x);
 437   return MSVCRT_acos(x);
 438 }
 439
 440 /*********************************************************************
 441  *              _CIasin (MSVCRT.@)
 442  */
 443 double CDECL _CIasin(void)
 444 {
 445   FPU_DOUBLE(x);
 446   return MSVCRT_asin(x);
 447 }
 448
 449 /*********************************************************************
 450  *              _CIatan (MSVCRT.@)
 451  */
 452 double CDECL _CIatan(void)
 453 {
 454   FPU_DOUBLE(x);
 455   return MSVCRT_atan(x);
 456 }
 457
 458 /*********************************************************************
 459  *              _CIatan2 (MSVCRT.@)
 460  */
 461 double CDECL _CIatan2(void)
 462 {
 463   FPU_DOUBLES(x,y);
 464   return MSVCRT_atan2(x,y);
 465 }
 466
 467 /*********************************************************************
 468  *              _CIcos (MSVCRT.@)
 469  */
 470 double CDECL _CIcos(void)
 471 {
 472   FPU_DOUBLE(x);
 473   return MSVCRT_cos(x);
 474 }
 475
 476 /*********************************************************************
 477  *              _CIcosh (MSVCRT.@)
 478  */
 479 double CDECL _CIcosh(void)
 480 {
 481   FPU_DOUBLE(x);
 482   return MSVCRT_cosh(x);
 483 }
 484
 485 /*********************************************************************
 486  *              _CIexp (MSVCRT.@)
 487  */
 488 double CDECL _CIexp(void)
 489 {
 490   FPU_DOUBLE(x);
 491   return MSVCRT_exp(x);
 492 }
 493
 494 /*********************************************************************
 495  *              _CIfmod (MSVCRT.@)
 496  */
 497 double CDECL _CIfmod(void)
 498 {
 499   FPU_DOUBLES(x,y);
 500   return MSVCRT_fmod(x,y);
 501 }
 502
 503 /*********************************************************************
 504  *              _CIlog (MSVCRT.@)
 505  */
 506 double CDECL _CIlog(void)
 507 {
 508   FPU_DOUBLE(x);
 509   return MSVCRT_log(x);
 510 }
 511
 512 /*********************************************************************
 513  *              _CIlog10 (MSVCRT.@)
 514  */
 515 double CDECL _CIlog10(void)
 516 {
 517   FPU_DOUBLE(x);
 518   return MSVCRT_log10(x);
 519 }
 520
 521 /*********************************************************************
 522  *              _CIpow (MSVCRT.@)
 523  */
 524 double CDECL _CIpow(void)
 525 {
 526   FPU_DOUBLES(x,y);
 527   return MSVCRT_pow(x,y);
 528 }
 529
 530 /*********************************************************************
 531  *              _CIsin (MSVCRT.@)
 532  */
 533 double CDECL _CIsin(void)
 534 {
 535   FPU_DOUBLE(x);
 536   return MSVCRT_sin(x);
 537 }
 538
 539 /*********************************************************************
 540  *              _CIsinh (MSVCRT.@)
 541  */
 542 double CDECL _CIsinh(void)
 543 {
 544   FPU_DOUBLE(x);
 545   return MSVCRT_sinh(x);
 546 }
 547
 548 /*********************************************************************
 549  *              _CIsqrt (MSVCRT.@)
 550  */
 551 double CDECL _CIsqrt(void)
 552 {
 553   FPU_DOUBLE(x);
 554   return MSVCRT_sqrt(x);
 555 }
 556
 557 /*********************************************************************
 558  *              _CItan (MSVCRT.@)
 559  */
 560 double CDECL _CItan(void)
 561 {
 562   FPU_DOUBLE(x);
 563   return MSVCRT_tan(x);
 564 }
 565
 566 /*********************************************************************
 567  *              _CItanh (MSVCRT.@)
 568  */
 569 double CDECL _CItanh(void)
 570 {
 571   FPU_DOUBLE(x);
 572   return MSVCRT_tanh(x);
 573 }
 574
 575 #endif /* defined(__GNUC__) && defined(__i386__) */
 576
 577 /*********************************************************************
 578  *              _fpclass (MSVCRT.@)
 579  */
 580 int CDECL _fpclass(double num)
 581 {
 582 #if defined(HAVE_FPCLASS) || defined(fpclass)
 583   switch (fpclass( num ))
 584   {
 585 #ifdef FP_SNAN
 586   case FP_SNAN:  return MSVCRT__FPCLASS_SNAN;
 587 #endif
 588 #ifdef FP_QNAN
 589   case FP_QNAN:  return MSVCRT__FPCLASS_QNAN;
 590 #endif
 591 #ifdef FP_NINF
 592   case FP_NINF:  return MSVCRT__FPCLASS_NINF;
 593 #endif
 594 #ifdef FP_PINF
 595   case FP_PINF:  return MSVCRT__FPCLASS_PINF;
 596 #endif
 597 #ifdef FP_NDENORM
 598   case FP_NDENORM: return MSVCRT__FPCLASS_ND;
 599 #endif
 600 #ifdef FP_PDENORM
 601   case FP_PDENORM: return MSVCRT__FPCLASS_PD;
 602 #endif
 603 #ifdef FP_NZERO
 604   case FP_NZERO: return MSVCRT__FPCLASS_NZ;
 605 #endif
 606 #ifdef FP_PZERO
 607   case FP_PZERO: return MSVCRT__FPCLASS_PZ;
 608 #endif
 609 #ifdef FP_NNORM
 610   case FP_NNORM: return MSVCRT__FPCLASS_NN;
 611 #endif
 612 #ifdef FP_PNORM
 613   case FP_PNORM: return MSVCRT__FPCLASS_PN;
 614 #endif
 615   default: return MSVCRT__FPCLASS_PN;
 616   }
 617 #elif defined (fpclassify)
 618   switch (fpclassify( num ))
 619   {
 620   case FP_NAN: return MSVCRT__FPCLASS_QNAN;
 621   case FP_INFINITE: return signbit(num) ? MSVCRT__FPCLASS_NINF : MSVCRT__FPCLASS_PINF;
 622   case FP_SUBNORMAL: return signbit(num) ?MSVCRT__FPCLASS_ND : MSVCRT__FPCLASS_PD;
 623   case FP_ZERO: return signbit(num) ? MSVCRT__FPCLASS_NZ : MSVCRT__FPCLASS_PZ;
 624   }
 625   return signbit(num) ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN;
 626 #else
 627   if (!finite(num))
 628     return MSVCRT__FPCLASS_QNAN;
 629   return num == 0.0 ? MSVCRT__FPCLASS_PZ : (num < 0 ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN);
 630 #endif
 631 }
 632
 633 /*********************************************************************
 634  *              _rotl (MSVCRT.@)
 635  */
 636 unsigned int CDECL _rotl(unsigned int num, int shift)
 637 {
 638   shift &= 31;
 639   return (num << shift) | (num >> (32-shift));
 640 }
 641
 642 /*********************************************************************
 643  *              _logb (MSVCRT.@)
 644  */
 645 double CDECL _logb(double num)
 646 {
 647   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 648   return logb(num);
 649 }
 650
 651 /*********************************************************************
 652  *              _lrotl (MSVCRT.@)
 653  */
 654 MSVCRT_ulong CDECL MSVCRT__lrotl(MSVCRT_ulong num, int shift)
 655 {
 656   shift &= 0x1f;
 657   return (num << shift) | (num >> (32-shift));
 658 }
 659
 660 /*********************************************************************
 661  *              _lrotr (MSVCRT.@)
 662  */
 663 MSVCRT_ulong CDECL MSVCRT__lrotr(MSVCRT_ulong num, int shift)
 664 {
 665   shift &= 0x1f;
 666   return (num >> shift) | (num << (32-shift));
 667 }
 668
 669 /*********************************************************************
 670  *              _rotr (MSVCRT.@)
 671  */
 672 unsigned int CDECL _rotr(unsigned int num, int shift)
 673 {
 674     shift &= 0x1f;
 675     return (num >> shift) | (num << (32-shift));
 676 }
 677
 678 /*********************************************************************
 679  *              _scalb (MSVCRT.@)
 680  */
 681 double CDECL MSVCRT__scalb(double num, MSVCRT_long power)
 682 {
 683   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 684   return ldexp(num, power);
 685 }
 686
 687 /*********************************************************************
 688  *              _hypot (MSVCRT.@)
 689  */
 690 double CDECL _hypot(double x, double y)
 691 {
 692   /* FIXME: errno handling */
 693   return hypot( x, y );
 694 }
 695
 696 /*********************************************************************
 697  *      _hypotf (MSVCRT.@)
 698  */
 699 float CDECL _hypotf(float x, float y)
 700 {
 701   /* FIXME: errno handling */
 702   return hypotf( x, y );
 703 }
 704
 705 /*********************************************************************
 706  *              ceil (MSVCRT.@)
 707  */
 708 double CDECL MSVCRT_ceil( double x )
 709 {
 710   return ceil(x);
 711 }
 712
 713 /*********************************************************************
 714  *              floor (MSVCRT.@)
 715  */
 716 double CDECL MSVCRT_floor( double x )
 717 {
 718   return floor(x);
 719 }
 720
 721 /*********************************************************************
 722  *              fabs (MSVCRT.@)
 723  */
 724 double CDECL MSVCRT_fabs( double x )
 725 {
 726   return fabs(x);
 727 }
 728
 729 /*********************************************************************
 730  *              frexp (MSVCRT.@)
 731  */
 732 double CDECL MSVCRT_frexp( double x, int *exp )
 733 {
 734   return frexp( x, exp );
 735 }
 736
 737 /*********************************************************************
 738  *              modf (MSVCRT.@)
 739  */
 740 double CDECL MSVCRT_modf( double x, double *iptr )
 741 {
 742   return modf( x, iptr );
 743 }
 744
 745 /*********************************************************************
 746  *              _matherr (MSVCRT.@)
 747  */
 748 int CDECL MSVCRT__matherr(struct MSVCRT__exception *e)
 749 {
 750   if (e)
 751     TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
 752           e->retval);
 753   else
 754     TRACE("(null)\n");
 755   if (MSVCRT_default_matherr_func)
 756     return MSVCRT_default_matherr_func(e);
 757   ERR(":Unhandled math error!\n");
 758   return 0;
 759 }
 760
 761 /*********************************************************************
 762  *              __setusermatherr (MSVCRT.@)
 763  */
 764 void CDECL MSVCRT___setusermatherr(MSVCRT_matherr_func func)
 765 {
 766   MSVCRT_default_matherr_func = func;
 767   TRACE(":new matherr handler %p\n", func);
 768 }
 769
 770 /**********************************************************************
 771  *              _statusfp2 (MSVCRT.@)
 772  *
 773  * Not exported by native msvcrt, added in msvcr80.
 774  */
 775 #if defined(__i386__) || defined(__x86_64__)
 776 void CDECL _statusfp2( unsigned int *x86_sw, unsigned int *sse2_sw )
 777 {
 778 #ifdef __GNUC__
 779     unsigned int flags;
 780     unsigned long fpword;
 781
 782     if (x86_sw)
 783     {
 784         __asm__ __volatile__( "fstsw %0" : "=m" (fpword) );
 785         flags = 0;
 786         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
 787         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
 788         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
 789         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
 790         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
 791         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
 792         *x86_sw = flags;
 793     }
 794
 795     if (!sse2_sw) return;
 796
 797     if (sse2_supported)
 798     {
 799         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
 800         flags = 0;
 801         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
 802         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
 803         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
 804         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
 805         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
 806         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
 807         *sse2_sw = flags;
 808     }
 809     else *sse2_sw = 0;
 810 #else
 811     FIXME( "not implemented\n" );
 812 #endif
 813 }
 814 #endif
 815
 816 /**********************************************************************
 817  *              _statusfp (MSVCRT.@)
 818  */
 819 unsigned int CDECL _statusfp(void)
 820 {
 821 #if defined(__i386__) || defined(__x86_64__)
 822     unsigned int x86_sw, sse2_sw;
 823
 824     _statusfp2( &x86_sw, &sse2_sw );
 825     /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
 826     return x86_sw | sse2_sw;
 827 #else
 828     FIXME( "not implemented\n" );
 829     return 0;
 830 #endif
 831 }
 832
 833 /*********************************************************************
 834  *              _clearfp (MSVCRT.@)
 835  */
 836 unsigned int CDECL _clearfp(void)
 837 {
 838     unsigned int flags = 0;
 839 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 840     unsigned long fpword;
 841
 842     __asm__ __volatile__( "fnstsw %0; fnclex" : "=m" (fpword) );
 843     if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
 844     if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
 845     if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
 846     if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
 847     if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
 848     if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
 849
 850     if (sse2_supported)
 851     {
 852         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
 853         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
 854         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
 855         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
 856         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
 857         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
 858         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
 859         fpword &= ~0x3f;
 860         __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
 861     }
 862 #else
 863     FIXME( "not implemented\n" );
 864 #endif
 865     return flags;
 866 }
 867
 868 /*********************************************************************
 869  *              __fpecode (MSVCRT.@)
 870  */
 871 int * CDECL __fpecode(void)
 872 {
 873     return &msvcrt_get_thread_data()->fpecode;
 874 }
 875
 876 /*********************************************************************
 877  *              ldexp (MSVCRT.@)
 878  */
 879 double CDECL MSVCRT_ldexp(double num, MSVCRT_long exp)
 880 {
 881   double z = ldexp(num,exp);
 882
 883   if (!finite(z))
 884     *MSVCRT__errno() = MSVCRT_ERANGE;
 885   else if (z == 0 && signbit(z))
 886     z = 0.0; /* Convert -0 -> +0 */
 887   return z;
 888 }
 889
 890 /*********************************************************************
 891  *              _cabs (MSVCRT.@)
 892  */
 893 double CDECL MSVCRT__cabs(struct MSVCRT__complex num)
 894 {
 895   return sqrt(num.x * num.x + num.y * num.y);
 896 }
 897
 898 /*********************************************************************
 899  *              _chgsign (MSVCRT.@)
 900  */
 901 double CDECL _chgsign(double num)
 902 {
 903   /* FIXME: +-infinity,Nan not tested */
 904   return -num;
 905 }
 906
 907 /*********************************************************************
 908  *              __control87_2 (MSVCRT.@)
 909  *
 910  * Not exported by native msvcrt, added in msvcr80.
 911  */
 912 #if defined(__i386__) || defined(__x86_64__)
 913 int CDECL __control87_2( unsigned int newval, unsigned int mask,
 914                          unsigned int *x86_cw, unsigned int *sse2_cw )
 915 {
 916 #ifdef __GNUC__
 917     unsigned long fpword;
 918     unsigned int flags;
 919
 920     if (x86_cw)
 921     {
 922         __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
 923
 924         /* Convert into mask constants */
 925         flags = 0;
 926         if (fpword & 0x1)  flags |= MSVCRT__EM_INVALID;
 927         if (fpword & 0x2)  flags |= MSVCRT__EM_DENORMAL;
 928         if (fpword & 0x4)  flags |= MSVCRT__EM_ZERODIVIDE;
 929         if (fpword & 0x8)  flags |= MSVCRT__EM_OVERFLOW;
 930         if (fpword & 0x10) flags |= MSVCRT__EM_UNDERFLOW;
 931         if (fpword & 0x20) flags |= MSVCRT__EM_INEXACT;
 932         switch (fpword & 0xc00)
 933         {
 934         case 0xc00: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
 935         case 0x800: flags |= MSVCRT__RC_UP; break;
 936         case 0x400: flags |= MSVCRT__RC_DOWN; break;
 937         }
 938         switch (fpword & 0x300)
 939         {
 940         case 0x0:   flags |= MSVCRT__PC_24; break;
 941         case 0x200: flags |= MSVCRT__PC_53; break;
 942         case 0x300: flags |= MSVCRT__PC_64; break;
 943         }
 944         if (fpword & 0x1000) flags |= MSVCRT__IC_AFFINE;
 945
 946         TRACE( "x86 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
 947         if (mask)
 948         {
 949             flags = (flags & ~mask) | (newval & mask);
 950
 951             /* Convert (masked) value back to fp word */
 952             fpword = 0;
 953             if (flags & MSVCRT__EM_INVALID)    fpword |= 0x1;
 954             if (flags & MSVCRT__EM_DENORMAL)   fpword |= 0x2;
 955             if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x4;
 956             if (flags & MSVCRT__EM_OVERFLOW)   fpword |= 0x8;
 957             if (flags & MSVCRT__EM_UNDERFLOW)  fpword |= 0x10;
 958             if (flags & MSVCRT__EM_INEXACT)    fpword |= 0x20;
 959             switch (flags & MSVCRT__MCW_RC)
 960             {
 961             case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0xc00; break;
 962             case MSVCRT__RC_UP:                 fpword |= 0x800; break;
 963             case MSVCRT__RC_DOWN:               fpword |= 0x400; break;
 964             }
 965             switch (flags & MSVCRT__MCW_PC)
 966             {
 967             case MSVCRT__PC_64: fpword |= 0x300; break;
 968             case MSVCRT__PC_53: fpword |= 0x200; break;
 969             case MSVCRT__PC_24: fpword |= 0x0; break;
 970             }
 971             if (flags & MSVCRT__IC_AFFINE) fpword |= 0x1000;
 972
 973             __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
 974         }
 975         *x86_cw = flags;
 976     }
 977
 978     if (!sse2_cw) return 1;
 979
 980     if (sse2_supported)
 981     {
 982         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
 983
 984         /* Convert into mask constants */
 985         flags = 0;
 986         if (fpword & 0x80)   flags |= MSVCRT__EM_INVALID;
 987         if (fpword & 0x100)  flags |= MSVCRT__EM_DENORMAL;
 988         if (fpword & 0x200)  flags |= MSVCRT__EM_ZERODIVIDE;
 989         if (fpword & 0x400)  flags |= MSVCRT__EM_OVERFLOW;
 990         if (fpword & 0x800)  flags |= MSVCRT__EM_UNDERFLOW;
 991         if (fpword & 0x1000) flags |= MSVCRT__EM_INEXACT;
 992         switch (fpword & 0x6000)
 993         {
 994         case 0x6000: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
 995         case 0x4000: flags |= MSVCRT__RC_UP; break;
 996         case 0x2000: flags |= MSVCRT__RC_DOWN; break;
 997         }
 998         switch (fpword & 0x8040)
 999         {
1000         case 0x0040: flags |= MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS; break;
1001         case 0x8000: flags |= MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS; break;
1002         case 0x8040: flags |= MSVCRT__DN_FLUSH; break;
1003         }
1004
1005         TRACE( "sse2 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1006         if (mask)
1007         {
1008             flags = (flags & ~mask) | (newval & mask);
1009
1010             /* Convert (masked) value back to fp word */
1011             fpword = 0;
1012             if (flags & MSVCRT__EM_INVALID)    fpword |= 0x80;
1013             if (flags & MSVCRT__EM_DENORMAL)   fpword |= 0x100;
1014             if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x200;
1015             if (flags & MSVCRT__EM_OVERFLOW)   fpword |= 0x400;
1016             if (flags & MSVCRT__EM_UNDERFLOW)  fpword |= 0x800;
1017             if (flags & MSVCRT__EM_INEXACT)    fpword |= 0x1000;
1018             switch (flags & MSVCRT__MCW_RC)
1019             {
1020             case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0x6000; break;
1021             case MSVCRT__RC_UP:                 fpword |= 0x4000; break;
1022             case MSVCRT__RC_DOWN:               fpword |= 0x2000; break;
1023             }
1024             switch (flags & MSVCRT__MCW_DN)
1025             {
1026             case MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS: fpword |= 0x0040; break;
1027             case MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS: fpword |= 0x8000; break;
1028             case MSVCRT__DN_FLUSH:                       fpword |= 0x8040; break;
1029             }
1030             __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
1031         }
1032         *sse2_cw = flags;
1033     }
1034     else *sse2_cw = 0;
1035
1036     return 1;
1037 #else
1038     FIXME( "not implemented\n" );
1039     return 0;
1040 #endif
1041 }
1042 #endif
1043
1044 /*********************************************************************
1045  *              _control87 (MSVCRT.@)
1046  */
1047 unsigned int CDECL _control87(unsigned int newval, unsigned int mask)
1048 {
1049 #if defined(__i386__) || defined(__x86_64__)
1050     unsigned int x86_cw, sse2_cw;
1051
1052     __control87_2( newval, mask, &x86_cw, &sse2_cw );
1053
1054     if ((x86_cw ^ sse2_cw) & (MSVCRT__MCW_EM | MSVCRT__MCW_RC)) x86_cw |= MSVCRT__EM_AMBIGUOUS;
1055     return x86_cw;
1056 #else
1057     FIXME( "not implemented\n" );
1058     return 0;
1059 #endif
1060 }
1061
1062 /*********************************************************************
1063  *              _controlfp (MSVCRT.@)
1064  */
1065 unsigned int CDECL _controlfp(unsigned int newval, unsigned int mask)
1066 {
1067   return _control87( newval, mask & ~MSVCRT__EM_DENORMAL );
1068 }
1069
1070 /*********************************************************************
1071  *              _controlfp_s (MSVCRT.@)
1072  */
1073 int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
1074 {
1075     static const unsigned int all_flags = (MSVCRT__MCW_EM | MSVCRT__MCW_IC | MSVCRT__MCW_RC |
1076                                            MSVCRT__MCW_PC | MSVCRT__MCW_DN);
1077     unsigned int val;
1078
1079     if (!MSVCRT_CHECK_PMT( !(newval & mask & ~all_flags) ))
1080     {
1081         if (cur) *cur = _controlfp( 0, 0 );  /* retrieve it anyway */
1082         *MSVCRT__errno() = MSVCRT_EINVAL;
1083         return MSVCRT_EINVAL;
1084     }
1085     val = _controlfp( newval, mask );
1086     if (cur) *cur = val;
1087     return 0;
1088 }
1089
1090 /*********************************************************************
1091  *              _copysign (MSVCRT.@)
1092  */
1093 double CDECL _copysign(double num, double sign)
1094 {
1095   /* FIXME: Behaviour for Nan/Inf? */
1096   if (sign < 0.0)
1097     return num < 0.0 ? num : -num;
1098   return num < 0.0 ? -num : num;
1099 }
1100
1101 /*********************************************************************
1102  *              _finite (MSVCRT.@)
1103  */
1104 int CDECL _finite(double num)
1105 {
1106   return (finite(num)?1:0); /* See comment for _isnan() */
1107 }
1108
1109 /*********************************************************************
1110  *              _fpreset (MSVCRT.@)
1111  */
1112 void CDECL _fpreset(void)
1113 {
1114 #if defined(__GNUC__) && defined(__i386__)
1115   __asm__ __volatile__( "fninit" );
1116 #else
1117   FIXME(":Not Implemented!\n");
1118 #endif
1119 }
1120
1121 /*********************************************************************
1122  *              _isnan (MSVCRT.@)
1123  */
1124 INT CDECL _isnan(double num)
1125 {
1126   /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
1127    * Do the same, as the result may be used in calculations
1128    */
1129   return isnan(num) ? 1 : 0;
1130 }
1131
1132 /*********************************************************************
1133  *              _j0 (MSVCRT.@)
1134  */
1135 double CDECL _j0(double num)
1136 {
1137   /* FIXME: errno handling */
1138   return j0(num);
1139 }
1140
1141 /*********************************************************************
1142  *              _j1 (MSVCRT.@)
1143  */
1144 double CDECL _j1(double num)
1145 {
1146   /* FIXME: errno handling */
1147   return j1(num);
1148 }
1149
1150 /*********************************************************************
1151  *              jn (MSVCRT.@)
1152  */
1153 double CDECL _jn(int n, double num)
1154 {
1155   /* FIXME: errno handling */
1156   return jn(n, num);
1157 }
1158
1159 /*********************************************************************
1160  *              _y0 (MSVCRT.@)
1161  */
1162 double CDECL _y0(double num)
1163 {
1164   double retval;
1165   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1166   retval  = y0(num);
1167   if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
1168   {
1169     *MSVCRT__errno() = MSVCRT_EDOM;
1170     retval = sqrt(-1);
1171   }
1172   return retval;
1173 }
1174
1175 /*********************************************************************
1176  *              _y1 (MSVCRT.@)
1177  */
1178 double CDECL _y1(double num)
1179 {
1180   double retval;
1181   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1182   retval  = y1(num);
1183   if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
1184   {
1185     *MSVCRT__errno() = MSVCRT_EDOM;
1186     retval = sqrt(-1);
1187   }
1188   return retval;
1189 }
1190
1191 /*********************************************************************
1192  *              _yn (MSVCRT.@)
1193  */
1194 double CDECL _yn(int order, double num)
1195 {
1196   double retval;
1197   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1198   retval  = yn(order,num);
1199   if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
1200   {
1201     *MSVCRT__errno() = MSVCRT_EDOM;
1202     retval = sqrt(-1);
1203   }
1204   return retval;
1205 }
1206
1207 /*********************************************************************
1208  *              _nextafter (MSVCRT.@)
1209  */
1210 double CDECL _nextafter(double num, double next)
1211 {
1212   double retval;
1213   if (!finite(num) || !finite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
1214   retval = nextafter(num,next);
1215   return retval;
1216 }
1217
1218 /*********************************************************************
1219  *              _ecvt (MSVCRT.@)
1220  */
1221 char * CDECL _ecvt( double number, int ndigits, int *decpt, int *sign )
1222 {
1223     int prec, len;
1224     thread_data_t *data = msvcrt_get_thread_data();
1225     /* FIXME: check better for overflow (native supports over 300 chars's) */
1226     ndigits = min( ndigits, 80 - 7); /* 7 : space for dec point, 1 for "e",
1227                                       * 4 for exponent and one for
1228                                       * terminating '\0' */
1229     if (!data->efcvt_buffer)
1230         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1231
1232     if( number < 0) {
1233         *sign = TRUE;
1234         number = -number;
1235     } else
1236         *sign = FALSE;
1237     /* handle cases with zero ndigits or less */
1238     prec = ndigits;
1239     if( prec < 1) prec = 2;
1240     len = snprintf(data->efcvt_buffer, 80, "%.*le", prec - 1, number);
1241     /* take the decimal "point away */
1242     if( prec != 1)
1243         memmove( data->efcvt_buffer + 1, data->efcvt_buffer + 2, len - 1 );
1244     /* take the exponential "e" out */
1245     data->efcvt_buffer[ prec] = '\0';
1246     /* read the exponent */
1247     sscanf( data->efcvt_buffer + prec + 1, "%d", decpt);
1248     (*decpt)++;
1249     /* adjust for some border cases */
1250     if( data->efcvt_buffer[0] == '0')/* value is zero */
1251         *decpt = 0;
1252     /* handle cases with zero ndigits or less */
1253     if( ndigits < 1){
1254         if( data->efcvt_buffer[ 0] >= '5')
1255             (*decpt)++;
1256         data->efcvt_buffer[ 0] = '\0';
1257     }
1258     TRACE("out=\"%s\"\n",data->efcvt_buffer);
1259     return data->efcvt_buffer;
1260 }
1261
1262 /*********************************************************************
1263  *              _ecvt_s (MSVCRT.@)
1264  */
1265 int CDECL _ecvt_s( char *buffer, MSVCRT_size_t length, double number, int ndigits, int *decpt, int *sign )
1266 {
1267     int prec, len;
1268     char *result;
1269     const char infret[] = "1#INF";
1270
1271     if(!MSVCRT_CHECK_PMT(buffer != NULL) || !MSVCRT_CHECK_PMT(decpt != NULL) || !MSVCRT_CHECK_PMT(sign != NULL))
1272     {
1273         *MSVCRT__errno() = MSVCRT_EINVAL;
1274         return MSVCRT_EINVAL;
1275     }
1276     if(!MSVCRT_CHECK_PMT(length > 2) || !MSVCRT_CHECK_PMT(ndigits < (int)length - 1))
1277     {
1278         *MSVCRT__errno() = MSVCRT_ERANGE;
1279         return MSVCRT_ERANGE;
1280     }
1281
1282     /* special case - inf */
1283     if(number == HUGE_VAL || number == -HUGE_VAL)
1284     {
1285         memset(buffer, '0', ndigits);
1286         memcpy(buffer, infret, min(ndigits, sizeof(infret) - 1 ) );
1287         buffer[ndigits] = '\0';
1288         (*decpt) = 1;
1289         if(number == -HUGE_VAL)
1290             (*sign) = 1;
1291         else
1292             (*sign) = 0;
1293         return 0;
1294     }
1295     result = (char*)MSVCRT_malloc(max(ndigits + 7, 7));
1296
1297     if( number < 0) {
1298         *sign = TRUE;
1299         number = -number;
1300     } else
1301         *sign = FALSE;
1302     /* handle cases with zero ndigits or less */
1303     prec = ndigits;
1304     if( prec < 1) prec = 2;
1305     len = snprintf(result, 80, "%.*le", prec - 1, number);
1306     /* take the decimal "point away */
1307     if( prec != 1)
1308         memmove( result + 1, result + 2, len - 1 );
1309     /* take the exponential "e" out */
1310     result[ prec] = '\0';
1311     /* read the exponent */
1312     sscanf( result + prec + 1, "%d", decpt);
1313     (*decpt)++;
1314     /* adjust for some border cases */
1315     if( result[0] == '0')/* value is zero */
1316         *decpt = 0;
1317     /* handle cases with zero ndigits or less */
1318     if( ndigits < 1){
1319         if( result[ 0] >= '5')
1320             (*decpt)++;
1321         result[ 0] = '\0';
1322     }
1323     memcpy( buffer, result, max(ndigits + 1, 1) );
1324     MSVCRT_free( result );
1325     return 0;
1326 }
1327
1328 /***********************************************************************
1329  *              _fcvt  (MSVCRT.@)
1330  */
1331 char * CDECL _fcvt( double number, int ndigits, int *decpt, int *sign )
1332 {
1333     thread_data_t *data = msvcrt_get_thread_data();
1334     int stop, dec1, dec2;
1335     char *ptr1, *ptr2, *first;
1336     char buf[80]; /* ought to be enough */
1337
1338     if (!data->efcvt_buffer)
1339         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1340
1341     if (number < 0)
1342     {
1343         *sign = 1;
1344         number = -number;
1345     } else *sign = 0;
1346
1347     snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1348     ptr1 = buf;
1349     ptr2 = data->efcvt_buffer;
1350     first = NULL;
1351     dec1 = 0;
1352     dec2 = 0;
1353
1354     /* For numbers below the requested resolution, work out where
1355        the decimal point will be rather than finding it in the string */
1356     if (number < 1.0 && number > 0.0) {
1357         dec2 = log10(number + 1e-10);
1358         if (-dec2 <= ndigits) dec2 = 0;
1359     }
1360
1361     /* If requested digits is zero or less, we will need to truncate
1362      * the returned string */
1363     if (ndigits < 1) {
1364         stop = strlen(buf) + ndigits;
1365     } else {
1366         stop = strlen(buf);
1367     }
1368
1369     while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1370     while (*ptr1 != '\0' && *ptr1 != '.') {
1371         if (!first) first = ptr2;
1372         if ((ptr1 - buf) < stop) {
1373             *ptr2++ = *ptr1++;
1374         } else {
1375             ptr1++;
1376         }
1377         dec1++;
1378     }
1379
1380     if (ndigits > 0) {
1381         ptr1++;
1382         if (!first) {
1383             while (*ptr1 == '0') { /* Process leading zeroes */
1384                 *ptr2++ = *ptr1++;
1385                 dec1--;
1386             }
1387         }
1388         while (*ptr1 != '\0') {
1389             if (!first) first = ptr2;
1390             *ptr2++ = *ptr1++;
1391         }
1392     }
1393
1394     *ptr2 = '\0';
1395
1396     /* We never found a non-zero digit, then our number is either
1397      * smaller than the requested precision, or 0.0 */
1398     if (!first) {
1399         if (number > 0.0) {
1400             first = ptr2;
1401         } else {
1402             first = data->efcvt_buffer;
1403             dec1 = 0;
1404         }
1405     }
1406
1407     *decpt = dec2 ? dec2 : dec1;
1408     return first;
1409 }
1410
1411 /***********************************************************************
1412  *              _gcvt  (MSVCRT.@)
1413  */
1414 char * CDECL _gcvt( double number, int ndigit, char *buff )
1415 {
1416     if(!buff) {
1417         *MSVCRT__errno() = MSVCRT_EINVAL;
1418         return NULL;
1419     }
1420
1421     if(ndigit < 0) {
1422         *MSVCRT__errno() = MSVCRT_ERANGE;
1423         return NULL;
1424     }
1425
1426     MSVCRT_sprintf(buff, "%.*g", ndigit, number);
1427     return buff;
1428 }
1429
1430 /***********************************************************************
1431  *              _gcvt_s  (MSVCRT.@)
1432  */
1433 int CDECL _gcvt_s(char *buff, MSVCRT_size_t size, double number, int digits)
1434 {
1435     int len;
1436
1437     if(!buff) {
1438         *MSVCRT__errno() = MSVCRT_EINVAL;
1439         return MSVCRT_EINVAL;
1440     }
1441
1442     if( digits<0 || digits>=size) {
1443         if(size)
1444             buff[0] = '\0';
1445
1446         *MSVCRT__errno() = MSVCRT_ERANGE;
1447         return MSVCRT_ERANGE;
1448     }
1449
1450     len = MSVCRT__scprintf("%.*g", digits, number);
1451     if(len > size) {
1452         buff[0] = '\0';
1453         *MSVCRT__errno() = MSVCRT_ERANGE;
1454         return MSVCRT_ERANGE;
1455     }
1456
1457     MSVCRT_sprintf(buff, "%.*g", digits, number);
1458     return 0;
1459 }
1460
1461 #include <stdlib.h> /* div_t, ldiv_t */
1462
1463 /*********************************************************************
1464  *              div (MSVCRT.@)
1465  * VERSION
1466  *      [i386] Windows binary compatible - returns the struct in eax/edx.
1467  */
1468 #ifdef __i386__
1469 unsigned __int64 CDECL MSVCRT_div(int num, int denom)
1470 {
1471   div_t dt = div(num,denom);
1472   return ((unsigned __int64)dt.rem << 32) | (unsigned int)dt.quot;
1473 }
1474 #else
1475 /*********************************************************************
1476  *              div (MSVCRT.@)
1477  * VERSION
1478  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1479  */
1480 MSVCRT_div_t CDECL MSVCRT_div(int num, int denom)
1481 {
1482   div_t dt = div(num,denom);
1483   MSVCRT_div_t     ret;
1484   ret.quot = dt.quot;
1485   ret.rem = dt.rem;
1486
1487   return ret;
1488
1489 }
1490 #endif /* ifdef __i386__ */
1491
1492
1493 /*********************************************************************
1494  *              ldiv (MSVCRT.@)
1495  * VERSION
1496  *      [i386] Windows binary compatible - returns the struct in eax/edx.
1497  */
1498 #ifdef __i386__
1499 unsigned __int64 CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1500 {
1501   ldiv_t ldt = ldiv(num,denom);
1502   return ((unsigned __int64)ldt.rem << 32) | (MSVCRT_ulong)ldt.quot;
1503 }
1504 #else
1505 /*********************************************************************
1506  *              ldiv (MSVCRT.@)
1507  * VERSION
1508  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1509  */
1510 MSVCRT_ldiv_t CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1511 {
1512   ldiv_t result = ldiv(num,denom);
1513
1514   MSVCRT_ldiv_t ret;
1515   ret.quot = result.quot;
1516   ret.rem = result.rem;
1517
1518   return ret;
1519 }
1520 #endif /* ifdef __i386__ */
1521
1522 #ifdef __i386__
1523
1524 /*********************************************************************
1525  *              _adjust_fdiv (MSVCRT.@)
1526  * Used by the MSVC compiler to work around the Pentium FDIV bug.
1527  */
1528 int MSVCRT__adjust_fdiv = 0;
1529
1530 /***********************************************************************
1531  *              _adj_fdiv_m16i (MSVCRT.@)
1532  *
1533  * NOTE
1534  *    I _think_ this function is intended to work around the Pentium
1535  *    fdiv bug.
1536  */
1537 void __stdcall _adj_fdiv_m16i( short arg )
1538 {
1539   TRACE("(): stub\n");
1540 }
1541
1542 /***********************************************************************
1543  *              _adj_fdiv_m32 (MSVCRT.@)
1544  *
1545  * NOTE
1546  *    I _think_ this function is intended to work around the Pentium
1547  *    fdiv bug.
1548  */
1549 void __stdcall _adj_fdiv_m32( unsigned int arg )
1550 {
1551   TRACE("(): stub\n");
1552 }
1553
1554 /***********************************************************************
1555  *              _adj_fdiv_m32i (MSVCRT.@)
1556  *
1557  * NOTE
1558  *    I _think_ this function is intended to work around the Pentium
1559  *    fdiv bug.
1560  */
1561 void __stdcall _adj_fdiv_m32i( int arg )
1562 {
1563   TRACE("(): stub\n");
1564 }
1565
1566 /***********************************************************************
1567  *              _adj_fdiv_m64 (MSVCRT.@)
1568  *
1569  * NOTE
1570  *    I _think_ this function is intended to work around the Pentium
1571  *    fdiv bug.
1572  */
1573 void __stdcall _adj_fdiv_m64( unsigned __int64 arg )
1574 {
1575   TRACE("(): stub\n");
1576 }
1577
1578 /***********************************************************************
1579  *              _adj_fdiv_r (MSVCRT.@)
1580  * FIXME
1581  *    This function is likely to have the wrong number of arguments.
1582  *
1583  * NOTE
1584  *    I _think_ this function is intended to work around the Pentium
1585  *    fdiv bug.
1586  */
1587 void _adj_fdiv_r(void)
1588 {
1589   TRACE("(): stub\n");
1590 }
1591
1592 /***********************************************************************
1593  *              _adj_fdivr_m16i (MSVCRT.@)
1594  *
1595  * NOTE
1596  *    I _think_ this function is intended to work around the Pentium
1597  *    fdiv bug.
1598  */
1599 void __stdcall _adj_fdivr_m16i( short arg )
1600 {
1601   TRACE("(): stub\n");
1602 }
1603
1604 /***********************************************************************
1605  *              _adj_fdivr_m32 (MSVCRT.@)
1606  *
1607  * NOTE
1608  *    I _think_ this function is intended to work around the Pentium
1609  *    fdiv bug.
1610  */
1611 void __stdcall _adj_fdivr_m32( unsigned int arg )
1612 {
1613   TRACE("(): stub\n");
1614 }
1615
1616 /***********************************************************************
1617  *              _adj_fdivr_m32i (MSVCRT.@)
1618  *
1619  * NOTE
1620  *    I _think_ this function is intended to work around the Pentium
1621  *    fdiv bug.
1622  */
1623 void __stdcall _adj_fdivr_m32i( int arg )
1624 {
1625   TRACE("(): stub\n");
1626 }
1627
1628 /***********************************************************************
1629  *              _adj_fdivr_m64 (MSVCRT.@)
1630  *
1631  * NOTE
1632  *    I _think_ this function is intended to work around the Pentium
1633  *    fdiv bug.
1634  */
1635 void __stdcall _adj_fdivr_m64( unsigned __int64 arg )
1636 {
1637   TRACE("(): stub\n");
1638 }
1639
1640 /***********************************************************************
1641  *              _adj_fpatan (MSVCRT.@)
1642  * FIXME
1643  *    This function is likely to have the wrong number of arguments.
1644  *
1645  * NOTE
1646  *    I _think_ this function is intended to work around the Pentium
1647  *    fdiv bug.
1648  */
1649 void _adj_fpatan(void)
1650 {
1651   TRACE("(): stub\n");
1652 }
1653
1654 /***********************************************************************
1655  *              _adj_fprem (MSVCRT.@)
1656  * FIXME
1657  *    This function is likely to have the wrong number of arguments.
1658  *
1659  * NOTE
1660  *    I _think_ this function is intended to work around the Pentium
1661  *    fdiv bug.
1662  */
1663 void _adj_fprem(void)
1664 {
1665   TRACE("(): stub\n");
1666 }
1667
1668 /***********************************************************************
1669  *              _adj_fprem1 (MSVCRT.@)
1670  * FIXME
1671  *    This function is likely to have the wrong number of arguments.
1672  *
1673  * NOTE
1674  *    I _think_ this function is intended to work around the Pentium
1675  *    fdiv bug.
1676  */
1677 void _adj_fprem1(void)
1678 {
1679   TRACE("(): stub\n");
1680 }
1681
1682 /***********************************************************************
1683  *              _adj_fptan (MSVCRT.@)
1684  * FIXME
1685  *    This function is likely to have the wrong number of arguments.
1686  *
1687  * NOTE
1688  *    I _think_ this function is intended to work around the Pentium
1689  *    fdiv bug.
1690  */
1691 void _adj_fptan(void)
1692 {
1693   TRACE("(): stub\n");
1694 }
1695
1696 /***********************************************************************
1697  *              _safe_fdiv (MSVCRT.@)
1698  * FIXME
1699  *    This function is likely to have the wrong number of arguments.
1700  *
1701  * NOTE
1702  *    I _think_ this function is intended to work around the Pentium
1703  *    fdiv bug.
1704  */
1705 void _safe_fdiv(void)
1706 {
1707   TRACE("(): stub\n");
1708 }
1709
1710 /***********************************************************************
1711  *              _safe_fdivr (MSVCRT.@)
1712  * FIXME
1713  *    This function is likely to have the wrong number of arguments.
1714  *
1715  * NOTE
1716  *    I _think_ this function is intended to work around the Pentium
1717  *    fdiv bug.
1718  */
1719 void _safe_fdivr(void)
1720 {
1721   TRACE("(): stub\n");
1722 }
1723
1724 /***********************************************************************
1725  *              _safe_fprem (MSVCRT.@)
1726  * FIXME
1727  *    This function is likely to have the wrong number of arguments.
1728  *
1729  * NOTE
1730  *    I _think_ this function is intended to work around the Pentium
1731  *    fdiv bug.
1732  */
1733 void _safe_fprem(void)
1734 {
1735   TRACE("(): stub\n");
1736 }
1737
1738 /***********************************************************************
1739  *              _safe_fprem1 (MSVCRT.@)
1740  *
1741  * FIXME
1742  *    This function is likely to have the wrong number of arguments.
1743  *
1744  * NOTE
1745  *    I _think_ this function is intended to work around the Pentium
1746  *    fdiv bug.
1747  */
1748 void _safe_fprem1(void)
1749 {
1750   TRACE("(): stub\n");
1751 }
1752
1753 #endif  /* __i386__ */