Moved most USER string functions to dlls/user.

Cleaned up a few more inter-dll dependencies.
This commit is contained in:
Alexandre Julliard 2000-08-06 02:42:46 +00:00
parent cb10fdab99
commit 3850c1ae16
25 changed files with 1158 additions and 1312 deletions

View File

@ -87,6 +87,8 @@ static int CONSOLE_Init(void)
if the resolution is set on the command-line... */ if the resolution is set on the command-line... */
CONSOLE_NotifyResizeScreen(driver.x_res, driver.y_res); CONSOLE_NotifyResizeScreen(driver.x_res, driver.y_res);
atexit(CONSOLE_Close);
/* For now, always return TRUE */ /* For now, always return TRUE */
return TRUE; return TRUE;
} }
@ -104,7 +106,7 @@ void CONSOLE_Write(char out, int fg_color, int bg_color, int attribute)
} }
} }
void CONSOLE_Close() void CONSOLE_Close(void)
{ {
if (driver.close) if (driver.close)
driver.close(); driver.close();

View File

@ -30,13 +30,6 @@ DEFAULT_DEBUG_CHANNEL(commctrl);
extern HANDLE COMCTL32_hHeap; /* handle to the private heap */ extern HANDLE COMCTL32_hHeap; /* handle to the private heap */
/*
* We put some function prototypes here that don't seem to belong in
* any header file. When they find their place, we can remove them.
*/
extern LPSTR WINAPI lstrrchr(LPCSTR, LPCSTR, WORD);
extern LPWSTR WINAPI lstrrchrw(LPCWSTR, LPCWSTR, WORD);
typedef struct _STREAMDATA typedef struct _STREAMDATA
{ {
@ -2168,18 +2161,43 @@ INT WINAPI COMCTL32_StrCmpNIW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) {
* StrRChrA [COMCTL32.351] * StrRChrA [COMCTL32.351]
* *
*/ */
LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch) { LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
return lstrrchr(lpStart, lpEnd, wMatch); {
LPCSTR lpGotIt = NULL;
BOOL dbcs = IsDBCSLeadByte( LOBYTE(wMatch) );
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
for(; lpStart < lpEnd; lpStart = CharNextA(lpStart))
{
if (*lpStart != LOBYTE(wMatch)) continue;
if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
lpGotIt = lpStart;
} }
return (LPSTR)lpGotIt;
}
/************************************************************************** /**************************************************************************
* StrRChrW [COMCTL32.359] * StrRChrW [COMCTL32.359]
* *
*/ */
LPWSTR WINAPI COMCTL32_StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch) { LPWSTR WINAPI COMCTL32_StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch)
return lstrrchrw(lpStart, lpEnd, wMatch); {
LPCWSTR lpGotIt = NULL;
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
if (!lpEnd) lpEnd = lpStart + strlenW(lpStart);
for(; lpStart < lpEnd; lpStart = CharNextW(lpStart))
if (*lpStart == wMatch) lpGotIt = lpStart;
return (LPWSTR)lpGotIt;
} }
/************************************************************************** /**************************************************************************
* StrStrA [COMCTL32.354] * StrStrA [COMCTL32.354]
* *

View File

@ -38,3 +38,12 @@ BOOL WINAPI MAIN_GdiInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved
return TRUE; return TRUE;
} }
/***********************************************************************
* Copy (GDI.250)
*/
void WINAPI Copy16( LPVOID src, LPVOID dst, WORD size )
{
memcpy( dst, src, size );
}

View File

@ -83,17 +83,17 @@ owner kernel32
75 stub OpenPathName 75 stub OpenPathName
76 stub DeletePathName 76 stub DeletePathName
# Reserved*: old Win 2.x functions now moved to USER (Win 3.0+) # Reserved*: old Win 2.x functions now moved to USER (Win 3.0+)
77 pascal Reserved1(segptr) AnsiNext16 77 stub Reserved1 #AnsiNext16
78 pascal Reserved2(segptr segptr) AnsiPrev16 78 stub Reserved2 #AnsiPrev16
79 pascal Reserved3(segstr) AnsiUpper16 79 stub Reserved3 #AnsiUpper16
80 pascal Reserved4(segstr) AnsiLower16 80 stub Reserved4 #AnsiLower16
81 pascal16 _lclose(word) _lclose16 81 pascal16 _lclose(word) _lclose16
82 pascal16 _lread(word segptr word) WIN16_lread 82 pascal16 _lread(word segptr word) WIN16_lread
83 pascal16 _lcreat(str word) _lcreat16 83 pascal16 _lcreat(str word) _lcreat16
84 pascal _llseek(word long word) _llseek16 84 pascal _llseek(word long word) _llseek16
85 pascal16 _lopen(str word) _lopen16 85 pascal16 _lopen(str word) _lopen16
86 pascal16 _lwrite(word ptr word) _lwrite16 86 pascal16 _lwrite(word ptr word) _lwrite16
87 pascal16 Reserved5(str str) lstrcmp16 87 pascal16 Reserved5(str str) strcmp
88 pascal lstrcpy(segptr str) lstrcpy16 88 pascal lstrcpy(segptr str) lstrcpy16
89 pascal lstrcat(segstr str) lstrcat16 89 pascal lstrcat(segstr str) lstrcat16
90 pascal16 lstrlen(str) lstrlen16 90 pascal16 lstrlen(str) lstrlen16
@ -291,7 +291,7 @@ owner kernel32
345 pascal16 IsSharedSelector(word) IsSharedSelector16 345 pascal16 IsSharedSelector(word) IsSharedSelector16
346 pascal16 IsBadHugeReadPtr(segptr long) IsBadHugeReadPtr16 346 pascal16 IsBadHugeReadPtr(segptr long) IsBadHugeReadPtr16
347 pascal16 IsBadHugeWritePtr(segptr long) IsBadHugeWritePtr16 347 pascal16 IsBadHugeWritePtr(segptr long) IsBadHugeWritePtr16
348 pascal16 hmemcpy(ptr ptr long) hmemcpy16 348 pascal16 hmemcpy(ptr ptr long) memcpy
349 pascal _hread(word segptr long) WIN16_hread 349 pascal _hread(word segptr long) WIN16_hread
350 pascal _hwrite(word ptr long) _hwrite16 350 pascal _hwrite(word ptr long) _hwrite16
351 pascal16 BUNNY_351() KERNEL_nop 351 pascal16 BUNNY_351() KERNEL_nop

View File

@ -98,3 +98,10 @@ BOOL WINAPI MAIN_KernelInit( HINSTANCE hinst, DWORD reason, LPVOID reserved )
} }
return TRUE; return TRUE;
} }
/***********************************************************************
* KERNEL_nop
*
* Entry point for kernel functions that do nothing.
*/
LONG WINAPI KERNEL_nop(void) { return 0; }

View File

@ -5,6 +5,7 @@
* Copyright 1999 Alexandre Julliard * Copyright 1999 Alexandre Julliard
*/ */
#include <assert.h>
#include <signal.h> #include <signal.h>
#include "winnt.h" #include "winnt.h"
#include "ntddk.h" #include "ntddk.h"
@ -75,12 +76,12 @@ static DWORD EXC_CallHandler( EXCEPTION_RECORD *record, EXCEPTION_FRAME *frame,
newframe.frame.Handler = nested_handler; newframe.frame.Handler = nested_handler;
newframe.prevFrame = frame; newframe.prevFrame = frame;
EXC_push_frame( &newframe.frame ); __wine_push_frame( &newframe.frame );
TRACE( "calling handler at %p code=%lx flags=%lx\n", TRACE( "calling handler at %p code=%lx flags=%lx\n",
handler, record->ExceptionCode, record->ExceptionFlags ); handler, record->ExceptionCode, record->ExceptionFlags );
ret = handler( record, frame, context, dispatcher ); ret = handler( record, frame, context, dispatcher );
TRACE( "handler returned %lx\n", ret ); TRACE( "handler returned %lx\n", ret );
EXC_pop_frame( &newframe.frame ); __wine_pop_frame( &newframe.frame );
return ret; return ret;
} }
@ -259,7 +260,7 @@ void WINAPI EXC_RtlUnwind( PEXCEPTION_FRAME pEndFrame, LPVOID unusedEip,
RtlRaiseException( &newrec ); /* never returns */ RtlRaiseException( &newrec ); /* never returns */
break; break;
} }
frame = EXC_pop_frame( frame ); frame = __wine_pop_frame( frame );
} }
} }
@ -292,3 +293,60 @@ void WINAPI RtlRaiseStatus( NTSTATUS status )
ExceptionRec.NumberParameters = 0; ExceptionRec.NumberParameters = 0;
RtlRaiseException( &ExceptionRec ); RtlRaiseException( &ExceptionRec );
} }
/*************************************************************
* __wine_exception_handler
*
* Exception handler for exception blocks declared in Wine code.
*/
DWORD __wine_exception_handler( EXCEPTION_RECORD *record, EXCEPTION_FRAME *frame,
CONTEXT *context, LPVOID pdispatcher )
{
__WINE_FRAME *wine_frame = (__WINE_FRAME *)frame;
if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND | EH_NESTED_CALL))
return ExceptionContinueSearch;
if (wine_frame->u.filter)
{
EXCEPTION_POINTERS ptrs;
ptrs.ExceptionRecord = record;
ptrs.ContextRecord = context;
switch(wine_frame->u.filter( &ptrs ))
{
case EXCEPTION_CONTINUE_SEARCH:
return ExceptionContinueSearch;
case EXCEPTION_CONTINUE_EXECUTION:
return ExceptionContinueExecution;
case EXCEPTION_EXECUTE_HANDLER:
break;
default:
MESSAGE( "Invalid return value from exception filter\n" );
assert( FALSE );
}
}
/* hack to make GetExceptionCode() work in handler */
wine_frame->ExceptionCode = record->ExceptionCode;
wine_frame->ExceptionRecord = wine_frame;
RtlUnwind( frame, 0, record, 0 );
__wine_pop_frame( frame );
longjmp( wine_frame->jmp, 1 );
}
/*************************************************************
* __wine_finally_handler
*
* Exception handler for try/finally blocks declared in Wine code.
*/
DWORD __wine_finally_handler( EXCEPTION_RECORD *record, EXCEPTION_FRAME *frame,
CONTEXT *context, LPVOID pdispatcher )
{
__WINE_FRAME *wine_frame = (__WINE_FRAME *)frame;
if (!(record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))
return ExceptionContinueSearch;
wine_frame->u.finally_func( FALSE );
return ExceptionContinueSearch;
}

View File

@ -991,3 +991,7 @@ type win32
@ stub _wtol @ stub _wtol
@ stub RtlSetPropertySetClassId @ stub RtlSetPropertySetClassId
@ stdcall NtPowerInformation(long long long long long) NtPowerInformation @ stdcall NtPowerInformation(long long long long long) NtPowerInformation
# Wine extensions
@ cdecl __wine_exception_handler(ptr ptr ptr ptr) __wine_exception_handler
@ cdecl __wine_finally_handler(ptr ptr ptr ptr) __wine_finally_handler

View File

@ -265,10 +265,10 @@ import kernel32.dll
314 stub StrNCmpW 314 stub StrNCmpW
315 stdcall StrNCpyA (ptr str long) lstrcpynA 315 stdcall StrNCpyA (ptr str long) lstrcpynA
316 stdcall StrNCpyW (ptr wstr long)lstrcpynW 316 stdcall StrNCpyW (ptr wstr long)lstrcpynW
317 stdcall StrRChrA (str str long) lstrrchr 317 forward StrRChrA shlwapi.StrRChrA
318 stub StrRChrIA 318 stub StrRChrIA
319 stub StrRChrIW 319 stub StrRChrIW
320 stdcall StrRChrW (wstr wstr long) lstrrchrw 320 forward StrRChrW shlwapi.StrRChrW
321 stub StrRStrA 321 stub StrRStrA
322 stub StrRStrIA 322 stub StrRStrIA
323 stub StrRStrIW 323 stub StrRStrIW

View File

@ -639,10 +639,10 @@ import kernel32
@ stub StrNCatW @ stub StrNCatW
@ stub StrPBrkA @ stub StrPBrkA
@ stub StrPBrkW @ stub StrPBrkW
@ stdcall StrRChrA (str str long) lstrrchr @ stdcall StrRChrA (str str long) StrRChrA
@ stub StrRChrIA @ stub StrRChrIA
@ stub StrRChrIW @ stub StrRChrIW
@ stdcall StrRChrW (wstr wstr long) lstrrchrw @ stdcall StrRChrW (wstr wstr long) StrRChrW
@ stub StrRStrIA @ stub StrRStrIA
@ stub StrRStrIW @ stub StrRStrIW
@ stub StrSpnA @ stub StrSpnA

View File

@ -169,7 +169,7 @@ LPSTR WINAPI StrDupA (LPCSTR lpSrc)
*/ */
LPWSTR WINAPI StrDupW (LPCWSTR lpSrc) LPWSTR WINAPI StrDupW (LPCWSTR lpSrc)
{ {
int len = lstrlenW(lpSrc); int len = strlenW(lpSrc);
LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1)); LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
TRACE("%s\n", debugstr_w(lpSrc)); TRACE("%s\n", debugstr_w(lpSrc));
@ -207,12 +207,12 @@ int WINAPI StrCSpnA (LPCSTR lpStr, LPCSTR lpSet)
*/ */
int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet) int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
{ {
int i,j, pos = lstrlenW(lpStr); int i,j, pos = strlenW(lpStr);
TRACE("(%p %s %p %s)\n", TRACE("(%p %s %p %s)\n",
lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet)); lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet));
for (i=0; i < lstrlenW(lpSet) ; i++ ) for (i=0; i < strlenW(lpSet) ; i++ )
{ {
for (j = 0; j < pos;j++) for (j = 0; j < pos;j++)
{ {
@ -226,6 +226,47 @@ int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
return pos; return pos;
} }
/**************************************************************************
* StrRChrA [SHLWAPI.@]
*
*/
LPSTR WINAPI StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
{
LPCSTR lpGotIt = NULL;
BOOL dbcs = IsDBCSLeadByte( LOBYTE(wMatch) );
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
for(; lpStart < lpEnd; lpStart = CharNextA(lpStart))
{
if (*lpStart != LOBYTE(wMatch)) continue;
if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
lpGotIt = lpStart;
}
return (LPSTR)lpGotIt;
}
/**************************************************************************
* StrRChrW [SHLWAPI.@]
*
*/
LPWSTR WINAPI StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch)
{
LPCWSTR lpGotIt = NULL;
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
if (!lpEnd) lpEnd = lpStart + strlenW(lpStart);
for(; lpStart < lpEnd; lpStart = CharNextW(lpStart))
if (*lpStart == wMatch) lpGotIt = lpStart;
return (LPWSTR)lpGotIt;
}
/************************************************************************* /*************************************************************************
* StrCatBuffA [SHLWAPI] * StrCatBuffA [SHLWAPI]
* *
@ -235,7 +276,7 @@ int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
*/ */
LPSTR WINAPI StrCatBuffA(LPSTR front, LPCSTR back, INT size) LPSTR WINAPI StrCatBuffA(LPSTR front, LPCSTR back, INT size)
{ {
LPSTR dst = front + lstrlenA(front); LPSTR dst = front + strlen(front);
LPCSTR src = back, end = front + size - 1; LPCSTR src = back, end = front + size - 1;
while(dst < end && *src) while(dst < end && *src)
@ -253,7 +294,7 @@ LPSTR WINAPI StrCatBuffA(LPSTR front, LPCSTR back, INT size)
*/ */
LPWSTR WINAPI StrCatBuffW(LPWSTR front, LPCWSTR back, INT size) LPWSTR WINAPI StrCatBuffW(LPWSTR front, LPCWSTR back, INT size)
{ {
LPWSTR dst = front + lstrlenW(front); LPWSTR dst = front + strlenW(front);
LPCWSTR src = back, end = front + size - 1; LPCWSTR src = back, end = front + size - 1;
while(dst < end && *src) while(dst < end && *src)

View File

@ -1,18 +1,22 @@
/* /*
* String functions * USER string functions
* *
* Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is) * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
* Copyright 1996 Alexandre Julliard
* Copyright 1996 Marcus Meissner * Copyright 1996 Marcus Meissner
*/ */
#include <ctype.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include "windef.h" #include "windef.h"
#include "winbase.h" #include "winbase.h"
#include "winnls.h"
#include "wine/winbase16.h" #include "wine/winbase16.h"
#include "wine/winuser16.h" #include "wine/winuser16.h"
#include "wine/unicode.h"
#include "heap.h" #include "heap.h"
#include "ldt.h" #include "ldt.h"
@ -20,6 +24,300 @@
DEFAULT_DEBUG_CHANNEL(resource); DEFAULT_DEBUG_CHANNEL(resource);
/***********************************************************************
* AnsiToOem16 (KEYBOARD.5)
*/
INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
{
CharToOemA( s, d );
return -1;
}
/***********************************************************************
* OemToAnsi16 (KEYBOARD.6)
*/
INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
{
OemToCharA( s, d );
return -1;
}
/***********************************************************************
* AnsiToOemBuff16 (KEYBOARD.134)
*/
void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
{
if (len != 0) CharToOemBuffA( s, d, len );
}
/***********************************************************************
* OemToAnsiBuff16 (KEYBOARD.135)
*/
void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
{
if (len != 0) OemToCharBuffA( s, d, len );
}
/***********************************************************************
* AnsiUpper16 (USER.431)
*/
SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
{
/* uppercase only one char if strOrChar < 0x10000 */
if (HIWORD(strOrChar))
{
CharUpperA( PTR_SEG_TO_LIN(strOrChar) );
return strOrChar;
}
else return toupper((char)strOrChar);
}
/***********************************************************************
* AnsiLower16 (USER.432)
*/
SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
{
/* lowercase only one char if strOrChar < 0x10000 */
if (HIWORD(strOrChar))
{
CharLowerA( PTR_SEG_TO_LIN(strOrChar) );
return strOrChar;
}
else return tolower((char)strOrChar);
}
/***********************************************************************
* AnsiUpperBuff16 (USER.437)
*/
UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
{
CharUpperBuffA( str, len ? len : 65536 );
return len;
}
/***********************************************************************
* AnsiLowerBuff16 (USER.438)
*/
UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
{
CharLowerBuffA( str, len ? len : 65536 );
return len;
}
/***********************************************************************
* AnsiNext16 (USER.472)
*/
SEGPTR WINAPI AnsiNext16(SEGPTR current)
{
char *ptr = (char *)PTR_SEG_TO_LIN(current);
return current + (CharNextA(ptr) - ptr);
}
/***********************************************************************
* AnsiPrev16 (USER.473)
*/
SEGPTR WINAPI AnsiPrev16( LPCSTR start, SEGPTR current )
{
char *ptr = (char *)PTR_SEG_TO_LIN(current);
return current - (ptr - CharPrevA( start, ptr ));
}
/***********************************************************************
* CharNextA (USER32.@)
*/
LPSTR WINAPI CharNextA( LPCSTR ptr )
{
if (!*ptr) return (LPSTR)ptr;
if (IsDBCSLeadByte( ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
return (LPSTR)(ptr + 1);
}
/***********************************************************************
* CharNextExA (USER32.@)
*/
LPSTR WINAPI CharNextExA( WORD codepage, LPCSTR ptr, DWORD flags )
{
if (!*ptr) return (LPSTR)ptr;
if (IsDBCSLeadByteEx( codepage, ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
return (LPSTR)(ptr + 1);
}
/***********************************************************************
* CharNextExW (USER32.@)
*/
LPWSTR WINAPI CharNextExW( WORD codepage, LPCWSTR ptr, DWORD flags )
{
/* doesn't make sense, there are no codepages for Unicode */
return NULL;
}
/***********************************************************************
* CharNextW (USER32.@)
*/
LPWSTR WINAPI CharNextW(LPCWSTR x)
{
if (*x) x++;
else return (LPWSTR)x;
}
/***********************************************************************
* CharPrevA (USER32.@)
*/
LPSTR WINAPI CharPrevA( LPCSTR start, LPCSTR ptr )
{
while (*start && (start < ptr))
{
LPCSTR next = CharNextA( start );
if (next >= ptr) break;
start = next;
}
return (LPSTR)start;
}
/***********************************************************************
* CharPrevExA (USER32.@)
*/
LPSTR WINAPI CharPrevExA( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
{
while (*start && (start < ptr))
{
LPCSTR next = CharNextExA( codepage, start, flags );
if (next > ptr) break;
start = next;
}
return (LPSTR)start;
}
/***********************************************************************
* CharPrevExW (USER32.@)
*/
LPSTR WINAPI CharPrevExW( WORD codepage, LPCWSTR start, LPCWSTR ptr, DWORD flags )
{
/* doesn't make sense, there are no codepages for Unicode */
return NULL;
}
/***********************************************************************
* CharPrevW (USER32.@)
*/
LPWSTR WINAPI CharPrevW(LPCWSTR start,LPCWSTR x)
{
if (x>start) return (LPWSTR)(x-1);
else return (LPWSTR)x;
}
/***********************************************************************
* CharToOemA (USER32.@)
*/
BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
{
if ( !s || !d ) return TRUE;
return CharToOemBuffA( s, d, strlen( s ) + 1 );
}
/***********************************************************************
* CharToOemBuffA (USER32.@)
*/
BOOL WINAPI CharToOemBuffA( LPCSTR s, LPSTR d, DWORD len )
{
WCHAR *bufW;
bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
if( bufW )
{
MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
HeapFree( GetProcessHeap(), 0, bufW );
}
return TRUE;
}
/***********************************************************************
* CharToOemBuffW (USER32.@)
*/
BOOL WINAPI CharToOemBuffW( LPCWSTR s, LPSTR d, DWORD len )
{
if ( !s || !d ) return TRUE;
WideCharToMultiByte( CP_OEMCP, 0, s, len, d, len, NULL, NULL );
return TRUE;
}
/***********************************************************************
* CharToOemW (USER32.@)
*/
BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
{
return CharToOemBuffW( s, d, strlenW( s ) + 1 );
}
/***********************************************************************
* OemToCharA (USER32.@)
*/
BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
{
return OemToCharBuffA( s, d, strlen( s ) + 1 );
}
/***********************************************************************
* OemToCharBuffA (USER32.@)
*/
BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
{
WCHAR *bufW;
bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
if( bufW )
{
MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
HeapFree( GetProcessHeap(), 0, bufW );
}
return TRUE;
}
/***********************************************************************
* OemToCharBuffW (USER32.@)
*/
BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
{
MultiByteToWideChar( CP_OEMCP, 0, s, len, d, len );
return TRUE;
}
/***********************************************************************
* OemToCharW (USER32.@)
*/
BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
{
return OemToCharBuffW( s, d, strlen( s ) + 1 );
}
/*********************************************************************** /***********************************************************************
* FormatMessage16 (USER.606) * FormatMessage16 (USER.606)
*/ */

View File

@ -207,3 +207,23 @@ DWORD WINAPI RegisterTaskList (DWORD x)
FIXME("0x%08lx\n",x); FIXME("0x%08lx\n",x);
return TRUE; return TRUE;
} }
/***********************************************************************
* stub_USER_489
*/
LONG WINAPI stub_USER_489(void) { FIXME("stub\n"); return 0; }
/***********************************************************************
* stub_USER_490
*/
LONG WINAPI stub_USER_490(void) { FIXME("stub\n"); return 0; }
/***********************************************************************
* stub_USER_492
*/
LONG WINAPI stub_USER_492(void) { FIXME("stub\n"); return 0; }
/***********************************************************************
* stub_USER_496
*/
LONG WINAPI stub_USER_496(void) { FIXME("stub\n"); return 0; }

View File

@ -405,13 +405,13 @@ owner user32
427 pascal16 FindWindowEx(word word str str) FindWindowEx16 427 pascal16 FindWindowEx(word word str str) FindWindowEx16
428 stub TileWindows 428 stub TileWindows
429 stub CascadeWindows 429 stub CascadeWindows
430 pascal16 lstrcmp(str str) lstrcmp16 430 pascal16 lstrcmp(str str) strcmp
431 pascal AnsiUpper(segstr) AnsiUpper16 431 pascal AnsiUpper(segstr) AnsiUpper16
432 pascal AnsiLower(segstr) AnsiLower16 432 pascal AnsiLower(segstr) AnsiLower16
433 pascal16 IsCharAlpha(word) IsCharAlpha16 433 pascal16 IsCharAlpha(word) IsCharAlphaA
434 pascal16 IsCharAlphaNumeric(word) IsCharAlphaNumeric16 434 pascal16 IsCharAlphaNumeric(word) IsCharAlphaNumericA
435 pascal16 IsCharUpper(word) IsCharUpper16 435 pascal16 IsCharUpper(word) IsCharUpperA
436 pascal16 IsCharLower(word) IsCharLower16 436 pascal16 IsCharLower(word) IsCharLowerA
437 pascal16 AnsiUpperBuff(str word) AnsiUpperBuff16 437 pascal16 AnsiUpperBuff(str word) AnsiUpperBuff16
438 pascal16 AnsiLowerBuff(str word) AnsiLowerBuff16 438 pascal16 AnsiLowerBuff(str word) AnsiLowerBuff16
441 pascal16 InsertMenuItem(word word word ptr) InsertMenuItem16 441 pascal16 InsertMenuItem(word word word ptr) InsertMenuItem16
@ -439,9 +439,9 @@ owner user32
465 pascal16 DragDetect(word long) DragDetect16 465 pascal16 DragDetect(word long) DragDetect16
466 pascal16 DrawFocusRect(word ptr) DrawFocusRect16 466 pascal16 DrawFocusRect(word ptr) DrawFocusRect16
470 stub StringFunc 470 stub StringFunc
471 pascal16 lstrcmpi(str str) lstrcmpi16 471 pascal16 lstrcmpi(str str) lstrcmpiA
472 pascal AnsiNext(segptr) AnsiNext16 472 pascal AnsiNext(segptr) AnsiNext16
473 pascal AnsiPrev(segptr segptr) AnsiPrev16 473 pascal AnsiPrev(str segptr) AnsiPrev16
475 pascal16 SetScrollInfo(word s_word ptr word) SetScrollInfo16 475 pascal16 SetScrollInfo(word s_word ptr word) SetScrollInfo16
476 pascal16 GetScrollInfo(word s_word ptr) GetScrollInfo16 476 pascal16 GetScrollInfo(word s_word ptr) GetScrollInfo16
477 pascal16 GetKeyboardLayoutName(ptr) GetKeyboardLayoutName16 477 pascal16 GetKeyboardLayoutName(ptr) GetKeyboardLayoutName16

File diff suppressed because it is too large Load Diff

View File

@ -7,7 +7,6 @@ MODULE = if1632
C_SRCS = \ C_SRCS = \
builtin.c \ builtin.c \
dummy.c \
relay.c \ relay.c \
snoop.c \ snoop.c \
thunk.c thunk.c

View File

@ -1,48 +0,0 @@
/*
* Dummy function definitions
*/
#include "windef.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(relay);
/***********************************************************************
* stub_GDI_379
*/
LONG WINAPI stub_GDI_379(HDC16 hdc) { FIXME("STARTPAGE: stub\n"); return 1; }
/***********************************************************************
* stub_GDI_381
*/
LONG WINAPI stub_GDI_381(HDC16 hdc, SEGPTR proc) { FIXME("SETABORTPROC: stub\n"); return 1; }
/***********************************************************************
* stub_GDI_382
*/
LONG WINAPI stub_GDI_382(void) { FIXME("ABORTPROC: stub\n"); return 1; }
/***********************************************************************
* stub_USER_489
*/
LONG WINAPI stub_USER_489(void) { FIXME("stub\n"); return 0; }
/***********************************************************************
* stub_USER_490
*/
LONG WINAPI stub_USER_490(void) { FIXME("stub\n"); return 0; }
/***********************************************************************
* stub_USER_492
*/
LONG WINAPI stub_USER_492(void) { FIXME("stub\n"); return 0; }
/***********************************************************************
* stub_USER_496
*/
LONG WINAPI stub_USER_496(void) { FIXME("stub\n"); return 0; }
/***********************************************************************
* KERNEL_nop
*/
LONG WINAPI KERNEL_nop(void) { return 0; }

View File

@ -70,12 +70,12 @@
#define __EXCEPT(func) \ #define __EXCEPT(func) \
} while(0); \ } while(0); \
EXC_pop_frame( &__f.frame ); \ __wine_pop_frame( &__f.frame ); \
break; \ break; \
} else { \ } else { \
__f.frame.Handler = (PEXCEPTION_HANDLER)WINE_exception_handler; \ __f.frame.Handler = (PEXCEPTION_HANDLER)__wine_exception_handler; \
__f.u.filter = (func); \ __f.u.filter = (func); \
EXC_push_frame( &__f.frame ); \ __wine_push_frame( &__f.frame ); \
if (setjmp( __f.jmp)) { \ if (setjmp( __f.jmp)) { \
const __WINE_FRAME * const __eptr WINE_UNUSED = &__f; \ const __WINE_FRAME * const __eptr WINE_UNUSED = &__f; \
do { do {
@ -90,13 +90,13 @@
#define __FINALLY(func) \ #define __FINALLY(func) \
} while(0); \ } while(0); \
EXC_pop_frame( &__f.frame ); \ __wine_pop_frame( &__f.frame ); \
(func)(1); \ (func)(1); \
break; \ break; \
} else { \ } else { \
__f.frame.Handler = (PEXCEPTION_HANDLER)WINE_finally_handler; \ __f.frame.Handler = (PEXCEPTION_HANDLER)WINE_finally_handler; \
__f.u.finally_func = (func); \ __f.u.finally_func = (func); \
EXC_push_frame( &__f.frame ); \ __wine_push_frame( &__f.frame ); \
__first = 0; \ __first = 0; \
} \ } \
} while (0); } while (0);
@ -128,14 +128,14 @@ typedef struct __tagWINE_FRAME
const struct __tagWINE_FRAME *ExceptionRecord; const struct __tagWINE_FRAME *ExceptionRecord;
} __WINE_FRAME; } __WINE_FRAME;
extern DWORD WINE_exception_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame, extern DWORD __wine_exception_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame,
CONTEXT *context, LPVOID pdispatcher ); CONTEXT *context, LPVOID pdispatcher );
extern DWORD WINE_finally_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame, extern DWORD __wine_finally_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame,
CONTEXT *context, LPVOID pdispatcher ); CONTEXT *context, LPVOID pdispatcher );
#endif /* USE_COMPILER_EXCEPTIONS */ #endif /* USE_COMPILER_EXCEPTIONS */
static inline EXCEPTION_FRAME * WINE_UNUSED EXC_push_frame( EXCEPTION_FRAME *frame ) static inline EXCEPTION_FRAME * WINE_UNUSED __wine_push_frame( EXCEPTION_FRAME *frame )
{ {
#if defined(__GNUC__) && defined(__i386__) #if defined(__GNUC__) && defined(__i386__)
EXCEPTION_FRAME *prev; EXCEPTION_FRAME *prev;
@ -152,7 +152,7 @@ static inline EXCEPTION_FRAME * WINE_UNUSED EXC_push_frame( EXCEPTION_FRAME *fra
#endif #endif
} }
static inline EXCEPTION_FRAME * WINE_UNUSED EXC_pop_frame( EXCEPTION_FRAME *frame ) static inline EXCEPTION_FRAME * WINE_UNUSED __wine_pop_frame( EXCEPTION_FRAME *frame )
{ {
#if defined(__GNUC__) && defined(__i386__) #if defined(__GNUC__) && defined(__i386__)
__asm__ __volatile__(".byte 0x64\n\tmovl %0,(0)" __asm__ __volatile__(".byte 0x64\n\tmovl %0,(0)"
@ -166,12 +166,7 @@ static inline EXCEPTION_FRAME * WINE_UNUSED EXC_pop_frame( EXCEPTION_FRAME *fram
} }
#ifdef __WINE__ #ifdef __WINE__
extern void WINAPI EXC_NtRaiseException( PEXCEPTION_RECORD, PCONTEXT, BOOL, PCONTEXT );
extern void WINAPI EXC_RtlRaiseException( PEXCEPTION_RECORD, PCONTEXT ); extern void WINAPI EXC_RtlRaiseException( PEXCEPTION_RECORD, PCONTEXT );
extern void WINAPI EXC_RtlUnwind( PEXCEPTION_FRAME, LPVOID,
PEXCEPTION_RECORD, DWORD, CONTEXT * );
extern void WINAPI EXC_DebugBreak( CONTEXT *context );
extern BOOL SIGNAL_Init(void); extern BOOL SIGNAL_Init(void);
#endif #endif

View File

@ -2,12 +2,14 @@
#define __WINE_WINE_WINESTRING_H #define __WINE_WINE_WINESTRING_H
#include "windef.h" #include "windef.h"
#include "winnls.h"
LPWSTR WINAPI lstrcpyAtoW(LPWSTR,LPCSTR);
LPSTR WINAPI lstrcpyWtoA(LPSTR,LPCWSTR);
LPWSTR WINAPI lstrcpynAtoW(LPWSTR,LPCSTR,INT); LPWSTR WINAPI lstrcpynAtoW(LPWSTR,LPCSTR,INT);
LPSTR WINAPI lstrcpynWtoA(LPSTR,LPCWSTR,INT); LPSTR WINAPI lstrcpynWtoA(LPSTR,LPCWSTR,INT);
/* compatibility macros; will be removed some day, please don't use them */
#define lstrcpyAtoW(dst,src) ((void)MultiByteToWideChar(CP_ACP,0,(src),-1,(dst),0x7fffffff))
#define lstrcpyWtoA(dst,src) ((void)WideCharToMultiByte(CP_ACP,0,(src),-1,(dst),0x7fffffff,NULL,NULL))
#define lstrncmpiA strncasecmp #define lstrncmpiA strncasecmp
#endif /* __WINE_WINE_WINESTRING_H */ #endif /* __WINE_WINE_WINESTRING_H */

View File

@ -615,7 +615,7 @@ BOOL16 WINAPI AdjustWindowRectEx16(LPRECT16,DWORD,BOOL16,DWORD);
SEGPTR WINAPI AnsiLower16(SEGPTR); SEGPTR WINAPI AnsiLower16(SEGPTR);
UINT16 WINAPI AnsiLowerBuff16(LPSTR,UINT16); UINT16 WINAPI AnsiLowerBuff16(LPSTR,UINT16);
SEGPTR WINAPI AnsiNext16(SEGPTR); SEGPTR WINAPI AnsiNext16(SEGPTR);
SEGPTR WINAPI AnsiPrev16(SEGPTR,SEGPTR); SEGPTR WINAPI AnsiPrev16(LPCSTR,SEGPTR);
SEGPTR WINAPI AnsiUpper16(SEGPTR); SEGPTR WINAPI AnsiUpper16(SEGPTR);
UINT16 WINAPI AnsiUpperBuff16(LPSTR,UINT16); UINT16 WINAPI AnsiUpperBuff16(LPSTR,UINT16);
BOOL16 WINAPI AnyPopup16(void); BOOL16 WINAPI AnyPopup16(void);

View File

@ -3247,14 +3247,12 @@ LPSTR WINAPI CharNextA(LPCSTR);
LPWSTR WINAPI CharNextW(LPCWSTR); LPWSTR WINAPI CharNextW(LPCWSTR);
#define CharNext WINELIB_NAME_AW(CharNext) #define CharNext WINELIB_NAME_AW(CharNext)
LPSTR WINAPI CharNextExA(WORD,LPCSTR,DWORD); LPSTR WINAPI CharNextExA(WORD,LPCSTR,DWORD);
LPWSTR WINAPI CharNextExW(WORD,LPCWSTR,DWORD); /* no CharNextExW (doesn't make sense) */
#define CharNextEx WINELIB_NAME_AW(CharNextEx)
LPSTR WINAPI CharPrevA(LPCSTR,LPCSTR); LPSTR WINAPI CharPrevA(LPCSTR,LPCSTR);
LPWSTR WINAPI CharPrevW(LPCWSTR,LPCWSTR); LPWSTR WINAPI CharPrevW(LPCWSTR,LPCWSTR);
#define CharPrev WINELIB_NAME_AW(CharPrev) #define CharPrev WINELIB_NAME_AW(CharPrev)
LPSTR WINAPI CharPrevExA(WORD,LPCSTR,LPCSTR,DWORD); LPSTR WINAPI CharPrevExA(WORD,LPCSTR,LPCSTR,DWORD);
LPWSTR WINAPI CharPrevExW(WORD,LPCWSTR,LPCWSTR,DWORD); /* no CharPrevExW (doesn't make sense) */
#define CharPrevEx WINELIB_NAME_AW(CharPrevEx)
LPSTR WINAPI CharUpperA(LPSTR); LPSTR WINAPI CharUpperA(LPSTR);
LPWSTR WINAPI CharUpperW(LPWSTR); LPWSTR WINAPI CharUpperW(LPWSTR);
#define CharUpper WINELIB_NAME_AW(CharUpper) #define CharUpper WINELIB_NAME_AW(CharUpper)

View File

@ -10,24 +10,16 @@
#include "windef.h" #include "windef.h"
#include "winbase.h" #include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/winbase16.h" #include "wine/winbase16.h"
#include "wine/winuser16.h"
#include "wine/keyboard16.h"
#include "wine/exception.h" #include "wine/exception.h"
#include "wine/unicode.h" #include "wine/unicode.h"
#include "winerror.h" #include "winerror.h"
#include "winnls.h"
#include "ldt.h" #include "ldt.h"
#include "debugtools.h" #include "debugtools.h"
#include "winnls.h"
DEFAULT_DEBUG_CHANNEL(string); DEFAULT_DEBUG_CHANNEL(string);
/* Internaly used by strchr family functions */
static BOOL ChrCmpA( WORD word1, WORD word2);
/* filter for page-fault exceptions */ /* filter for page-fault exceptions */
static WINE_EXCEPTION_FILTER(page_fault) static WINE_EXCEPTION_FILTER(page_fault)
{ {
@ -37,15 +29,6 @@ static WINE_EXCEPTION_FILTER(page_fault)
} }
/***********************************************************************
* hmemcpy (KERNEL.348)
*/
void WINAPI hmemcpy16( LPVOID dst, LPCVOID src, LONG count )
{
memcpy( dst, src, count );
}
/*********************************************************************** /***********************************************************************
* lstrcat16 (KERNEL.89) * lstrcat16 (KERNEL.89)
*/ */
@ -109,15 +92,6 @@ SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
} }
/***********************************************************************
* lstrcmp16 (USER.430)
*/
INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
{
return (INT16)strcmp( str1, str2 );
}
/*********************************************************************** /***********************************************************************
* lstrcmpA (KERNEL.602) * lstrcmpA (KERNEL.602)
*/ */
@ -145,15 +119,6 @@ INT WINAPI lstrcmpW( LPCWSTR str1, LPCWSTR str2 )
} }
/***********************************************************************
* lstrcmpi16 (USER.471)
*/
INT16 WINAPI lstrcmpi16( LPCSTR str1, LPCSTR str2 )
{
return (INT16)lstrcmpiA( str1, str2 );
}
/*********************************************************************** /***********************************************************************
* lstrcmpiA (KERNEL32.605) * lstrcmpiA (KERNEL32.605)
*/ */
@ -332,26 +297,6 @@ INT WINAPI lstrlenW( LPCWSTR str )
} }
/***********************************************************************
* lstrcpyAtoW (Not a Windows API)
*/
LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
{
MultiByteToWideChar( CP_ACP, 0, src, -1, dst, 0x7fffffff );
return dst;
}
/***********************************************************************
* lstrcpyWtoA (Not a Windows API)
*/
LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
{
WideCharToMultiByte( CP_ACP, 0, src, -1, dst, 0x7fffffff, NULL, NULL );
return dst;
}
/*********************************************************************** /***********************************************************************
* lstrcpynAtoW (Not a Windows API) * lstrcpynAtoW (Not a Windows API)
* Note: this function differs from the UNIX strncpy, it _always_ writes * Note: this function differs from the UNIX strncpy, it _always_ writes
@ -389,212 +334,3 @@ INT16 WINAPI UnicodeToAnsi16( LPCWSTR src, LPSTR dst, INT16 codepage )
return WideCharToMultiByte( codepage, 0, src, -1, dst, 0x7fffffff, NULL, NULL ); return WideCharToMultiByte( codepage, 0, src, -1, dst, 0x7fffffff, NULL, NULL );
} }
/***********************************************************************
* Copy (GDI.250)
*/
void WINAPI Copy16( LPVOID src, LPVOID dst, WORD size )
{
memcpy( dst, src, size );
}
/***********************************************************************
* AnsiToOem16 (KEYBOARD.5)
*/
INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
{
CharToOemA( s, d );
return -1;
}
/***********************************************************************
* OemToAnsi16 (KEYBOARD.6)
*/
INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
{
OemToCharA( s, d );
return -1;
}
/***********************************************************************
* AnsiToOemBuff16 (KEYBOARD.134)
*/
void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
{
if (len != 0) CharToOemBuffA( s, d, len );
}
/***********************************************************************
* OemToAnsiBuff16 (KEYBOARD.135)
*/
void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
{
if (len != 0) OemToCharBuffA( s, d, len );
}
/***********************************************************************
* CharToOemA (USER32.37)
*/
BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
{
if ( !s || !d ) return TRUE;
return CharToOemBuffA( s, d, strlen( s ) + 1 );
}
/***********************************************************************
* CharToOemBuffA (USER32.38)
*/
BOOL WINAPI CharToOemBuffA( LPCSTR s, LPSTR d, DWORD len )
{
WCHAR *bufW;
bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
if( bufW )
{
MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
HeapFree( GetProcessHeap(), 0, bufW );
}
return TRUE;
}
/***********************************************************************
* CharToOemBuffW (USER32.39)
*/
BOOL WINAPI CharToOemBuffW( LPCWSTR s, LPSTR d, DWORD len )
{
if ( !s || !d ) return TRUE;
WideCharToMultiByte( CP_OEMCP, 0, s, len, d, len, NULL, NULL );
return TRUE;
}
/***********************************************************************
* CharToOemW (USER32.40)
*/
BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
{
return CharToOemBuffW( s, d, strlenW( s ) + 1 );
}
/***********************************************************************
* OemToCharA (USER32.402)
*/
BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
{
return OemToCharBuffA( s, d, strlen( s ) + 1 );
}
/***********************************************************************
* OemToCharBuffA (USER32.403)
*/
BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
{
WCHAR *bufW;
bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
if( bufW )
{
MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
HeapFree( GetProcessHeap(), 0, bufW );
}
return TRUE;
}
/***********************************************************************
* OemToCharBuffW (USER32.404)
*/
BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
{
MultiByteToWideChar( CP_OEMCP, 0, s, len, d, len );
return TRUE;
}
/***********************************************************************
* OemToCharW (USER32.405)
*/
BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
{
return OemToCharBuffW( s, d, strlen( s ) + 1 );
}
/***********************************************************************
* lstrrchr (Not a Windows API)
*
* This is the implementation meant to be invoked from within
* COMCTL32_StrRChrA and shell32(TODO)...
*
* Return a pointer to the last occurence of wMatch in lpStart
* not looking further than lpEnd...
*/
LPSTR WINAPI lstrrchr( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
{
LPCSTR lpGotIt = NULL;
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
for(; lpStart < lpEnd; lpStart = CharNextA(lpStart))
if (!ChrCmpA( GET_WORD(lpStart), wMatch))
lpGotIt = lpStart;
return ((LPSTR)lpGotIt);
}
/***********************************************************************
* ChrCmpW
* This fuction returns FALSE if both words match, TRUE otherwise...
*/
static BOOL ChrCmpW( WORD word1, WORD word2) {
return (word1 != word2);
}
/***********************************************************************
* lstrrchrw (Not a Windows API)
*
* This is the implementation meant to be invoked form within
* COMCTL32_StrRChrW and shell32(TODO)...
*
* Return a pointer to the last occurence of wMatch in lpStart
* not looking further than lpEnd...
*/
LPWSTR WINAPI lstrrchrw( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch )
{
LPCWSTR lpGotIt = NULL;
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
if (!lpEnd) lpEnd = lpStart + lstrlenW(lpStart);
for(; lpStart < lpEnd; lpStart = CharNextW(lpStart))
if (!ChrCmpW( GET_WORD(lpStart), wMatch))
lpGotIt = lpStart;
return (LPWSTR)lpGotIt;
}
/***********************************************************************
* ChrCmpA
* This fuction returns FALSE if both words match, TRUE otherwise...
*/
static BOOL ChrCmpA( WORD word1, WORD word2) {
if (LOBYTE(word1) == LOBYTE(word2)) {
if (IsDBCSLeadByte(LOBYTE(word1))) {
return (word1 != word2);
}
return FALSE;
}
return TRUE;
}

View File

@ -38,207 +38,6 @@ DEFAULT_DEBUG_CHANNEL(resource);
extern const WORD OLE2NLS_CT_CType3_LUT[]; /* FIXME: does not belong here */ extern const WORD OLE2NLS_CT_CType3_LUT[]; /* FIXME: does not belong here */
/* Funny to divide them between user and kernel. */
/***********************************************************************
* IsCharAlpha (USER.433)
*/
BOOL16 WINAPI IsCharAlpha16(CHAR ch)
{
return isalpha(ch); /* This is probably not right for NLS */
}
/***********************************************************************
* IsCharAlphaNumeric (USER.434)
*/
BOOL16 WINAPI IsCharAlphaNumeric16(CHAR ch)
{
return isalnum(ch);
}
/***********************************************************************
* IsCharUpper (USER.435)
*/
BOOL16 WINAPI IsCharUpper16(CHAR ch)
{
return isupper(ch);
}
/***********************************************************************
* IsCharLower (USER.436)
*/
BOOL16 WINAPI IsCharLower16(CHAR ch)
{
return islower(ch);
}
/***********************************************************************
* AnsiUpper16 (USER.431)
*/
SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
{
/* I am not sure if the locale stuff works with toupper, but then again
I am not sure if the Linux libc locale stuffs works at all */
/* uppercase only one char if strOrChar < 0x10000 */
if (HIWORD(strOrChar))
{
char *s;
for (s = PTR_SEG_TO_LIN(strOrChar); *s; s++) *s = toupper(*s);
return strOrChar;
}
else return toupper((char)strOrChar);
}
/***********************************************************************
* AnsiUpperBuff16 (USER.437)
*/
UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
{
UINT count = len ? len : 65536;
for (; count; count--, str++) *str = toupper(*str);
return len;
}
/***********************************************************************
* AnsiLower16 (USER.432)
*/
SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
{
/* I am not sure if the locale stuff works with toupper, but then again
I am not sure if the Linux libc locale stuffs works at all */
/* lowercase only one char if strOrChar < 0x10000 */
if (HIWORD(strOrChar))
{
char *s;
for (s = PTR_SEG_TO_LIN( strOrChar ); *s; s++) *s = tolower( *s );
return strOrChar;
}
else return tolower((char)strOrChar);
}
/***********************************************************************
* AnsiLowerBuff16 (USER.438)
*/
UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
{
UINT count = len ? len : 65536;
for (; count; count--, str++) *str = tolower(*str);
return len;
}
/***********************************************************************
* AnsiNext16 (USER.472)
*/
SEGPTR WINAPI AnsiNext16(SEGPTR current)
{
return (*(char *)PTR_SEG_TO_LIN(current)) ? current + 1 : current;
}
/***********************************************************************
* AnsiPrev16 (USER.473)
*/
SEGPTR WINAPI AnsiPrev16( SEGPTR start, SEGPTR current )
{
return (current == start) ? start : current - 1;
}
/***********************************************************************
* CharNextA (USER32.29)
*/
LPSTR WINAPI CharNextA( LPCSTR ptr )
{
if (!*ptr) return (LPSTR)ptr;
if (IsDBCSLeadByte( *ptr ) && (*(ptr+1) != 0) ) return (LPSTR)(ptr + 2);
return (LPSTR)(ptr + 1);
}
/***********************************************************************
* CharNextExA (USER32.30)
*/
LPSTR WINAPI CharNextExA( WORD codepage, LPCSTR ptr, DWORD flags )
{
if (!*ptr) return (LPSTR)ptr;
if (IsDBCSLeadByteEx( codepage, *ptr ) && (*(ptr+1) != 0) ) return (LPSTR)(ptr + 2);
return (LPSTR)(ptr + 1);
}
/***********************************************************************
* CharNextExW (USER32.31)
*/
LPWSTR WINAPI CharNextExW(WORD codepage,LPCWSTR x,DWORD flags)
{
/* FIXME: add DBCS / codepage stuff */
if (*x) return (LPWSTR)(x+1);
else return (LPWSTR)x;
}
/***********************************************************************
* CharNextW (USER32.32)
*/
LPWSTR WINAPI CharNextW(LPCWSTR x)
{
if (*x) return (LPWSTR)(x+1);
else return (LPWSTR)x;
}
/***********************************************************************
* CharPrevA (USER32.33)
*/
LPSTR WINAPI CharPrevA( LPCSTR start, LPCSTR ptr )
{
while (*start && (start < ptr))
{
LPCSTR next = CharNextA( start );
if (next >= ptr) break;
start = next;
}
return (LPSTR)start;
}
/***********************************************************************
* CharPrevExA (USER32.34)
*/
LPSTR WINAPI CharPrevExA( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
{
while (*start && (start < ptr))
{
LPCSTR next = CharNextExA( codepage, start, flags );
if (next > ptr) break;
start = next;
}
return (LPSTR)start;
}
/***********************************************************************
* CharPrevExW (USER32.35)
*/
LPWSTR WINAPI CharPrevExW(WORD codepage,LPCWSTR start,LPCWSTR x,DWORD flags)
{
/* FIXME: add DBCS / codepage stuff */
if (x>start) return (LPWSTR)(x-1);
else return (LPWSTR)x;
}
/***********************************************************************
* CharPrevW (USER32.36)
*/
LPWSTR WINAPI CharPrevW(LPCWSTR start,LPCWSTR x)
{
if (x>start) return (LPWSTR)(x-1);
else return (LPWSTR)x;
}
/*********************************************************************** /***********************************************************************
* CharLowerA (USER32.25) * CharLowerA (USER32.25)
* FIXME: handle current locale * FIXME: handle current locale
@ -337,36 +136,24 @@ LPSTR WINAPI CharUpperA(LPSTR x)
* CharUpperBuffA (USER32.42) * CharUpperBuffA (USER32.42)
* FIXME: handle current locale * FIXME: handle current locale
*/ */
DWORD WINAPI CharUpperBuffA(LPSTR x,DWORD buflen) DWORD WINAPI CharUpperBuffA( LPSTR str, DWORD len )
{ {
DWORD done=0; DWORD ret = len;
if (!str) return 0; /* YES */
if (!x) return 0; /* YES */ for (; len; len--, str++) *str = toupper(*str);
while (*x && (buflen--)) return ret;
{
*x=toupper(*x);
x++;
done++;
}
return done;
} }
/*********************************************************************** /***********************************************************************
* CharUpperBuffW (USER32.43) * CharUpperBuffW (USER32.43)
* FIXME: handle current locale * FIXME: handle current locale
*/ */
DWORD WINAPI CharUpperBuffW(LPWSTR x,DWORD buflen) DWORD WINAPI CharUpperBuffW( LPWSTR str, DWORD len )
{ {
DWORD done=0; DWORD ret = len;
if (!str) return 0; /* YES */
if (!x) return 0; /* YES */ for (; len; len--, str++) *str = toupperW(*str);
while (*x && (buflen--)) return ret;
{
*x=toupperW(*x);
x++;
done++;
}
return done;
} }
/*********************************************************************** /***********************************************************************
@ -389,7 +176,7 @@ LPWSTR WINAPI CharUpperW(LPWSTR x)
} }
/*********************************************************************** /***********************************************************************
* IsCharAlphaA (USER32.331) * IsCharAlphaA (USER.433) (USER32.331)
* FIXME: handle current locale * FIXME: handle current locale
*/ */
BOOL WINAPI IsCharAlphaA(CHAR x) BOOL WINAPI IsCharAlphaA(CHAR x)
@ -398,7 +185,7 @@ BOOL WINAPI IsCharAlphaA(CHAR x)
} }
/*********************************************************************** /***********************************************************************
* IsCharAlphaNumericA (USER32.332) * IsCharAlphaNumericA (USER.434) (USER32.332)
* FIXME: handle current locale * FIXME: handle current locale
*/ */
BOOL WINAPI IsCharAlphaNumericA(CHAR x) BOOL WINAPI IsCharAlphaNumericA(CHAR x)
@ -425,7 +212,7 @@ BOOL WINAPI IsCharAlphaW(WCHAR x)
} }
/*********************************************************************** /***********************************************************************
* IsCharLowerA (USER32.335) * IsCharLowerA (USER.436) (USER32.335)
* FIXME: handle current locale * FIXME: handle current locale
*/ */
BOOL WINAPI IsCharLowerA(CHAR x) BOOL WINAPI IsCharLowerA(CHAR x)
@ -443,7 +230,7 @@ BOOL WINAPI IsCharLowerW(WCHAR x)
} }
/*********************************************************************** /***********************************************************************
* IsCharUpperA (USER32.337) * IsCharUpperA (USER.435) (USER32.337)
* FIXME: handle current locale * FIXME: handle current locale
*/ */
BOOL WINAPI IsCharUpperA(CHAR x) BOOL WINAPI IsCharUpperA(CHAR x)

View File

@ -543,14 +543,6 @@ end_MAIN_GetLanguageID:
} }
/***********************************************************************
* called_at_exit
*/
static void called_at_exit(void)
{
CONSOLE_Close();
}
/*********************************************************************** /***********************************************************************
* MAIN_WineInit * MAIN_WineInit
* *
@ -558,8 +550,6 @@ static void called_at_exit(void)
*/ */
void MAIN_WineInit(void) void MAIN_WineInit(void)
{ {
struct timeval tv;
#ifdef MALLOC_DEBUGGING #ifdef MALLOC_DEBUGGING
char *trace; char *trace;
@ -577,10 +567,7 @@ void MAIN_WineInit(void)
setbuf(stdout,NULL); setbuf(stdout,NULL);
setbuf(stderr,NULL); setbuf(stderr,NULL);
setlocale(LC_CTYPE,""); setlocale(LC_CTYPE,"");
gettimeofday( &tv, NULL);
atexit(called_at_exit);
} }
/*********************************************************************** /***********************************************************************

View File

@ -208,16 +208,7 @@ SNOOP_PrintArg(DWORD x) {
static char buf[200]; static char buf[200];
int i,nostring; int i,nostring;
char * volatile ret=0; char * volatile ret=0;
MEMORY_BASIC_INFORMATION mbi;
if ( !HIWORD(x) ||
!VirtualQuery((LPVOID)x,&mbi,sizeof(mbi)) ||
!mbi.Type ||
(mbi.Protect == PAGE_NOACCESS)
) {
sprintf(buf,"%08lx",x);
return buf;
}
__TRY{ __TRY{
LPBYTE s=(LPBYTE)x; LPBYTE s=(LPBYTE)x;
i=0;nostring=0; i=0;nostring=0;

View File

@ -22,7 +22,6 @@
* *
*/ */
#include <assert.h>
#include <stdio.h> #include <stdio.h>
#include "windef.h" #include "windef.h"
#include "winerror.h" #include "winerror.h"
@ -205,60 +204,3 @@ void WINAPI FatalAppExitW( UINT action, LPCWSTR str )
Callout.MessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK ); Callout.MessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
ExitProcess(0); ExitProcess(0);
} }
/*************************************************************
* WINE_exception_handler
*
* Exception handler for exception blocks declared in Wine code.
*/
DWORD WINE_exception_handler( EXCEPTION_RECORD *record, EXCEPTION_FRAME *frame,
CONTEXT *context, LPVOID pdispatcher )
{
__WINE_FRAME *wine_frame = (__WINE_FRAME *)frame;
if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND | EH_NESTED_CALL))
return ExceptionContinueSearch;
if (wine_frame->u.filter)
{
EXCEPTION_POINTERS ptrs;
ptrs.ExceptionRecord = record;
ptrs.ContextRecord = context;
switch(wine_frame->u.filter( &ptrs ))
{
case EXCEPTION_CONTINUE_SEARCH:
return ExceptionContinueSearch;
case EXCEPTION_CONTINUE_EXECUTION:
return ExceptionContinueExecution;
case EXCEPTION_EXECUTE_HANDLER:
break;
default:
MESSAGE( "Invalid return value from exception filter\n" );
assert( FALSE );
}
}
/* hack to make GetExceptionCode() work in handler */
wine_frame->ExceptionCode = record->ExceptionCode;
wine_frame->ExceptionRecord = wine_frame;
RtlUnwind( frame, 0, record, 0 );
EXC_pop_frame( frame );
longjmp( wine_frame->jmp, 1 );
}
/*************************************************************
* WINE_finally_handler
*
* Exception handler for try/finally blocks declared in Wine code.
*/
DWORD WINE_finally_handler( EXCEPTION_RECORD *record, EXCEPTION_FRAME *frame,
CONTEXT *context, LPVOID pdispatcher )
{
__WINE_FRAME *wine_frame = (__WINE_FRAME *)frame;
if (!(record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))
return ExceptionContinueSearch;
wine_frame->u.finally_func( FALSE );
return ExceptionContinueSearch;
}