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 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  35
  36 #if defined(__GNUC__) && defined(__i386__)
  37 #define DO_FPU(x,y) __asm__ __volatile__( x " %0;fwait" : "=m" (y) : )
  38 #define POP_FPU(x) DO_FPU("fstpl",x)
  39 #endif
  40
  41 LPCSTR debugstr_ObjectAttributes(const OBJECT_ATTRIBUTES *oa)
  42 {
  43     if (!oa) return "<null>";
  44     return wine_dbg_sprintf( "{name=%s, attr=0x%08x, hRoot=%p, sd=%p}\n",
  45                              debugstr_us(oa->ObjectName), oa->Attributes,
  46                              oa->RootDirectory, oa->SecurityDescriptor );
  47 }
  48
  49 LPCSTR debugstr_us( const UNICODE_STRING *us )
  50 {
  51     if (!us) return "<null>";
  52     return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
  53 }
  54
  55 /*********************************************************************
  56  *                  wine_get_version   (NTDLL.@)
  57  */
  58 const char * CDECL NTDLL_wine_get_version(void)
  59 {
  60     return wine_get_version();
  61 }
  62
  63 /*********************************************************************
  64  *                  wine_get_build_id   (NTDLL.@)
  65  */
  66 const char * CDECL NTDLL_wine_get_build_id(void)
  67 {
  68     return wine_get_build_id();
  69 }
  70
  71 /*********************************************************************
  72  *                  wine_get_host_version   (NTDLL.@)
  73  */
  74 void CDECL NTDLL_wine_get_host_version( const char **sysname, const char **release )
  75 {
  76 #ifdef HAVE_SYS_UTSNAME_H
  77     static struct utsname buf;
  78     static int init_done;
  79
  80     if (!init_done)
  81     {
  82         uname( &buf );
  83         init_done = 1;
  84     }
  85     if (sysname) *sysname = buf.sysname;
  86     if (release) *release = buf.release;
  87 #else
  88     if (sysname) *sysname = "";
  89     if (release) *release = "";
  90 #endif
  91 }
  92
  93 /*********************************************************************
  94  *                  abs   (NTDLL.@)
  95  */
  96 int CDECL NTDLL_abs( int i )
  97 {
  98     return abs( i );
  99 }
 100
 101 /*********************************************************************
 102  *                  labs   (NTDLL.@)
 103  */
 104 LONG CDECL NTDLL_labs( LONG i )
 105 {
 106     return labs( i );
 107 }
 108
 109 /*********************************************************************
 110  *                  atan   (NTDLL.@)
 111  */
 112 double CDECL NTDLL_atan( double d )
 113 {
 114     return atan( d );
 115 }
 116
 117 /*********************************************************************
 118  *                  ceil   (NTDLL.@)
 119  */
 120 double CDECL NTDLL_ceil( double d )
 121 {
 122     return ceil( d );
 123 }
 124
 125 /*********************************************************************
 126  *                  cos   (NTDLL.@)
 127  */
 128 double CDECL NTDLL_cos( double d )
 129 {
 130     return cos( d );
 131 }
 132
 133 /*********************************************************************
 134  *                  fabs   (NTDLL.@)
 135  */
 136 double CDECL NTDLL_fabs( double d )
 137 {
 138     return fabs( d );
 139 }
 140
 141 /*********************************************************************
 142  *                  floor   (NTDLL.@)
 143  */
 144 double CDECL NTDLL_floor( double d )
 145 {
 146     return floor( d );
 147 }
 148
 149 /*********************************************************************
 150  *                  log   (NTDLL.@)
 151  */
 152 double CDECL NTDLL_log( double d )
 153 {
 154     return log( d );
 155 }
 156
 157 /*********************************************************************
 158  *                  pow   (NTDLL.@)
 159  */
 160 double CDECL NTDLL_pow( double x, double y )
 161 {
 162     return pow( x, y );
 163 }
 164
 165 /*********************************************************************
 166  *                  sin   (NTDLL.@)
 167  */
 168 double CDECL NTDLL_sin( double d )
 169 {
 170     return sin( d );
 171 }
 172
 173 /*********************************************************************
 174  *                  sqrt   (NTDLL.@)
 175  */
 176 double CDECL NTDLL_sqrt( double d )
 177 {
 178     return sqrt( d );
 179 }
 180
 181 /*********************************************************************
 182  *                  tan   (NTDLL.@)
 183  */
 184 double CDECL NTDLL_tan( double d )
 185 {
 186     return tan( d );
 187 }
 188
 189 #if defined(__GNUC__) && defined(__i386__)
 190
 191 #define FPU_DOUBLE(var) double var; \
 192     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 193 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 194     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 195     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 196
 197 /*********************************************************************
 198  *              _CIcos (NTDLL.@)
 199  */
 200 double CDECL NTDLL__CIcos(void)
 201 {
 202     FPU_DOUBLE(x);
 203     return NTDLL_cos(x);
 204 }
 205
 206 /*********************************************************************
 207  *              _CIlog (NTDLL.@)
 208  */
 209 double CDECL NTDLL__CIlog(void)
 210 {
 211     FPU_DOUBLE(x);
 212     return NTDLL_log(x);
 213 }
 214
 215 /*********************************************************************
 216  *              _CIpow (NTDLL.@)
 217  */
 218 double CDECL NTDLL__CIpow(void)
 219 {
 220     FPU_DOUBLES(x,y);
 221     return NTDLL_pow(x,y);
 222 }
 223
 224 /*********************************************************************
 225  *              _CIsin (NTDLL.@)
 226  */
 227 double CDECL NTDLL__CIsin(void)
 228 {
 229     FPU_DOUBLE(x);
 230     return NTDLL_sin(x);
 231 }
 232
 233 /*********************************************************************
 234  *              _CIsqrt (NTDLL.@)
 235  */
 236 double CDECL NTDLL__CIsqrt(void)
 237 {
 238     FPU_DOUBLE(x);
 239     return NTDLL_sqrt(x);
 240 }
 241
 242 /*********************************************************************
 243  *                  _ftol   (NTDLL.@)
 244  */
 245 LONGLONG CDECL NTDLL__ftol(void)
 246 {
 247     FPU_DOUBLE(x);
 248     return (LONGLONG)x;
 249 }
 250
 251 #endif /* defined(__GNUC__) && defined(__i386__) */
 252
 253 static void
 254 NTDLL_mergesort( void *arr, void *barr, size_t elemsize, int(__cdecl *compar)(const void *, const void *),
 255                  size_t left, size_t right )
 256 {
 257     if(right>left) {
 258         size_t i, j, k, m;
 259         m=left+(right-left)/2;
 260         NTDLL_mergesort( arr, barr, elemsize, compar, left, m);
 261         NTDLL_mergesort( arr, barr, elemsize, compar, m+1, right);
 262
 263 #define X(a,i) ((char*)a+elemsize*(i))
 264         for (k=left, i=left, j=m+1; i<=m && j<=right; k++) {
 265             if (compar(X(arr, i), X(arr,j)) <= 0) {
 266                 memcpy(X(barr,k), X(arr, i), elemsize);
 267                 i++;
 268             } else {
 269                 memcpy(X(barr,k), X(arr, j), elemsize);
 270                 j++;
 271             }
 272         }
 273         if (i<=m)
 274             memcpy(X(barr,k), X(arr,i), (m-i+1)*elemsize);
 275         else
 276             memcpy(X(barr,k), X(arr,j), (right-j+1)*elemsize);
 277
 278         memcpy(X(arr, left), X(barr, left), (right-left+1)*elemsize);
 279     }
 280 #undef X
 281 }
 282
 283 /*********************************************************************
 284  *                  qsort   (NTDLL.@)
 285  */
 286 void __cdecl NTDLL_qsort( void *base, size_t nmemb, size_t size,
 287                           int(__cdecl *compar)(const void *, const void *) )
 288 {
 289     void *secondarr;
 290     if (nmemb < 2 || size == 0) return;
 291     secondarr = RtlAllocateHeap (GetProcessHeap(), 0, nmemb*size);
 292     NTDLL_mergesort( base, secondarr, size, compar, 0, nmemb-1 );
 293     RtlFreeHeap (GetProcessHeap(),0, secondarr);
 294 }
 295
 296 /*********************************************************************
 297  *                  bsearch   (NTDLL.@)
 298  */
 299 void * __cdecl
 300 NTDLL_bsearch( const void *key, const void *base, size_t nmemb,
 301                size_t size, int (__cdecl *compar)(const void *, const void *) )
 302 {
 303     ssize_t min = 0;
 304     ssize_t max = nmemb - 1;
 305
 306     while (min <= max)
 307     {
 308         ssize_t cursor = (min + max) / 2;
 309         int ret = compar(key,(const char *)base+(cursor*size));
 310         if (!ret)
 311             return (char*)base+(cursor*size);
 312         if (ret < 0)
 313             max = cursor - 1;
 314         else
 315             min = cursor + 1;
 316     }
 317     return NULL;
 318 }
 319
 320
 321 /*********************************************************************
 322  *                  _lfind   (NTDLL.@)
 323  */
 324 void * __cdecl _lfind( const void *key, const void *base, unsigned int *nmemb,
 325                        size_t size, int(__cdecl *compar)(const void *, const void *) )
 326 {
 327     size_t i, n = *nmemb;
 328
 329     for (i=0;i<n;i++)
 330         if (!compar(key,(char*)base+(size*i)))
 331             return (char*)base+(size*i);
 332     return NULL;
 333 }