dlls/msvcrt/unixlib.c

   1 /*
   2  * MSVCRT Unix interface
   3  *
   4  * Copyright 2020 Alexandre Julliard
   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
  21 #if 0
  22 #pragma makedep unix
  23 #endif
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <stdio.h>
  29 #include <stdarg.h>
  30 #define __USE_ISOC9X 1
  31 #define __USE_ISOC99 1
  32 #include <math.h>
  33 #ifdef HAVE_IEEEFP_H
  34 #include <ieeefp.h>
  35 #endif
  36
  37 #include "ntstatus.h"
  38 #define WIN32_NO_STATUS
  39 #include "winternl.h"
  40 #include "unixlib.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  44
  45 /*********************************************************************
  46  *      acosh
  47  */
  48 static double CDECL unix_acosh(double x)
  49 {
  50 #ifdef HAVE_ACOSH
  51     return acosh(x);
  52 #else
  53     if (!isfinite(x*x)) return log(2) + log(x);
  54     return log(x + sqrt(x*x-1));
  55 #endif
  56 }
  57
  58 /*********************************************************************
  59  *      acoshf
  60  */
  61 static float CDECL unix_acoshf(float x)
  62 {
  63 #ifdef HAVE_ACOSHF
  64     return acoshf(x);
  65 #else
  66     return unix_acosh(x);
  67 #endif
  68 }
  69
  70 /*********************************************************************
  71  *      asinh
  72  */
  73 static double CDECL unix_asinh(double x)
  74 {
  75 #ifdef HAVE_ASINH
  76     return asinh(x);
  77 #else
  78     if (!isfinite(x*x+1))
  79     {
  80         if (x > 0) return log(2) + log(x);
  81         else return -log(2) - log(-x);
  82     }
  83     return log(x + sqrt(x*x+1));
  84 #endif
  85 }
  86
  87 /*********************************************************************
  88  *      asinhf
  89  */
  90 static float CDECL unix_asinhf(float x)
  91 {
  92 #ifdef HAVE_ASINHF
  93     return asinhf(x);
  94 #else
  95     return unix_asinh(x);
  96 #endif
  97 }
  98
  99 /*********************************************************************
 100  *      atanh
 101  */
 102 static double CDECL unix_atanh(double x)
 103 {
 104 #ifdef HAVE_ATANH
 105     return atanh(x);
 106 #else
 107     if (-1e-6 < x && x < 1e-6) return x + x*x*x/3;
 108     else return (log(1+x) - log(1-x)) / 2;
 109 #endif
 110 }
 111
 112 /*********************************************************************
 113  *      atanhf
 114  */
 115 static float CDECL unix_atanhf(float x)
 116 {
 117 #ifdef HAVE_ATANHF
 118     return atanhf(x);
 119 #else
 120     return unix_atanh(x);
 121 #endif
 122 }
 123
 124 /*********************************************************************
 125  *      cosh
 126  */
 127 static double CDECL unix_cosh( double x )
 128 {
 129     return cosh( x );
 130 }
 131
 132 /*********************************************************************
 133  *      coshf
 134  */
 135 static float CDECL unix_coshf( float x )
 136 {
 137     return coshf( x );
 138 }
 139
 140 /*********************************************************************
 141  *      exp
 142  */
 143 static double CDECL unix_exp( double x )
 144 {
 145     return exp( x );
 146 }
 147
 148 /*********************************************************************
 149  *      expf
 150  */
 151 static float CDECL unix_expf( float x )
 152 {
 153     return expf( x );
 154 }
 155
 156 /*********************************************************************
 157  *      exp2
 158  */
 159 static double CDECL unix_exp2( double x )
 160 {
 161 #ifdef HAVE_EXP2
 162     return exp2(x);
 163 #else
 164     return pow(2, x);
 165 #endif
 166 }
 167
 168 /*********************************************************************
 169  *      exp2f
 170  */
 171 static float CDECL unix_exp2f( float x )
 172 {
 173 #ifdef HAVE_EXP2F
 174     return exp2f(x);
 175 #else
 176     return unix_exp2(x);
 177 #endif
 178 }
 179
 180 /*********************************************************************
 181  *      expm1
 182  */
 183 static double CDECL unix_expm1(double x)
 184 {
 185 #ifdef HAVE_EXPM1
 186     return expm1(x);
 187 #else
 188     return exp(x) - 1;
 189 #endif
 190 }
 191
 192 /*********************************************************************
 193  *      expm1f
 194  */
 195 static float CDECL unix_expm1f(float x)
 196 {
 197 #ifdef HAVE_EXPM1F
 198     return expm1f(x);
 199 #else
 200     return exp(x) - 1;
 201 #endif
 202 }
 203
 204 /*********************************************************************
 205  *      fma
 206  */
 207 static double CDECL unix_fma( double x, double y, double z )
 208 {
 209 #ifdef HAVE_FMA
 210     return fma(x, y, z);
 211 #else
 212     return x * y + z;
 213 #endif
 214 }
 215
 216 /*********************************************************************
 217  *      fmaf
 218  */
 219 static float CDECL unix_fmaf( float x, float y, float z )
 220 {
 221 #ifdef HAVE_FMAF
 222     return fmaf(x, y, z);
 223 #else
 224     return x * y + z;
 225 #endif
 226 }
 227
 228 /*********************************************************************
 229  *      frexp
 230  */
 231 static double CDECL unix_frexp( double x, int *exp )
 232 {
 233     return frexp( x, exp );
 234 }
 235
 236 /*********************************************************************
 237  *      frexpf
 238  */
 239 static float CDECL unix_frexpf( float x, int *exp )
 240 {
 241     return frexpf( x, exp );
 242 }
 243
 244 /*********************************************************************
 245  *      hypot
 246  */
 247 static double CDECL unix_hypot(double x, double y)
 248 {
 249     return hypot( x, y );
 250 }
 251
 252 /*********************************************************************
 253  *      hypotf
 254  */
 255 static float CDECL unix_hypotf(float x, float y)
 256 {
 257     return hypotf( x, y );
 258 }
 259
 260 /*********************************************************************
 261  *      ldexp
 262  */
 263 static double CDECL unix_ldexp(double num, int exp)
 264 {
 265     return ldexp( num, exp );
 266 }
 267
 268 /*********************************************************************
 269  *      lgamma
 270  */
 271 static double CDECL unix_lgamma(double x)
 272 {
 273 #ifdef HAVE_LGAMMA
 274     return lgamma(x);
 275 #else
 276     FIXME( "not implemented\n" );
 277     return 0;
 278 #endif
 279 }
 280
 281 /*********************************************************************
 282  *      lgammaf
 283  */
 284 static float CDECL unix_lgammaf(float x)
 285 {
 286 #ifdef HAVE_LGAMMAF
 287     return lgammaf(x);
 288 #else
 289     FIXME( "not implemented\n" );
 290     return 0;
 291 #endif
 292 }
 293
 294 /*********************************************************************
 295  *      log
 296  */
 297 static double CDECL unix_log( double x )
 298 {
 299     return log( x );
 300 }
 301
 302 /*********************************************************************
 303  *      logf
 304  */
 305 static float CDECL unix_logf( float x )
 306 {
 307     return logf( x );
 308 }
 309
 310 /*********************************************************************
 311  *      log10
 312  */
 313 static double CDECL unix_log10( double x )
 314 {
 315     return log10( x );
 316 }
 317
 318 /*********************************************************************
 319  *      log10f
 320  */
 321 static float CDECL unix_log10f( float x )
 322 {
 323     return log10f( x );
 324 }
 325
 326 /*********************************************************************
 327  *      log1p
 328  */
 329 static double CDECL unix_log1p(double x)
 330 {
 331 #ifdef HAVE_LOG1P
 332     return log1p(x);
 333 #else
 334     return log(1 + x);
 335 #endif
 336 }
 337
 338 /*********************************************************************
 339  *      log1pf
 340  */
 341 static float CDECL unix_log1pf(float x)
 342 {
 343 #ifdef HAVE_LOG1PF
 344     return log1pf(x);
 345 #else
 346     return log(1 + x);
 347 #endif
 348 }
 349
 350 /*********************************************************************
 351  *      log2
 352  */
 353 static double CDECL unix_log2(double x)
 354 {
 355 #ifdef HAVE_LOG2
 356     return log2(x);
 357 #else
 358     return log(x) / log(2);
 359 #endif
 360 }
 361
 362 /*********************************************************************
 363  *      log2f
 364  */
 365 static float CDECL unix_log2f(float x)
 366 {
 367 #ifdef HAVE_LOG2F
 368     return log2f(x);
 369 #else
 370     return unix_log2(x);
 371 #endif
 372 }
 373
 374 /*********************************************************************
 375  *      pow
 376  */
 377 static double CDECL unix_pow( double x, double y )
 378 {
 379     return pow( x, y );
 380 }
 381
 382 /*********************************************************************
 383  *      powf
 384  */
 385 static float CDECL unix_powf( float x, float y )
 386 {
 387     return powf( x, y );
 388 }
 389
 390 /*********************************************************************
 391  *      sinf
 392  */
 393 static float CDECL unix_sinf( float x )
 394 {
 395     return sinf( x );
 396 }
 397
 398 /*********************************************************************
 399  *      sinh
 400  */
 401 static double CDECL unix_sinh( double x )
 402 {
 403     return sinh( x );
 404 }
 405
 406 /*********************************************************************
 407  *      sinhf
 408  */
 409 static float CDECL unix_sinhf( float x )
 410 {
 411     return sinhf( x );
 412 }
 413
 414 /*********************************************************************
 415  *      tanf
 416  */
 417 static float CDECL unix_tanf( float x )
 418 {
 419     return tanf( x );
 420 }
 421
 422 /*********************************************************************
 423  *      tanh
 424  */
 425 static double CDECL unix_tanh( double x )
 426 {
 427     return tanh( x );
 428 }
 429
 430 /*********************************************************************
 431  *      tanhf
 432  */
 433 static float CDECL unix_tanhf( float x )
 434 {
 435     return tanhf( x );
 436 }
 437
 438 /*********************************************************************
 439  *      tgamma
 440  */
 441 static double CDECL unix_tgamma(double x)
 442 {
 443 #ifdef HAVE_TGAMMA
 444     return tgamma(x);
 445 #else
 446     FIXME( "not implemented\n" );
 447     return 0;
 448 #endif
 449 }
 450
 451 /*********************************************************************
 452  *      tgammaf
 453  */
 454 static float CDECL unix_tgammaf(float x)
 455 {
 456 #ifdef HAVE_TGAMMAF
 457     return tgammaf(x);
 458 #else
 459     FIXME( "not implemented\n" );
 460     return 0;
 461 #endif
 462 }
 463
 464 static const struct unix_funcs funcs =
 465 {
 466     unix_acosh,
 467     unix_acoshf,
 468     unix_asinh,
 469     unix_asinhf,
 470     unix_atanh,
 471     unix_atanhf,
 472     unix_cosh,
 473     unix_coshf,
 474     unix_exp,
 475     unix_expf,
 476     unix_exp2,
 477     unix_exp2f,
 478     unix_expm1,
 479     unix_expm1f,
 480     unix_fma,
 481     unix_fmaf,
 482     unix_frexp,
 483     unix_frexpf,
 484     unix_hypot,
 485     unix_hypotf,
 486     unix_ldexp,
 487     unix_lgamma,
 488     unix_lgammaf,
 489     unix_log,
 490     unix_logf,
 491     unix_log10,
 492     unix_log10f,
 493     unix_log1p,
 494     unix_log1pf,
 495     unix_log2,
 496     unix_log2f,
 497     unix_pow,
 498     unix_powf,
 499     unix_sinf,
 500     unix_sinh,
 501     unix_sinhf,
 502     unix_tanf,
 503     unix_tanh,
 504     unix_tanhf,
 505     unix_tgamma,
 506     unix_tgammaf,
 507 };
 508
 509 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
 510 {
 511     if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
 512     TRACE( "\n" );
 513     *(const struct unix_funcs **)ptr_out = &funcs;
 514     return STATUS_SUCCESS;
 515 }