shell32: Implement "make new folder" functionality in SHBrowseForFolder.
[wine] / 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  *                  _ftol   (NTDLL.@)
57  *
58  * VERSION
59  *      [GNUC && i386]
60  */
61 #if defined(__GNUC__) && defined(__i386__)
62 LONGLONG CDECL NTDLL__ftol(void)
63 {
64         /* don't just do DO_FPU("fistp",retval), because the rounding
65          * mode must also be set to "round towards zero"... */
66         double fl;
67         POP_FPU(fl);
68         return (LONGLONG)fl;
69 }
70 #endif /* defined(__GNUC__) && defined(__i386__) */
71
72 /*********************************************************************
73  *                  _ftol   (NTDLL.@)
74  *
75  * FIXME
76  *      Should be register function
77  * VERSION
78  *      [!GNUC && i386]
79  */
80 #if !defined(__GNUC__) && defined(__i386__)
81 LONGLONG CDECL NTDLL__ftol(double fl)
82 {
83         FIXME("should be register function\n");
84         return (LONGLONG)fl;
85 }
86 #endif /* !defined(__GNUC__) && defined(__i386__) */
87
88 /*********************************************************************
89  *                  _CIpow   (NTDLL.@)
90  * VERSION
91  *      [GNUC && i386]
92  */
93 #if defined(__GNUC__) && defined(__i386__)
94 double CDECL NTDLL__CIpow(void)
95 {
96         double x,y;
97         POP_FPU(y);
98         POP_FPU(x);
99         return pow(x,y);
100 }
101 #endif /* defined(__GNUC__) && defined(__i386__) */
102
103
104 /*********************************************************************
105  *                  _CIpow   (NTDLL.@)
106  *
107  * FIXME
108  *      Should be register function
109  *
110  * VERSION
111  *      [!GNUC && i386]
112  */
113 #if !defined(__GNUC__) && defined(__i386__)
114 double CDECL NTDLL__CIpow(double x,double y)
115 {
116         FIXME("should be register function\n");
117         return pow(x,y);
118 }
119 #endif /* !defined(__GNUC__) && defined(__i386__) */
120
121 /*********************************************************************
122  *                  wine_get_version   (NTDLL.@)
123  */
124 const char * CDECL NTDLL_wine_get_version(void)
125 {
126     return wine_get_version();
127 }
128
129 /*********************************************************************
130  *                  wine_get_build_id   (NTDLL.@)
131  */
132 const char * CDECL NTDLL_wine_get_build_id(void)
133 {
134     return wine_get_build_id();
135 }
136
137 /*********************************************************************
138  *                  wine_get_host_version   (NTDLL.@)
139  */
140 void CDECL NTDLL_wine_get_host_version( const char **sysname, const char **release )
141 {
142 #ifdef HAVE_SYS_UTSNAME_H
143     static struct utsname buf;
144     static int init_done;
145
146     if (!init_done)
147     {
148         uname( &buf );
149         init_done = 1;
150     }
151     if (sysname) *sysname = buf.sysname;
152     if (release) *release = buf.release;
153 #else
154     if (sysname) *sysname = "";
155     if (release) *release = "";
156 #endif
157 }
158
159 /*********************************************************************
160  *                  abs   (NTDLL.@)
161  */
162 int CDECL NTDLL_abs( int i )
163 {
164     return abs( i );
165 }
166
167 /*********************************************************************
168  *                  labs   (NTDLL.@)
169  */
170 LONG CDECL NTDLL_labs( LONG i )
171 {
172     return labs( i );
173 }
174
175 /*********************************************************************
176  *                  atan   (NTDLL.@)
177  */
178 double CDECL NTDLL_atan( double d )
179 {
180     return atan( d );
181 }
182
183 /*********************************************************************
184  *                  ceil   (NTDLL.@)
185  */
186 double CDECL NTDLL_ceil( double d )
187 {
188     return ceil( d );
189 }
190
191 /*********************************************************************
192  *                  cos   (NTDLL.@)
193  */
194 double CDECL NTDLL_cos( double d )
195 {
196     return cos( d );
197 }
198
199 /*********************************************************************
200  *                  fabs   (NTDLL.@)
201  */
202 double CDECL NTDLL_fabs( double d )
203 {
204     return fabs( d );
205 }
206
207 /*********************************************************************
208  *                  floor   (NTDLL.@)
209  */
210 double CDECL NTDLL_floor( double d )
211 {
212     return floor( d );
213 }
214
215 /*********************************************************************
216  *                  log   (NTDLL.@)
217  */
218 double CDECL NTDLL_log( double d )
219 {
220     return log( d );
221 }
222
223 /*********************************************************************
224  *                  pow   (NTDLL.@)
225  */
226 double CDECL NTDLL_pow( double x, double y )
227 {
228     return pow( x, y );
229 }
230
231 /*********************************************************************
232  *                  sin   (NTDLL.@)
233  */
234 double CDECL NTDLL_sin( double d )
235 {
236     return sin( d );
237 }
238
239 /*********************************************************************
240  *                  sqrt   (NTDLL.@)
241  */
242 double CDECL NTDLL_sqrt( double d )
243 {
244     return sqrt( d );
245 }
246
247 /*********************************************************************
248  *                  tan   (NTDLL.@)
249  */
250 double CDECL NTDLL_tan( double d )
251 {
252     return tan( d );
253 }
254
255
256 static void
257 NTDLL_mergesort( void *arr, void *barr, size_t elemsize, int(__cdecl *compar)(const void *, const void *),
258                  size_t left, size_t right )
259 {
260     if(right>left) {
261         size_t i, j, k, m;
262         m=left+(right-left)/2;
263         NTDLL_mergesort( arr, barr, elemsize, compar, left, m);
264         NTDLL_mergesort( arr, barr, elemsize, compar, m+1, right);
265
266 #define X(a,i) ((char*)a+elemsize*(i))
267         for (k=left, i=left, j=m+1; i<=m && j<=right; k++) {
268             if (compar(X(arr, i), X(arr,j)) <= 0) {
269                 memcpy(X(barr,k), X(arr, i), elemsize);
270                 i++;
271             } else {
272                 memcpy(X(barr,k), X(arr, j), elemsize);
273                 j++;
274             }
275         }
276         if (i<=m)
277             memcpy(X(barr,k), X(arr,i), (m-i+1)*elemsize);
278         else
279             memcpy(X(barr,k), X(arr,j), (right-j+1)*elemsize);
280
281         memcpy(X(arr, left), X(barr, left), (right-left+1)*elemsize);
282     }
283 #undef X
284 }
285
286 /*********************************************************************
287  *                  qsort   (NTDLL.@)
288  */
289 void __cdecl NTDLL_qsort( void *base, size_t nmemb, size_t size,
290                           int(__cdecl *compar)(const void *, const void *) )
291 {
292     void *secondarr;
293     if (nmemb < 2 || size == 0) return;
294     secondarr = RtlAllocateHeap (GetProcessHeap(), 0, nmemb*size);
295     NTDLL_mergesort( base, secondarr, size, compar, 0, nmemb-1 );
296     RtlFreeHeap (GetProcessHeap(),0, secondarr);
297 }
298
299 /*********************************************************************
300  *                  bsearch   (NTDLL.@)
301  */
302 void * __cdecl
303 NTDLL_bsearch( const void *key, const void *base, size_t nmemb,
304                size_t size, int (__cdecl *compar)(const void *, const void *) )
305 {
306     ssize_t min = 0;
307     ssize_t max = nmemb - 1;
308
309     while (min <= max)
310     {
311         ssize_t cursor = (min + max) / 2;
312         int ret = compar(key,(const char *)base+(cursor*size));
313         if (!ret)
314             return (char*)base+(cursor*size);
315         if (ret < 0)
316             max = cursor - 1;
317         else
318             min = cursor + 1;
319     }
320     return NULL;
321 }
322
323
324 /*********************************************************************
325  *                  _lfind   (NTDLL.@)
326  */
327 void * __cdecl _lfind( const void *key, const void *base, unsigned int *nmemb,
328                        size_t size, int(__cdecl *compar)(const void *, const void *) )
329 {
330     size_t i, n = *nmemb;
331
332     for (i=0;i<n;i++)
333         if (!compar(key,(char*)base+(size*i)))
334             return (char*)base+(size*i);
335     return NULL;
336 }