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