Call the equivalent delegate function for all of the simple
[wine] / dlls / ntdll / string.c
1 /*
2  * NTDLL string functions
3  *
4  * Copyright 2000 Alexandre Julliard
5  * Copyright 2000 Jon Griffiths
6  * Copyright 2003 Thomas Mertes
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #include "config.h"
24
25 #include <ctype.h>
26 #include <stdarg.h>
27 #include <string.h>
28
29 #include "windef.h"
30 #include "winternl.h"
31
32
33 /*********************************************************************
34  *                  _memicmp   (NTDLL.@)
35  *
36  * Compare two blocks of memory as strings, ignoring case.
37  *
38  * PARAMS
39  *  s1  [I] First string to compare to s2
40  *  s2  [I] Second string to compare to s1
41  *  len [I] Number of bytes to compare
42  *
43  * RETURNS
44  *  An integer less than, equal to, or greater than zero indicating that
45  *  s1 is less than, equal to or greater than s2 respectively.
46  *
47  * NOTES
48  *  Any Nul characters in s1 or s2 are ignored. This function always
49  *  compares up to len bytes or the first place where s1 and s2 differ.
50  */
51 INT __cdecl NTDLL__memicmp( LPCSTR s1, LPCSTR s2, DWORD len )
52 {
53     int ret = 0;
54     while (len--)
55     {
56         if ((ret = tolower(*s1) - tolower(*s2))) break;
57         s1++;
58         s2++;
59     }
60     return ret;
61 }
62
63
64 /*********************************************************************
65  *                  _strupr   (NTDLL.@)
66  *
67  * Convert a string to upper case.
68  *
69  * PARAMS
70  *  str [I/O] String to convert
71  *
72  * RETURNS
73  *  str. There is no error return, if str is NULL or invalid, this
74  *  function will crash.
75  */
76 LPSTR __cdecl _strupr( LPSTR str )
77 {
78     LPSTR ret = str;
79     for ( ; *str; str++) *str = toupper(*str);
80     return ret;
81 }
82
83
84 /*********************************************************************
85  *                  _strlwr   (NTDLL.@)
86  *
87  * Convert a string to lowercase
88  *
89  * PARAMS
90  *  str [I/O] String to convert
91  *
92  * RETURNS
93  *  str. There is no error return, if str is NULL or invalid, this
94  *  function will crash.
95  */
96 LPSTR __cdecl _strlwr( LPSTR str )
97 {
98     LPSTR ret = str;
99     for ( ; *str; str++) *str = tolower(*str);
100     return ret;
101 }
102
103
104 /*********************************************************************
105  *      _ultoa   (NTDLL.@)
106  *
107  * Convert an unsigned long integer to a string.
108  *
109  * RETURNS
110  *  str.
111  *
112  * NOTES
113  *  - Converts value to a Nul terminated string which is copied to str.
114  *  - The maximum length of the copied str is 33 bytes.
115  *  - Does not check if radix is in the range of 2 to 36.
116  *  - If str is NULL it crashes, as the native function does.
117  */
118 char * __cdecl _ultoa(
119     unsigned long value, /* [I] Value to be converted */
120     char *str,           /* [O] Destination for the converted value */
121     int radix)           /* [I] Number base for conversion */
122 {
123     char buffer[33];
124     char *pos;
125     int digit;
126
127     pos = &buffer[32];
128     *pos = '\0';
129
130     do {
131         digit = value % radix;
132         value = value / radix;
133         if (digit < 10) {
134             *--pos = '0' + digit;
135         } else {
136             *--pos = 'a' + digit - 10;
137         } /* if */
138     } while (value != 0L);
139
140     memcpy(str, pos, &buffer[32] - pos + 1);
141     return str;
142 }
143
144
145 /*********************************************************************
146  *      _ltoa   (NTDLL.@)
147  *
148  * Convert a long integer to a string.
149  *
150  * RETURNS
151  *  str.
152  *
153  * NOTES
154  *  - Converts value to a Nul terminated string which is copied to str.
155  *  - The maximum length of the copied str is 33 bytes. If radix
156  *  is 10 and value is negative, the value is converted with sign.
157  *  - Does not check if radix is in the range of 2 to 36.
158  *  - If str is NULL it crashes, as the native function does.
159  */
160 char * __cdecl _ltoa(
161     long value, /* [I] Value to be converted */
162     char *str,  /* [O] Destination for the converted value */
163     int radix)  /* [I] Number base for conversion */
164 {
165     unsigned long val;
166     int negative;
167     char buffer[33];
168     char *pos;
169     int digit;
170
171     if (value < 0 && radix == 10) {
172         negative = 1;
173         val = -value;
174     } else {
175         negative = 0;
176         val = value;
177     } /* if */
178
179     pos = &buffer[32];
180     *pos = '\0';
181
182     do {
183         digit = val % radix;
184         val = val / radix;
185         if (digit < 10) {
186             *--pos = '0' + digit;
187         } else {
188             *--pos = 'a' + digit - 10;
189         } /* if */
190     } while (val != 0L);
191
192     if (negative) {
193         *--pos = '-';
194     } /* if */
195
196     memcpy(str, pos, &buffer[32] - pos + 1);
197     return str;
198 }
199
200
201 /*********************************************************************
202  *      _itoa    (NTDLL.@)
203  *
204  * Converts an integer to a string.
205  *
206  * RETURNS
207  *  str.
208  *
209  * NOTES
210  *  - Converts value to a '\0' terminated string which is copied to str.
211  *  - The maximum length of the copied str is 33 bytes. If radix
212  *  is 10 and value is negative, the value is converted with sign.
213  *  - Does not check if radix is in the range of 2 to 36.
214  *  - If str is NULL it crashes, as the native function does.
215  */
216 char * __cdecl _itoa(
217     int value, /* [I] Value to be converted */
218     char *str, /* [O] Destination for the converted value */
219     int radix) /* [I] Number base for conversion */
220 {
221     return _ltoa(value, str, radix);
222 }
223
224
225 /*********************************************************************
226  *      _ui64toa   (NTDLL.@)
227  *
228  * Converts a large unsigned integer to a string.
229  *
230  * RETURNS
231  *  str.
232  *
233  * NOTES
234  *  - Converts value to a '\0' terminated string which is copied to str.
235  *  - The maximum length of the copied str is 65 bytes.
236  *  - Does not check if radix is in the range of 2 to 36.
237  *  - If str is NULL it crashes, as the native function does.
238  */
239 char * __cdecl _ui64toa(
240     ULONGLONG value, /* [I] Value to be converted */
241     char *str,       /* [O] Destination for the converted value */
242     int radix)       /* [I] Number base for conversion */
243 {
244     char buffer[65];
245     char *pos;
246     int digit;
247
248     pos = &buffer[64];
249     *pos = '\0';
250
251     do {
252         digit = value % radix;
253         value = value / radix;
254         if (digit < 10) {
255             *--pos = '0' + digit;
256         } else {
257             *--pos = 'a' + digit - 10;
258         } /* if */
259     } while (value != 0L);
260
261     memcpy(str, pos, &buffer[64] - pos + 1);
262     return str;
263 }
264
265
266 /*********************************************************************
267  *      _i64toa   (NTDLL.@)
268  *
269  * Converts a large integer to a string.
270  *
271  * RETURNS
272  *  str.
273  *
274  * NOTES
275  *  - Converts value to a Nul terminated string which is copied to str.
276  *  - The maximum length of the copied str is 65 bytes. If radix
277  *  is 10 and value is negative, the value is converted with sign.
278  *  - Does not check if radix is in the range of 2 to 36.
279  *  - If str is NULL it crashes, as the native function does.
280  *
281  * DIFFERENCES
282  * - The native DLL converts negative values (for base 10) wrong:
283  *|                     -1 is converted to -18446744073709551615
284  *|                     -2 is converted to -18446744073709551614
285  *|   -9223372036854775807 is converted to  -9223372036854775809
286  *|   -9223372036854775808 is converted to  -9223372036854775808
287  *   The native msvcrt _i64toa function and our ntdll _i64toa function
288  *   do not have this bug.
289  */
290 char * __cdecl _i64toa(
291     LONGLONG value, /* [I] Value to be converted */
292     char *str,      /* [O] Destination for the converted value */
293     int radix)      /* [I] Number base for conversion */
294 {
295     ULONGLONG val;
296     int negative;
297     char buffer[65];
298     char *pos;
299     int digit;
300
301     if (value < 0 && radix == 10) {
302         negative = 1;
303         val = -value;
304     } else {
305         negative = 0;
306         val = value;
307     } /* if */
308
309     pos = &buffer[64];
310     *pos = '\0';
311
312     do {
313         digit = val % radix;
314         val = val / radix;
315         if (digit < 10) {
316             *--pos = '0' + digit;
317         } else {
318             *--pos = 'a' + digit - 10;
319         } /* if */
320     } while (val != 0L);
321
322     if (negative) {
323         *--pos = '-';
324     } /* if */
325
326     memcpy(str, pos, &buffer[64] - pos + 1);
327     return str;
328 }
329
330
331 /*********************************************************************
332  *      _atoi64   (NTDLL.@)
333  *
334  * Convert a string to a large integer.
335  *
336  * PARAMS
337  *  str [I] String to be converted
338  *
339  * RETURNS
340  *  Success: The integer value represented by str.
341  *  Failure: 0. Note that this cannot be distinguished from a successful
342  *           return, if the string contains "0".
343  *
344  * NOTES
345  *  - Accepts: {whitespace} [+|-] {digits}
346  *  - No check is made for value overflow, only the lower 64 bits are assigned.
347  *  - If str is NULL it crashes, as the native function does.
348  */
349 LONGLONG __cdecl _atoi64( char *str )
350 {
351     ULONGLONG RunningTotal = 0;
352     char bMinus = 0;
353
354     while (*str == ' ' || (*str >= '\011' && *str <= '\015')) {
355         str++;
356     } /* while */
357
358     if (*str == '+') {
359         str++;
360     } else if (*str == '-') {
361         bMinus = 1;
362         str++;
363     } /* if */
364
365     while (*str >= '0' && *str <= '9') {
366         RunningTotal = RunningTotal * 10 + *str - '0';
367         str++;
368     } /* while */
369
370     return bMinus ? -RunningTotal : RunningTotal;
371 }
372
373
374 /*********************************************************************
375  *              _splitpath (NTDLL.@)
376  *
377  * Split a path into its component pieces.
378  *
379  * PARAMS
380  *  inpath [I] Path to split
381  *  drv    [O] Destination for drive component (e.g. "A:"). Must be at least 3 characters.
382  *  dir    [O] Destination for directory component. Should be at least MAX_PATH characters.
383  *  fname  [O] Destination for File name component. Should be at least MAX_PATH characters.
384  *  ext    [O] Destination for file extension component. Should be at least MAX_PATH characters.
385  *
386  * RETURNS
387  *  Nothing.
388  */
389 void __cdecl _splitpath(const char* inpath, char * drv, char * dir,
390                         char* fname, char * ext )
391 {
392     const char *p, *end;
393
394     if (inpath[0] && inpath[1] == ':')
395     {
396         if (drv)
397         {
398             drv[0] = inpath[0];
399             drv[1] = inpath[1];
400             drv[2] = 0;
401         }
402         inpath += 2;
403     }
404     else if (drv) drv[0] = 0;
405
406     /* look for end of directory part */
407     end = NULL;
408     for (p = inpath; *p; p++) if (*p == '/' || *p == '\\') end = p + 1;
409
410     if (end)  /* got a directory */
411     {
412         if (dir)
413         {
414             memcpy( dir, inpath, end - inpath );
415             dir[end - inpath] = 0;
416         }
417         inpath = end;
418     }
419     else if (dir) dir[0] = 0;
420
421     /* look for extension: what's after the last dot */
422     end = NULL;
423     for (p = inpath; *p; p++) if (*p == '.') end = p;
424
425     if (!end) end = p; /* there's no extension */
426
427     if (fname)
428     {
429         memcpy( fname, inpath, end - inpath );
430         fname[end - inpath] = 0;
431     }
432     if (ext) strcpy( ext, end );
433 }