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  *      cosh
  47  */
  48 static double CDECL unix_cosh( double x )
  49 {
  50     return cosh( x );
  51 }
  52
  53 /*********************************************************************
  54  *      coshf
  55  */
  56 static float CDECL unix_coshf( float x )
  57 {
  58     return coshf( x );
  59 }
  60
  61 /*********************************************************************
  62  *      exp
  63  */
  64 static double CDECL unix_exp( double x )
  65 {
  66     return exp( x );
  67 }
  68
  69 /*********************************************************************
  70  *      expf
  71  */
  72 static float CDECL unix_expf( float x )
  73 {
  74     return expf( x );
  75 }
  76
  77 /*********************************************************************
  78  *      exp2
  79  */
  80 static double CDECL unix_exp2( double x )
  81 {
  82 #ifdef HAVE_EXP2
  83     return exp2(x);
  84 #else
  85     return pow(2, x);
  86 #endif
  87 }
  88
  89 /*********************************************************************
  90  *      exp2f
  91  */
  92 static float CDECL unix_exp2f( float x )
  93 {
  94 #ifdef HAVE_EXP2F
  95     return exp2f(x);
  96 #else
  97     return unix_exp2(x);
  98 #endif
  99 }
 100
 101 /*********************************************************************
 102  *      fma
 103  */
 104 static double CDECL unix_fma( double x, double y, double z )
 105 {
 106 #ifdef HAVE_FMA
 107     return fma(x, y, z);
 108 #else
 109     return x * y + z;
 110 #endif
 111 }
 112
 113 /*********************************************************************
 114  *      fmaf
 115  */
 116 static float CDECL unix_fmaf( float x, float y, float z )
 117 {
 118 #ifdef HAVE_FMAF
 119     return fmaf(x, y, z);
 120 #else
 121     return x * y + z;
 122 #endif
 123 }
 124
 125 /*********************************************************************
 126  *      frexp
 127  */
 128 static double CDECL unix_frexp( double x, int *exp )
 129 {
 130     return frexp( x, exp );
 131 }
 132
 133 /*********************************************************************
 134  *      frexpf
 135  */
 136 static float CDECL unix_frexpf( float x, int *exp )
 137 {
 138     return frexpf( x, exp );
 139 }
 140
 141 /*********************************************************************
 142  *      hypot
 143  */
 144 static double CDECL unix_hypot(double x, double y)
 145 {
 146     return hypot( x, y );
 147 }
 148
 149 /*********************************************************************
 150  *      hypotf
 151  */
 152 static float CDECL unix_hypotf(float x, float y)
 153 {
 154     return hypotf( x, y );
 155 }
 156
 157 /*********************************************************************
 158  *      ldexp
 159  */
 160 static double CDECL unix_ldexp(double num, int exp)
 161 {
 162     return ldexp( num, exp );
 163 }
 164
 165 /*********************************************************************
 166  *      lgamma
 167  */
 168 static double CDECL unix_lgamma(double x)
 169 {
 170 #ifdef HAVE_LGAMMA
 171     return lgamma(x);
 172 #else
 173     FIXME( "not implemented\n" );
 174     return 0;
 175 #endif
 176 }
 177
 178 /*********************************************************************
 179  *      lgammaf
 180  */
 181 static float CDECL unix_lgammaf(float x)
 182 {
 183 #ifdef HAVE_LGAMMAF
 184     return lgammaf(x);
 185 #else
 186     FIXME( "not implemented\n" );
 187     return 0;
 188 #endif
 189 }
 190
 191 /*********************************************************************
 192  *      log
 193  */
 194 static double CDECL unix_log( double x )
 195 {
 196     return log( x );
 197 }
 198
 199 /*********************************************************************
 200  *      logf
 201  */
 202 static float CDECL unix_logf( float x )
 203 {
 204     return logf( x );
 205 }
 206
 207 /*********************************************************************
 208  *      log10
 209  */
 210 static double CDECL unix_log10( double x )
 211 {
 212     return log10( x );
 213 }
 214
 215 /*********************************************************************
 216  *      log10f
 217  */
 218 static float CDECL unix_log10f( float x )
 219 {
 220     return log10f( x );
 221 }
 222
 223 /*********************************************************************
 224  *      log1p
 225  */
 226 static double CDECL unix_log1p(double x)
 227 {
 228 #ifdef HAVE_LOG1P
 229     return log1p(x);
 230 #else
 231     return log(1 + x);
 232 #endif
 233 }
 234
 235 /*********************************************************************
 236  *      log1pf
 237  */
 238 static float CDECL unix_log1pf(float x)
 239 {
 240 #ifdef HAVE_LOG1PF
 241     return log1pf(x);
 242 #else
 243     return log(1 + x);
 244 #endif
 245 }
 246
 247 /*********************************************************************
 248  *      log2
 249  */
 250 static double CDECL unix_log2(double x)
 251 {
 252 #ifdef HAVE_LOG2
 253     return log2(x);
 254 #else
 255     return log(x) / log(2);
 256 #endif
 257 }
 258
 259 /*********************************************************************
 260  *      log2f
 261  */
 262 static float CDECL unix_log2f(float x)
 263 {
 264 #ifdef HAVE_LOG2F
 265     return log2f(x);
 266 #else
 267     return unix_log2(x);
 268 #endif
 269 }
 270
 271 /*********************************************************************
 272  *      pow
 273  */
 274 static double CDECL unix_pow( double x, double y )
 275 {
 276     return pow( x, y );
 277 }
 278
 279 /*********************************************************************
 280  *      powf
 281  */
 282 static float CDECL unix_powf( float x, float y )
 283 {
 284     return powf( x, y );
 285 }
 286
 287 /*********************************************************************
 288  *      sinh
 289  */
 290 static double CDECL unix_sinh( double x )
 291 {
 292     return sinh( x );
 293 }
 294
 295 /*********************************************************************
 296  *      sinhf
 297  */
 298 static float CDECL unix_sinhf( float x )
 299 {
 300     return sinhf( x );
 301 }
 302
 303 /*********************************************************************
 304  *      tanh
 305  */
 306 static double CDECL unix_tanh( double x )
 307 {
 308     return tanh( x );
 309 }
 310
 311 /*********************************************************************
 312  *      tanhf
 313  */
 314 static float CDECL unix_tanhf( float x )
 315 {
 316     return tanhf( x );
 317 }
 318
 319 /*********************************************************************
 320  *      tgamma
 321  */
 322 static double CDECL unix_tgamma(double x)
 323 {
 324 #ifdef HAVE_TGAMMA
 325     return tgamma(x);
 326 #else
 327     FIXME( "not implemented\n" );
 328     return 0;
 329 #endif
 330 }
 331
 332 /*********************************************************************
 333  *      tgammaf
 334  */
 335 static float CDECL unix_tgammaf(float x)
 336 {
 337 #ifdef HAVE_TGAMMAF
 338     return tgammaf(x);
 339 #else
 340     FIXME( "not implemented\n" );
 341     return 0;
 342 #endif
 343 }
 344
 345 static const struct unix_funcs funcs =
 346 {
 347     unix_cosh,
 348     unix_coshf,
 349     unix_exp,
 350     unix_expf,
 351     unix_exp2,
 352     unix_exp2f,
 353     unix_fma,
 354     unix_fmaf,
 355     unix_frexp,
 356     unix_frexpf,
 357     unix_hypot,
 358     unix_hypotf,
 359     unix_ldexp,
 360     unix_lgamma,
 361     unix_lgammaf,
 362     unix_log,
 363     unix_logf,
 364     unix_log10,
 365     unix_log10f,
 366     unix_log1p,
 367     unix_log1pf,
 368     unix_log2,
 369     unix_log2f,
 370     unix_pow,
 371     unix_powf,
 372     unix_sinh,
 373     unix_sinhf,
 374     unix_tanh,
 375     unix_tanhf,
 376     unix_tgamma,
 377     unix_tgammaf,
 378 };
 379
 380 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
 381 {
 382     if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
 383     TRACE( "\n" );
 384     *(const struct unix_funcs **)ptr_out = &funcs;
 385     return STATUS_SUCCESS;
 386 }