comcat: Get rid of the redundant IUnknown vtable for the manager implementation.
[wine] / dlls / kernel32 / string.c
1 /*
2  * Kernel string functions
3  *
4  * Copyright 1993 Yngvi Sigurjonsson
5  * Copyright 1996 Alexandre Julliard
6  * Copyright 2001 Dmitry Timoshkov for CodeWeavers
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <ctype.h>
27 #include <stdarg.h>
28 #include <string.h>
29
30 #define WINE_NO_INLINE_STRING
31 #include "windef.h"
32 #include "winbase.h"
33 #include "wine/winbase16.h"
34 #include "wine/unicode.h"
35 #include "wine/exception.h"
36
37
38 static INT (WINAPI *pLoadStringA)(HINSTANCE, UINT, LPSTR, INT);
39 static INT (WINAPI *pwvsprintfA)(LPSTR, LPCSTR, va_list);
40
41
42 /***********************************************************************
43  * Helper for k32 family functions
44  */
45 static void *user32_proc_address(const char *proc_name)
46 {
47     static HMODULE hUser32;
48
49     if(!hUser32) hUser32 = LoadLibraryA("user32.dll");
50     return GetProcAddress(hUser32, proc_name);
51 }
52
53
54 /***********************************************************************
55  *              k32CharToOemBuffA   (KERNEL32.11)
56  */
57 BOOL WINAPI k32CharToOemBuffA(LPCSTR s, LPSTR d, DWORD len)
58 {
59     WCHAR *bufW;
60
61     if ((bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
62     {
63         MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
64         WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
65         HeapFree( GetProcessHeap(), 0, bufW );
66     }
67     return TRUE;
68 }
69
70
71 /***********************************************************************
72  *              k32CharToOemA   (KERNEL32.10)
73  */
74 BOOL WINAPI k32CharToOemA(LPCSTR s, LPSTR d)
75 {
76     if (!s || !d) return TRUE;
77     return k32CharToOemBuffA( s, d, strlen(s) + 1 );
78 }
79
80
81 /***********************************************************************
82  *              k32OemToCharBuffA   (KERNEL32.13)
83  */
84 BOOL WINAPI k32OemToCharBuffA(LPCSTR s, LPSTR d, DWORD len)
85 {
86     WCHAR *bufW;
87
88     if ((bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
89     {
90         MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
91         WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
92         HeapFree( GetProcessHeap(), 0, bufW );
93     }
94     return TRUE;
95 }
96
97
98 /***********************************************************************
99  *              k32OemToCharA   (KERNEL32.12)
100  */
101 BOOL WINAPI k32OemToCharA(LPCSTR s, LPSTR d)
102 {
103     return k32OemToCharBuffA( s, d, strlen(s) + 1 );
104 }
105
106
107 /**********************************************************************
108  *              k32LoadStringA   (KERNEL32.14)
109  */
110 INT WINAPI k32LoadStringA(HINSTANCE instance, UINT resource_id,
111                           LPSTR buffer, INT buflen)
112 {
113     if(!pLoadStringA) pLoadStringA = user32_proc_address("LoadStringA");
114     return pLoadStringA(instance, resource_id, buffer, buflen);
115 }
116
117
118 /***********************************************************************
119  *              k32wvsprintfA   (KERNEL32.16)
120  */
121 INT WINAPI k32wvsprintfA(LPSTR buffer, LPCSTR spec, va_list args)
122 {
123     if(!pwvsprintfA) pwvsprintfA = user32_proc_address("wvsprintfA");
124     return (*pwvsprintfA)(buffer, spec, args);
125 }
126
127
128 /***********************************************************************
129  *              k32wsprintfA   (KERNEL32.15)
130  */
131 INT WINAPIV k32wsprintfA(LPSTR buffer, LPCSTR spec, ...)
132 {
133     va_list args;
134     INT res;
135
136     va_start(args, spec);
137     res = k32wvsprintfA(buffer, spec, args);
138     va_end(args);
139     return res;
140 }
141
142
143 /***********************************************************************
144  *           hmemcpy   (KERNEL.348)
145  */
146 void WINAPI hmemcpy16( LPVOID dst, LPCVOID src, LONG count )
147 {
148     memcpy( dst, src, count );
149 }
150
151
152 /***********************************************************************
153  *           lstrcat   (KERNEL.89)
154  */
155 SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
156 {
157     /* Windows does not check for NULL pointers here, so we don't either */
158     strcat( MapSL(dst), src );
159     return dst;
160 }
161
162
163 /***********************************************************************
164  *           lstrcatA   (KERNEL32.@)
165  *           lstrcat    (KERNEL32.@)
166  */
167 LPSTR WINAPI lstrcatA( LPSTR dst, LPCSTR src )
168 {
169     __TRY
170     {
171         strcat( dst, src );
172     }
173     __EXCEPT_PAGE_FAULT
174     {
175         SetLastError( ERROR_INVALID_PARAMETER );
176         return NULL;
177     }
178     __ENDTRY
179     return dst;
180 }
181
182
183 /***********************************************************************
184  *           lstrcatW   (KERNEL32.@)
185  */
186 LPWSTR WINAPI lstrcatW( LPWSTR dst, LPCWSTR src )
187 {
188     __TRY
189     {
190         strcatW( dst, src );
191     }
192     __EXCEPT_PAGE_FAULT
193     {
194         SetLastError( ERROR_INVALID_PARAMETER );
195         return NULL;
196     }
197     __ENDTRY
198     return dst;
199 }
200
201
202 /***********************************************************************
203  *           lstrcatn   (KERNEL.352)
204  */
205 SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
206 {
207     LPSTR p = MapSL(dst);
208     LPSTR start = p;
209
210     while (*p) p++;
211     if ((n -= (p - start)) <= 0) return dst;
212     lstrcpynA( p, src, n );
213     return dst;
214 }
215
216
217 /***********************************************************************
218  *           lstrcpy   (KERNEL.88)
219  */
220 SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
221 {
222     if (!lstrcpyA( MapSL(dst), src )) dst = 0;
223     return dst;
224 }
225
226
227 /***********************************************************************
228  *           lstrcpyA   (KERNEL32.@)
229  *           lstrcpy    (KERNEL32.@)
230  */
231 LPSTR WINAPI lstrcpyA( LPSTR dst, LPCSTR src )
232 {
233     __TRY
234     {
235         /* this is how Windows does it */
236         memmove( dst, src, strlen(src)+1 );
237     }
238     __EXCEPT_PAGE_FAULT
239     {
240         SetLastError( ERROR_INVALID_PARAMETER );
241         return NULL;
242     }
243     __ENDTRY
244     return dst;
245 }
246
247
248 /***********************************************************************
249  *           lstrcpyW   (KERNEL32.@)
250  */
251 LPWSTR WINAPI lstrcpyW( LPWSTR dst, LPCWSTR src )
252 {
253     __TRY
254     {
255         strcpyW( dst, src );
256     }
257     __EXCEPT_PAGE_FAULT
258     {
259         SetLastError( ERROR_INVALID_PARAMETER );
260         return NULL;
261     }
262     __ENDTRY
263     return dst;
264 }
265
266
267 /***********************************************************************
268  *           lstrcpyn   (KERNEL.353)
269  */
270 SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
271 {
272     lstrcpynA( MapSL(dst), src, n );
273     return dst;
274 }
275
276
277 /***********************************************************************
278  *           lstrcpynA   (KERNEL32.@)
279  *           lstrcpyn    (KERNEL32.@)
280  *
281  * Note: this function differs from the UNIX strncpy, it _always_ writes
282  * a terminating \0.
283  *
284  * Note: n is an INT but Windows treats it as unsigned, and will happily
285  * copy a gazillion chars if n is negative.
286  */
287 LPSTR WINAPI lstrcpynA( LPSTR dst, LPCSTR src, INT n )
288 {
289     __TRY
290     {
291         LPSTR d = dst;
292         LPCSTR s = src;
293         UINT count = n;
294
295         while ((count > 1) && *s)
296         {
297             count--;
298             *d++ = *s++;
299         }
300         if (count) *d = 0;
301     }
302     __EXCEPT_PAGE_FAULT
303     {
304         SetLastError( ERROR_INVALID_PARAMETER );
305         return 0;
306     }
307     __ENDTRY
308     return dst;
309 }
310
311
312 /***********************************************************************
313  *           lstrcpynW   (KERNEL32.@)
314  *
315  * Note: this function differs from the UNIX strncpy, it _always_ writes
316  * a terminating \0
317  *
318  * Note: n is an INT but Windows treats it as unsigned, and will happily
319  * copy a gazillion chars if n is negative.
320  */
321 LPWSTR WINAPI lstrcpynW( LPWSTR dst, LPCWSTR src, INT n )
322 {
323     __TRY
324     {
325         LPWSTR d = dst;
326         LPCWSTR s = src;
327         UINT count = n;
328
329         while ((count > 1) && *s)
330         {
331             count--;
332             *d++ = *s++;
333         }
334         if (count) *d = 0;
335     }
336     __EXCEPT_PAGE_FAULT
337     {
338         SetLastError( ERROR_INVALID_PARAMETER );
339         return 0;
340     }
341     __ENDTRY
342     return dst;
343 }
344
345
346 /***********************************************************************
347  *           lstrlen   (KERNEL.90)
348  */
349 INT16 WINAPI lstrlen16( LPCSTR str )
350 {
351     return (INT16)lstrlenA( str );
352 }
353
354
355 /***********************************************************************
356  *           lstrlenA   (KERNEL32.@)
357  *           lstrlen    (KERNEL32.@)
358  */
359 INT WINAPI lstrlenA( LPCSTR str )
360 {
361     INT ret;
362     __TRY
363     {
364         ret = strlen(str);
365     }
366     __EXCEPT_PAGE_FAULT
367     {
368         SetLastError( ERROR_INVALID_PARAMETER );
369         return 0;
370     }
371     __ENDTRY
372     return ret;
373 }
374
375
376 /***********************************************************************
377  *           lstrlenW   (KERNEL32.@)
378  */
379 INT WINAPI lstrlenW( LPCWSTR str )
380 {
381     INT ret;
382     __TRY
383     {
384         ret = strlenW(str);
385     }
386     __EXCEPT_PAGE_FAULT
387     {
388         SetLastError( ERROR_INVALID_PARAMETER );
389         return 0;
390     }
391     __ENDTRY
392     return ret;
393 }
394
395
396 /***********************************************************************
397  *           UnicodeToAnsi   (KERNEL.434)
398  */
399 INT16 WINAPI UnicodeToAnsi16( LPCWSTR src, LPSTR dst, INT16 codepage )
400 {
401     if ( codepage == -1 ) codepage = CP_ACP;
402     return WideCharToMultiByte( codepage, 0, src, -1, dst, 0x7fffffff, NULL, NULL );
403 }
404
405
406 /***************************************************************************
407  *
408  * Win 2.x string functions now moved to USER
409  *
410  * We rather want to implement them here instead of doing Callouts
411  */
412
413 /***********************************************************************
414  *              Reserved1 (KERNEL.77)
415  */
416 SEGPTR WINAPI KERNEL_AnsiNext16(SEGPTR current)
417 {
418     return (*(char *)MapSL(current)) ? current + 1 : current;
419 }
420
421 /***********************************************************************
422  *              Reserved2(KERNEL.78)
423  */
424 SEGPTR WINAPI KERNEL_AnsiPrev16( SEGPTR start, SEGPTR current )
425 {
426     return (current==start)?start:current-1;
427 }
428
429 /***********************************************************************
430  *              Reserved3 (KERNEL.79)
431  */
432 SEGPTR WINAPI KERNEL_AnsiUpper16( SEGPTR strOrChar )
433 {
434     /* uppercase only one char if strOrChar < 0x10000 */
435     if (HIWORD(strOrChar))
436     {
437         char *s = MapSL(strOrChar);
438         while (*s)
439         {
440             *s = toupper(*s);
441             s++;
442         }
443         return strOrChar;
444     }
445     else return toupper((char)strOrChar);
446 }
447
448 /***********************************************************************
449  *              Reserved4 (KERNEL.80)
450  */
451 SEGPTR WINAPI KERNEL_AnsiLower16( SEGPTR strOrChar )
452 {
453     /* lowercase only one char if strOrChar < 0x10000 */
454     if (HIWORD(strOrChar))
455     {
456         char *s = MapSL(strOrChar);
457         while (*s)
458         {
459             *s = tolower(*s);
460             s++;
461         }
462         return strOrChar;
463     }
464     else return tolower((char)strOrChar);
465 }
466
467
468 /***********************************************************************
469  *              Reserved5 (KERNEL.87)
470  */
471 INT16 WINAPI KERNEL_lstrcmp16( LPCSTR str1, LPCSTR str2 )
472 {
473     return (INT16)strcmp( str1, str2 );
474 }