git.oblomov.eu Git - wine/blob - dlls/msvcrt/math.c

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