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