git.oblomov.eu Git - wine/blob - dlls/ntdll/misc.c

   1 /*
   2  * Helper functions for ntdll
   3  *
   4  * Copyright 2000 Juergen Schmied
   5  * Copyright 2010 Marcus Meissner
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <time.h>
  25 #include <math.h>
  26 #ifdef HAVE_SYS_UTSNAME_H
  27 #include <sys/utsname.h>
  28 #endif
  29
  30 #include "wine/library.h"
  31 #include "wine/debug.h"
  32 #include "ntdll_misc.h"
  33
  34
  35 #if defined(__GNUC__) && defined(__i386__)
  36 #define DO_FPU(x,y) __asm__ __volatile__( x " %0;fwait" : "=m" (y) : )
  37 #define POP_FPU(x) DO_FPU("fstpl",x)
  38 #endif
  39
  40 LPCSTR debugstr_ObjectAttributes(const OBJECT_ATTRIBUTES *oa)
  41 {
  42     if (!oa) return "<null>";
  43     return wine_dbg_sprintf( "{name=%s, attr=0x%08x, hRoot=%p, sd=%p}\n",
  44                              debugstr_us(oa->ObjectName), oa->Attributes,
  45                              oa->RootDirectory, oa->SecurityDescriptor );
  46 }
  47
  48 LPCSTR debugstr_us( const UNICODE_STRING *us )
  49 {
  50     if (!us) return "<null>";
  51     return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
  52 }
  53
  54 /*********************************************************************
  55  *                  wine_get_version   (NTDLL.@)
  56  */
  57 const char * CDECL NTDLL_wine_get_version(void)
  58 {
  59     return wine_get_version();
  60 }
  61
  62 /*********************************************************************
  63  *                  wine_get_build_id   (NTDLL.@)
  64  */
  65 const char * CDECL NTDLL_wine_get_build_id(void)
  66 {
  67     return wine_get_build_id();
  68 }
  69
  70 /*********************************************************************
  71  *                  wine_get_host_version   (NTDLL.@)
  72  */
  73 void CDECL NTDLL_wine_get_host_version( const char **sysname, const char **release )
  74 {
  75 #ifdef HAVE_SYS_UTSNAME_H
  76     static struct utsname buf;
  77     static int init_done;
  78
  79     if (!init_done)
  80     {
  81         uname( &buf );
  82         init_done = 1;
  83     }
  84     if (sysname) *sysname = buf.sysname;
  85     if (release) *release = buf.release;
  86 #else
  87     if (sysname) *sysname = "";
  88     if (release) *release = "";
  89 #endif
  90 }
  91
  92 /*********************************************************************
  93  *                  abs   (NTDLL.@)
  94  */
  95 int CDECL NTDLL_abs( int i )
  96 {
  97     return abs( i );
  98 }
  99
 100 /*********************************************************************
 101  *                  labs   (NTDLL.@)
 102  */
 103 LONG CDECL NTDLL_labs( LONG i )
 104 {
 105     return labs( i );
 106 }
 107
 108 /*********************************************************************
 109  *                  atan   (NTDLL.@)
 110  */
 111 double CDECL NTDLL_atan( double d )
 112 {
 113     return atan( d );
 114 }
 115
 116 /*********************************************************************
 117  *                  ceil   (NTDLL.@)
 118  */
 119 double CDECL NTDLL_ceil( double d )
 120 {
 121     return ceil( d );
 122 }
 123
 124 /*********************************************************************
 125  *                  cos   (NTDLL.@)
 126  */
 127 double CDECL NTDLL_cos( double d )
 128 {
 129     return cos( d );
 130 }
 131
 132 /*********************************************************************
 133  *                  fabs   (NTDLL.@)
 134  */
 135 double CDECL NTDLL_fabs( double d )
 136 {
 137     return fabs( d );
 138 }
 139
 140 /*********************************************************************
 141  *                  floor   (NTDLL.@)
 142  */
 143 double CDECL NTDLL_floor( double d )
 144 {
 145     return floor( d );
 146 }
 147
 148 /*********************************************************************
 149  *                  log   (NTDLL.@)
 150  */
 151 double CDECL NTDLL_log( double d )
 152 {
 153     return log( d );
 154 }
 155
 156 /*********************************************************************
 157  *                  pow   (NTDLL.@)
 158  */
 159 double CDECL NTDLL_pow( double x, double y )
 160 {
 161     return pow( x, y );
 162 }
 163
 164 /*********************************************************************
 165  *                  sin   (NTDLL.@)
 166  */
 167 double CDECL NTDLL_sin( double d )
 168 {
 169     return sin( d );
 170 }
 171
 172 /*********************************************************************
 173  *                  sqrt   (NTDLL.@)
 174  */
 175 double CDECL NTDLL_sqrt( double d )
 176 {
 177     return sqrt( d );
 178 }
 179
 180 /*********************************************************************
 181  *                  tan   (NTDLL.@)
 182  */
 183 double CDECL NTDLL_tan( double d )
 184 {
 185     return tan( d );
 186 }
 187
 188 #if defined(__GNUC__) && defined(__i386__)
 189
 190 #define FPU_DOUBLE(var) double var; \
 191     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 192 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 193     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 194     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 195
 196 /*********************************************************************
 197  *              _CIcos (NTDLL.@)
 198  */
 199 double CDECL NTDLL__CIcos(void)
 200 {
 201     FPU_DOUBLE(x);
 202     return NTDLL_cos(x);
 203 }
 204
 205 /*********************************************************************
 206  *              _CIlog (NTDLL.@)
 207  */
 208 double CDECL NTDLL__CIlog(void)
 209 {
 210     FPU_DOUBLE(x);
 211     return NTDLL_log(x);
 212 }
 213
 214 /*********************************************************************
 215  *              _CIpow (NTDLL.@)
 216  */
 217 double CDECL NTDLL__CIpow(void)
 218 {
 219     FPU_DOUBLES(x,y);
 220     return NTDLL_pow(x,y);
 221 }
 222
 223 /*********************************************************************
 224  *              _CIsin (NTDLL.@)
 225  */
 226 double CDECL NTDLL__CIsin(void)
 227 {
 228     FPU_DOUBLE(x);
 229     return NTDLL_sin(x);
 230 }
 231
 232 /*********************************************************************
 233  *              _CIsqrt (NTDLL.@)
 234  */
 235 double CDECL NTDLL__CIsqrt(void)
 236 {
 237     FPU_DOUBLE(x);
 238     return NTDLL_sqrt(x);
 239 }
 240
 241 /*********************************************************************
 242  *                  _ftol   (NTDLL.@)
 243  */
 244 LONGLONG CDECL NTDLL__ftol(void)
 245 {
 246     FPU_DOUBLE(x);
 247     return (LONGLONG)x;
 248 }
 249
 250 #endif /* defined(__GNUC__) && defined(__i386__) */
 251
 252 static void
 253 NTDLL_mergesort( void *arr, void *barr, size_t elemsize, int(__cdecl *compar)(const void *, const void *),
 254                  size_t left, size_t right )
 255 {
 256     if(right>left) {
 257         size_t i, j, k, m;
 258         m=left+(right-left)/2;
 259         NTDLL_mergesort( arr, barr, elemsize, compar, left, m);
 260         NTDLL_mergesort( arr, barr, elemsize, compar, m+1, right);
 261
 262 #define X(a,i) ((char*)a+elemsize*(i))
 263         for (k=left, i=left, j=m+1; i<=m && j<=right; k++) {
 264             if (compar(X(arr, i), X(arr,j)) <= 0) {
 265                 memcpy(X(barr,k), X(arr, i), elemsize);
 266                 i++;
 267             } else {
 268                 memcpy(X(barr,k), X(arr, j), elemsize);
 269                 j++;
 270             }
 271         }
 272         if (i<=m)
 273             memcpy(X(barr,k), X(arr,i), (m-i+1)*elemsize);
 274         else
 275             memcpy(X(barr,k), X(arr,j), (right-j+1)*elemsize);
 276
 277         memcpy(X(arr, left), X(barr, left), (right-left+1)*elemsize);
 278     }
 279 #undef X
 280 }
 281
 282 /*********************************************************************
 283  *                  qsort   (NTDLL.@)
 284  */
 285 void __cdecl NTDLL_qsort( void *base, size_t nmemb, size_t size,
 286                           int(__cdecl *compar)(const void *, const void *) )
 287 {
 288     void *secondarr;
 289     if (nmemb < 2 || size == 0) return;
 290     secondarr = RtlAllocateHeap (GetProcessHeap(), 0, nmemb*size);
 291     NTDLL_mergesort( base, secondarr, size, compar, 0, nmemb-1 );
 292     RtlFreeHeap (GetProcessHeap(),0, secondarr);
 293 }
 294
 295 /*********************************************************************
 296  *                  bsearch   (NTDLL.@)
 297  */
 298 void * __cdecl
 299 NTDLL_bsearch( const void *key, const void *base, size_t nmemb,
 300                size_t size, int (__cdecl *compar)(const void *, const void *) )
 301 {
 302     ssize_t min = 0;
 303     ssize_t max = nmemb - 1;
 304
 305     while (min <= max)
 306     {
 307         ssize_t cursor = (min + max) / 2;
 308         int ret = compar(key,(const char *)base+(cursor*size));
 309         if (!ret)
 310             return (char*)base+(cursor*size);
 311         if (ret < 0)
 312             max = cursor - 1;
 313         else
 314             min = cursor + 1;
 315     }
 316     return NULL;
 317 }
 318
 319
 320 /*********************************************************************
 321  *                  _lfind   (NTDLL.@)
 322  */
 323 void * __cdecl _lfind( const void *key, const void *base, unsigned int *nmemb,
 324                        size_t size, int(__cdecl *compar)(const void *, const void *) )
 325 {
 326     size_t i, n = *nmemb;
 327
 328     for (i=0;i<n;i++)
 329         if (!compar(key,(char*)base+(size*i)))
 330             return (char*)base+(size*i);
 331     return NULL;
 332 }