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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include "config.h"
  21 #include "msvcrt.h"
  22 #include "msvcrt/errno.h"
  23
  24 #define __USE_ISOC9X 1
  25 #define __USE_ISOC99 1
  26 #include <math.h>
  27 #ifdef HAVE_IEEEFP_H
  28 #include <ieeefp.h>
  29 #endif
  30
  31 #include "msvcrt/stdlib.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  36
  37 #ifndef HAVE_FINITE
  38 #ifndef finite /* Could be a macro */
  39 #ifdef isfinite
  40 #define finite(x) isfinite(x)
  41 #else
  42 #define finite(x) (!isnan(x)) /* At least catch some cases */
  43 #endif
  44 #endif
  45 #endif
  46
  47 #ifndef signbit
  48 #define signbit(x) 0
  49 #endif
  50
  51 /* fpclass constants */
  52 #define _FPCLASS_SNAN 1
  53 #define _FPCLASS_QNAN 2
  54 #define _FPCLASS_NINF 4
  55 #define _FPCLASS_NN   8
  56 #define _FPCLASS_ND   16
  57 #define _FPCLASS_NZ   32
  58 #define _FPCLASS_PZ   64
  59 #define _FPCLASS_PD   128
  60 #define _FPCLASS_PN   256
  61 #define _FPCLASS_PINF 512
  62
  63 /* _statusfp bit flags */
  64 #define _SW_INEXACT    0x1
  65 #define _SW_UNDERFLOW  0x2
  66 #define _SW_OVERFLOW   0x4
  67 #define _SW_ZERODIVIDE 0x8
  68 #define _SW_INVALID    0x10
  69 #define _SW_DENORMAL   0x80000
  70
  71 /* _controlfp masks and bitflags - x86 only so far*/
  72 #ifdef __i386__
  73 #define _MCW_EM        0x8001f
  74 #define _EM_INEXACT    0x1
  75 #define _EM_UNDERFLOW  0x2
  76 #define _EM_OVERFLOW   0x4
  77 #define _EM_ZERODIVIDE 0x8
  78 #define _EM_INVALID    0x10
  79
  80 #define _MCW_RC        0x300
  81 #define _RC_NEAR       0x0
  82 #define _RC_DOWN       0x100
  83 #define _RC_UP         0x200
  84 #define _RC_CHOP       0x300
  85
  86 #define _MCW_PC        0x30000
  87 #define _PC_64         0x0
  88 #define _PC_53         0x10000
  89 #define _PC_24         0x20000
  90
  91 #define _MCW_IC        0x40000
  92 #define _IC_AFFINE     0x40000
  93 #define _IC_PROJECTIVE 0x0
  94
  95 #define _EM_DENORMAL   0x80000
  96 #endif
  97
  98 typedef struct __MSVCRT_complex
  99 {
 100   double real;
 101   double imaginary;
 102 } MSVCRT_complex;
 103
 104 typedef struct __MSVCRT_exception
 105 {
 106   int type;
 107   char *name;
 108   double arg1;
 109   double arg2;
 110   double retval;
 111 } MSVCRT_exception;
 112
 113
 114 typedef int (*MSVCRT_matherr_func)(MSVCRT_exception *);
 115
 116 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
 117
 118 #if defined(__GNUC__) && defined(__i386__)
 119
 120 #define FPU_DOUBLE(var) double var; \
 121   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 122 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 123   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 124   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 125
 126 /*********************************************************************
 127  *              _CIacos (MSVCRT.@)
 128  */
 129 double _CIacos(void)
 130 {
 131   FPU_DOUBLE(x);
 132   if (x < -1.0 || x > 1.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 133   return acos(x);
 134 }
 135
 136 /*********************************************************************
 137  *              _CIasin (MSVCRT.@)
 138  */
 139 double _CIasin(void)
 140 {
 141   FPU_DOUBLE(x);
 142   if (x < -1.0 || x > 1.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 143   return asin(x);
 144 }
 145
 146 /*********************************************************************
 147  *              _CIatan (MSVCRT.@)
 148  */
 149 double _CIatan(void)
 150 {
 151   FPU_DOUBLE(x);
 152   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 153   return atan(x);
 154 }
 155
 156 /*********************************************************************
 157  *              _CIatan2 (MSVCRT.@)
 158  */
 159 double _CIatan2(void)
 160 {
 161   FPU_DOUBLES(x,y);
 162   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 163   return atan2(x,y);
 164 }
 165
 166 /*********************************************************************
 167  *              _CIcos (MSVCRT.@)
 168  */
 169 double _CIcos(void)
 170 {
 171   FPU_DOUBLE(x);
 172   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 173   return cos(x);
 174 }
 175
 176 /*********************************************************************
 177  *              _CIcosh (MSVCRT.@)
 178  */
 179 double _CIcosh(void)
 180 {
 181   FPU_DOUBLE(x);
 182   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 183   return cosh(x);
 184 }
 185
 186 /*********************************************************************
 187  *              _CIexp (MSVCRT.@)
 188  */
 189 double _CIexp(void)
 190 {
 191   FPU_DOUBLE(x);
 192   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 193   return exp(x);
 194 }
 195
 196 /*********************************************************************
 197  *              _CIfmod (MSVCRT.@)
 198  */
 199 double _CIfmod(void)
 200 {
 201   FPU_DOUBLES(x,y);
 202   if (!finite(x) || !finite(y)) *MSVCRT__errno() = MSVCRT_EDOM;
 203   return fmod(x,y);
 204 }
 205
 206 /*********************************************************************
 207  *              _CIlog (MSVCRT.@)
 208  */
 209 double _CIlog(void)
 210 {
 211   FPU_DOUBLE(x);
 212   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 213   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 214   return log(x);
 215 }
 216
 217 /*********************************************************************
 218  *              _CIlog10 (MSVCRT.@)
 219  */
 220 double _CIlog10(void)
 221 {
 222   FPU_DOUBLE(x);
 223   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 224   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
 225   return log10(x);
 226 }
 227
 228 /*********************************************************************
 229  *              _CIpow (MSVCRT.@)
 230  */
 231 double _CIpow(void)
 232 {
 233   double z;
 234   FPU_DOUBLES(x,y);
 235   /* FIXME: If x < 0 and y is not integral, set EDOM */
 236   z = pow(x,y);
 237   if (!finite(z)) *MSVCRT__errno() = MSVCRT_EDOM;
 238   return z;
 239 }
 240
 241 /*********************************************************************
 242  *              _CIsin (MSVCRT.@)
 243  */
 244 double _CIsin(void)
 245 {
 246   FPU_DOUBLE(x);
 247   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 248   return sin(x);
 249 }
 250
 251 /*********************************************************************
 252  *              _CIsinh (MSVCRT.@)
 253  */
 254 double _CIsinh(void)
 255 {
 256   FPU_DOUBLE(x);
 257   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 258   return sinh(x);
 259 }
 260
 261 /*********************************************************************
 262  *              _CIsqrt (MSVCRT.@)
 263  */
 264 double _CIsqrt(void)
 265 {
 266   FPU_DOUBLE(x);
 267   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 268   return sqrt(x);
 269 }
 270
 271 /*********************************************************************
 272  *              _CItan (MSVCRT.@)
 273  */
 274 double _CItan(void)
 275 {
 276   FPU_DOUBLE(x);
 277   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 278   return tan(x);
 279 }
 280
 281 /*********************************************************************
 282  *              _CItanh (MSVCRT.@)
 283  */
 284 double _CItanh(void)
 285 {
 286   FPU_DOUBLE(x);
 287   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
 288   return tanh(x);
 289 }
 290
 291 #else /* defined(__GNUC__) && defined(__i386__) */
 292
 293 /* The above cannot be called on non x86 platforms, stub them for linking */
 294
 295 #define IX86_ONLY(func) double func(void) { return 0.0; }
 296
 297 IX86_ONLY(_CIacos)
 298 IX86_ONLY(_CIasin)
 299 IX86_ONLY(_CIatan)
 300 IX86_ONLY(_CIatan2)
 301 IX86_ONLY(_CIcos)
 302 IX86_ONLY(_CIcosh)
 303 IX86_ONLY(_CIexp)
 304 IX86_ONLY(_CIfmod)
 305 IX86_ONLY(_CIlog)
 306 IX86_ONLY(_CIlog10)
 307 IX86_ONLY(_CIpow)
 308 IX86_ONLY(_CIsin)
 309 IX86_ONLY(_CIsinh)
 310 IX86_ONLY(_CIsqrt)
 311 IX86_ONLY(_CItan)
 312 IX86_ONLY(_CItanh)
 313
 314 #endif /* defined(__GNUC__) && defined(__i386__) */
 315
 316 /*********************************************************************
 317  *              _fpclass (MSVCRT.@)
 318  */
 319 int _fpclass(double num)
 320 {
 321 #if defined(HAVE_FPCLASS) || defined(fpclass)
 322   switch (fpclass( num ))
 323   {
 324   case FP_SNAN:  return _FPCLASS_SNAN;
 325   case FP_QNAN:  return _FPCLASS_QNAN;
 326   case FP_NINF:  return _FPCLASS_NINF;
 327   case FP_PINF:  return _FPCLASS_PINF;
 328   case FP_NDENORM: return _FPCLASS_ND;
 329   case FP_PDENORM: return _FPCLASS_PD;
 330   case FP_NZERO: return _FPCLASS_NZ;
 331   case FP_PZERO: return _FPCLASS_PZ;
 332   case FP_NNORM: return _FPCLASS_NN;
 333   case FP_PNORM: return _FPCLASS_PN;
 334   }
 335   return _FPCLASS_PN;
 336 #elif defined (fpclassify)
 337   switch (fpclassify( num ))
 338   {
 339   case FP_NAN: return _FPCLASS_QNAN;
 340   case FP_INFINITE: return signbit(num) ? _FPCLASS_NINF : _FPCLASS_PINF;
 341   case FP_SUBNORMAL: return signbit(num) ?_FPCLASS_ND : _FPCLASS_PD;
 342   case FP_ZERO: return signbit(num) ? _FPCLASS_NZ : _FPCLASS_PZ;
 343   }
 344   return signbit(num) ? _FPCLASS_NN : _FPCLASS_PN;
 345 #else
 346   if (!finite(num))
 347     return _FPCLASS_QNAN;
 348   return num == 0.0 ? _FPCLASS_PZ : (num < 0 ? _FPCLASS_NN : _FPCLASS_PN);
 349 #endif
 350 }
 351
 352 /*********************************************************************
 353  *              _rotl (MSVCRT.@)
 354  */
 355 unsigned int _rotl(unsigned int num, int shift)
 356 {
 357   shift &= 31;
 358   return (num << shift) | (num >> (32-shift));
 359 }
 360
 361 /*********************************************************************
 362  *              _logb (MSVCRT.@)
 363  */
 364 double _logb(double num)
 365 {
 366   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 367   return logb(num);
 368 }
 369
 370 /*********************************************************************
 371  *              _lrotl (MSVCRT.@)
 372  */
 373 unsigned long _lrotl(unsigned long num, int shift)
 374 {
 375   shift &= 0x1f;
 376   return (num << shift) | (num >> (32-shift));
 377 }
 378
 379 /*********************************************************************
 380  *              _lrotr (MSVCRT.@)
 381  */
 382 unsigned long _lrotr(unsigned long num, int shift)
 383 {
 384   shift &= 0x1f;
 385   return (num >> shift) | (num << (32-shift));
 386 }
 387
 388 /*********************************************************************
 389  *              _rotr (MSVCRT.@)
 390  */
 391 unsigned int _rotr(unsigned int num, int shift)
 392 {
 393     shift &= 0x1f;
 394     return (num >> shift) | (num << (32-shift));
 395 }
 396
 397 /*********************************************************************
 398  *              _scalb (MSVCRT.@)
 399  */
 400 double _scalb(double num, long power)
 401 {
 402   /* Note - Can't forward directly as libc expects y as double */
 403   double dblpower = (double)power;
 404   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 405   return scalb(num, dblpower);
 406 }
 407
 408 /*********************************************************************
 409  *              _matherr (MSVCRT.@)
 410  */
 411 int _matherr(MSVCRT_exception *e)
 412 {
 413   if (e)
 414     TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
 415           e->retval);
 416   else
 417     TRACE("(null)\n");
 418   if (MSVCRT_default_matherr_func)
 419     return MSVCRT_default_matherr_func(e);
 420   ERR(":Unhandled math error!\n");
 421   return 0;
 422 }
 423
 424 /*********************************************************************
 425  *              __setusermatherr (MSVCRT.@)
 426  */
 427 void MSVCRT___setusermatherr(MSVCRT_matherr_func func)
 428 {
 429   MSVCRT_default_matherr_func = func;
 430   TRACE(":new matherr handler %p\n", func);
 431 }
 432
 433 /**********************************************************************
 434  *              _statusfp (MSVCRT.@)
 435  */
 436 unsigned int _statusfp(void)
 437 {
 438    unsigned int retVal = 0;
 439 #if defined(__GNUC__) && defined(__i386__)
 440   unsigned int fpword;
 441
 442   __asm__ __volatile__( "fstsw %0" : "=m" (fpword) : );
 443   if (fpword & 0x1)  retVal |= _SW_INVALID;
 444   if (fpword & 0x2)  retVal |= _SW_DENORMAL;
 445   if (fpword & 0x4)  retVal |= _SW_ZERODIVIDE;
 446   if (fpword & 0x8)  retVal |= _SW_OVERFLOW;
 447   if (fpword & 0x10) retVal |= _SW_UNDERFLOW;
 448   if (fpword & 0x20) retVal |= _SW_INEXACT;
 449 #else
 450   FIXME(":Not implemented!\n");
 451 #endif
 452   return retVal;
 453 }
 454
 455 /*********************************************************************
 456  *              _clearfp (MSVCRT.@)
 457  */
 458 unsigned int _clearfp(void)
 459 {
 460   unsigned int retVal = _statusfp();
 461 #if defined(__GNUC__) && defined(__i386__)
 462   __asm__ __volatile__( "fnclex" );
 463 #else
 464   FIXME(":Not Implemented\n");
 465 #endif
 466   return retVal;
 467 }
 468
 469 /*********************************************************************
 470  *              ldexp (MSVCRT.@)
 471  */
 472 double MSVCRT_ldexp(double num, long exp)
 473 {
 474   double z = ldexp(num,exp);
 475
 476   if (!finite(z))
 477     *MSVCRT__errno() = MSVCRT_ERANGE;
 478   else if (z == 0 && signbit(z))
 479     z = 0.0; /* Convert -0 -> +0 */
 480   return z;
 481 }
 482
 483 /*********************************************************************
 484  *              _cabs (MSVCRT.@)
 485  */
 486 double _cabs(MSVCRT_complex num)
 487 {
 488   return sqrt(num.real * num.real + num.imaginary * num.imaginary);
 489 }
 490
 491 /*********************************************************************
 492  *              _chgsign (MSVCRT.@)
 493  */
 494 double _chgsign(double num)
 495 {
 496   /* FIXME: +-infinity,Nan not tested */
 497   return -num;
 498 }
 499
 500 /*********************************************************************
 501  *              _control87 (MSVCRT.@)
 502  */
 503 unsigned int _control87(unsigned int newval, unsigned int mask)
 504 {
 505 #if defined(__GNUC__) && defined(__i386__)
 506   unsigned int fpword = 0;
 507   unsigned int flags = 0;
 508
 509   TRACE("(%08x, %08x): Called\n", newval, mask);
 510
 511   /* Get fp control word */
 512   __asm__ __volatile__( "fstcw %0" : "=m" (fpword) : );
 513
 514   TRACE("Control word before : %08x\n", fpword);
 515
 516   /* Convert into mask constants */
 517   if (fpword & 0x1)  flags |= _EM_INVALID;
 518   if (fpword & 0x2)  flags |= _EM_DENORMAL;
 519   if (fpword & 0x4)  flags |= _EM_ZERODIVIDE;
 520   if (fpword & 0x8)  flags |= _EM_OVERFLOW;
 521   if (fpword & 0x10) flags |= _EM_UNDERFLOW;
 522   if (fpword & 0x20) flags |= _EM_INEXACT;
 523   switch(fpword & 0xC00) {
 524   case 0xC00: flags |= _RC_UP|_RC_DOWN; break;
 525   case 0x800: flags |= _RC_UP; break;
 526   case 0x400: flags |= _RC_DOWN; break;
 527   }
 528   switch(fpword & 0x300) {
 529   case 0x0:   flags |= _PC_24; break;
 530   case 0x200: flags |= _PC_53; break;
 531   case 0x300: flags |= _PC_64; break;
 532   }
 533   if (fpword & 0x1000) flags |= _IC_AFFINE;
 534
 535   /* Mask with parameters */
 536   flags = (flags & ~mask) | (newval & mask);
 537
 538   /* Convert (masked) value back to fp word */
 539   fpword = 0;
 540   if (flags & _EM_INVALID)    fpword |= 0x1;
 541   if (flags & _EM_DENORMAL)   fpword |= 0x2;
 542   if (flags & _EM_ZERODIVIDE) fpword |= 0x4;
 543   if (flags & _EM_OVERFLOW)   fpword |= 0x8;
 544   if (flags & _EM_UNDERFLOW)  fpword |= 0x10;
 545   if (flags & _EM_INEXACT)    fpword |= 0x20;
 546   switch(flags & (_RC_UP | _RC_DOWN)) {
 547   case _RC_UP|_RC_DOWN: fpword |= 0xC00; break;
 548   case _RC_UP:          fpword |= 0x800; break;
 549   case _RC_DOWN:        fpword |= 0x400; break;
 550   }
 551   switch (flags & (_PC_24 | _PC_53)) {
 552   case _PC_64: fpword |= 0x300; break;
 553   case _PC_53: fpword |= 0x200; break;
 554   case _PC_24: fpword |= 0x0; break;
 555   }
 556   if (flags & _IC_AFFINE) fpword |= 0x1000;
 557
 558   TRACE("Control word after  : %08x\n", fpword);
 559
 560   /* Put fp control word */
 561   __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
 562
 563   return flags;
 564 #else
 565   FIXME(":Not Implemented!\n");
 566   return 0;
 567 #endif
 568 }
 569
 570 /*********************************************************************
 571  *              _controlfp (MSVCRT.@)
 572  */
 573 unsigned int _controlfp(unsigned int newval, unsigned int mask)
 574 {
 575 #ifdef __i386__
 576   return _control87( newval, mask & ~_EM_DENORMAL );
 577 #else
 578   FIXME(":Not Implemented!\n");
 579   return 0;
 580 #endif
 581 }
 582
 583 /*********************************************************************
 584  *              _copysign (MSVCRT.@)
 585  */
 586 double _copysign(double num, double sign)
 587 {
 588   /* FIXME: Behaviour for Nan/Inf? */
 589   if (sign < 0.0)
 590     return num < 0.0 ? num : -num;
 591   return num < 0.0 ? -num : num;
 592 }
 593
 594 /*********************************************************************
 595  *              _finite (MSVCRT.@)
 596  */
 597 int  _finite(double num)
 598 {
 599   return (finite(num)?1:0); /* See comment for _isnan() */
 600 }
 601
 602 /*********************************************************************
 603  *              _fpreset (MSVCRT.@)
 604  */
 605 void _fpreset(void)
 606 {
 607 #if defined(__GNUC__) && defined(__i386__)
 608   __asm__ __volatile__( "fninit" );
 609 #else
 610   FIXME(":Not Implemented!\n");
 611 #endif
 612 }
 613
 614 /*********************************************************************
 615  *              _isnan (MSVCRT.@)
 616  */
 617 INT  _isnan(double num)
 618 {
 619   /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
 620    * Do the same, as the result may be used in calculations
 621    */
 622   return isnan(num) ? 1 : 0;
 623 }
 624
 625 /*********************************************************************
 626  *              _y0 (MSVCRT.@)
 627  */
 628 double _y0(double num)
 629 {
 630   double retval;
 631   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 632   retval  = y0(num);
 633   if (_fpclass(retval) == _FPCLASS_NINF)
 634   {
 635     *MSVCRT__errno() = MSVCRT_EDOM;
 636     retval = sqrt(-1);
 637   }
 638   return retval;
 639 }
 640
 641 /*********************************************************************
 642  *              _y1 (MSVCRT.@)
 643  */
 644 double _y1(double num)
 645 {
 646   double retval;
 647   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 648   retval  = y1(num);
 649   if (_fpclass(retval) == _FPCLASS_NINF)
 650   {
 651     *MSVCRT__errno() = MSVCRT_EDOM;
 652     retval = sqrt(-1);
 653   }
 654   return retval;
 655 }
 656
 657 /*********************************************************************
 658  *              _yn (MSVCRT.@)
 659  */
 660 double _yn(int order, double num)
 661 {
 662   double retval;
 663   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
 664   retval  = yn(order,num);
 665   if (_fpclass(retval) == _FPCLASS_NINF)
 666   {
 667     *MSVCRT__errno() = MSVCRT_EDOM;
 668     retval = sqrt(-1);
 669   }
 670   return retval;
 671 }
 672
 673 /*********************************************************************
 674  *              _nextafter (MSVCRT.@)
 675  */
 676 double _nextafter(double num, double next)
 677 {
 678   double retval;
 679   if (!finite(num) || !finite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
 680   retval = nextafter(num,next);
 681   return retval;
 682 }
 683
 684 #include <stdlib.h> /* div_t, ldiv_t */
 685
 686 /*********************************************************************
 687  *              div (MSVCRT.@)
 688  * VERSION
 689  *      [i386] Windows binary compatible - returns the struct in eax/edx.
 690  */
 691 #ifdef __i386__
 692 LONGLONG MSVCRT_div(int num, int denom)
 693 {
 694   LONGLONG retval;
 695   div_t dt = div(num,denom);
 696   retval = ((LONGLONG)dt.rem << 32) | dt.quot;
 697   return retval;
 698 }
 699 #else
 700 /*********************************************************************
 701  *              div (MSVCRT.@)
 702  * VERSION
 703  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
 704  */
 705 MSVCRT_div_t MSVCRT_div(int num, int denom)
 706 {
 707   div_t dt = div(num,denom);
 708   MSVCRT_div_t     ret;
 709   ret.quot = dt.quot;
 710   ret.rem = dt.rem;
 711
 712   return ret;
 713
 714 }
 715 #endif /* ifdef __i386__ */
 716
 717
 718 /*********************************************************************
 719  *              ldiv (MSVCRT.@)
 720  * VERSION
 721  *      [i386] Windows binary compatible - returns the struct in eax/edx.
 722  */
 723 #ifdef __i386__
 724 ULONGLONG MSVCRT_ldiv(long num, long denom)
 725 {
 726   ULONGLONG retval;
 727   ldiv_t ldt = ldiv(num,denom);
 728   retval = ((ULONGLONG)ldt.rem << 32) | (ULONG)ldt.quot;
 729   return retval;
 730 }
 731 #else
 732 /*********************************************************************
 733  *              ldiv (MSVCRT.@)
 734  * VERSION
 735  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
 736  */
 737 MSVCRT_ldiv_t MSVCRT_ldiv(long num, long denom)
 738 {
 739   ldiv_t result = ldiv(num,denom);
 740
 741   MSVCRT_ldiv_t ret;
 742   ret.quot = result.quot;
 743   ret.rem = result.rem;
 744
 745   return ret;
 746 }
 747 #endif /* ifdef __i386__ */
 748
 749 /***********************************************************************
 750  *              _adj_fdiv_m16i (MSVCRT.@)
 751  * FIXME
 752  *    This function is likely to have the wrong number of arguments.
 753  *
 754  * NOTE
 755  *    I _think_ this function is intended to work around the Pentium
 756  *    fdiv bug.
 757  */
 758 void _adj_fdiv_m16i(void)
 759 {
 760   TRACE("(): stub\n");
 761 }
 762
 763 /***********************************************************************
 764  *              _adj_fdiv_m32 (MSVCRT.@)
 765  * FIXME
 766  *    This function is likely to have the wrong number of arguments.
 767  *
 768  * NOTE
 769  *    I _think_ this function is intended to work around the Pentium
 770  *    fdiv bug.
 771  */
 772 void _adj_fdiv_m32(void)
 773 {
 774   TRACE("(): stub\n");
 775 }
 776
 777 /***********************************************************************
 778  *              _adj_fdiv_m32i (MSVCRT.@)
 779  * FIXME
 780  *    This function is likely to have the wrong number of arguments.
 781  *
 782  * NOTE
 783  *    I _think_ this function is intended to work around the Pentium
 784  *    fdiv bug.
 785  */
 786 void _adj_fdiv_m32i(void)
 787 {
 788   TRACE("(): stub\n");
 789 }
 790
 791 /***********************************************************************
 792  *              _adj_fdiv_m64 (MSVCRT.@)
 793  * FIXME
 794  *    This function is likely to have the wrong number of arguments.
 795  *
 796  * NOTE
 797  *    I _think_ this function is intended to work around the Pentium
 798  *    fdiv bug.
 799  */
 800 void _adj_fdiv_m64(void)
 801 {
 802   TRACE("(): stub\n");
 803 }
 804
 805 /***********************************************************************
 806  *              _adj_fdiv_r (MSVCRT.@)
 807  * FIXME
 808  *    This function is likely to have the wrong number of arguments.
 809  *
 810  * NOTE
 811  *    I _think_ this function is intended to work around the Pentium
 812  *    fdiv bug.
 813  */
 814 void _adj_fdiv_r(void)
 815 {
 816   TRACE("(): stub\n");
 817 }
 818
 819 /***********************************************************************
 820  *              _adj_fdivr_m16i (MSVCRT.@)
 821  * FIXME
 822  *    This function is likely to have the wrong number of arguments.
 823  *
 824  * NOTE
 825  *    I _think_ this function is intended to work around the Pentium
 826  *    fdiv bug.
 827  */
 828 void _adj_fdivr_m16i(void)
 829 {
 830   TRACE("(): stub\n");
 831 }
 832
 833 /***********************************************************************
 834  *              _adj_fdivr_m32 (MSVCRT.@)
 835  * FIXME
 836  *    This function is likely to have the wrong number of arguments.
 837  *
 838  * NOTE
 839  *    I _think_ this function is intended to work around the Pentium
 840  *    fdiv bug.
 841  */
 842 void _adj_fdivr_m32(void)
 843 {
 844   TRACE("(): stub\n");
 845 }
 846
 847 /***********************************************************************
 848  *              _adj_fdivr_m32i (MSVCRT.@)
 849  * FIXME
 850  *    This function is likely to have the wrong number of arguments.
 851  *
 852  * NOTE
 853  *    I _think_ this function is intended to work around the Pentium
 854  *    fdiv bug.
 855  */
 856 void _adj_fdivr_m32i(void)
 857 {
 858   TRACE("(): stub\n");
 859 }
 860
 861 /***********************************************************************
 862  *              _adj_fdivr_m64 (MSVCRT.@)
 863  * FIXME
 864  *    This function is likely to have the wrong number of arguments.
 865  *
 866  * NOTE
 867  *    I _think_ this function is intended to work around the Pentium
 868  *    fdiv bug.
 869  */
 870 void _adj_fdivr_m64(void)
 871 {
 872   TRACE("(): stub\n");
 873 }
 874
 875 /***********************************************************************
 876  *              _adj_fpatan (MSVCRT.@)
 877  * FIXME
 878  *    This function is likely to have the wrong number of arguments.
 879  *
 880  * NOTE
 881  *    I _think_ this function is intended to work around the Pentium
 882  *    fdiv bug.
 883  */
 884 void _adj_fpatan(void)
 885 {
 886   TRACE("(): stub\n");
 887 }
 888
 889 /***********************************************************************
 890  *              _adj_fprem (MSVCRT.@)
 891  * FIXME
 892  *    This function is likely to have the wrong number of arguments.
 893  *
 894  * NOTE
 895  *    I _think_ this function is intended to work around the Pentium
 896  *    fdiv bug.
 897  */
 898 void _adj_fprem(void)
 899 {
 900   TRACE("(): stub\n");
 901 }
 902
 903 /***********************************************************************
 904  *              _adj_fprem1 (MSVCRT.@)
 905  * FIXME
 906  *    This function is likely to have the wrong number of arguments.
 907  *
 908  * NOTE
 909  *    I _think_ this function is intended to work around the Pentium
 910  *    fdiv bug.
 911  */
 912 void _adj_fprem1(void)
 913 {
 914   TRACE("(): stub\n");
 915 }
 916
 917 /***********************************************************************
 918  *              _adj_fptan (MSVCRT.@)
 919  * FIXME
 920  *    This function is likely to have the wrong number of arguments.
 921  *
 922  * NOTE
 923  *    I _think_ this function is intended to work around the Pentium
 924  *    fdiv bug.
 925  */
 926 void _adj_fptan(void)
 927 {
 928   TRACE("(): stub\n");
 929 }
 930
 931 /***********************************************************************
 932  *              _adjust_fdiv (MSVCRT.@)
 933  * FIXME
 934  *    I _think_ this function should be a variable indicating whether
 935  *    Pentium fdiv bug safe code should be used.
 936  */
 937 void _adjust_fdiv(void)
 938 {
 939   TRACE("(): stub\n");
 940 }
 941
 942 /***********************************************************************
 943  *              _safe_fdiv (MSVCRT.@)
 944  * FIXME
 945  *    This function is likely to have the wrong number of arguments.
 946  *
 947  * NOTE
 948  *    I _think_ this function is intended to work around the Pentium
 949  *    fdiv bug.
 950  */
 951 void _safe_fdiv(void)
 952 {
 953   TRACE("(): stub\n");
 954 }
 955
 956 /***********************************************************************
 957  *              _safe_fdivr (MSVCRT.@)
 958  * FIXME
 959  *    This function is likely to have the wrong number of arguments.
 960  *
 961  * NOTE
 962  *    I _think_ this function is intended to work around the Pentium
 963  *    fdiv bug.
 964  */
 965 void _safe_fdivr(void)
 966 {
 967   TRACE("(): stub\n");
 968 }
 969
 970 /***********************************************************************
 971  *              _safe_fprem (MSVCRT.@)
 972  * FIXME
 973  *    This function is likely to have the wrong number of arguments.
 974  *
 975  * NOTE
 976  *    I _think_ this function is intended to work around the Pentium
 977  *    fdiv bug.
 978  */
 979 void _safe_fprem(void)
 980 {
 981   TRACE("(): stub\n");
 982 }
 983
 984 /***********************************************************************
 985  *              _safe_fprem1 (MSVCRT.@)
 986  *
 987  * FIXME
 988  *    This function is likely to have the wrong number of arguments.
 989  *
 990  * NOTE
 991  *    I _think_ this function is intended to work around the Pentium
 992  *    fdiv bug.
 993  */
 994 void _safe_fprem1(void)
 995 {
 996   TRACE("(): stub\n");
 997 }