*
* Copyright 1993 Yngvi Sigurjonsson
* Copyright 1996 Alexandre Julliard
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <ctype.h>
#include <string.h>
-#include "windows.h"
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/winbase16.h"
+#include "wine/exception.h"
+#include "wine/unicode.h"
#include "winerror.h"
-#include "ldt.h"
-#include "debug.h"
-#include "debugstr.h"
-
-static const BYTE STRING_Oem2Ansi[256] =
-"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
-"\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
-"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
-"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
-"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
-"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
-"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
-"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
-"\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
-"\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
-"\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
-"\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
-"\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
-"\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
-"\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
-"\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
-
-static const BYTE STRING_Ansi2Oem[256] =
-"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
-"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
-"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
-"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
-"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
-"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
-"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
-"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
-"\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
-"\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
-"\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
-"\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
-"\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
-"\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
-"\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
-"\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
-
-#define OEM_TO_ANSI(ch) (STRING_Oem2Ansi[(unsigned char)(ch)])
-#define ANSI_TO_OEM(ch) (STRING_Ansi2Oem[(unsigned char)(ch)])
+#include "winnls.h"
+#include "msvcrt/excpt.h"
+#include "wine/debug.h"
+WINE_DEFAULT_DEBUG_CHANNEL(string);
-/***********************************************************************
- * hmemcpy (KERNEL.348)
- */
-void WINAPI hmemcpy( LPVOID dst, LPCVOID src, LONG count )
+/* filter for page-fault exceptions */
+static WINE_EXCEPTION_FILTER(page_fault)
{
- memcpy( dst, src, count );
+ if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
+ return EXCEPTION_EXECUTE_HANDLER;
+ return EXCEPTION_CONTINUE_SEARCH;
}
/***********************************************************************
- * lstrcat16 (KERNEL.89)
+ * hmemcpy (KERNEL.348)
*/
-SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
+void WINAPI hmemcpy16( LPVOID dst, LPCVOID src, LONG count )
{
- lstrcat32A( (LPSTR)PTR_SEG_TO_LIN(dst), src );
- return dst;
+ memcpy( dst, src, count );
}
/***********************************************************************
- * lstrcat32A (KERNEL32.599)
+ * lstrcat (KERNEL.89)
*/
-LPSTR WINAPI lstrcat32A( LPSTR dst, LPCSTR src )
+SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
{
- dprintf_info(string,"strcat: Append %s to %s\n",
- debugstr_a (src), debugstr_a (dst));
/* Windows does not check for NULL pointers here, so we don't either */
- strcat( dst, src );
+ strcat( MapSL(dst), src );
return dst;
}
/***********************************************************************
- * lstrcat32W (KERNEL32.600)
+ * lstrcat (KERNEL32.@)
+ * lstrcatA (KERNEL32.@)
*/
-LPWSTR WINAPI lstrcat32W( LPWSTR dst, LPCWSTR src )
+LPSTR WINAPI lstrcatA( LPSTR dst, LPCSTR src )
{
- register LPWSTR p = dst;
- dprintf_info(string,"strcat: Append L%s to L%s\n",
- debugstr_w (src), debugstr_w (dst));
- /* Windows does not check for NULL pointers here, so we don't either */
- while (*p) p++;
- while ((*p++ = *src++));
+ __TRY
+ {
+ strcat( dst, src );
+ }
+ __EXCEPT(page_fault)
+ {
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return NULL;
+ }
+ __ENDTRY
return dst;
}
/***********************************************************************
- * lstrcatn16 (KERNEL.352)
+ * lstrcatW (KERNEL32.@)
*/
-SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
+LPWSTR WINAPI lstrcatW( LPWSTR dst, LPCWSTR src )
{
- lstrcatn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
+ __TRY
+ {
+ strcatW( dst, src );
+ }
+ __EXCEPT(page_fault)
+ {
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return NULL;
+ }
+ __ENDTRY
return dst;
}
/***********************************************************************
- * lstrcatn32A (Not a Windows API)
+ * lstrcatn (KERNEL.352)
*/
-LPSTR WINAPI lstrcatn32A( LPSTR dst, LPCSTR src, INT32 n )
+SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
{
- register LPSTR p = dst;
- dprintf_info(string,"strcatn add %d chars from %s to %s\n",
- n, debugstr_an (src, n), debugstr_a (dst));
- while (*p) p++;
- if ((n -= (INT32)(p - dst)) <= 0) return dst;
- lstrcpyn32A( p, src, n );
- return dst;
-}
+ LPSTR p = MapSL(dst);
+ LPSTR start = p;
-
-/***********************************************************************
- * lstrcatn32W (Not a Windows API)
- */
-LPWSTR WINAPI lstrcatn32W( LPWSTR dst, LPCWSTR src, INT32 n )
-{
- register LPWSTR p = dst;
- dprintf_info(string,"strcatn add %d chars from L%s to L%s\n",
- n, debugstr_wn (src, n), debugstr_w (dst));
while (*p) p++;
- if ((n -= (INT32)(p - dst)) <= 0) return dst;
- lstrcpyn32W( p, src, n );
+ if ((n -= (p - start)) <= 0) return dst;
+ lstrcpynA( p, src, n );
return dst;
}
/***********************************************************************
- * lstrcmp16 (USER.430)
+ * lstrcpy (KERNEL.88)
*/
-INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
-{
- return (INT16)lstrcmp32A( str1, str2 );
-}
-
-
-/***********************************************************************
- * lstrcmp32A (KERNEL.602)
- */
-INT32 WINAPI lstrcmp32A( LPCSTR str1, LPCSTR str2 )
-{
- dprintf_info(string,"strcmp: %s and %s\n",
- debugstr_a (str1), debugstr_a (str2));
- /* Win95 KERNEL32.DLL does it that way. Hands off! */
- if (!str1 || !str2) {
- SetLastError(ERROR_INVALID_PARAMETER);
- return 0;
- }
- return (INT32)strcmp( str1, str2 );
-}
-
-
-/***********************************************************************
- * lstrcmp32W (KERNEL.603)
- */
-INT32 WINAPI lstrcmp32W( LPCWSTR str1, LPCWSTR str2 )
-{
- dprintf_info(string,"strcmp: L%s and L%s\n",
- debugstr_w (str1), debugstr_w (str2));
- if (!str1 || !str2) {
- SetLastError(ERROR_INVALID_PARAMETER);
- return 0;
- }
- while (*str1 && (*str1 == *str2)) { str1++; str2++; }
- return (INT32)(*str1 - *str2);
-}
-
-
-/***********************************************************************
- * lstrcmpi16 (USER.471)
- */
-INT16 WINAPI lstrcmpi16( LPCSTR str1, LPCSTR str2 )
+SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
{
- return (INT16)lstrcmpi32A( str1, str2 );
+ if (!lstrcpyA( MapSL(dst), src )) dst = 0;
+ return dst;
}
/***********************************************************************
- * lstrcmpi32A (KERNEL32.605)
+ * lstrcpy (KERNEL32.@)
+ * lstrcpyA (KERNEL32.@)
*/
-INT32 WINAPI lstrcmpi32A( LPCSTR str1, LPCSTR str2 )
+LPSTR WINAPI lstrcpyA( LPSTR dst, LPCSTR src )
{
- INT32 res;
-
- dprintf_info(string,"strcmpi %s and %s\n",
- debugstr_a (str1), debugstr_a (str2));
- if (!str1 || !str2) {
- SetLastError(ERROR_INVALID_PARAMETER);
- return 0;
+ __TRY
+ {
+ /* this is how Windows does it */
+ memmove( dst, src, strlen(src)+1 );
}
- while (*str1)
+ __EXCEPT(page_fault)
{
- if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
- str1++;
- str2++;
+ ERR("(%p, %p): page fault occurred ! Caused by bug ?\n", dst, src);
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return NULL;
}
- return toupper(*str1) - toupper(*str2);
+ __ENDTRY
+ return dst;
}
/***********************************************************************
- * lstrcmpi32W (KERNEL32.606)
+ * lstrcpyW (KERNEL32.@)
*/
-INT32 WINAPI lstrcmpi32W( LPCWSTR str1, LPCWSTR str2 )
+LPWSTR WINAPI lstrcpyW( LPWSTR dst, LPCWSTR src )
{
- INT32 res;
-
-#if 0
- /* Too much! (From registry loading.) */
- dprintf_info(string,"strcmpi L%s and L%s\n",
- debugstr_w (str1), debugstr_w (str2));
-#endif
- if (!str1 || !str2) {
- SetLastError(ERROR_INVALID_PARAMETER);
- return 0;
+ __TRY
+ {
+ strcpyW( dst, src );
}
- while (*str1)
+ __EXCEPT(page_fault)
{
- /* FIXME: Unicode */
- if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
- str1++;
- str2++;
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return NULL;
}
- return toupper(*str1) - toupper(*str2);
-}
-
-
-/***********************************************************************
- * lstrcpy16 (KERNEL.88)
- */
-SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
-{
- lstrcpy32A( (LPSTR)PTR_SEG_TO_LIN(dst), src );
- return dst;
-}
-
-
-/***********************************************************************
- * lstrcpy32A (KERNEL32.608)
- */
-LPSTR WINAPI lstrcpy32A( LPSTR dst, LPCSTR src )
-{
- dprintf_info(string,"strcpy %s\n", debugstr_a (src));
- /* Windows does not check for NULL pointers here, so we don't either */
- strcpy( dst, src );
- return dst;
-}
-
-
-/***********************************************************************
- * lstrcpy32W (KERNEL32.609)
- */
-LPWSTR WINAPI lstrcpy32W( LPWSTR dst, LPCWSTR src )
-{
- register LPWSTR p = dst;
- dprintf_info(string,"strcpy L%s\n", debugstr_w (src));
- /* Windows does not check for NULL pointers here, so we don't either */
- while ((*p++ = *src++));
+ __ENDTRY
return dst;
}
/***********************************************************************
- * lstrcpyn16 (KERNEL.353)
+ * lstrcpyn (KERNEL.353)
*/
SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
{
- lstrcpyn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
+ lstrcpynA( MapSL(dst), src, n );
return dst;
}
/***********************************************************************
- * lstrcpyn32A (KERNEL32.611)
+ * lstrcpyn (KERNEL32.@)
+ * lstrcpynA (KERNEL32.@)
+ *
+ * Note: this function differs from the UNIX strncpy, it _always_ writes
+ * a terminating \0.
+ *
+ * Note: n is an INT but Windows treats it as unsigned, and will happily
+ * copy a gazillion chars if n is negative.
*/
-LPSTR WINAPI lstrcpyn32A( LPSTR dst, LPCSTR src, INT32 n )
+LPSTR WINAPI lstrcpynA( LPSTR dst, LPCSTR src, INT n )
{
LPSTR p = dst;
- dprintf_info(string,"strcpyn %s for %d chars\n",
- debugstr_an (src,n), n);
- /* Windows does not check for NULL pointers here, so we don't either */
- while ((n-- > 1) && *src) *p++ = *src++;
- if (n >= 0) *p = 0;
- return dst;
-}
-
-
-/***********************************************************************
- * lstrcpyn32W (KERNEL32.612)
- */
-LPWSTR WINAPI lstrcpyn32W( LPWSTR dst, LPCWSTR src, INT32 n )
-{
- LPWSTR p = dst;
- dprintf_info(string,"strcpyn L%s for %d chars\n",
- debugstr_wn (src,n), n);
- /* Windows does not check for NULL pointers here, so we don't either */
- while ((n-- > 1) && *src) *p++ = *src++;
- if (n >= 0) *p = 0;
- return dst;
-}
-
-
-/***********************************************************************
- * lstrlen16 (KERNEL.90)
- */
-INT16 WINAPI lstrlen16( LPCSTR str )
-{
- return (INT16)lstrlen32A( str );
-}
+ UINT count = n;
+ TRACE("(%p, %s, %i)\n", dst, debugstr_a(src), n);
-/***********************************************************************
- * lstrlen32A (KERNEL32.614)
- */
-INT32 WINAPI lstrlen32A( LPCSTR str )
-{
- /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
- * in lstrlen() ... we check only for NULL pointer reference.
- * - Marcus Meissner
+ /* In real windows the whole function is protected by an exception handler
+ * that returns ERROR_INVALID_PARAMETER on faulty parameters
+ * We currently just check for NULL.
*/
- dprintf_info(string,"strlen %s\n", debugstr_a (str));
- if (!str) return 0;
- return (INT32)strlen(str);
-}
-
-
-/***********************************************************************
- * lstrlen32W (KERNEL32.615)
- */
-INT32 WINAPI lstrlen32W( LPCWSTR str )
-{
- INT32 len = 0;
- dprintf_info(string,"strlen L%s\n", debugstr_w (str));
- if (!str) return 0;
- while (*str++) len++;
- return len;
-}
-
-
-/***********************************************************************
- * lstrncmp32A (Not a Windows API)
- */
-INT32 WINAPI lstrncmp32A( LPCSTR str1, LPCSTR str2, INT32 n )
-{
- dprintf_info(string,"strncmp %s and %s for %d chars\n",
- debugstr_an (str1, n), debugstr_an (str2, n), n);
- return (INT32)strncmp( str1, str2, n );
-}
-
-
-/***********************************************************************
- * lstrncmp32W (Not a Windows API)
- */
-INT32 WINAPI lstrncmp32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
-{
- dprintf_info(string,"strncmp L%s and L%s for %d chars\n",
- debugstr_wn (str1, n), debugstr_wn (str2, n), n);
- if (!n) return 0;
- while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
- return (INT32)(*str1 - *str2);
-}
-
-
-/***********************************************************************
- * lstrncmpi32A (Not a Windows API)
- */
-INT32 WINAPI lstrncmpi32A( LPCSTR str1, LPCSTR str2, INT32 n )
-{
- INT32 res;
-
- dprintf_info(string,"strncmpi %s and %s for %d chars\n",
- debugstr_an (str1, n), debugstr_an (str2, n), n);
- if (!n) return 0;
- while ((--n > 0) && *str1)
- if ( (res = toupper(*str1++) - toupper(*str2++)) ) return res;
-
- return toupper(*str1) - toupper(*str2);
-}
-
-
-/***********************************************************************
- * lstrncmpi32W (Not a Windows API)
- */
-INT32 WINAPI lstrncmpi32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
-{
- INT32 res;
-
- dprintf_info(string,"strncmpi L%s and L%s for %d chars\n",
- debugstr_wn (str1, n), debugstr_wn (str2, n), n);
- if (!n) return 0;
- while ((--n > 0) && *str1)
+ if (!dst || !src) {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+ while ((count > 1) && *src)
{
- /* FIXME: Unicode */
- if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
- str1++;
- str2++;
+ count--;
+ *p++ = *src++;
}
- return toupper(*str1) - toupper(*str2);
-}
-
-
-/***********************************************************************
- * lstrcpyAtoW (Not a Windows API)
- */
-LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
-{
- register LPWSTR p = dst;
- while ((*p++ = (WCHAR)(unsigned char)*src++));
- return dst;
-}
-
-
-/***********************************************************************
- * lstrcpyWtoA (Not a Windows API)
- */
-LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
-{
- register LPSTR p = dst;
- while ((*p++ = (CHAR)*src++));
+ if (count) *p = 0;
return dst;
}
/***********************************************************************
- * lstrcpynAtoW (Not a Windows API)
+ * lstrcpynW (KERNEL32.@)
+ *
+ * Note: this function differs from the UNIX strncpy, it _always_ writes
+ * a terminating \0
+ *
+ * Note: n is an INT but Windows treats it as unsigned, and will happily
+ * copy a gazillion chars if n is negative.
*/
-LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
+LPWSTR WINAPI lstrcpynW( LPWSTR dst, LPCWSTR src, INT n )
{
LPWSTR p = dst;
- while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
- if (n >= 0) *p = 0;
- return dst;
-}
+ UINT count = n;
+ TRACE("(%p, %s, %i)\n", dst, debugstr_w(src), n);
-/***********************************************************************
- * lstrcpynWtoA (Not a Windows API)
- */
-LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT32 n )
-{
- LPSTR p = dst;
- while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
- if (n >= 0) *p = 0;
+ /* In real windows the whole function is protected by an exception handler
+ * that returns ERROR_INVALID_PARAMETER on faulty parameters
+ * We currently just check for NULL.
+ */
+ if (!dst || !src) {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+ while ((count > 1) && *src)
+ {
+ count--;
+ *p++ = *src++;
+ }
+ if (count) *p = 0;
return dst;
}
/***********************************************************************
- * Copy (GDI.250)
- */
-void WINAPI Copy( LPVOID src, LPVOID dst, WORD size )
-{
- memcpy( dst, src, size );
-}
-
-
-/***********************************************************************
- * RtlFillMemory (KERNEL32.441)
- */
-VOID WINAPI RtlFillMemory( LPVOID ptr, UINT32 len, UINT32 fill )
-{
- memset( ptr, fill, len );
-}
-
-
-/***********************************************************************
- * RtlMoveMemory (KERNEL32.442)
- */
-VOID WINAPI RtlMoveMemory( LPVOID dst, LPCVOID src, UINT32 len )
-{
- memmove( dst, src, len );
-}
-
-
-/***********************************************************************
- * RtlZeroMemory (KERNEL32.444)
- */
-VOID WINAPI RtlZeroMemory( LPVOID ptr, UINT32 len )
-{
- memset( ptr, 0, len );
-}
-
-
-/***********************************************************************
- * AnsiToOem16 (KEYBOARD.5)
- */
-INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
-{
- CharToOem32A( s, d );
- return -1;
-}
-
-
-/***********************************************************************
- * OemToAnsi16 (KEYBOARD.6)
- */
-INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
-{
- OemToChar32A( s, d );
- return -1;
-}
-
-
-/***********************************************************************
- * AnsiToOemBuff16 (KEYBOARD.134)
- */
-void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
-{
- CharToOemBuff32A( s, d, len ? len : 65536 );
-}
-
-
-/***********************************************************************
- * OemToAnsiBuff16 (KEYBOARD.135)
- */
-void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
-{
- OemToCharBuff32A( s, d, len ? len : 65536 );
-}
-
-
-/***********************************************************************
- * CharToOem32A (USER32.36)
+ * lstrlen (KERNEL.90)
*/
-BOOL32 WINAPI CharToOem32A( LPCSTR s, LPSTR d )
-{
- LPSTR oldd = d;
- if (!s || !d) return TRUE;
- dprintf_info(string,"CharToOem %s\n", debugstr_a (s));
- while ((*d++ = ANSI_TO_OEM(*s++)));
- dprintf_info(string," to %s\n", debugstr_a (oldd));
- return TRUE;
-}
-
-
-/***********************************************************************
- * CharToOemBuff32A (USER32.37)
- */
-BOOL32 WINAPI CharToOemBuff32A( LPCSTR s, LPSTR d, DWORD len )
-{
- while (len--) *d++ = ANSI_TO_OEM(*s++);
- return TRUE;
-}
-
-
-/***********************************************************************
- * CharToOemBuff32W (USER32.38)
- */
-BOOL32 WINAPI CharToOemBuff32W( LPCWSTR s, LPSTR d, DWORD len )
-{
- while (len--) *d++ = ANSI_TO_OEM(*s++);
- return TRUE;
-}
-
-
-/***********************************************************************
- * CharToOem32W (USER32.39)
- */
-BOOL32 WINAPI CharToOem32W( LPCWSTR s, LPSTR d )
+INT16 WINAPI lstrlen16( LPCSTR str )
{
- LPSTR oldd = d;
- if (!s || !d) return TRUE;
- dprintf_info(string,"CharToOem L%s\n", debugstr_w (s));
- while ((*d++ = ANSI_TO_OEM(*s++)));
- dprintf_info(string," to %s\n", debugstr_a (oldd));
- return TRUE;
+ return (INT16)lstrlenA( str );
}
/***********************************************************************
- * OemToChar32A (USER32.401)
+ * lstrlen (KERNEL32.@)
+ * lstrlenA (KERNEL32.@)
*/
-BOOL32 WINAPI OemToChar32A( LPCSTR s, LPSTR d )
+INT WINAPI lstrlenA( LPCSTR str )
{
- LPSTR oldd = d;
- dprintf_info(string,"OemToChar %s\n", debugstr_a (s));
- while ((*d++ = OEM_TO_ANSI(*s++)));
- dprintf_info(string," to %s\n", debugstr_a (oldd));
- return TRUE;
+ INT ret;
+ __TRY
+ {
+ ret = strlen(str);
+ }
+ __EXCEPT(page_fault)
+ {
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return 0;
+ }
+ __ENDTRY
+ return ret;
}
/***********************************************************************
- * OemToCharBuff32A (USER32.402)
+ * lstrlenW (KERNEL32.@)
*/
-BOOL32 WINAPI OemToCharBuff32A( LPCSTR s, LPSTR d, DWORD len )
+INT WINAPI lstrlenW( LPCWSTR str )
{
- dprintf_info(string,"OemToCharBuff %s\n", debugstr_an (s, len));
- while (len--) *d++ = OEM_TO_ANSI(*s++);
- return TRUE;
+ INT ret;
+ __TRY
+ {
+ ret = strlenW(str);
+ }
+ __EXCEPT(page_fault)
+ {
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return 0;
+ }
+ __ENDTRY
+ return ret;
}
/***********************************************************************
- * OemToCharBuff32W (USER32.403)
+ * UnicodeToAnsi (KERNEL.434)
*/
-BOOL32 WINAPI OemToCharBuff32W( LPCSTR s, LPWSTR d, DWORD len )
+INT16 WINAPI UnicodeToAnsi16( LPCWSTR src, LPSTR dst, INT16 codepage )
{
- dprintf_info(string,"OemToCharBuff %s\n", debugstr_an (s, len));
- while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
- return TRUE;
-}
+ if ( codepage == -1 )
+ codepage = CP_ACP;
-
-/***********************************************************************
- * OemToChar32W (USER32.404)
- */
-BOOL32 WINAPI OemToChar32W( LPCSTR s, LPWSTR d )
-{
- while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
- return TRUE;
+ return WideCharToMultiByte( codepage, 0, src, -1, dst, 0x7fffffff, NULL, NULL );
}