ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Make use of the DEFAULT_DEBUG_CHANNEL where appropriate. 

Use the default version of FIXME, ERR, WARN, TRACE for the default
channel.
This commit is contained in:
Dimitrie O. Paun 1999-12-08 03:56:23 +00:00 committed by Alexandre Julliard
parent 0106f85e5f
commit dd03cc19fd
45 changed files with 1288 additions and 1339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
controls/edit.c
View File

@ -25,8 +25,8 @@
#include "tweak.h"
#include "winversion.h"
DEFAULT_DEBUG_CHANNEL(edit)
DECLARE_DEBUG_CHANNEL(combo)
DECLARE_DEBUG_CHANNEL(edit)
DECLARE_DEBUG_CHANNEL(relay)
#define BUFLIMIT_MULTI 65534 /* maximum buffer size (not including '\0')
@ -118,7 +118,7 @@ typedef struct
#define ORDER_UINT(x,y) do { if ((UINT)(y) < (UINT)(x)) SWAP_UINT32((x),(y)); } while(0)
#define DPRINTF_EDIT_NOTIFY(hwnd, str) \
do {TRACE_(edit)("notification " str " sent to hwnd=%08x\n", \
do {TRACE("notification " str " sent to hwnd=%08x\n", \
(UINT)(hwnd));} while(0)
/* used for disabled or read-only edit control */
@ -134,11 +134,11 @@ typedef struct
MAKEWPARAM((wnd)->wIDmenu, wNotifyCode), \
(LPARAM)(wnd)->hwndSelf);} while(0)
#define DPRINTF_EDIT_MSG16(str) \
TRACE_(edit)(\
TRACE(\
"16 bit : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
(UINT)hwnd, (UINT)wParam, (UINT)lParam)
#define DPRINTF_EDIT_MSG32(str) \
TRACE_(edit)(\
TRACE(\
"32 bit : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
(UINT)hwnd, (UINT)wParam, (UINT)lParam)
@ -1194,7 +1194,7 @@ static LPSTR EDIT_GetPasswordPointer_SL(WND *wnd, EDITSTATE *es)
static void EDIT_LockBuffer(WND *wnd, EDITSTATE *es)
{
if (!es) {
ERR_(edit)("no EDITSTATE ... please report\n");
ERR("no EDITSTATE ... please report\n");
return;
}
if (!(es->style & ES_MULTILINE))
@ -1205,7 +1205,7 @@ static void EDIT_LockBuffer(WND *wnd, EDITSTATE *es)
else if (es->hloc16)
es->text = LOCAL_Lock(wnd->hInstance, es->hloc16);
else {
ERR_(edit)("no buffer ... please report\n");
ERR("no buffer ... please report\n");
return;
}
}
@ -1344,7 +1344,7 @@ static BOOL EDIT_MakeFit(WND *wnd, EDITSTATE *es, INT size)
if (size > es->buffer_limit)
size = es->buffer_limit;
TRACE_(edit)("trying to ReAlloc to %d+1\n", size);
TRACE("trying to ReAlloc to %d+1\n", size);
EDIT_UnlockBuffer(wnd, es, TRUE);
if (es->text) {
@ -1354,25 +1354,25 @@ static BOOL EDIT_MakeFit(WND *wnd, EDITSTATE *es, INT size)
es->buffer_size = 0;
} else if (es->hloc32) {
if ((hNew32 = LocalReAlloc(es->hloc32, size + 1, 0))) {
TRACE_(edit)("Old 32 bit handle %08x, new handle %08x\n", es->hloc32, hNew32);
TRACE("Old 32 bit handle %08x, new handle %08x\n", es->hloc32, hNew32);
es->hloc32 = hNew32;
es->buffer_size = MIN(LocalSize(es->hloc32) - 1, es->buffer_limit);
}
} else if (es->hloc16) {
if ((hNew16 = LOCAL_ReAlloc(wnd->hInstance, es->hloc16, size + 1, LMEM_MOVEABLE))) {
TRACE_(edit)("Old 16 bit handle %08x, new handle %08x\n", es->hloc16, hNew16);
TRACE("Old 16 bit handle %08x, new handle %08x\n", es->hloc16, hNew16);
es->hloc16 = hNew16;
es->buffer_size = MIN(LOCAL_Size(wnd->hInstance, es->hloc16) - 1, es->buffer_limit);
}
}
if (es->buffer_size < size) {
EDIT_LockBuffer(wnd, es);
WARN_(edit)("FAILED ! We now have %d+1\n", es->buffer_size);
WARN("FAILED ! We now have %d+1\n", es->buffer_size);
EDIT_NOTIFY_PARENT(wnd, EN_ERRSPACE, "EN_ERRSPACE");
return FALSE;
} else {
EDIT_LockBuffer(wnd, es);
TRACE_(edit)("We now have %d+1\n", es->buffer_size);
TRACE("We now have %d+1\n", es->buffer_size);
return TRUE;
}
}
@ -1391,12 +1391,12 @@ static BOOL EDIT_MakeUndoFit(WND *wnd, EDITSTATE *es, INT size)
return TRUE;
size = ((size / GROWLENGTH) + 1) * GROWLENGTH;
TRACE_(edit)("trying to ReAlloc to %d+1\n", size);
TRACE("trying to ReAlloc to %d+1\n", size);
if ((es->undo_text = HeapReAlloc(es->heap, 0, es->undo_text, size + 1))) {
es->undo_buffer_size = HeapSize(es->heap, 0, es->undo_text) - 1;
if (es->undo_buffer_size < size) {
WARN_(edit)("FAILED ! We now have %d+1\n", es->undo_buffer_size);
WARN("FAILED ! We now have %d+1\n", es->undo_buffer_size);
return FALSE;
}
return TRUE;
@ -1686,7 +1686,7 @@ static void EDIT_PaintLine(WND *wnd, EDITSTATE *es, HDC dc, INT line, BOOL rev)
} else if (line)
return;
TRACE_(edit)("line=%d\n", line);
TRACE("line=%d\n", line);
pos = EDIT_EM_PosFromChar(wnd, es, EDIT_EM_LineIndex(wnd, es, line), FALSE);
x = SLOWORD(pos);
@ -1815,17 +1815,17 @@ static void EDIT_SetRectNP(WND *wnd, EDITSTATE *es, LPRECT rc)
static void EDIT_UnlockBuffer(WND *wnd, EDITSTATE *es, BOOL force)
{
if (!es) {
ERR_(edit)("no EDITSTATE ... please report\n");
ERR("no EDITSTATE ... please report\n");
return;
}
if (!(es->style & ES_MULTILINE))
return;
if (!es->lock_count) {
ERR_(edit)("lock_count == 0 ... please report\n");
ERR("lock_count == 0 ... please report\n");
return;
}
if (!es->text) {
ERR_(edit)("es->text == 0 ... please report\n");
ERR("es->text == 0 ... please report\n");
return;
}
if (force || (es->lock_count == 1)) {
@ -1856,7 +1856,7 @@ static INT EDIT_WordBreakProc(LPSTR s, INT index, INT count, INT action)
{
INT ret = 0;
TRACE_(edit)("s=%p, index=%u, count=%u, action=%d\n",
TRACE("s=%p, index=%u, count=%u, action=%d\n",
s, index, count, action);
switch (action) {
@ -1900,7 +1900,7 @@ static INT EDIT_WordBreakProc(LPSTR s, INT index, INT count, INT action)
ret = (s[index] == ' ');
break;
default:
ERR_(edit)("unknown action code, please report !\n");
ERR("unknown action code, please report !\n");
break;
}
return ret;
@ -1946,7 +1946,7 @@ static BOOL EDIT_EM_FmtLines(WND *wnd, EDITSTATE *es, BOOL add_eol)
es->flags &= ~EF_USE_SOFTBRK;
if (add_eol) {
es->flags |= EF_USE_SOFTBRK;
FIXME_(edit)("soft break enabled, not implemented\n");
FIXME("soft break enabled, not implemented\n");
}
return add_eol;
}
@ -1983,12 +1983,12 @@ static HLOCAL EDIT_EM_GetHandle(WND *wnd, EDITSTATE *es)
return (HLOCAL)es->hloc16;
if (!(newBuf = LocalAlloc(LMEM_MOVEABLE, lstrlenA(es->text) + 1))) {
ERR_(edit)("could not allocate new 32 bit buffer\n");
ERR("could not allocate new 32 bit buffer\n");
return 0;
}
newSize = MIN(LocalSize(newBuf) - 1, es->buffer_limit);
if (!(newText = LocalLock(newBuf))) {
ERR_(edit)("could not lock new 32 bit buffer\n");
ERR("could not lock new 32 bit buffer\n");
LocalFree(newBuf);
return 0;
}
@ -2001,7 +2001,7 @@ static HLOCAL EDIT_EM_GetHandle(WND *wnd, EDITSTATE *es)
es->buffer_size = newSize;
es->text = newText;
EDIT_LockBuffer(wnd, es);
TRACE_(edit)("switched to 32 bit local heap\n");
TRACE("switched to 32 bit local heap\n");
return es->hloc32;
}
@ -2037,18 +2037,18 @@ static HLOCAL16 EDIT_EM_GetHandle16(WND *wnd, EDITSTATE *es)
if (!LOCAL_HeapSize(wnd->hInstance)) {
if (!LocalInit16(wnd->hInstance, 0,
GlobalSize16(wnd->hInstance))) {
ERR_(edit)("could not initialize local heap\n");
ERR("could not initialize local heap\n");
return 0;
}
TRACE_(edit)("local heap initialized\n");
TRACE("local heap initialized\n");
}
if (!(newBuf = LOCAL_Alloc(wnd->hInstance, LMEM_MOVEABLE, lstrlenA(es->text) + 1))) {
ERR_(edit)("could not allocate new 16 bit buffer\n");
ERR("could not allocate new 16 bit buffer\n");
return 0;
}
newSize = MIN(LOCAL_Size(wnd->hInstance, newBuf) - 1, es->buffer_limit);
if (!(newText = LOCAL_Lock(wnd->hInstance, newBuf))) {
ERR_(edit)("could not lock new 16 bit buffer\n");
ERR("could not lock new 16 bit buffer\n");
LOCAL_Free(wnd->hInstance, newBuf);
return 0;
}
@ -2065,7 +2065,7 @@ static HLOCAL16 EDIT_EM_GetHandle16(WND *wnd, EDITSTATE *es)
es->buffer_size = newSize;
es->text = newText;
EDIT_LockBuffer(wnd, es);
TRACE_(edit)("switched to 16 bit buffer\n");
TRACE("switched to 16 bit buffer\n");
return es->hloc16;
}
@ -2567,7 +2567,7 @@ static void EDIT_EM_SetHandle(WND *wnd, EDITSTATE *es, HLOCAL hloc)
return;
if (!hloc) {
WARN_(edit)("called with NULL handle\n");
WARN("called with NULL handle\n");
return;
}
@ -2610,7 +2610,7 @@ static void EDIT_EM_SetHandle16(WND *wnd, EDITSTATE *es, HLOCAL16 hloc)
return;
if (!hloc) {
WARN_(edit)("called with NULL handle\n");
WARN("called with NULL handle\n");
return;
}
@ -2689,7 +2689,7 @@ static void EDIT_EM_SetMargins(WND *wnd, EDITSTATE *es, INT action,
else
es->right_margin = es->char_width / 3;
}
TRACE_(edit)("left=%d, right=%d\n", es->left_margin, es->right_margin);
TRACE("left=%d, right=%d\n", es->left_margin, es->right_margin);
}
@ -2873,7 +2873,7 @@ static BOOL EDIT_EM_Undo(WND *wnd, EDITSTATE *es)
lstrcpyA(utext, es->undo_text);
TRACE_(edit)("before UNDO:insertion length = %d, deletion buffer = %s\n",
TRACE("before UNDO:insertion length = %d, deletion buffer = %s\n",
es->undo_insert_count, utext);
EDIT_EM_SetSel(wnd, es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
@ -2882,7 +2882,7 @@ static BOOL EDIT_EM_Undo(WND *wnd, EDITSTATE *es)
EDIT_EM_SetSel(wnd, es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
HeapFree(es->heap, 0, utext);
TRACE_(edit)("after UNDO:insertion length = %d, deletion buffer = %s\n",
TRACE("after UNDO:insertion length = %d, deletion buffer = %s\n",
es->undo_insert_count, es->undo_text);
return TRUE;
@ -2970,7 +2970,7 @@ static void EDIT_WM_Command(WND *wnd, EDITSTATE *es, INT code, INT id, HWND cont
EDIT_EM_ScrollCaret(wnd, es);
break;
default:
ERR_(edit)("unknown menu item, please report\n");
ERR("unknown menu item, please report\n");
break;
}
}
@ -3162,9 +3162,9 @@ static LRESULT EDIT_HScroll_Hack(WND *wnd, EDITSTATE *es, INT action, INT pos, H
LRESULT ret = 0;
if (!(es->flags & EF_HSCROLL_HACK)) {
ERR_(edit)("hacked WM_HSCROLL handler invoked\n");
ERR_(edit)(" if you are _not_ running 16 bit notepad, please report\n");
ERR_(edit)(" (this message is only displayed once per edit control)\n");
ERR("hacked WM_HSCROLL handler invoked\n");
ERR(" if you are _not_ running 16 bit notepad, please report\n");
ERR(" (this message is only displayed once per edit control)\n");
es->flags |= EF_HSCROLL_HACK;
}
@ -3219,7 +3219,7 @@ static LRESULT EDIT_HScroll_Hack(WND *wnd, EDITSTATE *es, INT action, INT pos, H
break;
default:
ERR_(edit)("undocumented (hacked) WM_HSCROLL parameter, please report\n");
ERR("undocumented (hacked) WM_HSCROLL parameter, please report\n");
return 0;
}
if (dx)
@ -3289,7 +3289,7 @@ static LRESULT EDIT_WM_HScroll(WND *wnd, EDITSTATE *es, INT action, INT pos, HWN
break;
default:
ERR_(edit)("undocumented WM_HSCROLL parameter, please report\n");
ERR("undocumented WM_HSCROLL parameter, please report\n");
return 0;
}
if (dx)
@ -3872,10 +3872,10 @@ static void EDIT_WM_SetText(WND *wnd, EDITSTATE *es, LPCSTR text)
{
EDIT_EM_SetSel(wnd, es, 0, -1, FALSE);
if (text) {
TRACE_(edit)("\t'%s'\n", text);
TRACE("\t'%s'\n", text);
EDIT_EM_ReplaceSel(wnd, es, FALSE, text);
} else {
TRACE_(edit)("\t<NULL>\n");
TRACE("\t<NULL>\n");
EDIT_EM_ReplaceSel(wnd, es, FALSE, "");
}
es->x_offset = 0;
@ -3961,9 +3961,9 @@ static LRESULT EDIT_VScroll_Hack(WND *wnd, EDITSTATE *es, INT action, INT pos, H
LRESULT ret = 0;
if (!(es->flags & EF_VSCROLL_HACK)) {
ERR_(edit)("hacked WM_VSCROLL handler invoked\n");
ERR_(edit)(" if you are _not_ running 16 bit notepad, please report\n");
ERR_(edit)(" (this message is only displayed once per edit control)\n");
ERR("hacked WM_VSCROLL handler invoked\n");
ERR(" if you are _not_ running 16 bit notepad, please report\n");
ERR(" (this message is only displayed once per edit control)\n");
es->flags |= EF_VSCROLL_HACK;
}
@ -4006,7 +4006,7 @@ static LRESULT EDIT_VScroll_Hack(WND *wnd, EDITSTATE *es, INT action, INT pos, H
break;
default:
ERR_(edit)("undocumented (hacked) WM_VSCROLL parameter, please report\n");
ERR("undocumented (hacked) WM_VSCROLL parameter, please report\n");
return 0;
}
if (dy)
@ -4063,8 +4063,8 @@ static LRESULT EDIT_WM_VScroll(WND *wnd, EDITSTATE *es, INT action, INT pos, HWN
break;
default:
ERR_(edit)("undocumented WM_VSCROLL action %d, please report\n",
action);
ERR("undocumented WM_VSCROLL action %d, please report\n",
action);
return 0;
}
if (dy)

5
dlls/advapi32/crypt.c
View File

@ -26,7 +26,7 @@ BOOL WINAPI
CryptAcquireContextA( HCRYPTPROV *phProv, LPCSTR pszContainer,
LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
{
FIXME_(advapi)("(%p, %s, %s, %ld, %08lx): stub!\n", phProv, pszContainer,
FIXME("(%p, %s, %s, %ld, %08lx): stub!\n", phProv, pszContainer,
pszProvider, dwProvType, dwFlags);
return FALSE;
}
@ -37,8 +37,7 @@ CryptAcquireContextA( HCRYPTPROV *phProv, LPCSTR pszContainer,
BOOL WINAPI
CryptSetKeyParam( HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
{
FIXME_(advapi)("(%lx, %lx, %p, %lx): stub!\n",
hKey, dwParam, pbData, dwFlags);
FIXME("(%lx, %lx, %p, %lx): stub!\n", hKey, dwParam, pbData, dwFlags);
return FALSE;
}

41
dlls/advapi32/security.c
View File

@ -11,7 +11,7 @@
#include "ntsecapi.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(advapi)
DEFAULT_DEBUG_CHANNEL(advapi)
DECLARE_DEBUG_CHANNEL(security)
@ -499,7 +499,7 @@ BOOL WINAPI
MakeSelfRelativeSD( PSECURITY_DESCRIPTOR lpabssecdesc,
PSECURITY_DESCRIPTOR lpselfsecdesc, LPDWORD lpbuflen )
{
FIXME_(advapi)("(%p,%p,%p),stub!\n",lpabssecdesc,lpselfsecdesc,lpbuflen);
FIXME("(%p,%p,%p),stub!\n",lpabssecdesc,lpselfsecdesc,lpbuflen);
return TRUE;
}
@ -509,7 +509,7 @@ MakeSelfRelativeSD( PSECURITY_DESCRIPTOR lpabssecdesc,
BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision)
{ FIXME_(advapi)("(%p,%p,%p),stub!\n",pSecurityDescriptor,pControl,lpdwRevision);
{ FIXME("(%p,%p,%p),stub!\n",pSecurityDescriptor,pControl,lpdwRevision);
return 1;
}
@ -535,8 +535,8 @@ BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR pSecurityDescri
BOOL WINAPI
LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, LPVOID lpLuid )
{
FIXME_(advapi)("(%s,%s,%p): stub\n",debugstr_w(lpSystemName),
debugstr_w(lpName), lpLuid);
FIXME("(%s,%s,%p): stub\n",debugstr_w(lpSystemName),
debugstr_w(lpName), lpLuid);
return TRUE;
}
@ -567,7 +567,7 @@ GetFileSecurityA( LPCSTR lpFileName,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD nLength, LPDWORD lpnLengthNeeded )
{
FIXME_(advapi)("(%s) : stub\n", debugstr_a(lpFileName));
FIXME("(%s) : stub\n", debugstr_a(lpFileName));
return TRUE;
}
@ -591,7 +591,7 @@ GetFileSecurityW( LPCWSTR lpFileName,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD nLength, LPDWORD lpnLengthNeeded )
{
FIXME_(advapi)("(%s) : stub\n", debugstr_w(lpFileName) );
FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
return TRUE;
}
@ -641,7 +641,7 @@ BOOL WINAPI SetFileSecurityA( LPCSTR lpFileName,
SECURITY_INFORMATION RequestedInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor)
{
FIXME_(advapi)("(%s) : stub\n", debugstr_a(lpFileName));
FIXME("(%s) : stub\n", debugstr_a(lpFileName));
return TRUE;
}
@ -659,7 +659,7 @@ SetFileSecurityW( LPCWSTR lpFileName,
SECURITY_INFORMATION RequestedInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor )
{
FIXME_(advapi)("(%s) : stub\n", debugstr_w(lpFileName) );
FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
return TRUE;
}
@ -672,7 +672,7 @@ SetFileSecurityW( LPCWSTR lpFileName,
BOOL WINAPI
QueryWindows31FilesMigration( DWORD x1 )
{
FIXME_(advapi)("(%ld):stub\n",x1);
FIXME("(%ld):stub\n",x1);
return TRUE;
}
@ -689,7 +689,7 @@ BOOL WINAPI
SynchronizeWindows31FilesAndWindowsNTRegistry( DWORD x1, DWORD x2, DWORD x3,
DWORD x4 )
{
FIXME_(advapi)("(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub\n",x1,x2,x3,x4);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub\n",x1,x2,x3,x4);
return TRUE;
}
@ -708,9 +708,8 @@ LsaOpenPolicy(PLSA_UNICODE_STRING SystemName,
ACCESS_MASK DesiredAccess,
PLSA_HANDLE PolicyHandle)
{
FIXME_(advapi)("(%p,%p,0x%08lx,%p):stub\n",
SystemName, ObjectAttributes,
DesiredAccess, PolicyHandle);
FIXME("(%p,%p,0x%08lx,%p):stub\n",
SystemName, ObjectAttributes, DesiredAccess, PolicyHandle);
return 0xc0000000; /* generic error */
}
@ -723,7 +722,7 @@ LsaOpenPolicy(PLSA_UNICODE_STRING SystemName,
BOOL WINAPI
NotifyBootConfigStatus( DWORD x1 )
{
FIXME_(advapi)("(0x%08lx):stub\n",x1);
FIXME("(0x%08lx):stub\n",x1);
return 1;
}
@ -736,7 +735,7 @@ NotifyBootConfigStatus( DWORD x1 )
BOOL WINAPI
RevertToSelf( void )
{
FIXME_(advapi)("(), stub\n");
FIXME("(), stub\n");
return TRUE;
}
@ -746,7 +745,7 @@ RevertToSelf( void )
BOOL WINAPI
ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
{
FIXME_(advapi)("(%08x), stub\n", ImpersonationLevel);
FIXME("(%08x), stub\n", ImpersonationLevel);
return TRUE;
}
@ -758,9 +757,9 @@ AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken,
DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet,
LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus)
{
FIXME_(advapi)("(%p, %04x, %08lx, %p, %p, %p, %p, %p), stub\n",
pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping,
PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus);
FIXME("(%p, %04x, %08lx, %p, %p, %p, %p, %p), stub\n",
pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping,
PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus);
*AccessStatus = TRUE;
return TRUE;
}
@ -777,7 +776,7 @@ AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken,
BOOL WINAPI SetThreadToken(PHANDLE thread, HANDLE token)
{
FIXME_(advapi)("(%p, %x): stub\n", thread, token);
FIXME("(%p, %x): stub\n", thread, token);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

64
dlls/avifil32/avifile.c
View File

@ -14,7 +14,7 @@
#include "debugstr.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(avifile)
DEFAULT_DEBUG_CHANNEL(avifile)
DECLARE_DEBUG_CHANNEL(msvideo)
DECLARE_DEBUG_CHANNEL(relay)
@ -104,7 +104,7 @@ typedef struct IAVIStreamImpl {
void WINAPI
AVIFileInit(void) {
FIXME_(avifile)("(),stub!\n");
FIXME("(),stub!\n");
}
typedef struct IAVIFileImpl {
@ -148,14 +148,14 @@ static ULONG WINAPI IAVIFile_fnRelease(IAVIFile* iface) {
}
static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size) {
FIXME_(avifile)("(%p)->Info(%p,%ld)\n",iface,afi,size);
FIXME("(%p)->Info(%p,%ld)\n",iface,afi,size);
/* FIXME: fill out struct? */
return E_FAIL;
}
static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam) {
FIXME_(avifile)("(%p)->GetStream(%p,0x%08lx,%ld)\n",iface,avis,fccType,lParam);
FIXME("(%p)->GetStream(%p,0x%08lx,%ld)\n",iface,avis,fccType,lParam);
/* FIXME: create interface etc. */
return E_FAIL;
}
@ -165,18 +165,18 @@ static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVI
char fcc[5];
IAVIStreamImpl *istream;
FIXME_(avifile)("(%p,%p,%p)\n",This,avis,asi);
FIXME("(%p,%p,%p)\n",This,avis,asi);
istream = (IAVIStreamImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IAVIStreamImpl));
istream->ref = 1;
ICOM_VTBL(istream) = &iavist;
fcc[4]='\0';
memcpy(fcc,(char*)&(asi->fccType),4);
FIXME_(avifile)("\tfccType '%s'\n",fcc);
FIXME("\tfccType '%s'\n",fcc);
memcpy(fcc,(char*)&(asi->fccHandler),4);
FIXME_(avifile)("\tfccHandler '%s'\n",fcc);
FIXME_(avifile)("\tdwFlags 0x%08lx\n",asi->dwFlags);
FIXME_(avifile)("\tdwCaps 0x%08lx\n",asi->dwCaps);
FIXME_(avifile)("\tname '%s'\n",debugstr_w(asi->szName));
FIXME("\tfccHandler '%s'\n",fcc);
FIXME("\tdwFlags 0x%08lx\n",asi->dwFlags);
FIXME("\tdwCaps 0x%08lx\n",asi->dwCaps);
FIXME("\tname '%s'\n",debugstr_w(asi->szName));
istream->curframe = 0;
*avis = (PAVISTREAM)istream;
@ -184,25 +184,25 @@ static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVI
}
static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size) {
FIXME_(avifile)("(%p)->WriteData(0x%08lx,%p,%ld)\n",iface,ckid,lpData,size);
FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",iface,ckid,lpData,size);
/* FIXME: write data to file */
return E_FAIL;
}
static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size) {
FIXME_(avifile)("(%p)->ReadData(0x%08lx,%p,%p)\n",iface,ckid,lpData,size);
FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",iface,ckid,lpData,size);
/* FIXME: read at most size bytes from file */
return E_FAIL;
}
static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface) {
FIXME_(avifile)("(%p)->EndRecord()\n",iface);
FIXME("(%p)->EndRecord()\n",iface);
/* FIXME: end record? */
return E_FAIL;
}
static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam) {
FIXME_(avifile)("(%p)->DeleteStream(0x%08lx,%ld)\n",iface,fccType,lParam);
FIXME("(%p)->DeleteStream(0x%08lx,%ld)\n",iface,fccType,lParam);
/* FIXME: delete stream? */
return E_FAIL;
}
@ -219,7 +219,7 @@ HRESULT WINAPI AVIFileOpenA(
else
sprintf(buf,"<clsid-0x%04lx>",(DWORD)lpHandler);
FIXME_(avifile)("(%p,%s,0x%08lx,%s),stub!\n",ppfile,szFile,(DWORD)uMode,buf);
FIXME("(%p,%s,0x%08lx,%s),stub!\n",ppfile,szFile,(DWORD)uMode,buf);
iavi = (IAVIFileImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IAVIFileImpl));
iavi->ref = 1;
ICOM_VTBL(iavi) = &iavift;
@ -262,22 +262,22 @@ static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface) {
}
static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2) {
FIXME_(avifile)("(%p)->Create(0x%08lx,0x%08lx)\n",iface,lParam1,lParam2);
FIXME("(%p)->Create(0x%08lx,0x%08lx)\n",iface,lParam1,lParam2);
return E_FAIL;
}
static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size) {
FIXME_(avifile)("(%p)->Info(%p,%ld)\n",iface,psi,size);
FIXME("(%p)->Info(%p,%ld)\n",iface,psi,size);
return E_FAIL;
}
static LONG WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags) {
FIXME_(avifile)("(%p)->FindSample(%ld,0x%08lx)\n",iface,pos,flags);
FIXME("(%p)->FindSample(%ld,0x%08lx)\n",iface,pos,flags);
return E_FAIL;
}
static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize) {
FIXME_(avifile)("(%p)->ReadFormat(%ld,%p,%p)\n",iface,pos,format,formatsize);
FIXME("(%p)->ReadFormat(%ld,%p,%p)\n",iface,pos,format,formatsize);
return E_FAIL;
}
@ -287,7 +287,7 @@ static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID f
static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize) {
IAVIStreamImpl *as = (IAVIStreamImpl*)iface;
FIXME_(avifile)("(%p)->SetFormat(%ld,%p,%ld)\n",iface,pos,format,formatsize);
FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",iface,pos,format,formatsize);
if (as->lpInputFormat) HeapFree(GetProcessHeap(),0,as->lpInputFormat);
as->inputformatsize = formatsize;
as->lpInputFormat = HeapAlloc(GetProcessHeap(),0,formatsize);
@ -319,7 +319,7 @@ static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID fo
}
static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread) {
FIXME_(avifile)("(%p)->Read(%ld,%ld,%p,%ld,%p,%p)\n",iface,start,samples,buffer,buffersize,bytesread,samplesread);
FIXME("(%p)->Read(%ld,%ld,%p,%ld,%p,%p)\n",iface,start,samples,buffer,buffersize,bytesread,samplesread);
return E_FAIL;
}
@ -327,7 +327,7 @@ static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG sample
IAVIStreamImpl *as = (IAVIStreamImpl*)iface;
DWORD ckid,xflags;
FIXME_(avifile)("(%p)->Write(%ld,%ld,%p,%ld,0x%08lx,%p,%p)\n",iface,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
FIXME("(%p)->Write(%ld,%ld,%p,%ld,0x%08lx,%p,%p)\n",iface,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
ICCompress(
as->hic,flags,
@ -353,21 +353,21 @@ static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG sample
}
static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples) {
FIXME_(avifile)("(%p)->Delete(%ld,%ld)\n",iface,start,samples);
FIXME("(%p)->Delete(%ld,%ld)\n",iface,start,samples);
return E_FAIL;
}
static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread) {
FIXME_(avifile)("(%p)->ReadData(0x%08lx,%p,%p)\n",iface,fcc,lp,lpread);
FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",iface,fcc,lp,lpread);
return E_FAIL;
}
static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size) {
FIXME_(avifile)("(%p)->WriteData(0x%08lx,%p,%ld)\n",iface,fcc,lp,size);
FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",iface,fcc,lp,size);
return E_FAIL;
}
static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen) {
FIXME_(avifile)("(%p)->SetInfo(%p,%ld)\n",iface,info,infolen);
FIXME("(%p)->SetInfo(%p,%ld)\n",iface,info,infolen);
return E_FAIL;
}
@ -426,13 +426,13 @@ HRESULT WINAPI AVIFileInfoW(PAVIFILE iface,LPAVIFILEINFOW afi,LONG size) {
HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *aco,CLSID *pclsidHandler) {
char fcc[5];
IAVIStreamImpl *as;
FIXME_(avifile)("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
fcc[4]='\0';
memcpy(fcc,&(aco->fccType),4);
FIXME_(avifile)("\tfccType: '%s'\n",fcc);
FIXME("\tfccType: '%s'\n",fcc);
memcpy(fcc,&(aco->fccHandler),4);
FIXME_(avifile)("\tfccHandler: '%s'\n",fcc);
FIXME_(avifile)("\tdwFlags: 0x%08lx\n",aco->dwFlags);
FIXME("\tfccHandler: '%s'\n",fcc);
FIXME("\tdwFlags: 0x%08lx\n",aco->dwFlags);
/* we just create a duplicate for now */
IAVIStream_AddRef(ppsSource);
@ -447,7 +447,7 @@ HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsS
return AVIERR_UNSUPPORTED;
ICGetInfo(as->hic,&(as->icinfo),sizeof(ICINFO));
FIXME_(avifile)("Opened compressor: '%s' '%s'\n",debugstr_w(as->icinfo.szName),debugstr_w(as->icinfo.szDescription));
FIXME("Opened compressor: '%s' '%s'\n",debugstr_w(as->icinfo.szName),debugstr_w(as->icinfo.szDescription));
as->iscompressing = TRUE;
memcpy(&(as->aco),aco,sizeof(*aco));
if (as->icinfo.dwFlags & VIDCF_COMPRESSFRAMES) {
@ -530,5 +530,5 @@ ULONG WINAPI AVIFileRelease(PAVIFILE iface) {
}
void WINAPI AVIFileExit(void) {
FIXME_(avifile)("(), stub.\n");
FIXME("(), stub.\n");
}

10
dlls/comctl32/comctl32undoc.c
View File

@ -2221,7 +2221,7 @@ INT WINAPI COMCTL32_StrSpnW( LPWSTR lpStr, LPWSTR lpSet) {
BOOL WINAPI comctl32_410( HWND hw, DWORD b, DWORD c, DWORD d) {
FIXME_(commctrl)("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
return TRUE;
}
@ -2235,7 +2235,7 @@ BOOL WINAPI comctl32_410( HWND hw, DWORD b, DWORD c, DWORD d) {
BOOL WINAPI comctl32_411( HWND hw, DWORD b, DWORD c) {
FIXME_(commctrl)("(%x, %lx, %lx): stub!\n", hw, b, c);
FIXME("(%x, %lx, %lx): stub!\n", hw, b, c);
return TRUE;
}
@ -2249,7 +2249,7 @@ BOOL WINAPI comctl32_411( HWND hw, DWORD b, DWORD c) {
BOOL WINAPI comctl32_412( HWND hwnd, DWORD b, DWORD c)
{
FIXME_(commctrl)("(%x, %lx, %lx): stub!\n", hwnd, b, c);
FIXME("(%x, %lx, %lx): stub!\n", hwnd, b, c);
if (IsWindow (hwnd) == FALSE)
return FALSE;
@ -2270,7 +2270,7 @@ BOOL WINAPI comctl32_412( HWND hwnd, DWORD b, DWORD c)
BOOL WINAPI comctl32_413( HWND hw, DWORD b, DWORD c, DWORD d) {
FIXME_(commctrl)("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
return TRUE;
}
@ -2284,7 +2284,7 @@ BOOL WINAPI comctl32_413( HWND hw, DWORD b, DWORD c, DWORD d) {
BOOL WINAPI InitMUILanguage( LANGID uiLang) {
FIXME_(commctrl)("(%04x): stub!\n", uiLang);
FIXME("(%04x): stub!\n", uiLang);
return TRUE;
}

30
dlls/comctl32/flatsb.c
View File

@ -20,7 +20,7 @@
#include "flatsb.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(commctrl)
DEFAULT_DEBUG_CHANNEL(commctrl)
#define FlatSB_GetInfoPtr(hwnd) ((FLATSB_INFO*)GetWindowLongA (hwnd, 0))
@ -29,42 +29,42 @@ DECLARE_DEBUG_CHANNEL(commctrl)
BOOL WINAPI
FlatSB_EnableScrollBar(HWND hwnd, INT dummy, UINT dummy2)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
BOOL WINAPI
FlatSB_ShowScrollBar(HWND hwnd, INT code, BOOL flag)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
BOOL WINAPI
FlatSB_GetScrollRange(HWND hwnd, INT code, LPINT min, LPINT max)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
BOOL WINAPI
FlatSB_GetScrollInfo(HWND hwnd, INT code, LPSCROLLINFO info)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
INT WINAPI
FlatSB_GetScrollPos(HWND hwnd, INT code)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
BOOL WINAPI
FlatSB_GetScrollProp(HWND hwnd, INT propIndex, LPINT prop)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
@ -72,41 +72,41 @@ FlatSB_GetScrollProp(HWND hwnd, INT propIndex, LPINT prop)
INT WINAPI
FlatSB_SetScrollPos(HWND hwnd, INT code, INT pos, BOOL fRedraw)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
INT WINAPI
FlatSB_SetScrollInfo(HWND hwnd, INT code, LPSCROLLINFO info, BOOL fRedraw)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
INT WINAPI
FlatSB_SetScrollRange(HWND hwnd, INT code, INT min, INT max, BOOL fRedraw)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
BOOL WINAPI
FlatSB_SetScrollProp(HWND hwnd, UINT index, INT newValue, BOOL flag)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
BOOL WINAPI InitializeFlatSB(HWND hwnd)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
HRESULT WINAPI UninitializeFlatSB(HWND hwnd)
{
FIXME_(commctrl)("stub\n");
FIXME("stub\n");
return 0;
}
@ -142,8 +142,8 @@ FlatSB_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
default:
if (uMsg >= WM_USER)
ERR_(commctrl)("unknown msg %04x wp=%08x lp=%08lx\n",
uMsg, wParam, lParam);
ERR("unknown msg %04x wp=%08x lp=%08lx\n",
uMsg, wParam, lParam);
return DefWindowProcA (hwnd, uMsg, wParam, lParam);
}
return 0;

56
dlls/ole32/storage.c
View File

@ -23,7 +23,7 @@
#include "ldt.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(ole)
DEFAULT_DEBUG_CHANNEL(ole)
DECLARE_DEBUG_CHANNEL(relay)
struct storage_header {
@ -89,12 +89,12 @@ static BOOL
STORAGE_get_big_block(HFILE hf,int n,BYTE *block) {
assert(n>=-1);
if (-1==_llseek(hf,(n+1)*BIGSIZE,SEEK_SET)) {
WARN_(ole)(" seek failed (%ld)\n",GetLastError());
WARN(" seek failed (%ld)\n",GetLastError());
return FALSE;
}
assert((n+1)*BIGSIZE==_llseek(hf,0,SEEK_CUR));
if (BIGSIZE!=_lread(hf,block,BIGSIZE)) {
WARN_(ole)("(block size %d): read didn't read (%ld)\n",n,GetLastError());
WARN("(block size %d): read didn't read (%ld)\n",n,GetLastError());
assert(0);
return FALSE;
}
@ -108,12 +108,12 @@ static BOOL
STORAGE_put_big_block(HFILE hf,int n,BYTE *block) {
assert(n>=-1);
if (-1==_llseek(hf,(n+1)*BIGSIZE,SEEK_SET)) {
WARN_(ole)(" seek failed (%ld)\n",GetLastError());
WARN(" seek failed (%ld)\n",GetLastError());
return FALSE;
}
assert((n+1)*BIGSIZE==_llseek(hf,0,SEEK_CUR));
if (BIGSIZE!=_lwrite(hf,block,BIGSIZE)) {
WARN_(ole)(" write failed (%ld)\n",GetLastError());
WARN(" write failed (%ld)\n",GetLastError());
return FALSE;
}
return TRUE;
@ -793,7 +793,7 @@ HRESULT WINAPI IStream16_fnRead(
int cc;
if (!STORAGE_get_small_block(This->hf,blocknr,block)) {
WARN_(ole)("small block read failed!!!\n");
WARN("small block read failed!!!\n");
return E_FAIL;
}
cc = cb;
@ -813,7 +813,7 @@ HRESULT WINAPI IStream16_fnRead(
int cc;
if (!STORAGE_get_big_block(This->hf,blocknr,block)) {
WARN_(ole)("big block read failed!!!\n");
WARN("big block read failed!!!\n");
return E_FAIL;
}
cc = cb;
@ -1267,7 +1267,7 @@ HRESULT WINAPI IStorage16_fnStat(
LPSTORAGE16 iface,STATSTG16 *pstatstg, DWORD grfStatFlag
) {
ICOM_THIS(IStorage16Impl,iface);
TRACE_(ole)("(%p)->(%p,0x%08lx)\n",
TRACE("(%p)->(%p,0x%08lx)\n",
This,pstatstg,grfStatFlag
);
pstatstg->pwcsName=(LPOLESTR16)SEGPTR_GET(SEGPTR_STRDUP_WtoA(This->stde.pps_rawname));
@ -1291,7 +1291,7 @@ HRESULT WINAPI IStorage16_fnCommit(
LPSTORAGE16 iface,DWORD commitflags
) {
ICOM_THIS(IStorage16Impl,iface);
FIXME_(ole)("(%p)->(0x%08lx),STUB!\n",
FIXME("(%p)->(0x%08lx),STUB!\n",
This,commitflags
);
return S_OK;
@ -1308,7 +1308,7 @@ HRESULT WINAPI IStorage16_fnCopyTo(LPSTORAGE16 iface,DWORD ciidExclude,const IID
WINE_StringFromCLSID(rgiidExclude,xguid);
else
strcpy(xguid,"<no guid>");
FIXME_(ole)("IStorage16(%p)->(0x%08lx,%s,%p,%p),stub!\n",
FIXME("IStorage16(%p)->(0x%08lx,%s,%p,%p),stub!\n",
This,ciidExclude,xguid,SNB16Exclude,pstgDest
);
return S_OK;
@ -1330,11 +1330,11 @@ HRESULT WINAPI IStorage16_fnCreateStorage(
READ_HEADER;
TRACE_(ole)("(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
TRACE("(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
This,pwcsName,grfMode,dwStgFormat,reserved2,ppstg
);
if (grfMode & STGM_TRANSACTED)
FIXME_(ole)("We do not support transacted Compound Storage. Using direct mode.\n");
FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
_create_istorage16(ppstg);
lpstg = (IStorage16Impl*)PTR_SEG_TO_LIN(*ppstg);
lpstg->hf = This->hf;
@ -1347,7 +1347,7 @@ HRESULT WINAPI IStorage16_fnCreateStorage(
stde.pps_dir = ppsent;
x = This->ppsent;
} else {
FIXME_(ole)(" use prev chain too ?\n");
FIXME(" use prev chain too ?\n");
x=stde.pps_dir;
if (1!=STORAGE_get_pps_entry(lpstg->hf,x,&stde))
return E_FAIL;
@ -1386,11 +1386,11 @@ HRESULT WINAPI IStorage16_fnCreateStream(
int ppsent,x;
struct storage_pps_entry stde;
TRACE_(ole)("(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
TRACE("(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
This,pwcsName,grfMode,reserved1,reserved2,ppstm
);
if (grfMode & STGM_TRANSACTED)
FIXME_(ole)("We do not support transacted Compound Storage. Using direct mode.\n");
FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
_create_istream16(ppstm);
lpstr = (IStream16Impl*)PTR_SEG_TO_LIN(*ppstm);
DuplicateHandle( GetCurrentProcess(), This->hf, GetCurrentProcess(),
@ -1443,7 +1443,7 @@ HRESULT WINAPI IStorage16_fnOpenStorage(
This,pwcsName,pstgPrio,grfMode,snbExclude,reserved,ppstg
);
if (grfMode & STGM_TRANSACTED)
FIXME_(ole)("We do not support transacted Compound Storage. Using direct mode.\n");
FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
_create_istorage16(ppstg);
lpstg = (IStream16Impl*)PTR_SEG_TO_LIN(*ppstg);
DuplicateHandle( GetCurrentProcess(), This->hf, GetCurrentProcess(),
@ -1478,7 +1478,7 @@ HRESULT WINAPI IStorage16_fnOpenStream(
This,pwcsName,reserved1,grfMode,reserved2,ppstm
);
if (grfMode & STGM_TRANSACTED)
FIXME_(ole)("We do not support transacted Compound Storage. Using direct mode.\n");
FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
_create_istream16(ppstm);
lpstr = (IStream16Impl*)PTR_SEG_TO_LIN(*ppstm);
DuplicateHandle( GetCurrentProcess(), This->hf, GetCurrentProcess(),
@ -1580,13 +1580,13 @@ HRESULT WINAPI StgCreateDocFile16(
IStorage16Impl* lpstg;
struct storage_pps_entry stde;
TRACE_(ole)("(%s,0x%08lx,0x%08lx,%p)\n",
TRACE("(%s,0x%08lx,0x%08lx,%p)\n",
pwcsName,grfMode,reserved,ppstgOpen
);
_create_istorage16(ppstgOpen);
hf = CreateFileA(pwcsName,GENERIC_READ|GENERIC_WRITE,0,NULL,CREATE_NEW,0,0);
if (hf==INVALID_HANDLE_VALUE) {
WARN_(ole)("couldn't open file for storage:%ld\n",GetLastError());
WARN("couldn't open file for storage:%ld\n",GetLastError());
return E_FAIL;
}
lpstg = (IStorage16Impl*)PTR_SEG_TO_LIN(*ppstgOpen);
@ -1622,31 +1622,31 @@ HRESULT WINAPI StgIsStorageFile16(LPCOLESTR16 fn) {
OFSTRUCT ofs;
BYTE magic[24];
TRACE_(ole)("(\'%s\')\n",fn);
TRACE("(\'%s\')\n",fn);
hf = OpenFile(fn,&ofs,OF_SHARE_DENY_NONE);
if (hf==HFILE_ERROR)
return STG_E_FILENOTFOUND;
if (24!=_lread(hf,magic,24)) {
WARN_(ole)(" too short\n");
WARN(" too short\n");
_lclose(hf);
return S_FALSE;
}
if (!memcmp(magic,STORAGE_magic,8)) {
WARN_(ole)(" -> YES\n");
WARN(" -> YES\n");
_lclose(hf);
return S_OK;
}
if (!memcmp(magic,STORAGE_notmagic,8)) {
WARN_(ole)(" -> NO\n");
WARN(" -> NO\n");
_lclose(hf);
return S_FALSE;
}
if (!memcmp(magic,STORAGE_oldmagic,8)) {
WARN_(ole)(" -> old format\n");
WARN(" -> old format\n");
_lclose(hf);
return STG_E_OLDFORMAT;
}
WARN_(ole)(" -> Invalid header.\n");
WARN(" -> Invalid header.\n");
_lclose(hf);
return STG_E_INVALIDHEADER;
}
@ -1677,13 +1677,13 @@ HRESULT WINAPI StgOpenStorage16(
IStorage16Impl* lpstg;
struct storage_pps_entry stde;
TRACE_(ole)("(%s,%p,0x%08lx,%p,%ld,%p)\n",
pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstgOpen
TRACE("(%s,%p,0x%08lx,%p,%ld,%p)\n",
pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstgOpen
);
_create_istorage16(ppstgOpen);
hf = CreateFileA(pwcsName,GENERIC_READ,0,NULL,0,0,0);
if (hf==INVALID_HANDLE_VALUE) {
WARN_(ole)("Couldn't open file for storage\n");
WARN("Couldn't open file for storage\n");
return E_FAIL;
}
lpstg = (IStorage16Impl*)PTR_SEG_TO_LIN(*ppstgOpen);

222
dlls/oleaut32/typelib.c
View File

@ -69,7 +69,7 @@ QueryPathOfRegTypeLib16(
);
} else {
sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
FIXME_(ole)("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
FIXME("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
return E_FAIL;
}
plen = sizeof(pathname);
@ -77,7 +77,7 @@ QueryPathOfRegTypeLib16(
/* try again without lang specific id */
if (SUBLANGID(lcid))
return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
FIXME_(ole)("key %s not found\n",typelibkey);
FIXME("key %s not found\n",typelibkey);
return E_FAIL;
}
*path = SysAllocString16(pathname);
@ -109,7 +109,7 @@ QueryPathOfRegTypeLib(
);
} else {
sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
FIXME_(ole)("(%s,%d,%d,0x%04lx,%p),stub!\n",xguid,wMaj,wMin,(DWORD)lcid,path);
FIXME("(%s,%d,%d,0x%04lx,%p),stub!\n",xguid,wMaj,wMin,(DWORD)lcid,path);
return E_FAIL;
}
plen = sizeof(pathname);
@ -117,7 +117,7 @@ QueryPathOfRegTypeLib(
/* try again without lang specific id */
if (SUBLANGID(lcid))
return QueryPathOfRegTypeLib(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
FIXME_(ole)("key %s not found\n",typelibkey);
FIXME("key %s not found\n",typelibkey);
return E_FAIL;
}
*path = HEAP_strdupAtoW(GetProcessHeap(),0,pathname);
@ -138,7 +138,7 @@ HRESULT WINAPI LoadTypeLib16(
LPOLESTR szFile, /* [in] Name of file to load from */
void * *pptLib) /* [out] Pointer to pointer to loaded type library */
{
FIXME_(ole)("('%s',%p): stub\n",debugstr_w((LPWSTR)szFile),pptLib);
FIXME("('%s',%p): stub\n",debugstr_w((LPWSTR)szFile),pptLib);
if (pptLib!=0)
*pptLib=0;
@ -180,17 +180,17 @@ HRESULT WINAPI LoadTypeLibEx(
{
LPSTR p;
HRESULT res;
TRACE_(typelib)("('%s',%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
TRACE("('%s',%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
p=HEAP_strdupWtoA(GetProcessHeap(),0,szFile);
if(regkind != REGKIND_NONE)
FIXME_(typelib) ("registration of typelibs not supported yet!\n");
FIXME ("registration of typelibs not supported yet!\n");
res= TLB_ReadTypeLib(p, pptLib);
/* XXX need to free p ?? */
TRACE_(typelib)(" returns %ld\n",res);
TRACE(" returns %ld\n",res);
return res;
}
@ -215,8 +215,8 @@ HRESULT WINAPI LoadRegTypeLib(
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)rguid,xriid);
TRACE_(typelib)("(IID: %s) load %s (%p)\n",xriid,
SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
TRACE("(IID: %s) load %s (%p)\n",xriid,
SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
}
return res;
}
@ -239,7 +239,7 @@ HRESULT WINAPI RegisterTypeLib(
OLECHAR * szFullPath, /*[in] full Path of the library*/
OLECHAR * szHelpDir) /*[in] dir to the helpfile for the library,
may be NULL*/
{ FIXME_(ole)("(%p,%s,%s): stub\n",ptlib, debugstr_w(szFullPath),debugstr_w(szHelpDir));
{ FIXME("(%p,%s,%s): stub\n",ptlib, debugstr_w(szFullPath),debugstr_w(szHelpDir));
return S_OK; /* FIXME: pretend everything is OK */
}
@ -262,7 +262,7 @@ HRESULT WINAPI UnRegisterTypeLib(
{
char xriid[50];
WINE_StringFromCLSID((LPCLSID)libid,xriid);
TRACE_(typelib)("(IID: %s): stub\n",xriid);
TRACE("(IID: %s): stub\n",xriid);
return S_OK; /* FIXME: pretend everything is OK */
}
@ -526,7 +526,7 @@ static void * TLB_Alloc(unsigned size)
void * ret;
if((ret=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size))==NULL){
/* FIXME */
ERR_(ole)("cannot allocate memory\n");
ERR("cannot allocate memory\n");
}
return ret;
}
@ -544,7 +544,7 @@ static BSTR TLB_DupAtoBstr(PCHAR Astr)
pdw[0]=(len)*sizeof(OLECHAR);
bstr=(BSTR)&( pdw[1]);
lstrcpyAtoW( bstr, Astr);
TRACE_(typelib)("copying %s to (%p)\n", Astr, bstr);
TRACE("copying %s to (%p)\n", Astr, bstr);
return bstr;
}
@ -564,7 +564,7 @@ DWORD TLB_Read(void *buffer, DWORD count, TLBContext *pcx, long where )
!ReadFile(pcx->hFile, buffer, count, &bytesread, NULL)
) {
/* FIXME */
ERR_(typelib)("read error is 0x%lx reading %ld bytes at 0x%lx\n",
ERR("read error is 0x%lx reading %ld bytes at 0x%lx\n",
GetLastError(), count, where);
TLB_abort();
exit(1);
@ -676,7 +676,7 @@ static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
case VT_CLSID :
default:
size=0;
FIXME_(ole)("VARTYPE %d is not supported, setting pointer to NULL\n",
FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
pVar->vt);
}
@ -915,7 +915,7 @@ static void TLB_DoRefType(TLBContext *pcx,
(*pprtd)->pImpTLInfo=pImpLib;
TLB_ReadGuid(&(*pprtd)->guid, impinfo.oGuid, pcx);
}else{
ERR_(typelib)("Cannot find a reference\n");
ERR("Cannot find a reference\n");
(*pprtd)->reference=-1;
(*pprtd)->pImpTLInfo=(void *)-1;
}
@ -983,7 +983,7 @@ TLBTypeInfo * TLB_DoTypeInfo(TLBContext *pcx, int count, TLBLibInfo* pLibInfo)
/* name, eventually add to a hash table */
ptiRet->Name=TLB_ReadName(pcx, tiBase.NameOffset);
TRACE_(typelib)("reading %s\n", ptiRet->Name);
TRACE("reading %s\n", ptiRet->Name);
/* help info */
ptiRet->DocString=TLB_ReadString(pcx, tiBase.docstringoffs);
ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
@ -1052,9 +1052,9 @@ long TLB_FindTlb(TLBContext *pcx)
LOOK_FOR_MAGIC(TLBMAGIC1);
if(count)
ERR_(ole)("type library format not (yet) implemented\n");
ERR("type library format not (yet) implemented\n");
else
ERR_(ole)("not type library found in this file\n");
ERR("not type library found in this file\n");
return -1;
}
#undef LOOK_FOR_MAGIC
@ -1068,16 +1068,16 @@ int TLB_ReadTypeLib(PCHAR file, ITypeLib **ppTypeLib)
TLB2Header tlbHeader;
TLBSegDir tlbSegDir;
if((cx.hFile=OpenFile(file, &ofStruct, OF_READWRITE))==HFILE_ERROR) {
ERR_(typelib)("cannot open %s error 0x%lx\n",file, GetLastError());
ERR("cannot open %s error 0x%lx\n",file, GetLastError());
return E_FAIL;
}
/* get pointer to beginning of typelib data */
cx.oStart=0;
if((oStart=TLB_FindTlb(&cx))<0){
if(oStart==-1)
ERR_(typelib)("cannot locate typelib in %s\n",file);
ERR("cannot locate typelib in %s\n",file);
else
ERR_(typelib)("unsupported typelib format in %s\n",file);
ERR("unsupported typelib format in %s\n",file);
return E_FAIL;
}
cx.oStart=oStart;
@ -1104,7 +1104,7 @@ int TLB_ReadTypeLib(PCHAR file, ITypeLib **ppTypeLib)
if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F ||
tlbSegDir.pImpInfo.res0c != 0x0F
) {
ERR_(typelib)("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
CloseHandle(cx.hFile);
return E_FAIL;
}
@ -1180,7 +1180,7 @@ int TLB_ReadTypeLib(PCHAR file, ITypeLib **ppTypeLib)
}
}else{
V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)=NULL;
ERR_(ole)("didn't find array description data\n");
ERR("didn't find array description data\n");
}
}
}
@ -1232,7 +1232,7 @@ static HRESULT WINAPI ITypeLib_fnQueryInterface( LPTYPELIB This, REFIID riid,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE_(typelib)("(%p)->(IID: %s)\n",This,xriid);
TRACE("(%p)->(IID: %s)\n",This,xriid);
}
*ppvObject=NULL;
if(IsEqualIID(riid, &IID_IUnknown) ||
@ -1241,10 +1241,10 @@ static HRESULT WINAPI ITypeLib_fnQueryInterface( LPTYPELIB This, REFIID riid,
*ppvObject = This;
if(*ppvObject){
ITypeLib_AddRef(This);
TRACE_(typelib)("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
return S_OK;
}
TRACE_(typelib)("-- Interface: E_NOINTERFACE\n");
TRACE("-- Interface: E_NOINTERFACE\n");
return E_NOINTERFACE;
}
@ -1253,7 +1253,7 @@ static HRESULT WINAPI ITypeLib_fnQueryInterface( LPTYPELIB This, REFIID riid,
static ULONG WINAPI ITypeLib_fnAddRef( LPTYPELIB iface)
{
ICOM_THIS( TLBLibInfo, iface);
TRACE_(typelib)("(%p)->ref is %u\n",This, This->ref);
TRACE("(%p)->ref is %u\n",This, This->ref);
return ++(This->ref);
}
@ -1262,7 +1262,7 @@ static ULONG WINAPI ITypeLib_fnAddRef( LPTYPELIB iface)
static ULONG WINAPI ITypeLib_fnRelease( LPTYPELIB iface)
{
ICOM_THIS( TLBLibInfo, iface);
FIXME_(typelib)("(%p)->ref is %u: stub\n",This, This->ref);
FIXME("(%p)->ref is %u: stub\n",This, This->ref);
(This->ref)--;
return S_OK;
}
@ -1274,7 +1274,7 @@ static ULONG WINAPI ITypeLib_fnRelease( LPTYPELIB iface)
static UINT WINAPI ITypeLib_fnGetTypeInfoCount( LPTYPELIB iface)
{
ICOM_THIS( TLBLibInfo, iface);
TRACE_(typelib)("(%p)->count is %d\n",This, This->TypeInfoCount);
TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
return This->TypeInfoCount;
}
@ -1288,15 +1288,15 @@ static HRESULT WINAPI ITypeLib_fnGetTypeInfo( LPTYPELIB iface, UINT index,
int i;
ICOM_THIS( TLBLibInfo, iface);
TLBTypeInfo **ppTLBTInfo=(TLBTypeInfo **)ppTInfo;
TRACE_(typelib)("(%p) index %d \n",This, index);
TRACE("(%p) index %d \n",This, index);
for(i=0,*ppTLBTInfo=This->pTypeInfo;*ppTLBTInfo && i != index;i++)
*ppTLBTInfo=(*ppTLBTInfo)->next;
if(*ppTLBTInfo){
(*ppTLBTInfo)->lpvtbl->fnAddRef(*ppTInfo);
TRACE_(typelib)("-- found (%p)->(%p)\n",ppTLBTInfo,*ppTLBTInfo);
TRACE("-- found (%p)->(%p)\n",ppTLBTInfo,*ppTLBTInfo);
return S_OK;
}
TRACE_(typelib)("-- element not found\n");
TRACE("-- element not found\n");
return TYPE_E_ELEMENTNOTFOUND;
}
@ -1310,15 +1310,15 @@ static HRESULT WINAPI ITypeLib_fnGetTypeInfoType( LPTYPELIB iface, UINT index,
int i;
TLBTypeInfo *pTInfo;
ICOM_THIS( TLBLibInfo, iface);
TRACE_(typelib)("(%p) index %d \n",This, index);
TRACE("(%p) index %d \n",This, index);
for(i=0,pTInfo=This->pTypeInfo;pTInfo && i != index;i++)
pTInfo=(pTInfo)->next;
if(pTInfo){
*pTKind=pTInfo->TypeAttr.typekind;
TRACE_(typelib)("-- found Type (%p)->%d\n",pTKind,*pTKind);
TRACE("-- found Type (%p)->%d\n",pTKind,*pTKind);
return S_OK;
}
TRACE_(typelib)("-- element not found\n");
TRACE("-- element not found\n");
return TYPE_E_ELEMENTNOTFOUND;
}
@ -1336,17 +1336,17 @@ static HRESULT WINAPI ITypeLib_fnGetTypeInfoOfGuid( LPTYPELIB iface,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)guid,xriid);
TRACE_(typelib)("(%p) guid %sx)\n",This,xriid);
TRACE("(%p) guid %sx)\n",This,xriid);
}
for(i=0,*ppTLBTInfo=This->pTypeInfo;*ppTLBTInfo &&
!IsEqualIID(guid,&(*ppTLBTInfo)->TypeAttr.guid);i++)
*ppTLBTInfo=(*ppTLBTInfo)->next;
if(*ppTLBTInfo){
(*ppTLBTInfo)->lpvtbl->fnAddRef(*ppTInfo);
TRACE_(typelib)("-- found (%p)->(%p)\n",ppTLBTInfo,*ppTLBTInfo);
TRACE("-- found (%p)->(%p)\n",ppTLBTInfo,*ppTLBTInfo);
return S_OK;
}
TRACE_(typelib)("-- element not found\n");
TRACE("-- element not found\n");
return TYPE_E_ELEMENTNOTFOUND;
}
@ -1359,7 +1359,7 @@ static HRESULT WINAPI ITypeLib_fnGetLibAttr( LPTYPELIB iface,
LPTLIBATTR *ppTLibAttr)
{
ICOM_THIS( TLBLibInfo, iface);
TRACE_(typelib)("(%p)\n",This);
TRACE("(%p)\n",This);
/* FIXME: must do a copy here */
*ppTLibAttr=&This->LibAttr;
return S_OK;
@ -1375,7 +1375,7 @@ static HRESULT WINAPI ITypeLib_fnGetTypeComp( LPTYPELIB iface,
ITypeComp **ppTComp)
{
ICOM_THIS( TLBLibInfo, iface);
FIXME_(typelib)("(%p): stub!\n",This);
FIXME("(%p): stub!\n",This);
return E_NOTIMPL;
}
@ -1393,7 +1393,7 @@ static HRESULT WINAPI ITypeLib_fnGetDocumentation( LPTYPELIB iface, INT index,
ICOM_THIS( TLBLibInfo, iface);
HRESULT result;
ITypeInfo *pTInfo;
TRACE_(typelib)("(%p) index %d Name(%p) DocString(%p)"
TRACE("(%p) index %d Name(%p) DocString(%p)"
" HelpContext(%p) HelpFile(%p)\n",
This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
if(index<0){ /* documentation for the typelib */
@ -1450,8 +1450,8 @@ static HRESULT WINAPI ITypeLib_fnIsName( LPTYPELIB iface, LPOLESTR szNameBuf,
*pfName=FALSE;
ITypeLib_fnIsName_exit:
TRACE_(typelib)("(%p)slow! search for %s: %s found!\n", This,
debugstr_a(astr), *pfName?"NOT":"");
TRACE("(%p)slow! search for %s: %s found!\n", This,
debugstr_a(astr), *pfName?"NOT":"");
HeapFree( GetProcessHeap(), 0, astr );
return S_OK;
@ -1488,8 +1488,8 @@ ITypeLib_fnFindName_exit:
ppTInfo[j]=(LPTYPEINFO)pTInfo;
j++;
}
TRACE_(typelib)("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
This, *pcFound, debugstr_a(astr), j);
TRACE("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
This, *pcFound, debugstr_a(astr), j);
*pcFound=j;
@ -1505,7 +1505,7 @@ ITypeLib_fnFindName_exit:
static VOID WINAPI ITypeLib_fnReleaseTLibAttr( LPTYPELIB iface, TLIBATTR *pTLibAttr)
{
ICOM_THIS( TLBLibInfo, iface);
TRACE_(typelib)("freeing (%p)\n",This);
TRACE("freeing (%p)\n",This);
/* nothing to do */
}
@ -1523,8 +1523,7 @@ static HRESULT WINAPI ITypeLib2_fnGetCustData( ITypeLib * iface, REFGUID guid,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)guid,xriid);
TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
pCData? "" : "NOT");
TRACE("(%p) guid %s %s found!x)\n", This, xriid, pCData? "" : "NOT");
}
if(pCData){
VariantInit( pVarVal);
@ -1544,7 +1543,7 @@ static HRESULT WINAPI ITypeLib2_fnGetLibStatistics( ITypeLib * iface,
UINT *pcUniqueNames, UINT *pcchUniqueNames)
{
ICOM_THIS( TLBLibInfo, iface);
FIXME_(typelib)("(%p): stub!\n", This);
FIXME("(%p): stub!\n", This);
if(pcUniqueNames) *pcUniqueNames=1;
if(pcchUniqueNames) *pcchUniqueNames=1;
return S_OK;
@ -1564,7 +1563,7 @@ static HRESULT WINAPI ITypeLib2_fnGetDocumentation2( ITypeLib * iface,
ICOM_THIS( TLBLibInfo, iface);
HRESULT result;
ITypeInfo *pTInfo;
FIXME_(typelib)("(%p) index %d lcid %ld half implemented stub!\n", This,
FIXME("(%p) index %d lcid %ld half implemented stub!\n", This,
index, lcid);
/* the help string should be obtained from the helpstringdll,
* using the _DLLGetDocumentation function, based on the supplied
@ -1601,7 +1600,7 @@ static HRESULT WINAPI ITypeLib2_fnGetAllCustData( ITypeLib * iface,
ICOM_THIS( TLBLibInfo, iface);
TLBCustData *pCData;
int i;
TRACE_(typelib)("(%p) returning %d items\n", This, This->ctCustData);
TRACE("(%p) returning %d items\n", This, This->ctCustData);
pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
if(pCustData->prgCustData ){
pCustData->cCustData=This->ctCustData;
@ -1610,7 +1609,7 @@ static HRESULT WINAPI ITypeLib2_fnGetAllCustData( ITypeLib * iface,
VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
}
}else{
ERR_(typelib)(" OUT OF MEMORY! \n");
ERR(" OUT OF MEMORY! \n");
return E_OUTOFMEMORY;
}
return S_OK;
@ -1628,7 +1627,7 @@ static HRESULT WINAPI ITypeInfo_fnQueryInterface( LPTYPEINFO iface, REFIID riid,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE_(typelib)("(%p)->(IID: %s)\n",This,xriid);
TRACE("(%p)->(IID: %s)\n",This,xriid);
}
*ppvObject=NULL;
if(IsEqualIID(riid, &IID_IUnknown) ||
@ -1637,10 +1636,10 @@ static HRESULT WINAPI ITypeInfo_fnQueryInterface( LPTYPEINFO iface, REFIID riid,
*ppvObject = This;
if(*ppvObject){
ITypeInfo_AddRef(iface);
TRACE_(typelib)("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
return S_OK;
}
TRACE_(typelib)("-- Interface: E_NOINTERFACE\n");
TRACE("-- Interface: E_NOINTERFACE\n");
return E_NOINTERFACE;
}
@ -1649,7 +1648,7 @@ static HRESULT WINAPI ITypeInfo_fnQueryInterface( LPTYPEINFO iface, REFIID riid,
static ULONG WINAPI ITypeInfo_fnAddRef( LPTYPEINFO iface)
{
ICOM_THIS( TLBTypeInfo, iface);
TRACE_(typelib)("(%p)->ref is %u\n",This, This->ref);
TRACE("(%p)->ref is %u\n",This, This->ref);
(This->pTypeLib->ref)++;
return ++(This->ref);
}
@ -1659,7 +1658,7 @@ static ULONG WINAPI ITypeInfo_fnAddRef( LPTYPEINFO iface)
static ULONG WINAPI ITypeInfo_fnRelease( LPTYPEINFO iface)
{
ICOM_THIS( TLBTypeInfo, iface);
FIXME_(typelib)("(%p)->ref is %u: stub\n",This, This->ref);
FIXME("(%p)->ref is %u: stub\n",This, This->ref);
(This->ref)--;
(This->pTypeLib->ref)--;
return S_OK;
@ -1675,7 +1674,7 @@ static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( LPTYPEINFO iface,
LPTYPEATTR *ppTypeAttr)
{
ICOM_THIS( TLBTypeInfo, iface);
TRACE_(typelib)("(%p)\n",This);
TRACE("(%p)\n",This);
/* FIXME: must do a copy here */
*ppTypeAttr=&This->TypeAttr;
return S_OK;
@ -1691,7 +1690,7 @@ static HRESULT WINAPI ITypeInfo_fnGetTypeComp( LPTYPEINFO iface,
ITypeComp * *ppTComp)
{
ICOM_THIS( TLBTypeInfo, iface);
FIXME_(typelib)("(%p) stub!\n", This);
FIXME("(%p) stub!\n", This);
return S_OK;
}
@ -1707,7 +1706,7 @@ static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( LPTYPEINFO iface, UINT index,
ICOM_THIS( TLBTypeInfo, iface);
int i;
TLBFuncDesc * pFDesc;
TRACE_(typelib)("(%p) index %d\n", This, index);
TRACE("(%p) index %d\n", This, index);
for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
;
if(pFDesc){
@ -1729,7 +1728,7 @@ static HRESULT WINAPI ITypeInfo_fnGetVarDesc( LPTYPEINFO iface, UINT index,
ICOM_THIS( TLBTypeInfo, iface);
int i;
TLBVarDesc * pVDesc;
TRACE_(typelib)("(%p) index %d\n", This, index);
TRACE("(%p) index %d\n", This, index);
for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
;
if(pVDesc){
@ -1753,7 +1752,7 @@ static HRESULT WINAPI ITypeInfo_fnGetNames( LPTYPEINFO iface, MEMBERID memid,
TLBFuncDesc * pFDesc;
TLBVarDesc * pVDesc;
int i;
TRACE_(typelib)("(%p) memid=0x%08lx Maxname=%d\n", This, memid,
TRACE("(%p) memid=0x%08lx Maxname=%d\n", This, memid,
cMaxNames);
for(pFDesc=This->funclist; pFDesc->funcdesc.memid != memid && pFDesc;
pFDesc=pFDesc->next)
@ -1788,9 +1787,9 @@ static HRESULT WINAPI ITypeInfo_fnGetNames( LPTYPEINFO iface, MEMBERID memid,
ITypeInfo_Release(pTInfo);
return result;
}
WARN_(typelib)("Could not search inherited interface!\n");
WARN("Could not search inherited interface!\n");
} else
WARN_(typelib)("no names found\n");
WARN("no names found\n");
*pcNames=0;
return TYPE_E_ELEMENTNOTFOUND;
}
@ -1813,7 +1812,7 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType( LPTYPEINFO iface,
ICOM_THIS( TLBTypeInfo, iface);
int(i);
TLBRefType *pIref;
TRACE_(typelib)("(%p) index %d\n", This, index);
TRACE("(%p) index %d\n", This, index);
for(i=0, pIref=This->impltypelist; i<index && pIref;
i++, pIref=pIref->next)
;
@ -1835,7 +1834,7 @@ static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( LPTYPEINFO iface,
ICOM_THIS( TLBTypeInfo, iface);
int(i);
TLBRefType *pIref;
TRACE_(typelib)("(%p) index %d\n", This, index);
TRACE("(%p) index %d\n", This, index);
for(i=0, pIref=This->impltypelist; i<index && pIref; i++, pIref=pIref->next)
;
if(i==index && pIref){
@ -1858,7 +1857,7 @@ static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( LPTYPEINFO iface,
TLBVarDesc * pVDesc;
HRESULT ret=S_OK;
PCHAR aszName= HEAP_strdupWtoA( GetProcessHeap(), 0, *rgszNames);
TRACE_(typelib)("(%p) Name %s cNames %d\n", This, debugstr_a(aszName),
TRACE("(%p) Name %s cNames %d\n", This, debugstr_a(aszName),
cNames);
for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next) {
int i, j;
@ -1899,9 +1898,9 @@ static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( LPTYPEINFO iface,
ITypeInfo_Release(pTInfo);
return ret;
}
WARN_(typelib)("Could not search inherited interface!\n");
WARN("Could not search inherited interface!\n");
} else
WARN_(typelib)("no names found\n");
WARN("no names found\n");
return DISP_E_UNKNOWNNAME;
}
@ -1915,7 +1914,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke( LPTYPEINFO iface, VOID *pIUnk,
VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *pArgErr)
{
ICOM_THIS( TLBTypeInfo, iface);
FIXME_(typelib)("(%p) stub!", This);
FIXME("(%p) stub!", This);
return S_OK;
}
@ -1931,8 +1930,8 @@ static HRESULT WINAPI ITypeInfo_fnGetDocumentation( LPTYPEINFO iface,
ICOM_THIS( TLBTypeInfo, iface);
TLBFuncDesc * pFDesc;
TLBVarDesc * pVDesc;
TRACE_(typelib)("(%p) memid %ld Name(%p) DocString(%p)"
" HelpContext(%p) HelpFile(%p)\n",
TRACE("(%p) memid %ld Name(%p) DocString(%p)"
" HelpContext(%p) HelpFile(%p)\n",
This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
if(pBstrName)
@ -1967,7 +1966,7 @@ static HRESULT WINAPI ITypeInfo_fnGetDllEntry( LPTYPEINFO iface, MEMBERID memid,
WORD *pwOrdinal)
{
ICOM_THIS( TLBTypeInfo, iface);
FIXME_(typelib)("(%p) stub!\n", This);
FIXME("(%p) stub!\n", This);
return E_FAIL;
}
@ -2021,8 +2020,8 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo( LPTYPEINFO iface,
}
}
}
TRACE_(typelib)("(%p) hreftype 0x%04lx loaded %s (%p)\n", This, hRefType,
SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
TRACE("(%p) hreftype 0x%04lx loaded %s (%p)\n", This, hRefType,
SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
return result;
}
@ -2035,7 +2034,7 @@ static HRESULT WINAPI ITypeInfo_fnAddressOfMember( LPTYPEINFO iface,
MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
{
ICOM_THIS( TLBTypeInfo, iface);
FIXME_(typelib)("(%p) stub!\n", This);
FIXME("(%p) stub!\n", This);
return S_OK;
}
@ -2048,7 +2047,7 @@ static HRESULT WINAPI ITypeInfo_fnCreateInstance( LPTYPEINFO iface,
IUnknown *pUnk, REFIID riid, VOID **ppvObj)
{
ICOM_THIS( TLBTypeInfo, iface);
FIXME_(typelib)("(%p) stub!\n", This);
FIXME("(%p) stub!\n", This);
return S_OK;
}
@ -2060,7 +2059,7 @@ static HRESULT WINAPI ITypeInfo_fnGetMops( LPTYPEINFO iface, MEMBERID memid,
BSTR *pBstrMops)
{
ICOM_THIS( TLBTypeInfo, iface);
FIXME_(typelib)("(%p) stub!\n", This);
FIXME("(%p) stub!\n", This);
return S_OK;
}
@ -2076,7 +2075,7 @@ static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( LPTYPEINFO iface,
*ppTLib=(LPTYPELIB )(This->pTypeLib);
*pIndex=This->index;
ITypeLib_AddRef(*ppTLib);
TRACE_(typelib)("(%p) returns (%p) index %d!\n", This, *ppTLib, *pIndex);
TRACE("(%p) returns (%p) index %d!\n", This, *ppTLib, *pIndex);
return S_OK;
}
@ -2089,7 +2088,7 @@ static HRESULT WINAPI ITypeInfo_fnReleaseTypeAttr( LPTYPEINFO iface,
TYPEATTR* pTypeAttr)
{
ICOM_THIS( TLBTypeInfo, iface);
TRACE_(typelib)("(%p)->(%p)\n", This, pTypeAttr);
TRACE("(%p)->(%p)\n", This, pTypeAttr);
return S_OK;
}
@ -2101,7 +2100,7 @@ static HRESULT WINAPI ITypeInfo_fnReleaseFuncDesc( LPTYPEINFO iface,
FUNCDESC *pFuncDesc)
{
ICOM_THIS( TLBTypeInfo, iface);
TRACE_(typelib)("(%p)->(%p)\n", This, pFuncDesc);
TRACE("(%p)->(%p)\n", This, pFuncDesc);
return S_OK;
}
@ -2113,7 +2112,7 @@ static HRESULT WINAPI ITypeInfo_fnReleaseVarDesc( LPTYPEINFO iface,
VARDESC *pVarDesc)
{
ICOM_THIS( TLBTypeInfo, iface);
TRACE_(typelib)("(%p)->(%p)\n", This, pVarDesc);
TRACE("(%p)->(%p)\n", This, pVarDesc);
return S_OK;
}
@ -2127,7 +2126,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo * iface,
{
ICOM_THIS( TLBTypeInfo, iface);
*pTypeKind=This->TypeAttr.typekind;
TRACE_(typelib)("(%p) type 0x%0x\n", This,*pTypeKind);
TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
return S_OK;
}
@ -2143,7 +2142,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo * iface,
{
ICOM_THIS( TLBTypeInfo, iface);
*pTypeFlags=This->TypeAttr.wTypeFlags;
TRACE_(typelib)("(%p) flags 0x%04x\n", This,*pTypeFlags);
TRACE("(%p) flags 0x%04x\n", This,*pTypeFlags);
return S_OK;
}
@ -2169,8 +2168,8 @@ static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo * iface,
*pFuncIndex=0;
result=E_INVALIDARG;
}
TRACE_(typelib)("(%p) memid 0x%08lx invKind 0x%04x -> %s\n", This,
memid, invKind, SUCCEEDED(result)? "SUCCES":"FAILED");
TRACE("(%p) memid 0x%08lx invKind 0x%04x -> %s\n", This,
memid, invKind, SUCCEEDED(result)? "SUCCES":"FAILED");
return result;
}
@ -2197,8 +2196,8 @@ static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo * iface,
*pVarIndex=0;
result=E_INVALIDARG;
}
TRACE_(typelib)("(%p) memid 0x%08lx -> %s\n", This,
memid, SUCCEEDED(result)? "SUCCES":"FAILED");
TRACE("(%p) memid 0x%08lx -> %s\n", This,
memid, SUCCEEDED(result)? "SUCCES":"FAILED");
return result;
}
@ -2216,8 +2215,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetCustData( ITypeInfo * iface,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)guid,xriid);
TRACE_(typelib)("(%p) guid %s %s found!x)\n", This, xriid,
pCData? "" : "NOT");
TRACE("(%p) guid %s %s found!x)\n", This, xriid, pCData? "" : "NOT");
}
if(pCData){
VariantInit( pVarVal);
@ -2247,8 +2245,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData( ITypeInfo * iface,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)guid,xriid);
TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
pCData? "" : "NOT");
TRACE("(%p) guid %s %s found!x)\n", This, xriid, pCData? "" : "NOT");
}
if(pCData){
VariantInit( pVarVal);
@ -2279,8 +2276,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetParamCustData( ITypeInfo * iface,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)guid,xriid);
TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
pCData? "" : "NOT");
TRACE("(%p) guid %s %s found!x)\n", This, xriid, pCData? "" : "NOT");
}
if(pCData){
VariantInit( pVarVal);
@ -2310,8 +2306,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetVarCustData( ITypeInfo * iface,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)guid,xriid);
TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
pCData? "" : "NOT");
TRACE("(%p) guid %s %s found!x)\n", This, xriid, pCData? "" : "NOT");
}
if(pCData){
VariantInit( pVarVal);
@ -2341,8 +2336,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData( ITypeInfo * iface,
if(TRACE_ON(typelib)){
char xriid[50];
WINE_StringFromCLSID((LPCLSID)guid,xriid);
TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
pCData? "" : "NOT");
TRACE("(%p) guid %s %s found!x)\n", This, xriid, pCData? "" : "NOT");
}
if(pCData){
VariantInit( pVarVal);
@ -2366,10 +2360,10 @@ static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2( ITypeInfo * iface,
ICOM_THIS( TLBTypeInfo, iface);
TLBFuncDesc * pFDesc;
TLBVarDesc * pVDesc;
TRACE_(typelib)("(%p) memid %ld lcid(0x%lx) HelpString(%p) "
"HelpStringContext(%p) HelpStringDll(%p)\n",
This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
pbstrHelpStringDll );
TRACE("(%p) memid %ld lcid(0x%lx) HelpString(%p) "
"HelpStringContext(%p) HelpStringDll(%p)\n",
This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
pbstrHelpStringDll );
/* the help string should be obtained from the helpstringdll,
* using the _DLLGetDocumentation function, based on the supplied
* lcid. Nice to do sometime...
@ -2421,7 +2415,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllCustData( ITypeInfo * iface,
ICOM_THIS( TLBTypeInfo, iface);
TLBCustData *pCData;
int i;
TRACE_(typelib)("(%p) returning %d items\n", This, This->ctCustData);
TRACE("(%p) returning %d items\n", This, This->ctCustData);
pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
if(pCustData->prgCustData ){
pCustData->cCustData=This->ctCustData;
@ -2430,7 +2424,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllCustData( ITypeInfo * iface,
VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
}
}else{
ERR_(typelib)(" OUT OF MEMORY! \n");
ERR(" OUT OF MEMORY! \n");
return E_OUTOFMEMORY;
}
return S_OK;
@ -2448,7 +2442,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData( ITypeInfo * iface,
TLBCustData *pCData;
TLBFuncDesc * pFDesc;
int i;
TRACE_(typelib)("(%p) index %d\n", This, index);
TRACE("(%p) index %d\n", This, index);
for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
pFDesc=pFDesc->next)
;
@ -2464,7 +2458,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData( ITypeInfo * iface,
& pCData->data);
}
}else{
ERR_(typelib)(" OUT OF MEMORY! \n");
ERR(" OUT OF MEMORY! \n");
return E_OUTOFMEMORY;
}
return S_OK;
@ -2484,7 +2478,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo * iface,
TLBCustData *pCData=NULL;
TLBFuncDesc * pFDesc;
int i;
TRACE_(typelib)("(%p) index %d\n", This, indexFunc);
TRACE("(%p) index %d\n", This, indexFunc);
for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
pFDesc=pFDesc->next)
;
@ -2501,7 +2495,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo * iface,
& pCData->data);
}
}else{
ERR_(typelib)(" OUT OF MEMORY! \n");
ERR(" OUT OF MEMORY! \n");
return E_OUTOFMEMORY;
}
return S_OK;
@ -2521,7 +2515,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo * iface,
TLBCustData *pCData;
TLBVarDesc * pVDesc;
int i;
TRACE_(typelib)("(%p) index %d\n", This, index);
TRACE("(%p) index %d\n", This, index);
for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
pVDesc=pVDesc->next)
;
@ -2537,7 +2531,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo * iface,
& pCData->data);
}
}else{
ERR_(typelib)(" OUT OF MEMORY! \n");
ERR(" OUT OF MEMORY! \n");
return E_OUTOFMEMORY;
}
return S_OK;
@ -2557,7 +2551,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData( ITypeInfo * iface,
TLBCustData *pCData;
TLBRefType * pRDesc;
int i;
TRACE_(typelib)("(%p) index %d\n", This, index);
TRACE("(%p) index %d\n", This, index);
for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
pRDesc=pRDesc->next)
;
@ -2573,7 +2567,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData( ITypeInfo * iface,
& pCData->data);
}
}else{
ERR_(typelib)(" OUT OF MEMORY! \n");
ERR(" OUT OF MEMORY! \n");
return E_OUTOFMEMORY;
}
return S_OK;

98
dlls/shell32/pidl.c
View File

@ -25,7 +25,7 @@
#include "pidl.h"
#include "wine/undocshell.h"
DECLARE_DEBUG_CHANNEL(pidl)
DEFAULT_DEBUG_CHANNEL(pidl)
DECLARE_DEBUG_CHANNEL(shell)
void pdump (LPCITEMIDLIST pidl)
@ -125,7 +125,7 @@ BOOL pcheck (LPCITEMIDLIST pidl)
szTemp[i+BYTES_PRINTED*3] = (c>=0x20 && c <=0x80) ? c : '.';
}
szTemp[BYTES_PRINTED*4] = 0x00;
ERR_(pidl)("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
ERR("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
ret = FALSE;
}
}
@ -153,7 +153,7 @@ BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl,LPSTR path)
LPITEMIDLIST WINAPI ILFindLastID(LPITEMIDLIST pidl)
{ LPITEMIDLIST pidlLast = pidl;
TRACE_(pidl)("(pidl=%p)\n",pidl);
TRACE("(pidl=%p)\n",pidl);
while (pidl->mkid.cb)
{
@ -196,7 +196,7 @@ LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
if (newpidl)
memcpy(newpidl,pidl,len);
TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
pdump(pidl);
return newpidl;
@ -211,7 +211,7 @@ LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
{ DWORD len;
LPITEMIDLIST pidlNew = NULL;
TRACE_(pidl)("pidl=%p \n",pidl);
TRACE("pidl=%p \n",pidl);
pdump(pidl);
if (pidl)
@ -226,7 +226,7 @@ LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
ILGetNext(pidlNew)->mkid.cb = 0x00;
}
}
TRACE_(pidl)("-- newpidl=%p\n",pidlNew);
TRACE("-- newpidl=%p\n",pidlNew);
return pidlNew;
}
@ -355,7 +355,7 @@ LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
if (newpidl)
memcpy(newpidl,pidl,len);
TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
pdump(pidl);
return newpidl;
@ -373,7 +373,7 @@ BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
LPITEMIDLIST pidltemp1 = pidl1;
LPITEMIDLIST pidltemp2 = pidl2;
TRACE_(pidl)("pidl1=%p pidl2=%p\n",pidl1, pidl2);
TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
/* explorer reads from registry directly (StreamMRU),
so we can only check here */
@ -418,7 +418,7 @@ BOOL WINAPI ILIsParent( LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL
LPITEMIDLIST pParent = pidlParent;
LPITEMIDLIST pChild = pidlChild;
TRACE_(pidl)("%p %p %x\n", pidlParent, pidlChild, bImmediate);
TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
while (pParent->mkid.cb && pChild->mkid.cb)
{
@ -462,7 +462,7 @@ LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
LPITEMIDLIST pidltemp2 = pidl2;
LPITEMIDLIST ret=NULL;
TRACE_(pidl)("pidl1=%p pidl2=%p\n",pidl1, pidl2);
TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
/* explorer reads from registry directly (StreamMRU),
so we can only check here */
@ -513,7 +513,7 @@ LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
DWORD len1,len2;
LPITEMIDLIST pidlNew;
TRACE_(pidl)("pidl=%p pidl=%p\n",pidl1,pidl2);
TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
if(!pidl1 && !pidl2) return NULL;
@ -552,7 +552,7 @@ LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
*/
LPITEMIDLIST WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl, DWORD z)
{
FIXME_(pidl)("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
FIXME("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
pdump (pidl);
return 0;
@ -567,7 +567,7 @@ LPITEMIDLIST WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl, DWORD z)
*/
LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
{
FIXME_(pidl)("(pidl=%p)\n",pidl);
FIXME("(pidl=%p)\n",pidl);
pdump(pidl);
@ -599,7 +599,7 @@ DWORD WINAPI ILGetSize(LPITEMIDLIST pidl)
}
len += 2;
}
TRACE_(pidl)("pidl=%p size=%lu\n",pidl, len);
TRACE("pidl=%p size=%lu\n",pidl, len);
return len;
}
@ -617,7 +617,7 @@ LPITEMIDLIST WINAPI ILGetNext(LPITEMIDLIST pidl)
{
WORD len;
TRACE_(pidl)("(pidl=%p)\n",pidl);
TRACE("(pidl=%p)\n",pidl);
if(pidl)
{
@ -643,7 +643,7 @@ LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl,LPCITEMIDLIST item,BOOL bEnd)
{
LPITEMIDLIST idlRet;
WARN_(pidl)("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
pdump (pidl);
pdump (item);
@ -677,7 +677,7 @@ LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl,LPCITEMIDLIST item,BOOL bEnd)
* exported by ordinal
*/
DWORD WINAPI ILFree(LPITEMIDLIST pidl)
{ TRACE_(pidl)("(pidl=0x%08lx)\n",(DWORD)pidl);
{ TRACE("(pidl=0x%08lx)\n",(DWORD)pidl);
if (!pidl)
return FALSE;
@ -690,7 +690,7 @@ DWORD WINAPI ILFree(LPITEMIDLIST pidl)
*/
DWORD WINAPI ILGlobalFree( LPITEMIDLIST pidl)
{
TRACE_(pidl)("%p\n",pidl);
TRACE("%p\n",pidl);
if (!pidl)
return FALSE;
@ -738,7 +738,7 @@ LPITEMIDLIST WINAPI SHSimpleIDListFromPathA (LPSTR lpszPath)
HANDLE hFile;
WIN32_FIND_DATAA stffile;
TRACE_(pidl)("path=%s\n", lpszPath);
TRACE("path=%s\n", lpszPath);
if (!lpszPath) return NULL;
@ -761,7 +761,7 @@ LPITEMIDLIST WINAPI SHSimpleIDListFromPathA (LPSTR lpszPath)
LPITEMIDLIST WINAPI SHSimpleIDListFromPathW (LPWSTR lpszPath)
{
char lpszTemp[MAX_PATH];
TRACE_(pidl)("path=L%s\n",debugstr_w(lpszPath));
TRACE("path=L%s\n",debugstr_w(lpszPath));
WideCharToLocal(lpszTemp, lpszPath, MAX_PATH);
@ -1059,37 +1059,37 @@ BOOL WINAPI SHGetPathFromIDListAW(LPCITEMIDLIST pidl,LPVOID pszPath)
* _ILCreateValue()
*/
LPITEMIDLIST _ILCreateDesktop()
{ TRACE_(pidl)("()\n");
{ TRACE("()\n");
return _ILCreate(PT_DESKTOP, NULL, 0);
}
LPITEMIDLIST _ILCreateMyComputer()
{ TRACE_(pidl)("()\n");
{ TRACE("()\n");
return _ILCreate(PT_MYCOMP, &CLSID_MyComputer, sizeof(GUID));
}
LPITEMIDLIST _ILCreateIExplore()
{ TRACE_(pidl)("()\n");
{ TRACE("()\n");
return _ILCreate(PT_MYCOMP, &CLSID_Internet, sizeof(GUID));
}
LPITEMIDLIST _ILCreateControl()
{ TRACE_(pidl)("()\n");
{ TRACE("()\n");
return _ILCreate(PT_SPECIAL, &CLSID_ControlPanel, sizeof(GUID));
}
LPITEMIDLIST _ILCreatePrinter()
{ TRACE_(pidl)("()\n");
{ TRACE("()\n");
return _ILCreate(PT_SPECIAL, &CLSID_Printers, sizeof(GUID));
}
LPITEMIDLIST _ILCreateNetwork()
{ TRACE_(pidl)("()\n");
{ TRACE("()\n");
return _ILCreate(PT_MYCOMP, &CLSID_NetworkPlaces, sizeof(GUID));
}
LPITEMIDLIST _ILCreateBitBucket()
{ TRACE_(pidl)("()\n");
{ TRACE("()\n");
return _ILCreate(PT_MYCOMP, &CLSID_RecycleBin, sizeof(GUID));
}
@ -1098,7 +1098,7 @@ LPITEMIDLIST _ILCreateDrive( LPCSTR lpszNew)
lstrcpynA (sTemp,lpszNew,4);
sTemp[2]='\\';
sTemp[3]=0x00;
TRACE_(pidl)("(%s)\n",sTemp);
TRACE("(%s)\n",sTemp);
return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
}
@ -1109,7 +1109,7 @@ LPITEMIDLIST _ILCreateFolder( WIN32_FIND_DATAA * stffile )
ULONG len, len1;
LPITEMIDLIST pidl;
TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
/* prepare buffer with both names */
len = strlen (stffile->cFileName) + 1;
@ -1149,7 +1149,7 @@ LPITEMIDLIST _ILCreateValue(WIN32_FIND_DATAA * stffile)
ULONG len, len1;
LPITEMIDLIST pidl;
TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
/* prepare buffer with both names */
len = strlen (stffile->cFileName) + 1;
@ -1203,14 +1203,14 @@ LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
UINT16 uSize = 0;
LPSTR pszDest;
TRACE_(pidl)("(0x%02x %p %i)\n",type,pIn,uInSize);
TRACE("(0x%02x %p %i)\n",type,pIn,uInSize);
switch (type)
{ case PT_DESKTOP:
uSize = 0;
pidlOut = SHAlloc(uSize + 2);
pidlOut->mkid.cb = uSize;
TRACE_(pidl)("- create Desktop\n");
TRACE("- create Desktop\n");
break;
case PT_MYCOMP:
@ -1221,7 +1221,7 @@ LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
pData =_ILGetDataPointer(pidlOut);
pData->type = type;
memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
TRACE_(pidl)("- create GUID-pidl\n");
TRACE("- create GUID-pidl\n");
break;
case PT_DRIVE:
@ -1233,7 +1233,7 @@ LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
pData->type = type;
pszDest = _ILGetTextPointer(pidlOut);
memcpy(pszDest, pIn, uInSize);
TRACE_(pidl)("- create Drive: %s\n",debugstr_a(pszDest));
TRACE("- create Drive: %s\n",debugstr_a(pszDest));
break;
case PT_FOLDER:
@ -1246,7 +1246,7 @@ LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
pData->type = type;
pszDest = _ILGetTextPointer(pidlOut);
memcpy(pszDest, pIn, uInSize);
TRACE_(pidl)("- create Value: %s\n",debugstr_a(pszDest));
TRACE("- create Value: %s\n",debugstr_a(pszDest));
break;
}
@ -1254,7 +1254,7 @@ LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
if (pidlTemp)
pidlTemp->mkid.cb = 0x00;
TRACE_(pidl)("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
TRACE("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
return pidlOut;
}
@ -1267,7 +1267,7 @@ LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
* strlen (lpszText)
*/
DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT16 uSize)
{ TRACE_(pidl)("(%p,%p,%u)\n",pidl,pOut,uSize);
{ TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
if(_ILIsMyComputer(pidl))
pidl = ILGetNext(pidl);
@ -1292,7 +1292,7 @@ DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT16 uSize)
* _ILIsPidlSimple()
*/
BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
{ TRACE_(pidl)("(%p)\n",pidl);
{ TRACE("(%p)\n",pidl);
return ( !pidl || (pidl && pidl->mkid.cb == 0x00) );
}
@ -1300,7 +1300,7 @@ BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
{
REFIID iid = _ILGetGUIDPointer(pidl);
TRACE_(pidl)("(%p)\n",pidl);
TRACE("(%p)\n",pidl);
if (iid)
return IsEqualIID(iid, &CLSID_MyComputer);
@ -1310,7 +1310,7 @@ BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
{
LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
TRACE_(pidl)("(%p)\n",pidl);
TRACE("(%p)\n",pidl);
return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) ||
(pidl && pidl->mkid.cb == 0x00)
));
@ -1318,7 +1318,7 @@ BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
BOOL _ILIsDrive(LPCITEMIDLIST pidl)
{ LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
TRACE_(pidl)("(%p)\n",pidl);
TRACE("(%p)\n",pidl);
return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
PT_DRIVE1 == lpPData->type ||
PT_DRIVE2 == lpPData->type ||
@ -1327,13 +1327,13 @@ BOOL _ILIsDrive(LPCITEMIDLIST pidl)
BOOL _ILIsFolder(LPCITEMIDLIST pidl)
{ LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
TRACE_(pidl)("(%p)\n",pidl);
TRACE("(%p)\n",pidl);
return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
}
BOOL _ILIsValue(LPCITEMIDLIST pidl)
{ LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
TRACE_(pidl)("(%p)\n",pidl);
TRACE("(%p)\n",pidl);
return (pidl && lpPData && PT_VALUE == lpPData->type);
}
@ -1352,7 +1352,7 @@ BOOL _ILIsPidlSimple ( LPCITEMIDLIST pidl)
ret = FALSE;
}
TRACE_(pidl)("%s\n", ret ? "Yes" : "No");
TRACE("%s\n", ret ? "Yes" : "No");
return ret;
}
@ -1375,7 +1375,7 @@ DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
GUID const * riid;
char szTemp[MAX_PATH];
TRACE_(pidl)("(%p %p %x)\n",pidl,szOut,uOutSize);
TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
if (!pidl) return 0;
@ -1414,10 +1414,10 @@ DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
}
else
{
ERR_(pidl)("-- no text\n");
ERR("-- no text\n");
}
TRACE_(pidl)("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
TRACE("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
return dwReturn;
}
@ -1603,7 +1603,7 @@ BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
const char * pPoint;
LPITEMIDLIST pidlTemp=pidl;
TRACE_(pidl)("pidl=%p\n",pidl);
TRACE("pidl=%p\n",pidl);
if (!pidl) return FALSE;
@ -1618,7 +1618,7 @@ BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
pPoint++;
lstrcpynA(pOut, pPoint, uOutSize);
TRACE_(pidl)("%s\n",pOut);
TRACE("%s\n",pOut);
return TRUE;
}

102
dlls/shell32/shell.c
View File

@ -26,8 +26,8 @@
#include "syslevel.h"
#include "imagelist.h"
DEFAULT_DEBUG_CHANNEL(shell)
DECLARE_DEBUG_CHANNEL(exec)
DECLARE_DEBUG_CHANNEL(shell)
/* .ICO file ICONDIR definitions */
@ -79,8 +79,8 @@ static int SHELL_Attach = 0;
BOOL WINAPI SHELL_DllEntryPoint(DWORD Reason, HINSTANCE16 hInst,
WORD ds, WORD HeapSize, DWORD res1, WORD res2)
{
TRACE_(shell)("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n",
Reason, hInst, ds, HeapSize, res1, res2);
TRACE("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n",
Reason, hInst, ds, HeapSize, res1, res2);
switch(Reason)
{
@ -88,7 +88,7 @@ BOOL WINAPI SHELL_DllEntryPoint(DWORD Reason, HINSTANCE16 hInst,
SHELL_Attach++;
if (SHELL_hInstance)
{
ERR_(shell)("shell.dll instantiated twice!\n");
ERR("shell.dll instantiated twice!\n");
/*
* We should return FALSE here, but that will break
* most apps that use CreateProcess because we do
@ -102,7 +102,7 @@ BOOL WINAPI SHELL_DllEntryPoint(DWORD Reason, HINSTANCE16 hInst,
{
if(!(SHELL_hInstance32 = LoadLibraryA("shell32.dll")))
{
ERR_(shell)("Could not load sibling shell32.dll\n");
ERR("Could not load sibling shell32.dll\n");
return FALSE;
}
}
@ -199,7 +199,7 @@ UINT WINAPI DragQueryFileA(HDROP hDrop, UINT lFile, LPSTR lpszFile,
LPSTR lpCurrent;
UINT i;
TRACE_(shell)("(%08x, %x, %p, %u)\n", hDrop,lFile,lpszFile,lLength);
TRACE("(%08x, %x, %p, %u)\n", hDrop,lFile,lpszFile,lLength);
lpDropFileStruct = (LPDROPFILESTRUCT) GlobalLock(hDrop);
if(!lpDropFileStruct)
@ -221,7 +221,7 @@ UINT WINAPI DragQueryFileW(HDROP hDrop, UINT lFile, LPWSTR lpszwFile,
LPWSTR lpwCurrent;
UINT i;
TRACE_(shell)("(%08x, %x, %p, %u)\n", hDrop,lFile,lpszwFile,lLength);
TRACE("(%08x, %x, %p, %u)\n", hDrop,lFile,lpszwFile,lLength);
lpDropFileStruct = (LPDROPFILESTRUCT) GlobalLock(hDrop);
if(!lpDropFileStruct)
@ -245,7 +245,7 @@ UINT16 WINAPI DragQueryFile16(HDROP16 hDrop, WORD wFile, LPSTR lpszFile,
LPSTR lpCurrent;
WORD i;
TRACE_(shell)("(%04x, %x, %p, %u)\n", hDrop,wFile,lpszFile,wLength);
TRACE("(%04x, %x, %p, %u)\n", hDrop,wFile,lpszFile,wLength);
lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop);
if(!lpDropFileStruct)
@ -265,7 +265,8 @@ UINT16 WINAPI DragQueryFile16(HDROP16 hDrop, WORD wFile, LPSTR lpszFile,
* DragFinish32 [SHELL32.80]
*/
void WINAPI DragFinish(HDROP h)
{ TRACE_(shell)("\n");
{
TRACE("\n");
GlobalFree((HGLOBAL)h);
}
@ -273,7 +274,8 @@ void WINAPI DragFinish(HDROP h)
* DragFinish16 [SHELL.12]
*/
void WINAPI DragFinish16(HDROP16 h)
{ TRACE_(shell)("\n");
{
TRACE("\n");
GlobalFree16((HGLOBAL16)h);
}
@ -285,7 +287,7 @@ BOOL WINAPI DragQueryPoint(HDROP hDrop, POINT *p)
{
LPDROPFILESTRUCT lpDropFileStruct;
BOOL bRet;
TRACE_(shell)("\n");
TRACE("\n");
lpDropFileStruct = (LPDROPFILESTRUCT) GlobalLock(hDrop);
memcpy(p,&lpDropFileStruct->ptMousePos,sizeof(POINT));
@ -302,7 +304,7 @@ BOOL16 WINAPI DragQueryPoint16(HDROP16 hDrop, POINT16 *p)
{
LPDROPFILESTRUCT16 lpDropFileStruct;
BOOL16 bRet;
TRACE_(shell)("\n");
TRACE("\n");
lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop);
memcpy(p,&lpDropFileStruct->ptMousePos,sizeof(POINT16));
@ -332,7 +334,7 @@ HINSTANCE SHELL_FindExecutable( LPCSTR lpFile,
int i; /* random counter */
char xlpFile[256]; /* result of SearchPath */
TRACE_(shell)("%s\n", (lpFile != NULL?lpFile:"-") );
TRACE("%s\n", (lpFile != NULL?lpFile:"-") );
lpResult[0]='\0'; /* Start off with an empty return string */
@ -344,7 +346,7 @@ HINSTANCE SHELL_FindExecutable( LPCSTR lpFile,
}
if (SearchPathA( NULL, lpFile,".exe",sizeof(xlpFile),xlpFile,NULL))
{ TRACE_(shell)("SearchPath32A returned non-zero\n");
{ TRACE("SearchPath32A returned non-zero\n");
lpFile = xlpFile;
}
@ -352,17 +354,17 @@ HINSTANCE SHELL_FindExecutable( LPCSTR lpFile,
extension = strrchr( xlpFile, '.' ); /* Assume last "." is the one; */
/* File->Run in progman uses */
/* .\FILE.EXE :( */
TRACE_(shell)("xlpFile=%s,extension=%s\n", xlpFile, extension);
TRACE("xlpFile=%s,extension=%s\n", xlpFile, extension);
if ((extension == NULL) || (extension == &xlpFile[strlen(xlpFile)]))
{ WARN_(shell)("Returning 31 - No association\n");
{ WARN("Returning 31 - No association\n");
return 31; /* no association */
}
/* Make local copy & lowercase it for reg & 'programs=' lookup */
lstrcpynA( tmpext, extension, 5 );
CharLowerA( tmpext );
TRACE_(shell)("%s file\n", tmpext);
TRACE("%s file\n", tmpext);
/* Three places to check: */
/* 1. win.ini, [windows], programs (NB no leading '.') */
@ -387,8 +389,8 @@ HINSTANCE SHELL_FindExecutable( LPCSTR lpFile,
strcpy(lpResult, xlpFile);
/* Need to perhaps check that the file has a path
* attached */
TRACE_(shell)("found %s\n", lpResult);
return 33;
TRACE("found %s\n", lpResult);
return 33;
/* Greater than 32 to indicate success FIXME According to the
* docs, I should be returning a handle for the
@ -404,7 +406,7 @@ HINSTANCE SHELL_FindExecutable( LPCSTR lpFile,
&filetypelen ) == ERROR_SUCCESS )
{
filetype[filetypelen]='\0';
TRACE_(shell)("File type: %s\n", filetype);
TRACE("File type: %s\n", filetype);
/* Looking for ...buffer\shell\lpOperation\command */
strcat( filetype, "\\shell\\" );
@ -457,7 +459,7 @@ HINSTANCE SHELL_FindExecutable( LPCSTR lpFile,
}
}
TRACE_(shell)("returning %s\n", lpResult);
TRACE("returning %s\n", lpResult);
return retval;
}
@ -471,7 +473,7 @@ HINSTANCE16 WINAPI ShellExecute16( HWND16 hWnd, LPCSTR lpOperation,
char old_dir[1024];
char cmd[256];
TRACE_(shell)("(%04x,'%s','%s','%s','%s',%x)\n",
TRACE("(%04x,'%s','%s','%s','%s',%x)\n",
hWnd, lpOperation ? lpOperation:"<null>", lpFile ? lpFile:"<null>",
lpParameters ? lpParameters : "<null>",
lpDirectory ? lpDirectory : "<null>", iShowCmd);
@ -495,7 +497,7 @@ HINSTANCE16 WINAPI ShellExecute16( HWND16 hWnd, LPCSTR lpOperation,
strcat(cmd,lpParameters);
}
TRACE_(shell)("starting %s\n",cmd);
TRACE("starting %s\n",cmd);
SYSLEVEL_ReleaseWin16Lock();
retval = WinExec( cmd, iShowCmd );
SYSLEVEL_RestoreWin16Lock();
@ -539,7 +541,7 @@ static DWORD SHELL_GetResourceTable(HFILE hFile,LPBYTE *retptr)
char magic[4];
int size;
TRACE_(shell)("\n");
TRACE("\n");
*retptr = NULL;
_llseek( hFile, 0, SEEK_SET );
@ -598,7 +600,7 @@ static HGLOBAL16 SHELL_LoadResource(HINSTANCE16 hInst, HFILE hFile, NE_NAMEINFO*
{ BYTE* ptr;
HGLOBAL16 handle = DirectResAlloc16( hInst, 0x10, (DWORD)pNInfo->length << sizeShift);
TRACE_(shell)("\n");
TRACE("\n");
if( (ptr = (BYTE*)GlobalLock16( handle )) )
{ _llseek( hFile, (DWORD)pNInfo->offset << sizeShift, SEEK_SET);
@ -614,7 +616,7 @@ static HGLOBAL16 SHELL_LoadResource(HINSTANCE16 hInst, HFILE hFile, NE_NAMEINFO*
static HGLOBAL16 ICO_LoadIcon(HINSTANCE16 hInst, HFILE hFile, LPicoICONDIRENTRY lpiIDE)
{ BYTE* ptr;
HGLOBAL16 handle = DirectResAlloc16( hInst, 0x10, lpiIDE->dwBytesInRes);
TRACE_(shell)("\n");
TRACE("\n");
if( (ptr = (BYTE*)GlobalLock16( handle )) )
{ _llseek( hFile, lpiIDE->dwImageOffset, SEEK_SET);
_lread( hFile, (char*)ptr, lpiIDE->dwBytesInRes);
@ -633,7 +635,7 @@ static HGLOBAL16 ICO_GetIconDirectory(HINSTANCE16 hInst, HFILE hFile, LPicoICOND
LPicoICONDIR lpiID;
int i;
TRACE_(shell)("\n");
TRACE("\n");
_llseek( hFile, 0, SEEK_SET );
if( _lread(hFile,(char*)id,sizeof(id)) != sizeof(id) ) return 0;
@ -688,7 +690,7 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
LPBYTE peimage;
HANDLE fmapping;
TRACE_(shell)("(%04x,file %s,start %d,extract %d\n",
TRACE("(%04x,file %s,start %d,extract %d\n",
hInstance, lpszExeFileName, nIconIndex, n);
if( hFile == HFILE_ERROR || !n )
@ -718,12 +720,12 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
{ if( pTInfo->type_id == NE_RSCTYPE_GROUP_ICON ) /* find icon directory and icon repository */
{ iconDirCount = pTInfo->count;
pIconDir = ((NE_NAMEINFO*)(pTInfo + 1));
TRACE_(shell)("\tfound directory - %i icon families\n", iconDirCount);
TRACE("\tfound directory - %i icon families\n", iconDirCount);
}
if( pTInfo->type_id == NE_RSCTYPE_ICON )
{ iconCount = pTInfo->count;
pIconStorage = ((NE_NAMEINFO*)(pTInfo + 1));
TRACE_(shell)("\ttotal icons - %i\n", iconCount);
TRACE("\ttotal icons - %i\n", iconCount);
}
pTInfo = (NE_TYPEINFO *)((char*)(pTInfo+1)+pTInfo->count*sizeof(NE_NAMEINFO));
}
@ -790,13 +792,13 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
fmapping = CreateFileMappingA(hFile,NULL,PAGE_READONLY|SEC_COMMIT,0,0,NULL);
if (fmapping == 0)
{ /* FIXME, INVALID_HANDLE_VALUE? */
WARN_(shell)("failed to create filemap.\n");
WARN("failed to create filemap.\n");
hRet = 0;
goto end_2; /* failure */
}
peimage = MapViewOfFile(fmapping,FILE_MAP_READ,0,0,0);
if (!peimage)
{ WARN_(shell)("failed to mmap filemap.\n");
{ WARN("failed to mmap filemap.\n");
hRet = 0;
goto end_2; /* failure */
}
@ -822,14 +824,14 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
}
if (!rootresdir)
{ WARN_(shell)("haven't found section for resource directory.\n");
{ WARN("haven't found section for resource directory.\n");
goto end_4; /* failure */
}
icongroupresdir = GetResDirEntryW(rootresdir,RT_GROUP_ICONW, (DWORD)rootresdir,FALSE);
if (!icongroupresdir)
{ WARN_(shell)("No Icongroupresourcedirectory!\n");
{ WARN("No Icongroupresourcedirectory!\n");
goto end_4; /* failure */
}
@ -841,7 +843,7 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
}
if (nIconIndex >= iconDirCount)
{ WARN_(shell)("nIconIndex %d is larger than iconDirCount %d\n",nIconIndex,iconDirCount);
{ WARN("nIconIndex %d is larger than iconDirCount %d\n",nIconIndex,iconDirCount);
GlobalFree16(hRet);
goto end_4; /* failure */
}
@ -882,7 +884,7 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
}
if (!igdata)
{ WARN_(shell)("no matching real address for icongroup!\n");
{ WARN("no matching real address for icongroup!\n");
goto end_4; /* failure */
}
/* found */
@ -894,7 +896,7 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
iconresdir=GetResDirEntryW(rootresdir,RT_ICONW,(DWORD)rootresdir,FALSE);
if (!iconresdir)
{ WARN_(shell)("No Iconresourcedirectory!\n");
{ WARN("No Iconresourcedirectory!\n");
goto end_4; /* failure */
}
@ -914,7 +916,7 @@ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
idata = peimage+(idataent->OffsetToData-pe_sections[j].VirtualAddress+pe_sections[j].PointerToRawData);
}
if (!idata)
{ WARN_(shell)("no matching real address found for icondata!\n");
{ WARN("no matching real address found for icondata!\n");
RetPtr[i]=0;
continue;
}
@ -937,7 +939,7 @@ end_1: _lclose( hFile);
*/
HICON16 WINAPI ExtractIcon16( HINSTANCE16 hInstance, LPCSTR lpszExeFileName,
UINT16 nIconIndex )
{ TRACE_(shell)("\n");
{ TRACE("\n");
return ExtractIconA( hInstance, lpszExeFileName, nIconIndex );
}
@ -981,14 +983,14 @@ HICON16 WINAPI ExtractIconEx16(
* executable) and patch parameters if needed.
*/
HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
{ TRACE_(shell)("\n");
{ TRACE("\n");
return ExtractAssociatedIcon16(hInst,lpIconPath,lpiIcon);
}
HICON16 WINAPI ExtractAssociatedIcon16(HINSTANCE16 hInst, LPSTR lpIconPath, LPWORD lpiIcon)
{ HICON16 hIcon;
TRACE_(shell)("\n");
TRACE("\n");
hIcon = ExtractIcon16(hInst, lpIconPath, *lpiIcon);
@ -1025,7 +1027,7 @@ HICON16 WINAPI ExtractAssociatedIcon16(HINSTANCE16 hInst, LPSTR lpIconPath, LPWO
LPSTR SHELL_FindString(LPSTR lpEnv, LPCSTR entry)
{ UINT16 l;
TRACE_(shell)("\n");
TRACE("\n");
l = strlen(entry);
for( ; *lpEnv ; lpEnv+=strlen(lpEnv)+1 )
@ -1042,7 +1044,7 @@ LPSTR SHELL_FindString(LPSTR lpEnv, LPCSTR entry)
SEGPTR WINAPI FindEnvironmentString16(LPSTR str)
{ SEGPTR spEnv;
LPSTR lpEnv,lpString;
TRACE_(shell)("\n");
TRACE("\n");
spEnv = GetDOSEnvironment16();
@ -1069,7 +1071,7 @@ DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
CharToOemA(str,str);
TRACE_(shell)("accept %s\n", str);
TRACE("accept %s\n", str);
while( *lpstr && lpbstr - lpBuffer < length )
{
@ -1089,7 +1091,7 @@ DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
if( l > length - (lpbstr - lpBuffer) - 1 )
{
WARN_(shell)("-- Env subst aborted - string too short\n");
WARN("-- Env subst aborted - string too short\n");
*lpend = '%';
break;
}
@ -1117,7 +1119,7 @@ DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
else
length = 0;
TRACE_(shell)("-- return %s\n", str);
TRACE("-- return %s\n", str);
OemToCharA(str,str);
HeapFree( GetProcessHeap(), 0, lpBuffer);
@ -1134,7 +1136,7 @@ DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
*/
LRESULT WINAPI ShellHookProc16(INT16 code, WPARAM16 wParam, LPARAM lParam)
{
TRACE_(shell)("%i, %04x, %08x\n", code, wParam,
TRACE("%i, %04x, %08x\n", code, wParam,
(unsigned)lParam );
if( SHELL_hHook && SHELL_hWnd )
{
@ -1155,7 +1157,7 @@ LRESULT WINAPI ShellHookProc16(INT16 code, WPARAM16 wParam, LPARAM lParam)
*/
BOOL WINAPI RegisterShellHook16(HWND16 hWnd, UINT16 uAction)
{
TRACE_(shell)("%04x [%u]\n", hWnd, uAction );
TRACE("%04x [%u]\n", hWnd, uAction );
switch( uAction )
{
@ -1172,7 +1174,7 @@ BOOL WINAPI RegisterShellHook16(HWND16 hWnd, UINT16 uAction)
uMsgShellActivate = RegisterWindowMessageA( lpstrMsgShellActivate );
}
else
WARN_(shell)("-- unable to install ShellHookProc()!\n");
WARN("-- unable to install ShellHookProc()!\n");
}
if ( SHELL_hHook )
@ -1180,7 +1182,7 @@ BOOL WINAPI RegisterShellHook16(HWND16 hWnd, UINT16 uAction)
break;
default:
WARN_(shell)("-- unknown code %i\n", uAction );
WARN("-- unknown code %i\n", uAction );
SHELL_hWnd = 0; /* just in case */
}
return FALSE;

72
dlls/shell32/shell32_main.c
View File

@ -28,8 +28,8 @@
#include "wine/undocshell.h"
#include "shpolicy.h"
DEFAULT_DEBUG_CHANNEL(shell)
DECLARE_DEBUG_CHANNEL(exec)
DECLARE_DEBUG_CHANNEL(shell)
#define MORE_DEBUG 1
/*************************************************************************
@ -38,7 +38,7 @@ DECLARE_DEBUG_CHANNEL(shell)
LPWSTR* WINAPI CommandLineToArgvW(LPWSTR cmdline,LPDWORD numargs)
{ LPWSTR *argv,s,t;
int i;
TRACE_(shell)("\n");
TRACE("\n");
/* to get writeable copy */
cmdline = HEAP_strdupW( GetProcessHeap(), 0, cmdline);
@ -91,7 +91,7 @@ LPWSTR* WINAPI CommandLineToArgvW(LPWSTR cmdline,LPDWORD numargs)
void WINAPI Control_RunDLL( HWND hwnd, LPCVOID code, LPCSTR cmd, DWORD arg4 )
{
FIXME_(shell)("(0x%08x, %p, %s, 0x%08lx): stub\n", hwnd, code,
FIXME("(0x%08x, %p, %s, 0x%08lx): stub\n", hwnd, code,
debugstr_a(cmd), arg4);
}
@ -111,7 +111,7 @@ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
LPITEMIDLIST pidlLast, pidl = NULL;
HRESULT hr = S_OK;
TRACE_(shell)("(%s,0x%lx,%p,0x%x,0x%x)\n",
TRACE("(%s,0x%lx,%p,0x%x,0x%x)\n",
(flags & SHGFI_PIDL)? "pidl" : path, dwFileAttributes, psfi, sizeofpsfi, flags);
#ifdef MORE_DEBUG
@ -127,7 +127,7 @@ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
pidl = (LPCITEMIDLIST) path;
if (!pidl )
{
ERR_(shell)("pidl is null!\n");
ERR("pidl is null!\n");
return FALSE;
}
}
@ -176,16 +176,16 @@ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
/* ### icons ###*/
if (flags & SHGFI_LINKOVERLAY)
FIXME_(shell)("set icon to link, stub\n");
FIXME("set icon to link, stub\n");
if (flags & SHGFI_OPENICON)
FIXME_(shell)("set to open icon, stub\n");
FIXME("set to open icon, stub\n");
if (flags & SHGFI_SELECTED)
FIXME_(shell)("set icon to selected, stub\n");
FIXME("set icon to selected, stub\n");
if (flags & SHGFI_SHELLICONSIZE)
FIXME_(shell)("set icon to shell size, stub\n");
FIXME("set icon to shell size, stub\n");
/* get the iconlocation */
if (SUCCEEDED(hr) && (flags & SHGFI_ICONLOCATION ))
@ -254,10 +254,10 @@ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
if (flags & SHGFI_EXETYPE)
FIXME_(shell)("type of executable, stub\n");
FIXME("type of executable, stub\n");
if (flags & (SHGFI_UNKNOWN1 | SHGFI_UNKNOWN2 | SHGFI_UNKNOWN3))
FIXME_(shell)("unknown attribute!\n");
FIXME("unknown attribute!\n");
if (psfParent)
IShellFolder_Release(psfParent);
@ -266,7 +266,7 @@ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
ret = FALSE;
#ifdef MORE_DEBUG
TRACE_(shell) ("icon=0x%08x index=0x%08x attr=0x%08lx name=%s type=%s\n",
TRACE ("icon=0x%08x index=0x%08x attr=0x%08lx name=%s type=%s\n",
psfi->hIcon, psfi->iIcon, psfi->dwAttributes, psfi->szDisplayName, psfi->szTypeName);
#endif
return ret;
@ -279,7 +279,7 @@ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
DWORD WINAPI SHGetFileInfoW(LPCWSTR path,DWORD dwFileAttributes,
SHFILEINFOW *psfi, UINT sizeofpsfi,
UINT flags )
{ FIXME_(shell)("(%s,0x%lx,%p,0x%x,0x%x)\n",
{ FIXME("(%s,0x%lx,%p,0x%x,0x%x)\n",
debugstr_w(path),dwFileAttributes,psfi,sizeofpsfi,flags);
return 0;
}
@ -290,7 +290,7 @@ DWORD WINAPI SHGetFileInfoW(LPCWSTR path,DWORD dwFileAttributes,
HICON WINAPI ExtractIconA( HINSTANCE hInstance, LPCSTR lpszExeFileName,
UINT nIconIndex )
{ HGLOBAL16 handle = InternalExtractIcon16(hInstance,lpszExeFileName,nIconIndex, 1);
TRACE_(shell)("\n");
TRACE("\n");
if( handle )
{
HICON16* ptr = (HICON16*)GlobalLock16(handle);
@ -309,7 +309,7 @@ HICON WINAPI ExtractIconW( HINSTANCE hInstance, LPCWSTR lpszExeFileName,
UINT nIconIndex )
{ LPSTR exefn;
HICON ret;
TRACE_(shell)("\n");
TRACE("\n");
exefn = HEAP_strdupWtoA(GetProcessHeap(),0,lpszExeFileName);
ret = ExtractIconA(hInstance,exefn,nIconIndex);
@ -326,7 +326,7 @@ HINSTANCE WINAPI FindExecutableA( LPCSTR lpFile, LPCSTR lpDirectory,
{ HINSTANCE retval=31; /* default - 'No association was found' */
char old_dir[1024];
TRACE_(shell)("File %s, Dir %s\n",
TRACE("File %s, Dir %s\n",
(lpFile != NULL?lpFile:"-"),
(lpDirectory != NULL?lpDirectory:"-"));
@ -345,7 +345,7 @@ HINSTANCE WINAPI FindExecutableA( LPCSTR lpFile, LPCSTR lpDirectory,
retval = SHELL_FindExecutable( lpFile, "open", lpResult );
TRACE_(shell)("returning %s\n", lpResult);
TRACE("returning %s\n", lpResult);
if (lpDirectory)
SetCurrentDirectoryA( old_dir );
return retval;
@ -357,7 +357,7 @@ HINSTANCE WINAPI FindExecutableA( LPCSTR lpFile, LPCSTR lpDirectory,
HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory,
LPWSTR lpResult)
{
FIXME_(shell)("(%p,%p,%p): stub\n", lpFile, lpDirectory, lpResult);
FIXME("(%p,%p,%p): stub\n", lpFile, lpDirectory, lpResult);
return 31; /* default - 'No association was found' */
}
@ -392,7 +392,7 @@ static BOOL __get_dropline( HWND hWnd, LPRECT lprect )
*/
UINT WINAPI SHAppBarMessage(DWORD msg, PAPPBARDATA data)
{
FIXME_(shell)("(0x%08lx,%p hwnd=0x%08x): stub\n", msg, data, data->hWnd);
FIXME("(0x%08lx,%p hwnd=0x%08x): stub\n", msg, data, data->hWnd);
switch (msg)
{ case ABM_GETSTATE:
@ -435,7 +435,7 @@ DWORD WINAPI SHHelpShortcuts_RunDLL (DWORD dwArg1, DWORD dwArg2, DWORD dwArg3, D
*/
DWORD WINAPI SHLoadInProc (DWORD dwArg1)
{ FIXME_(shell)("(%lx) empty stub!\n", dwArg1);
{ FIXME("(%lx) empty stub!\n", dwArg1);
return 0;
}
@ -445,7 +445,7 @@ DWORD WINAPI SHLoadInProc (DWORD dwArg1)
HINSTANCE WINAPI ShellExecuteA( HWND hWnd, LPCSTR lpOperation,
LPCSTR lpFile, LPCSTR lpParameters,
LPCSTR lpDirectory, INT iShowCmd )
{ TRACE_(shell)("\n");
{ TRACE("\n");
return ShellExecute16( hWnd, lpOperation, lpFile, lpParameters,
lpDirectory, iShowCmd );
}
@ -465,7 +465,7 @@ ShellExecuteW(
LPCWSTR lpDirectory,
INT nShowCmd) {
FIXME_(shell)(": stub\n");
FIXME(": stub\n");
return 0;
}
@ -477,7 +477,7 @@ BOOL WINAPI AboutDlgProc( HWND hWnd, UINT msg, WPARAM wParam,
{ HWND hWndCtl;
char Template[512], AppTitle[512];
TRACE_(shell)("\n");
TRACE("\n");
switch(msg)
{ case WM_INITDIALOG:
@ -612,7 +612,7 @@ BOOL WINAPI ShellAboutA( HWND hWnd, LPCSTR szApp, LPCSTR szOtherStuff,
{ ABOUT_INFO info;
HRSRC hRes;
LPVOID template;
TRACE_(shell)("\n");
TRACE("\n");
if(!(hRes = FindResourceA(shell32_hInstance, "SHELL_ABOUT_MSGBOX", RT_DIALOGA)))
return FALSE;
@ -638,7 +638,7 @@ BOOL WINAPI ShellAboutW( HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff,
HRSRC hRes;
LPVOID template;
TRACE_(shell)("\n");
TRACE("\n");
if(!(hRes = FindResourceA(shell32_hInstance, "SHELL_ABOUT_MSGBOX", RT_DIALOGA)))
return FALSE;
@ -663,7 +663,7 @@ BOOL WINAPI ShellAboutW( HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff,
* Any ideas on how this is to be implimented?
*/
BOOL WINAPI Shell_NotifyIcon( DWORD dwMessage, PNOTIFYICONDATAA pnid )
{ FIXME_(shell)("Taskbar Notification Area functionality not implemented !\n");
{ FIXME("Taskbar Notification Area functionality not implemented !\n");
return TRUE; /* pretend success */
}
@ -674,7 +674,7 @@ BOOL WINAPI Shell_NotifyIcon( DWORD dwMessage, PNOTIFYICONDATAA pnid )
* Any ideas on how this is to be implimented?
*/
BOOL WINAPI Shell_NotifyIconA(DWORD dwMessage, PNOTIFYICONDATAA pnid )
{ FIXME_(shell)("Taskbar Notification Area functionality not implemented !\n");
{ FIXME("Taskbar Notification Area functionality not implemented !\n");
return TRUE; /* pretend success */
}
@ -682,7 +682,7 @@ BOOL WINAPI Shell_NotifyIconA(DWORD dwMessage, PNOTIFYICONDATAA pnid )
* FreeIconList
*/
void WINAPI FreeIconList( DWORD dw )
{ FIXME_(shell)("(%lx): stub\n",dw);
{ FIXME("(%lx): stub\n",dw);
}
/***********************************************************************
@ -704,7 +704,7 @@ void WINAPI FreeIconList( DWORD dw )
HRESULT WINAPI SHELL32_DllGetVersion (DLLVERSIONINFO *pdvi)
{
if (pdvi->cbSize != sizeof(DLLVERSIONINFO))
{ WARN_(shell)("wrong DLLVERSIONINFO size from app");
{ WARN("wrong DLLVERSIONINFO size from app");
return E_INVALIDARG;
}
@ -713,7 +713,7 @@ HRESULT WINAPI SHELL32_DllGetVersion (DLLVERSIONINFO *pdvi)
pdvi->dwBuildNumber = 3110;
pdvi->dwPlatformID = 1;
TRACE_(shell)("%lu.%lu.%lu.%lu\n",
TRACE("%lu.%lu.%lu.%lu\n",
pdvi->dwMajorVersion, pdvi->dwMinorVersion,
pdvi->dwBuildNumber, pdvi->dwPlatformID);
@ -775,7 +775,7 @@ BOOL WINAPI Shell32LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
{
HMODULE hUser32;
TRACE_(shell)("0x%x 0x%lx %p\n", hinstDLL, fdwReason, fImpLoad);
TRACE("0x%x 0x%lx %p\n", hinstDLL, fdwReason, fImpLoad);
switch (fdwReason)
{
@ -783,7 +783,7 @@ BOOL WINAPI Shell32LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
shell32_RefCount++;
if (shell32_hInstance)
{
ERR_(shell)("shell32.dll instantiated twice in one address space!\n");
ERR("shell32.dll instantiated twice in one address space!\n");
}
else
{
@ -799,7 +799,7 @@ BOOL WINAPI Shell32LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
if (!hComctl32 || !hUser32 || !hOle32)
{
ERR_(shell)("P A N I C SHELL32 loading failed\n");
ERR("P A N I C SHELL32 loading failed\n");
return FALSE;
}
@ -867,14 +867,14 @@ BOOL WINAPI Shell32LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
/* this one is here to check if AddRef/Release is balanced */
if (shell32_ObjCount)
{
WARN_(shell)("leaving with %u objects left (memory leak)\n", shell32_ObjCount);
WARN("leaving with %u objects left (memory leak)\n", shell32_ObjCount);
}
}
FreeLibrary(hOle32);
FreeLibrary(hComctl32);
TRACE_(shell)("refcount=%u objcount=%u \n", shell32_RefCount, shell32_ObjCount);
TRACE("refcount=%u objcount=%u \n", shell32_RefCount, shell32_ObjCount);
break;
}
return TRUE;
@ -891,7 +891,7 @@ BOOL WINAPI Shell32LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
{
FIXME_(shell)("(%s, %s): stub!\n", bInstall ? "TRUE":"FALSE", debugstr_w(cmdline));
FIXME("(%s, %s): stub!\n", bInstall ? "TRUE":"FALSE", debugstr_w(cmdline));
return S_OK; /* indicate success */
}

4
dlls/shell32/shellole.c
View File

@ -170,7 +170,7 @@ DWORD WINAPI SHGetDesktopFolder(IShellFolder **psf)
{
HRESULT hres = S_OK;
LPCLASSFACTORY lpclf;
TRACE_(shell)("%p->(%p)\n",psf,*psf);
TRACE("%p->(%p)\n",psf,*psf);
*psf=NULL;
@ -191,7 +191,7 @@ DWORD WINAPI SHGetDesktopFolder(IShellFolder **psf)
*psf = pdesktopfolder;
}
TRACE_(shell)("-- %p->(%p)\n",psf, *psf);
TRACE("-- %p->(%p)\n",psf, *psf);
return hres;
}

156
dlls/tapi32/line.c
View File

@ -12,253 +12,253 @@
#include "tapi.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(tapi)
DECLARE_DEBUG_CHANNEL(comm)
DECLARE_DEBUG_CHANNEL(tapi)
DWORD WINAPI lineAccept(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
FIXME_(tapi)("(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
FIXME("(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
}
DWORD WINAPI lineAddProvider(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
{
FIXME_(tapi)("(%s, %04x, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
FIXME("(%s, %04x, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
return 1;
}
DWORD WINAPI lineAddToConference(HCALL hConfCall, HCALL hConsultCall)
{
FIXME_(tapi)("(%04x, %04x): stub.\n", hConfCall, hConsultCall);
FIXME("(%04x, %04x): stub.\n", hConfCall, hConsultCall);
return 1;
}
DWORD WINAPI lineAnswer(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
FIXME_(tapi)("(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
FIXME("(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
}
DWORD WINAPI lineBlindTransfer(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
{
FIXME_(tapi)("(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
return 1;
}
DWORD WINAPI lineClose(HLINE hLine)
{
FIXME_(tapi)("(%04x): stub.\n", hLine);
FIXME("(%04x): stub.\n", hLine);
return 0;
}
DWORD WINAPI lineCompleteCall(HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
{
FIXME_(tapi)("(%04x, %p, %08lx, %08lx): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
FIXME("(%04x, %p, %08lx, %08lx): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
return 1;
}
DWORD WINAPI lineCompleteTransfer(HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
{
FIXME_(tapi)("(%04x, %04x, %p, %08lx): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
FIXME("(%04x, %04x, %p, %08lx): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
return 1;
}
DWORD WINAPI lineConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
{
FIXME_(tapi)("(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
FIXME("(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
return 0;
}
DWORD WINAPI lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
{
FIXME_(tapi)("stub.\n");
FIXME("stub.\n");
return 0;
}
DWORD WINAPI lineConfigProvider(HWND hwndOwner, DWORD dwPermanentProviderID)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hwndOwner, dwPermanentProviderID);
FIXME("(%04x, %08lx): stub.\n", hwndOwner, dwPermanentProviderID);
return 0;
}
DWORD WINAPI lineDeallocateCall(HCALL hCall)
{
FIXME_(tapi)("(%04x): stub.\n", hCall);
FIXME("(%04x): stub.\n", hCall);
return 0;
}
DWORD WINAPI lineDevSpecific(HLINE hLine, DWORD dwAddressId, HCALL hCall, LPVOID lpParams, DWORD dwSize)
{
FIXME_(tapi)("(%04x, %08lx, %04x, %p, %ld): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
FIXME("(%04x, %08lx, %04x, %p, %ld): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
return 1;
}
DWORD WINAPI lineDevSpecificFeature(HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
{
FIXME_(tapi)("(%04x, %08lx, %p, %ld): stub.\n", hLine, dwFeature, lpParams, dwSize);
FIXME("(%04x, %08lx, %p, %ld): stub.\n", hLine, dwFeature, lpParams, dwSize);
return 1;
}
DWORD WINAPI lineDial(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
{
FIXME_(tapi)("(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
return 1;
}
DWORD WINAPI lineDrop(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
FIXME_(tapi)("(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
}
DWORD WINAPI lineForward(HLINE hLine, DWORD bAllAddress, DWORD dwAdressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
{
FIXME_(tapi)("stub.\n");
FIXME("stub.\n");
return 1;
}
DWORD WINAPI lineGatherDigits(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
{
FIXME_(tapi)("stub.\n");
FIXME("stub.\n");
return 0;
}
DWORD WINAPI lineGenerateDigits(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
{
FIXME_(tapi)("(%04x, %08lx, %s, %ld): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
FIXME("(%04x, %08lx, %s, %ld): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
return 0;
}
DWORD WINAPI lineGenerateTone(HCALL hCall, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE lpTones)
{
FIXME_(tapi)("(%04x, %08lx, %ld, %ld, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
FIXME("(%04x, %08lx, %ld, %ld, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
return 0;
}
DWORD WINAPI lineGetAddressCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
{
FIXME_(tapi)("(%04x, %08lx, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
FIXME("(%04x, %08lx, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
return 0;
}
DWORD WINAPI lineGetAddressID(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
{
FIXME_(tapi)("%04x, %p, %08lx, %s, %ld): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
FIXME("%04x, %p, %08lx, %s, %ld): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
return 0;
}
DWORD WINAPI lineGetAddressStatus(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
{
FIXME_(tapi)("(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
FIXME("(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
return 0;
}
DWORD WINAPI lineGetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
{
FIXME_(tapi)("(%s, %08lx, %p, %08lx, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
FIXME("(%s, %08lx, %p, %08lx, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
return 0;
}
DWORD WINAPI lineGetCallInfo(HCALL hCall, LPLINECALLINFO lpCallInfo)
{
FIXME_(tapi)("(%04x, %p): stub.\n", hCall, lpCallInfo);
FIXME("(%04x, %p): stub.\n", hCall, lpCallInfo);
return 0;
}
DWORD WINAPI lineGetCallStatus(HCALL hCall, LPLINECALLSTATUS lpCallStatus)
{
FIXME_(tapi)("(%04x, %p): stub.\n", hCall, lpCallStatus);
FIXME("(%04x, %p): stub.\n", hCall, lpCallStatus);
return 0;
}
DWORD WINAPI lineGetConfRelatedCalls(HCALL hCall, LPLINECALLLIST lpCallList)
{
FIXME_(tapi)("(%04x, %p): stub.\n", hCall, lpCallList);
FIXME("(%04x, %p): stub.\n", hCall, lpCallList);
return 0;
}
DWORD WINAPI lineGetCountry(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
{
FIXME_(tapi)("(%08lx, %08lx, %p): stub.\n", dwCountryID, dwAPIVersion, lpLineCountryList);
FIXME("(%08lx, %08lx, %p): stub.\n", dwCountryID, dwAPIVersion, lpLineCountryList);
return 0;
}
DWORD WINAPI lineGetDevCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
{
FIXME_(tapi)("(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpLineDevCaps);
FIXME("(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpLineDevCaps);
return 0;
}
DWORD WINAPI lineGetDevConfig(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
{
FIXME_(tapi)("(%08lx, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
FIXME("(%08lx, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
return 0;
}
DWORD WINAPI lineGetID(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
{
FIXME_(tapi)("(%04x, %08lx, %04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, hCall, dwSelect, lpDeviceID, lpszDeviceClass);
FIXME("(%04x, %08lx, %04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, hCall, dwSelect, lpDeviceID, lpszDeviceClass);
return 0;
}
DWORD WINAPI lineGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
{
FIXME_(tapi)("(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
FIXME("(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
return 0;
}
DWORD WINAPI lineGetLineDevStatus(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
{
FIXME_(tapi)("(%04x, %p): stub.\n", hLine, lpLineDevStatus);
FIXME("(%04x, %p): stub.\n", hLine, lpLineDevStatus);
return 0;
}
DWORD WINAPI lineGetNewCalls(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
{
FIXME_(tapi)("(%04x, %08lx, %08lx, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
FIXME("(%04x, %08lx, %08lx, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
return 0;
}
DWORD WINAPI lineGetNumRings(HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
{
FIXME_(tapi)("(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
FIXME("(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
return 0;
}
DWORD WINAPI lineGetProviderList(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
{
FIXME_(tapi)("(%08lx, %p): stub.\n", dwAPIVersion, lpProviderList);
FIXME("(%08lx, %p): stub.\n", dwAPIVersion, lpProviderList);
return 0;
}
DWORD WINAPI lineGetRequest(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
{
FIXME_(tapi)("%04x, %08lx, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
FIXME("%04x, %08lx, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
return 0;
}
DWORD WINAPI lineGetStatusMessages(HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
{
FIXME_(tapi)("(%04x, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
FIXME("(%04x, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
return 0;
}
DWORD WINAPI lineGetTranslateCaps(HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps)
{
FIXME_(tapi)("(%04x, %08lx, %p): stub.\n", hLineApp, dwAPIVersion, lpTranslateCaps);
FIXME("(%04x, %08lx, %p): stub.\n", hLineApp, dwAPIVersion, lpTranslateCaps);
return 0;
}
DWORD WINAPI lineHandoff(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
{
FIXME_(tapi)("(%04x, %s, %08lx): stub.\n", hCall, lpszFileName, dwMediaMode);
FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpszFileName, dwMediaMode);
return 0;
}
DWORD WINAPI lineHold(HCALL hCall)
{
FIXME_(tapi)("(%04x): stub.\n", hCall);
FIXME("(%04x): stub.\n", hCall);
return 1;
}
@ -275,25 +275,25 @@ DWORD WINAPI lineInitialize(
DWORD WINAPI lineMakeCall(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
{
FIXME_(tapi)("(%04x, %p, %s, %08lx, %p): stub.\n", hLine, lphCall, lpszDestAddress, dwCountryCode, lpCallParams);
FIXME("(%04x, %p, %s, %08lx, %p): stub.\n", hLine, lphCall, lpszDestAddress, dwCountryCode, lpCallParams);
return 1;
}
DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hCall, dwDigitModes);
FIXME("(%04x, %08lx): stub.\n", hCall, dwDigitModes);
return 0;
}
DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hCall, dwMediaModes);
FIXME("(%04x, %08lx): stub.\n", hCall, dwMediaModes);
return 0;
}
DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
{
FIXME_(tapi)("(%04x, %p, %08lx): stub.\n", hCall, lpToneList, dwNumEntries);
FIXME("(%04x, %p, %08lx): stub.\n", hCall, lpToneList, dwNumEntries);
return 0;
}
@ -313,31 +313,31 @@ DWORD WINAPI lineNegotiateAPIVersion(
DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
{
FIXME_(tapi)("stub.\n");
FIXME("stub.\n");
return 0;
}
DWORD WINAPI lineOpen(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
{
FIXME_(tapi)("stub.\n");
FIXME("stub.\n");
return 0;
}
DWORD WINAPI linePark(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
{
FIXME_(tapi)("(%04x, %08lx, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
FIXME("(%04x, %08lx, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
return 1;
}
DWORD WINAPI linePickup(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
{
FIXME_(tapi)("(%04x, %08lx, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
FIXME("(%04x, %08lx, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
return 1;
}
DWORD WINAPI linePrepareAddToConference(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
{
FIXME_(tapi)("(%04x, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
FIXME("(%04x, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
return 1;
}
@ -356,73 +356,73 @@ DWORD WINAPI lineRedirect(
DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
{
FIXME_(tapi)("(%04x, %08lx, %08lx, %08lx): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
FIXME("(%04x, %08lx, %08lx, %08lx): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
return 1;
}
DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
{
FIXME_(tapi)("(%04x): stub.\n", hCall);
FIXME("(%04x): stub.\n", hCall);
return 1;
}
DWORD WINAPI lineRemoveFromConference(HCALL hCall)
{
FIXME_(tapi)("(%04x): stub.\n", hCall);
FIXME("(%04x): stub.\n", hCall);
return 1;
}
DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
{
FIXME_(tapi)("(%08lx, %04x): stub.\n", dwPermanentProviderID, hwndOwner);
FIXME("(%08lx, %04x): stub.\n", dwPermanentProviderID, hwndOwner);
return 1;
}
DWORD WINAPI lineSecureCall(HCALL hCall)
{
FIXME_(tapi)("(%04x): stub.\n", hCall);
FIXME("(%04x): stub.\n", hCall);
return 1;
}
DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
FIXME_(tapi)("(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
}
DWORD WINAPI lineSetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
{
FIXME_(tapi)("(%s, %08lx, %p, %08lx, %s, %08lx): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
FIXME("(%s, %08lx, %p, %08lx, %s, %08lx): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
return 0;
}
DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hCall, dwAppSpecific);
FIXME("(%04x, %08lx): stub.\n", hCall, dwAppSpecific);
return 0;
}
DWORD WINAPI lineSetCallParams(HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
{
FIXME_(tapi)("(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
FIXME("(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
return 1;
}
DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hCall, dwCallPrivilege);
FIXME("(%04x, %08lx): stub.\n", hCall, dwCallPrivilege);
return 0;
}
DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hLineApp, dwLocation);
FIXME("(%04x, %08lx): stub.\n", hLineApp, dwLocation);
return 0;
}
DWORD WINAPI lineSetDevConfig(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
{
FIXME_(tapi)("(%0lx, %p, %08lx, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
FIXME("(%0lx, %p, %08lx, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
return 0;
}
@ -440,90 +440,90 @@ DWORD dwToneNumEntries,
LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
DWORD dwCallStateNumEntries)
{
FIXME_(tapi)(": stub.\n");
FIXME(": stub.\n");
return 0;
}
DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hCall, dwMediaModes);
FIXME("(%04x, %08lx): stub.\n", hCall, dwMediaModes);
return 0;
}
DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
{
FIXME_(tapi)("(%04x, %08lx, %08lx): stub.\n", hLine, dwAddressID, dwNumRings);
FIXME("(%04x, %08lx, %08lx): stub.\n", hLine, dwAddressID, dwNumRings);
return 0;
}
DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
{
FIXME_(tapi)("(%04x, %08lx, %08lx): stub.\n", hLine, dwLineStates, dwAddressStates);
FIXME("(%04x, %08lx, %08lx): stub.\n", hLine, dwLineStates, dwAddressStates);
return 0;
}
DWORD WINAPI lineSetTerminal(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
{
FIXME_(tapi)("(%04x, %08lx, %04x, %08lx, %08lx, %08lx, %08lx): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
FIXME("(%04x, %08lx, %04x, %08lx, %08lx, %08lx, %08lx): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
return 1;
}
DWORD WINAPI lineSetTollList(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
{
FIXME_(tapi)("(%04x, %08lx, %s, %08lx): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
FIXME("(%04x, %08lx, %s, %08lx): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
return 0;
}
DWORD WINAPI lineSetupConference(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
{
FIXME_(tapi)("(%04x, %04x, %p, %p, %08lx, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
FIXME("(%04x, %04x, %p, %p, %08lx, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
return 1;
}
DWORD WINAPI lineSetupTransfer(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
{
FIXME_(tapi)("(%04x, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
FIXME("(%04x, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
return 1;
}
DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
{
FIXME_(tapi)("(%04x): stub.\n", hLineApp);
FIXME("(%04x): stub.\n", hLineApp);
return 0;
}
DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
{
FIXME_(tapi)("(active: %04x, held: %04x): stub.\n", hActiveCall, hHeldCall);
FIXME("(active: %04x, held: %04x): stub.\n", hActiveCall, hHeldCall);
return 1;
}
DWORD WINAPI lineTranslateAddress(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
{
FIXME_(tapi)("(%04x, %08lx, %08lx, %s, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
FIXME("(%04x, %08lx, %08lx, %s, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
return 0;
}
DWORD WINAPI lineTranslateDialog(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
{
FIXME_(tapi)("(%04x, %08lx, %08lx, %04x, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
FIXME("(%04x, %08lx, %08lx, %04x, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
return 0;
}
DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
{
FIXME_(tapi)("(%04x, %08lx): stub.\n", hLine, dwCompletionID);
FIXME("(%04x, %08lx): stub.\n", hLine, dwCompletionID);
return 1;
}
DWORD WINAPI lineUnHold(HCALL hCall)
{
FIXME_(tapi)("(%04x): stub.\n", hCall);
FIXME("(%04x): stub.\n", hCall);
return 1;
}
DWORD WINAPI lineUnpark(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
{
FIXME_(tapi)("(%04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
FIXME("(%04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
return 1;
}

14
files/directory.c
View File

@ -30,7 +30,7 @@
#include "options.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(dosfs)
DEFAULT_DEBUG_CHANNEL(dosfs)
DECLARE_DEBUG_CHANNEL(file)
static DOS_FULL_NAME DIR_Windows;
@ -125,14 +125,14 @@ int DIR_Init(void)
SetEnvironmentVariableA( "windir", DIR_Windows.short_name );
SetEnvironmentVariableA( "winsysdir", DIR_System.short_name );
TRACE_(dosfs)("WindowsDir = %s (%s)\n",
TRACE("WindowsDir = %s (%s)\n",
DIR_Windows.short_name, DIR_Windows.long_name );
TRACE_(dosfs)("SystemDir = %s (%s)\n",
TRACE("SystemDir = %s (%s)\n",
DIR_System.short_name, DIR_System.long_name );
TRACE_(dosfs)("TempDir = %s (%s)\n",
TRACE("TempDir = %s (%s)\n",
tmp_dir.short_name, tmp_dir.long_name );
TRACE_(dosfs)("Path = %s\n", path );
TRACE_(dosfs)("Cwd = %c:\\%s\n",
TRACE("Path = %s\n", path );
TRACE("Cwd = %c:\\%s\n",
'A' + drive, DRIVE_GetDosCwd( drive ) );
return 1;
@ -650,7 +650,7 @@ DWORD WINAPI SearchPathA( LPCSTR path, LPCSTR name, LPCSTR ext, DWORD buflen,
for (p = buffer; *p; p++) if (*p == '/') *p = '\\';
if (lastpart) *lastpart = strrchr( buffer, '\\' ) + 1;
}
TRACE_(dosfs)("Returning %d\n", strlen(res) + 3 );
TRACE("Returning %d\n", strlen(res) + 3 );
return strlen(res) + 3;
}

40
files/dos_fs.c
View File

@ -35,7 +35,7 @@
#include "options.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(dosfs)
DEFAULT_DEBUG_CHANNEL(dosfs)
DECLARE_DEBUG_CHANNEL(file)
/* Define the VFAT ioctl to get both short and long file names */
@ -528,13 +528,13 @@ BOOL DOSFS_FindUnixName( LPCSTR path, LPCSTR name, LPSTR long_buf,
while (len > 1 && name[len-1] == '.') len--;
if (long_len < len + 1) return FALSE;
TRACE_(dosfs)("%s,%s\n", path, name );
TRACE("%s,%s\n", path, name );
if (!DOSFS_ToDosFCBFormat( name, dos_name )) dos_name[0] = '\0';
if (!(dir = DOSFS_OpenDir( path )))
{
WARN_(dosfs)("(%s,%s): can't open dir: %s\n",
WARN("(%s,%s): can't open dir: %s\n",
path, name, strerror(errno) );
return FALSE;
}
@ -574,11 +574,11 @@ BOOL DOSFS_FindUnixName( LPCSTR path, LPCSTR name, LPSTR long_buf,
else
DOSFS_Hash( long_name, short_buf, FALSE, ignore_case );
}
TRACE_(dosfs)("(%s,%s) -> %s (%s)\n",
path, name, long_name, short_buf ? short_buf : "***");
TRACE("(%s,%s) -> %s (%s)\n",
path, name, long_name, short_buf ? short_buf : "***");
}
else
WARN_(dosfs)("'%s' not found in '%s'\n", name, path);
WARN("'%s' not found in '%s'\n", name, path);
DOSFS_CloseDir( dir );
return ret;
}
@ -666,7 +666,7 @@ HFILE DOSFS_OpenDevice( const char *name, DWORD access )
to_dup = GetStdHandle( STD_OUTPUT_HANDLE );
break;
default:
FIXME_(dosfs)("can't open CON read/write\n");
FIXME("can't open CON read/write\n");
return HFILE_ERROR;
break;
}
@ -688,7 +688,7 @@ HFILE DOSFS_OpenDevice( const char *name, DWORD access )
if(devname[0])
{
TRACE_(file)("DOSFS_OpenDevice %s is %s\n",
DOSFS_Devices[i].name,devname);
DOSFS_Devices[i].name,devname);
r = FILE_CreateFile( devname, access,
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, -1 );
@ -697,7 +697,7 @@ HFILE DOSFS_OpenDevice( const char *name, DWORD access )
}
}
FIXME_(dosfs)("device open %s not supported (yet)\n",DOSFS_Devices[i].name);
FIXME("device open %s not supported (yet)\n",DOSFS_Devices[i].name);
return HFILE_ERROR;
}
}
@ -757,8 +757,7 @@ BOOL DOSFS_GetFullName( LPCSTR name, BOOL check_last, DOS_FULL_NAME *full )
UINT flags;
char *p_l, *p_s, *root;
TRACE_(dosfs)("%s (last=%d)\n",
name, check_last );
TRACE("%s (last=%d)\n", name, check_last );
if ((full->drive = DOSFS_GetPathDrive( &name )) == -1) return FALSE;
flags = DRIVE_GetFlags( full->drive );
@ -870,8 +869,7 @@ BOOL DOSFS_GetFullName( LPCSTR name, BOOL check_last, DOS_FULL_NAME *full )
}
if (!full->long_name[0]) strcpy( full->long_name, "/" );
if (!full->short_name[2]) strcpy( full->short_name + 2, "\\" );
TRACE_(dosfs)("returning %s = %s\n",
full->long_name, full->short_name );
TRACE("returning %s = %s\n", full->long_name, full->short_name );
return TRUE;
}
@ -1070,7 +1068,7 @@ static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
char *endchar = buffer + sizeof(buffer) - 2;
*endchar = '\0';
TRACE_(dosfs)("converting '%s'\n", name );
TRACE("converting '%s'\n", name );
if (!name || ((drive = DOSFS_GetPathDrive( &name )) == -1) )
{ SetLastError( ERROR_INVALID_PARAMETER );
@ -1144,7 +1142,7 @@ static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
lstrcpynA( result, buffer, len );
}
TRACE_(dosfs)("returning '%s'\n", buffer );
TRACE("returning '%s'\n", buffer );
/* If the lpBuffer buffer is too small, the return value is the
size of the buffer, in characters, required to hold the path. */
@ -1278,7 +1276,7 @@ static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATAA *entry )
lstrcpynA( p, long_name, sizeof(buffer) - (int)(p - buffer) );
if (!FILE_Stat( buffer, &fileinfo ))
{
WARN_(dosfs)("can't stat %s\n", buffer);
WARN("can't stat %s\n", buffer);
continue;
}
if (fileinfo.dwFileAttributes & ~attr) continue;
@ -1300,9 +1298,9 @@ static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATAA *entry )
lstrcpynA( entry->cFileName, long_name, sizeof(entry->cFileName) );
if (!(flags & DRIVE_CASE_PRESERVING)) CharLowerA( entry->cFileName );
TRACE_(dosfs)("returning %s (%s) %02lx %ld\n",
entry->cFileName, entry->cAlternateFileName,
entry->dwFileAttributes, entry->nFileSizeLow );
TRACE("returning %s (%s) %02lx %ld\n",
entry->cFileName, entry->cAlternateFileName,
entry->dwFileAttributes, entry->nFileSizeLow );
return 1;
}
return 0; /* End of directory */
@ -1865,7 +1863,7 @@ DWORD WINAPI QueryDosDeviceA(LPCSTR devname,LPSTR target,DWORD bufsize)
LPSTR s;
char buffer[200];
TRACE_(dosfs)("(%s,...)\n",devname?devname:"<null>");
TRACE("(%s,...)\n", devname ? devname : "<null>");
if (!devname) {
/* return known MSDOS devices */
strcpy(buffer,"CON COM1 COM2 LPT1 NUL ");
@ -1941,7 +1939,7 @@ BOOL WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
* DefineDosDeviceA (KERNEL32.182)
*/
BOOL WINAPI DefineDosDeviceA(DWORD flags,LPCSTR devname,LPCSTR targetpath) {
FIXME_(dosfs)("(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
FIXME("(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}

52
files/drive.c
View File

@ -45,7 +45,7 @@
#include "task.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(dosfs)
DEFAULT_DEBUG_CHANNEL(dosfs)
DECLARE_DEBUG_CHANNEL(file)
typedef struct
@ -204,12 +204,13 @@ int DRIVE_Init(void)
DRIVE_CurDrive = i;
count++;
TRACE_(dosfs)("%s: path=%s type=%s label='%s' serial=%08lx flags=%08x dev=%x ino=%x\n",
name, path, DRIVE_Types[drive->type],
drive->label, drive->serial, drive->flags,
(int)drive->dev, (int)drive->ino );
TRACE("%s: path=%s type=%s label='%s' serial=%08lx "
"flags=%08x dev=%x ino=%x\n",
name, path, DRIVE_Types[drive->type],
drive->label, drive->serial, drive->flags,
(int)drive->dev, (int)drive->ino );
}
else WARN_(dosfs)("%s: not defined\n", name );
else WARN("%s: not defined\n", name );
}
if (!count)
@ -276,7 +277,7 @@ int DRIVE_SetCurrentDrive( int drive )
SetLastError( ERROR_INVALID_DRIVE );
return 0;
}
TRACE_(dosfs)("%c:\n", 'A' + drive );
TRACE("%c:\n", 'A' + drive );
DRIVE_CurDrive = drive;
if (pTask) pTask->curdrive = drive | 0x80;
return 1;
@ -336,9 +337,8 @@ int DRIVE_FindDriveRoot( const char **path )
*next = 0;
if (rootdrive != -1)
TRACE_(dosfs)("%s -> drive %c:, root='%s', name='%s'\n",
buffer, 'A' + rootdrive,
DOSDrives[rootdrive].root, *path );
TRACE("%s -> drive %c:, root='%s', name='%s'\n",
buffer, 'A' + rootdrive, DOSDrives[rootdrive].root, *path );
return rootdrive;
}
@ -459,7 +459,7 @@ int DRIVE_Chdir( int drive, const char *path )
strcpy( buffer, "A:" );
buffer[0] += drive;
TRACE_(dosfs)("(%c:,%s)\n", buffer[0], path );
TRACE("(%c:,%s)\n", buffer[0], path );
lstrcpynA( buffer + 2, path, sizeof(buffer) - 2 );
if (!DOSFS_GetFullName( buffer, TRUE, &full_name )) return 0;
@ -472,7 +472,7 @@ int DRIVE_Chdir( int drive, const char *path )
unix_cwd = full_name.long_name + strlen( DOSDrives[drive].root );
while (*unix_cwd == '/') unix_cwd++;
TRACE_(dosfs)("(%c:): unix_cwd=%s dos_cwd=%s\n",
TRACE("(%c:): unix_cwd=%s dos_cwd=%s\n",
'A' + drive, unix_cwd, full_name.short_name + 3 );
HeapFree( SystemHeap, 0, DOSDrives[drive].dos_cwd );
@ -545,10 +545,8 @@ int DRIVE_SetLogicalMapping ( int existing_drive, int new_drive )
if ( new->root )
{
TRACE_(dosfs)("Can\'t map drive %c to drive %c - "
"drive %c already exists\n",
'A' + existing_drive, 'A' + new_drive,
'A' + new_drive );
TRACE("Can\'t map drive %c to drive %c - drive %c already exists\n",
'A' + existing_drive, 'A' + new_drive, 'A' + new_drive );
/* it is already mapped there, so return success */
if (!strcmp(old->root,new->root))
return 1;
@ -565,8 +563,8 @@ int DRIVE_SetLogicalMapping ( int existing_drive, int new_drive )
new->dev = old->dev;
new->ino = old->ino;
TRACE_(dosfs)("Drive %c is now equal to drive %c\n",
'A' + new_drive, 'A' + existing_drive );
TRACE("Drive %c is now equal to drive %c\n",
'A' + new_drive, 'A' + existing_drive );
return 1;
}
@ -662,7 +660,7 @@ static int DRIVE_GetFreeSpace( int drive, PULARGE_INTEGER size,
#endif
{
FILE_SetDosError();
WARN_(dosfs)("cannot do statfs(%s)\n", DOSDrives[drive].root);
WARN("cannot do statfs(%s)\n", DOSDrives[drive].root);
return 0;
}
@ -855,10 +853,10 @@ BOOL WINAPI GetDiskFreeSpaceExA( LPCSTR root,
{
if ((root[1]) && ((root[1] != ':') || (root[2] != '\\')))
{
FIXME_(dosfs)("there are valid root names which are not supported yet\n");
FIXME("there are valid root names which are not supported yet\n");
/* ..like UNC names, for instance. */
WARN_(dosfs)("invalid root '%s'\n", root );
WARN("invalid root '%s'\n", root );
return FALSE;
}
drive = toupper(root[0]) - 'A';
@ -893,7 +891,7 @@ BOOL WINAPI GetDiskFreeSpaceExA( LPCSTR root,
if (GetVersionExA(&ovi))
{
if (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4)
FIXME_(dosfs)("no per-user quota support yet\n");
FIXME("no per-user quota support yet\n");
}
}
@ -936,7 +934,7 @@ BOOL WINAPI GetDiskFreeSpaceExW( LPCWSTR root, PULARGE_INTEGER avail,
UINT16 WINAPI GetDriveType16(
UINT16 drive /* [in] number (NOT letter) of drive */
) {
TRACE_(dosfs)("(%c:)\n", 'A' + drive );
TRACE("(%c:)\n", 'A' + drive );
switch(DRIVE_GetType(drive))
{
case TYPE_FLOPPY: return DRIVE_REMOVABLE;
@ -981,14 +979,14 @@ UINT16 WINAPI GetDriveType16(
UINT WINAPI GetDriveTypeA(LPCSTR root /* String describing drive */)
{
int drive;
TRACE_(dosfs)("(%s)\n", debugstr_a(root));
TRACE("(%s)\n", debugstr_a(root));
if (NULL == root) drive = DRIVE_GetCurrentDrive();
else
{
if ((root[1]) && (root[1] != ':'))
{
WARN_(dosfs)("invalid root '%s'\n", debugstr_a(root));
WARN("invalid root '%s'\n", debugstr_a(root));
return DRIVE_DOESNOTEXIST;
}
drive = toupper(root[0]) - 'A';
@ -1198,7 +1196,7 @@ BOOL WINAPI GetVolumeInformationA( LPCSTR root, LPSTR label,
{
if ((root[1]) && (root[1] != ':'))
{
WARN_(dosfs)("invalid root '%s'\n",root);
WARN("invalid root '%s'\n",root);
return FALSE;
}
drive = toupper(root[0]) - 'A';
@ -1271,7 +1269,7 @@ BOOL WINAPI GetVolumeInformationW( LPCWSTR root, LPWSTR label,
*/
BOOL WINAPI SetVolumeLabelA(LPCSTR rootpath,LPCSTR volname)
{
FIXME_(dosfs)("(%s,%s),stub!\n",rootpath,volname);
FIXME("(%s,%s),stub!\n",rootpath,volname);
return TRUE;
}

36
graphics/bitblt.c
View File

@ -7,7 +7,7 @@
#include "dc.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(bitblt)
DEFAULT_DEBUG_CHANNEL(bitblt)
DECLARE_DEBUG_CHANNEL(bitmap)
DECLARE_DEBUG_CHANNEL(gdi)
@ -21,8 +21,7 @@ BOOL16 WINAPI PatBlt16( HDC16 hdc, INT16 left, INT16 top,
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
TRACE_(bitblt)("%04x %d,%d %dx%d %06lx\n",
hdc, left, top, width, height, rop );
TRACE("%04x %d,%d %dx%d %06lx\n", hdc, left, top, width, height, rop );
return dc->funcs->pPatBlt( dc, left, top, width, height, rop );
}
@ -36,8 +35,7 @@ BOOL WINAPI PatBlt( HDC hdc, INT left, INT top,
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
TRACE_(bitblt)("%04x %d,%d %dx%d %06lx\n",
hdc, left, top, width, height, rop );
TRACE("%04x %d,%d %dx%d %06lx\n", hdc, left, top, width, height, rop );
return dc->funcs->pPatBlt( dc, left, top, width, height, rop );
}
@ -55,9 +53,9 @@ BOOL16 WINAPI BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
if (!dcDst->funcs->pBitBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE_(bitblt)("hdcSrc=%04x %d,%d %d bpp -> hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
TRACE("hdcSrc=%04x %d,%d %d bpp->hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
return dcDst->funcs->pBitBlt( dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, rop );
}
@ -76,9 +74,9 @@ BOOL WINAPI BitBlt( HDC hdcDst, INT xDst, INT yDst, INT width,
if (!dcDst->funcs->pBitBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE_(bitblt)("hdcSrc=%04x %d,%d %d bpp -> hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
TRACE("hdcSrc=%04x %d,%d %d bpp->hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
return dcDst->funcs->pBitBlt( dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, rop );
}
@ -98,10 +96,10 @@ BOOL16 WINAPI StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
if (!dcDst->funcs->pStretchBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE_(bitblt)("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
TRACE("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
return dcDst->funcs->pStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc,
rop );
@ -122,10 +120,10 @@ BOOL WINAPI StretchBlt( HDC hdcDst, INT xDst, INT yDst,
if (!dcDst->funcs->pStretchBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE_(bitblt)("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
TRACE("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
return dcDst->funcs->pStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc,
rop );

7
graphics/metafiledrv/objects.c
View File

@ -16,8 +16,8 @@
#include "debugtools.h"
#include "heap.h"
DEFAULT_DEBUG_CHANNEL(metafile)
DECLARE_DEBUG_CHANNEL(gdi)
DECLARE_DEBUG_CHANNEL(metafile)
/***********************************************************************
* MFDRV_BITMAP_SelectObject
@ -67,7 +67,7 @@ INT16 MFDRV_CreateBrushIndirect(DC *dc, HBRUSH hBrush )
GetObjectA(brushObj->logbrush.lbHatch, sizeof(bm), &bm);
if(bm.bmBitsPixel != 1 || bm.bmPlanes != 1) {
FIXME_(metafile)("Trying to store a colour pattern brush\n");
FIXME("Trying to store a colour pattern brush\n");
return FALSE;
}
@ -123,8 +123,7 @@ INT16 MFDRV_CreateBrushIndirect(DC *dc, HBRUSH hBrush )
break;
}
default:
FIXME_(metafile)("Unkonwn brush style %x\n",
brushObj->logbrush.lbStyle);
FIXME("Unkonwn brush style %x\n", brushObj->logbrush.lbStyle);
return -1;
}
index = MFDRV_AddHandleDC( dc );

126
graphics/x11drv/dib.c
View File

@ -32,7 +32,7 @@
#include "global.h"
#include "xmalloc.h" /* for XCREATEIMAGE macro */
DECLARE_DEBUG_CHANNEL(bitmap)
DEFAULT_DEBUG_CHANNEL(bitmap)
DECLARE_DEBUG_CHANNEL(x11drv)
static int bitmapDepthTable[] = { 8, 1, 32, 16, 24, 15, 4, 0 };
@ -76,7 +76,7 @@ int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
if( bitmapDepthTable[i] == depth )
return (4 * ((width * ximageDepthTable[i] + 31)/32));
WARN_(bitmap)("(%d): Unsupported depth\n", depth );
WARN("(%d): Unsupported depth\n", depth );
return (4 * width);
}
@ -108,7 +108,7 @@ int *X11DRV_DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth,
if (colors > 256)
{
ERR_(bitmap)("called with >256 colors!\n");
ERR("called with >256 colors!\n");
return NULL;
}
@ -169,7 +169,7 @@ int X11DRV_DIB_MapColor( int *physMap, int nPhysMap, int phys )
if (physMap[color] == phys)
return color;
WARN_(bitmap)("Strange color %08x\n", phys);
WARN("Strange color %08x\n", phys);
return 0;
}
@ -494,9 +494,9 @@ static void X11DRV_DIB_GetImageBits_1( int lines, BYTE *dstbits,
{
unsigned long white = (1 << bmpImage->bits_per_pixel) - 1;
FIXME_(bitmap)("from %d bit bitmap with mask R,G,B %x,%x,%x to 1 bit DIB\n",
bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 1 bit DIB\n",
bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
for( h = lines - 1; h >= 0; h-- ) {
for( x = 0; x < dstwidth; x++ ) {
@ -775,9 +775,9 @@ static void X11DRV_DIB_GetImageBits_4( int lines, BYTE *dstbits,
default: /* ? bit bmp -> 4 bit DIB */
notsupported:
FIXME_(bitmap)("from %d bit bitmap with mask R,G,B %x,%x,%x to 4 bit DIB\n",
bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 4 bit DIB\n",
bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
for (h = lines-1; h >= 0; h--) {
for (x = 0; x < dstwidth/2; x++) {
*bits++ = (X11DRV_DIB_MapColor((int *)colors, 16,
@ -1126,9 +1126,9 @@ static void X11DRV_DIB_GetImageBits_8( int lines, BYTE *dstbits,
default: /* ? bit bmp -> 8 bit DIB */
notsupported:
FIXME_(bitmap)("from %d bit bitmap with mask R,G,B %x,%x,%x to 8 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 8 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
updatesection:
for (h = lines - 1; h >= 0; h--) {
for (x = 0; x < dstwidth; x++, bits++) {
@ -1266,8 +1266,8 @@ static void X11DRV_DIB_SetImageBits_RLE8( int lines, const BYTE *bits,
line -= (*pIn++);
if (line == 0)
{
TRACE_(bitmap)("Delta to last line of bitmap "
"(wrongly?) causes loop exit\n");
TRACE("Delta to last line of bitmap "
"(wrongly?) causes loop exit\n");
}
break;
}
@ -1311,11 +1311,8 @@ static void X11DRV_DIB_SetImageBits_RLE8( int lines, const BYTE *bits,
*/
if ( (*(pIn-2) != 0/*escape*/) || (*(pIn-1)!= RleEnd) )
{
TRACE_(bitmap)("End-of-bitmap "
"without (strictly) proper escape code. Last two "
"bytes were: %02X %02X.\n",
(int)*(pIn-2),
(int)*(pIn-1));
TRACE("End-of-bitmap without (strictly) proper escape code. Last two "
"bytes were: %02X %02X.\n", (int)*(pIn-2),(int)*(pIn-1));
}
}
@ -1462,8 +1459,7 @@ static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits,
break;
default:
FIXME_(bitmap)("16 bit DIB %d bit bitmap\n",
bmpImage->bits_per_pixel);
FIXME("16 bit DIB %d bit bitmap\n", bmpImage->bits_per_pixel);
break;
}
@ -1655,9 +1651,9 @@ static void X11DRV_DIB_GetImageBits_16( int lines, BYTE *dstbits,
BYTE r,g, b;
LPWORD ptr = (LPWORD)dstbits;
FIXME_(bitmap)("from %d bit bitmap with mask R,G,B %x,%x,%x to 16 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 16 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
for (h = lines - 1; h >= 0; h--)
{
for (x = 0; x < dstwidth; x++, ptr++)
@ -1886,9 +1882,9 @@ static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits,
default:
notsupported:
FIXME_(bitmap)("from 24 bit DIB to %d bit bitmap with mask R,G,B %x,%x,%x\n",
bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
FIXME("from 24 bit DIB to %d bit bitmap with mask R,G,B %x,%x,%x\n",
bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
break;
}
}
@ -2112,9 +2108,9 @@ static void X11DRV_DIB_GetImageBits_24( int lines, BYTE *dstbits,
{
LPBYTE bits = dstbits;
FIXME_(bitmap)("from %d bit bitmap with mask R,G,B %x,%x,%x to 24 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 24 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
for (h = lines - 1; h >= 0; h--)
{
for (x = 0; x < dstwidth; x++, bits += 3)
@ -2262,8 +2258,7 @@ static void X11DRV_DIB_SetImageBits_32( int lines, const BYTE *srcbits,
default:
notsupported:
FIXME_(bitmap)("32 bit DIB %d bit bitmap\n",
bmpImage->bits_per_pixel);
FIXME("32 bit DIB %d bit bitmap\n", bmpImage->bits_per_pixel);
break;
}
@ -2442,9 +2437,9 @@ static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *dstbits,
default:
notsupported:
FIXME_(bitmap)("from %d bit bitmap with mask R,G,B %x,%x,%x to 32 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 32 bit DIB\n",
bmpImage->depth, (int)bmpImage->red_mask,
(int)bmpImage->green_mask, (int)bmpImage->blue_mask );
for (h = lines - 1; h >= 0; h--)
{
for (x = 0; x < dstwidth; x++, bits += 4)
@ -2544,7 +2539,7 @@ int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
bmpImage);
break;
default:
WARN_(bitmap)("(%d): Invalid depth\n", descr->infoBpp );
WARN("(%d): Invalid depth\n", descr->infoBpp );
break;
}
@ -2601,7 +2596,7 @@ int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
case 4:
if (descr->compression)
FIXME_(bitmap)("Compression not yet supported!\n");
FIXME("Compression not yet supported!\n");
else
X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
descr->infoWidth, descr->width,
@ -2611,7 +2606,7 @@ int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
case 8:
if (descr->compression)
FIXME_(bitmap)("Compression not yet supported!\n");
FIXME("Compression not yet supported!\n");
else
X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
descr->infoWidth, descr->width,
@ -2638,7 +2633,7 @@ int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
break;
default:
WARN_(bitmap)("(%d): Invalid depth\n", descr->infoBpp );
WARN("(%d): Invalid depth\n", descr->infoBpp );
break;
}
@ -2843,10 +2838,10 @@ INT X11DRV_DIB_GetDIBits(
X11DRV_PHYSBITMAP *pbitmap;
PALETTEOBJ * palette;
TRACE_(bitmap)("%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
TRACE("%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
lines, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
(int)info->bmiHeader.biWidth, (int)info->bmiHeader.biHeight,
startscan );
startscan );
if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
return 0;
@ -2939,8 +2934,7 @@ static void X11DRV_DIB_DoProtectDIBSection( BITMAPOBJ *bmp, DWORD new_prot )
DWORD old_prot;
VirtualProtect(dib->dsBm.bmBits, totalSize, new_prot, &old_prot);
TRACE_(bitmap)("Changed protection from %ld to %ld\n",
old_prot, new_prot);
TRACE("Changed protection from %ld to %ld\n", old_prot, new_prot);
}
/***********************************************************************
@ -2998,14 +2992,14 @@ static void X11DRV_DIB_DoUpdateDIBSection(BITMAPOBJ *bmp, BOOL toDIB)
if (toDIB)
{
TRACE_(bitmap)("Copying from Pixmap to DIB bits\n");
TRACE("Copying from Pixmap to DIB bits\n");
EnterCriticalSection( &X11DRV_CritSection );
CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
}
else
{
TRACE_(bitmap)("Copying from DIB bits to Pixmap\n");
TRACE("Copying from DIB bits to Pixmap\n");
EnterCriticalSection( &X11DRV_CritSection );
CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
@ -3027,7 +3021,7 @@ static BOOL X11DRV_DIB_FaultHandler( LPVOID res, LPCVOID addr )
switch (((X11DRV_DIBSECTION *) bmp->dib)->status)
{
case X11DRV_DIB_GdiMod:
TRACE_(bitmap)("called in status DIB_GdiMod\n" );
TRACE("called in status DIB_GdiMod\n" );
X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
@ -3036,20 +3030,18 @@ static BOOL X11DRV_DIB_FaultHandler( LPVOID res, LPCVOID addr )
break;
case X11DRV_DIB_InSync:
TRACE_(bitmap)("called in status X11DRV_DIB_InSync\n" );
TRACE("called in status X11DRV_DIB_InSync\n" );
X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_AppMod;
handled = TRUE;
break;
case X11DRV_DIB_AppMod:
FIXME_(bitmap)("called in status X11DRV_DIB_AppMod: "
"this can't happen!\n" );
FIXME("called in status X11DRV_DIB_AppMod: this can't happen!\n" );
break;
case X11DRV_DIB_NoHandler:
FIXME_(bitmap)("called in status DIB_NoHandler: "
"this can't happen!\n" );
FIXME("called in status DIB_NoHandler: this can't happen!\n" );
break;
}
@ -3090,17 +3082,17 @@ void X11DRV_DIB_UpdateDIBSection(DC *dc, BOOL toDIB)
break;
case X11DRV_DIB_GdiMod:
TRACE_(bitmap)("fromDIB called in status X11DRV_DIB_GdiMod\n" );
TRACE("fromDIB called in status X11DRV_DIB_GdiMod\n" );
/* nothing to do */
break;
case X11DRV_DIB_InSync:
TRACE_(bitmap)("fromDIB called in status X11DRV_DIB_InSync\n" );
TRACE("fromDIB called in status X11DRV_DIB_InSync\n" );
/* nothing to do */
break;
case X11DRV_DIB_AppMod:
TRACE_(bitmap)("fromDIB called in status X11DRV_DIB_AppMod\n" );
TRACE("fromDIB called in status X11DRV_DIB_AppMod\n" );
X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE );
X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_InSync;
@ -3119,19 +3111,19 @@ void X11DRV_DIB_UpdateDIBSection(DC *dc, BOOL toDIB)
break;
case X11DRV_DIB_GdiMod:
TRACE_(bitmap)(" toDIB called in status X11DRV_DIB_GdiMod\n" );
TRACE(" toDIB called in status X11DRV_DIB_GdiMod\n" );
/* nothing to do */
break;
case X11DRV_DIB_InSync:
TRACE_(bitmap)(" toDIB called in status X11DRV_DIB_InSync\n" );
TRACE(" toDIB called in status X11DRV_DIB_InSync\n" );
X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS );
((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_GdiMod;
break;
case X11DRV_DIB_AppMod:
FIXME_(bitmap)(" toDIB called in status X11DRV_DIB_AppMod: "
"this can't happen!\n" );
FIXME(" toDIB called in status X11DRV_DIB_AppMod: "
"this can't happen!\n" );
break;
}
}
@ -3165,7 +3157,7 @@ HBITMAP16 X11DRV_DIB_CreateDIBSection16(
SELECTOR_AllocBlock( dib->dsBm.bmBits, size,
SEGMENT_DATA, FALSE, FALSE );
}
TRACE_(bitmap)("ptr = %p, size =%d, selector = %04x, segptr = %ld\n",
TRACE("ptr = %p, size =%d, selector = %04x, segptr = %ld\n",
dib->dsBm.bmBits, size, ((X11DRV_DIBSECTION *) bmp->dib)->selector,
PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0));
}
@ -3262,7 +3254,7 @@ HBITMAP X11DRV_DIB_CreateDIBSection(
INT effHeight, totalSize;
BITMAP bm;
TRACE_(bitmap)("format (%ld,%ld), planes %d, bpp %d, size %ld, colors %ld (%s)\n",
TRACE("format (%ld,%ld), planes %d, bpp %d, size %ld, colors %ld (%s)\n",
bi->biWidth, bi->biHeight, bi->biPlanes, bi->biBitCount,
bi->biSizeImage, bi->biClrUsed, usage == DIB_PAL_COLORS? "PAL" : "RGB");
@ -3367,7 +3359,7 @@ HBITMAP X11DRV_DIB_CreateDIBSection(
/* Clean up in case of errors */
if (!res || !bmp || !dib || !bm.bmBits || (bm.bmBitsPixel <= 8 && !colorMap))
{
TRACE_(bitmap)("got an error res=%08x, bmp=%p, dib=%p, bm.bmBits=%p\n",
TRACE("got an error res=%08x, bmp=%p, dib=%p, bm.bmBits=%p\n",
res, bmp, dib, bm.bmBits);
if (bm.bmBits)
{
@ -3447,7 +3439,7 @@ HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc, BOOL bDeletePixma
hBmp = X11DRV_BITMAP_CreateBitmapHeaderFromPixmap(pixmap);
if (!hBmp)
{
TRACE_(bitmap)("\tCould not create bitmap header for Pixmap\n");
TRACE("\tCould not create bitmap header for Pixmap\n");
goto END;
}
@ -3476,7 +3468,7 @@ HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc, BOOL bDeletePixma
DeleteObject(hBmp);
END:
TRACE_(bitmap)("\tReturning packed DIB %x\n", hPackedDIB);
TRACE("\tReturning packed DIB %x\n", hPackedDIB);
return hPackedDIB;
}
@ -3514,7 +3506,7 @@ Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
GlobalUnlock(hPackedDIB);
TRACE_(bitmap)("CreateDIBitmap returned %x\n", hBmp);
TRACE("CreateDIBitmap returned %x\n", hBmp);
/* Retrieve the internal Pixmap from the DDB */
@ -3524,7 +3516,7 @@ Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
{
pixmap = ((X11DRV_PHYSBITMAP *)(pBmp->DDBitmap->physBitmap))->pixmap;
if (!pixmap)
TRACE_(bitmap)("NULL Pixmap in DDBitmap->physBitmap!\n");
TRACE("NULL Pixmap in DDBitmap->physBitmap!\n");
/* Manually free the BITMAPOBJ internals so that we can steal its pixmap */
HeapFree( GetProcessHeap(), 0, pBmp->DDBitmap->physBitmap );
@ -3535,7 +3527,7 @@ Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
/* Delete the DDB we created earlier now that we have stolen its pixmap */
DeleteObject(hBmp);
TRACE_(bitmap)("\tReturning Pixmap %ld\n", pixmap);
TRACE("\tReturning Pixmap %ld\n", pixmap);
return pixmap;
}

42
if1632/thunk.c
View File

@ -22,7 +22,7 @@
#include "keyboard.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(thunk)
DEFAULT_DEBUG_CHANNEL(thunk)
/* List of the 16-bit callback functions. This list is used */
@ -150,8 +150,8 @@ FARPROC THUNK_Alloc( FARPROC16 func, RELAY relay )
{
FARPROC proc = (FARPROC)((ENTRYPOINT16 *)PTR_SEG_TO_LIN( func ))->target;
TRACE_(thunk)( "(%04x:%04x, %p) -> built-in API %p\n",
SELECTOROF( func ), OFFSETOF( func ), relay, proc );
TRACE( "(%04x:%04x, %p) -> built-in API %p\n",
SELECTOROF( func ), OFFSETOF( func ), relay, proc );
return proc;
}
@ -170,8 +170,8 @@ FARPROC THUNK_Alloc( FARPROC16 func, RELAY relay )
firstThunk = thunk;
}
TRACE_(thunk)( "(%04x:%04x, %p) -> allocated thunk %p\n",
SELECTOROF( func ), OFFSETOF( func ), relay, thunk );
TRACE( "(%04x:%04x, %p) -> allocated thunk %p\n",
SELECTOROF( func ), OFFSETOF( func ), relay, thunk );
return (FARPROC)thunk;
}
@ -196,7 +196,7 @@ void THUNK_Free( FARPROC thunk )
return;
}
}
ERR_(thunk)("invalid thunk addr %p\n", thunk );
ERR("invalid thunk addr %p\n", thunk );
return;
}
@ -428,20 +428,20 @@ UINT WINAPI ThunkConnect16(
{
directionSL = TRUE;
TRACE_(thunk)("SL01 thunk %s (%lx) -> %s (%s), Reason: %ld\n",
module16, (DWORD)TD, module32, thunkfun32, dwReason);
TRACE("SL01 thunk %s (%lx) -> %s (%s), Reason: %ld\n",
module16, (DWORD)TD, module32, thunkfun32, dwReason);
}
else if (!strncmp(TD->magic, "LS01", 4))
{
directionSL = FALSE;
TRACE_(thunk)("LS01 thunk %s (%lx) <- %s (%s), Reason: %ld\n",
module16, (DWORD)TD, module32, thunkfun32, dwReason);
TRACE("LS01 thunk %s (%lx) <- %s (%s), Reason: %ld\n",
module16, (DWORD)TD, module32, thunkfun32, dwReason);
}
else
{
ERR_(thunk)("Invalid magic %c%c%c%c\n",
TD->magic[0], TD->magic[1], TD->magic[2], TD->magic[3]);
ERR("Invalid magic %c%c%c%c\n",
TD->magic[0], TD->magic[1], TD->magic[2], TD->magic[3]);
return 0;
}
@ -477,7 +477,7 @@ UINT WINAPI ThunkConnect16(
if (SL->flags2 & 0x80000000)
{
TRACE_(thunk)("Preloading 32-bit library\n");
TRACE("Preloading 32-bit library\n");
LoadLibraryA(module32);
}
}
@ -561,11 +561,11 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
if (!td)
{
ERR_(thunk)("ThunkConnect16 was not called!\n");
ERR("ThunkConnect16 was not called!\n");
return;
}
TRACE_(thunk)("Creating stub for ThunkDataSL %08lx\n", (DWORD)td);
TRACE("Creating stub for ThunkDataSL %08lx\n", (DWORD)td);
/* We produce the following code:
@ -605,8 +605,8 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
DWORD targetNr = CX_reg(context) / 4;
struct SLTargetDB *tdb;
TRACE_(thunk)("Process %08lx calling target %ld of ThunkDataSL %08lx\n",
(DWORD)PROCESS_Current(), targetNr, (DWORD)td);
TRACE("Process %08lx calling target %ld of ThunkDataSL %08lx\n",
(DWORD)PROCESS_Current(), targetNr, (DWORD)td);
for (tdb = td->targetDB; tdb; tdb = tdb->next)
if (tdb->process == PROCESS_Current())
@ -614,7 +614,7 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
if (!tdb)
{
TRACE_(thunk)("Loading 32-bit library %s\n", td->pszDll32);
TRACE("Loading 32-bit library %s\n", td->pszDll32);
LoadLibraryA(td->pszDll32);
for (tdb = td->targetDB; tdb; tdb = tdb->next)
@ -626,7 +626,7 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
{
EDX_reg(context) = tdb->targetTable[targetNr];
TRACE_(thunk)("Call target is %08lx\n", EDX_reg(context));
TRACE("Call target is %08lx\n", EDX_reg(context));
}
else
{
@ -637,8 +637,8 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
CS_reg(context) = stack[3];
ESP_reg(context) += td->apiDB[targetNr].nrArgBytes + 4;
ERR_(thunk)("Process %08lx did not ThunkConnect32 %s to %s\n",
(DWORD)PROCESS_Current(), td->pszDll32, td->pszDll16);
ERR("Process %08lx did not ThunkConnect32 %s to %s\n",
(DWORD)PROCESS_Current(), td->pszDll32, td->pszDll16);
}
}
}

16
loader/elfdll.c
View File

@ -20,7 +20,7 @@
#include "debugtools.h"
#include "winerror.h"
DECLARE_DEBUG_CHANNEL(elfdll)
DEFAULT_DEBUG_CHANNEL(elfdll)
#if defined(HAVE_DL_API)
#include <dlfcn.h>
@ -84,7 +84,7 @@ void *ELFDLL_dlopen(const char *libname, int flags)
if(len + namelen + 1 >= sizeof(buffer))
{
ERR_(elfdll)("Buffer overflow! Check EXTRA_LD_LIBRARY_PATH or increase buffer size.\n");
ERR("Buffer overflow! Check EXTRA_LD_LIBRARY_PATH or increase buffer size.\n");
return NULL;
}
@ -97,7 +97,7 @@ void *ELFDLL_dlopen(const char *libname, int flags)
else
strcpy(buffer + len, libname);
TRACE_(elfdll)("Trying dlopen('%s', %d)\n", buffer, flags);
TRACE("Trying dlopen('%s', %d)\n", buffer, flags);
handle = dlopen(buffer, flags);
if(handle)
@ -216,7 +216,7 @@ static WINE_MODREF *ELFDLL_CreateModref(HMODULE hModule, LPCSTR path)
{
if ( PROCESS_Current()->exe_modref )
FIXME_(elfdll)( "Trying to load second .EXE file: %s\n", path );
FIXME( "Trying to load second .EXE file: %s\n", path );
else
PROCESS_Current()->exe_modref = wm;
}
@ -301,7 +301,7 @@ WINE_MODREF *ELFDLL_LoadLibraryExA(LPCSTR path, DWORD flags, DWORD *err)
dlhandle = ELFDLL_dlopen(soname, RTLD_LAZY);
if(!dlhandle)
{
WARN_(elfdll)("Could not load %s (%s)\n", soname, dlerror());
WARN("Could not load %s (%s)\n", soname, dlerror());
*err = ERROR_FILE_NOT_FOUND;
return NULL;
}
@ -312,7 +312,7 @@ WINE_MODREF *ELFDLL_LoadLibraryExA(LPCSTR path, DWORD flags, DWORD *err)
image = (struct elfdll_image *)dlsym(dlhandle, soname);
if(!image)
{
ERR_(elfdll)("Could not get elfdll image descriptor %s (%s)\n", soname, dlerror());
ERR("Could not get elfdll image descriptor %s (%s)\n", soname, dlerror());
dlclose(dlhandle);
*err = ERROR_BAD_FORMAT;
return NULL;
@ -322,7 +322,7 @@ WINE_MODREF *ELFDLL_LoadLibraryExA(LPCSTR path, DWORD flags, DWORD *err)
hmod16 = ELFDLL_CreateNEModule(image->ne_module_start, image->ne_module_size);
if(!hmod16)
{
ERR_(elfdll)("Could not create win16 dummy module for %s\n", path);
ERR("Could not create win16 dummy module for %s\n", path);
dlclose(dlhandle);
*err = ERROR_OUTOFMEMORY;
return NULL;
@ -333,7 +333,7 @@ WINE_MODREF *ELFDLL_LoadLibraryExA(LPCSTR path, DWORD flags, DWORD *err)
wm = ELFDLL_CreateModref(image->pe_module_start, path);
if(!wm)
{
ERR_(elfdll)("Could not create WINE_MODREF for %s\n", path);
ERR("Could not create WINE_MODREF for %s\n", path);
GLOBAL_FreeBlock((HGLOBAL16)hmod16);
dlclose(dlhandle);
*err = ERROR_OUTOFMEMORY;

135
loader/module.c
View File

@ -32,7 +32,7 @@
#include "loadorder.h"
#include "elfdll.h"
DECLARE_DEBUG_CHANNEL(module)
DEFAULT_DEBUG_CHANNEL(module)
DECLARE_DEBUG_CHANNEL(win32)
/*************************************************************************
@ -77,7 +77,7 @@ WINE_MODREF *MODULE32_LookupHMODULE( HMODULE hmod )
return PROCESS_Current()->exe_modref;
if (!HIWORD(hmod)) {
ERR_(module)("tried to lookup 0x%04x in win32 module handler!\n",hmod);
ERR("tried to lookup 0x%04x in win32 module handler!\n",hmod);
return NULL;
}
for ( wm = PROCESS_Current()->modref_list; wm; wm=wm->next )
@ -105,8 +105,8 @@ static BOOL MODULE_InitDll( WINE_MODREF *wm, DWORD type, LPVOID lpReserved )
return TRUE;
TRACE_(module)("(%s,%s,%p) - CALL\n",
wm->modname, typeName[type], lpReserved );
TRACE("(%s,%s,%p) - CALL\n",
wm->modname, typeName[type], lpReserved );
/* Call the initialization routine */
switch ( wm->type )
@ -120,13 +120,13 @@ static BOOL MODULE_InitDll( WINE_MODREF *wm, DWORD type, LPVOID lpReserved )
break;
default:
ERR_(module)("wine_modref type %d not handled.\n", wm->type );
ERR("wine_modref type %d not handled.\n", wm->type );
retv = FALSE;
break;
}
TRACE_(module)("(%s,%s,%p) - RETURN %d\n",
wm->modname, typeName[type], lpReserved, retv );
TRACE("(%s,%s,%p) - RETURN %d\n",
wm->modname, typeName[type], lpReserved, retv );
return retv;
}
@ -174,8 +174,7 @@ BOOL MODULE_DllProcessAttach( WINE_MODREF *wm, LPVOID lpReserved )
|| ( wm->flags & WINE_MODREF_PROCESS_ATTACHED ) )
return retv;
TRACE_(module)("(%s,%p) - START\n",
wm->modname, lpReserved );
TRACE("(%s,%p) - START\n", wm->modname, lpReserved );
/* Tag current MODREF to prevent recursive loop */
wm->flags |= WINE_MODREF_MARKER;
@ -207,8 +206,7 @@ BOOL MODULE_DllProcessAttach( WINE_MODREF *wm, LPVOID lpReserved )
/* Remove recursion flag */
wm->flags &= ~WINE_MODREF_MARKER;
TRACE_(module)("(%s,%p) - END\n",
wm->modname, lpReserved );
TRACE("(%s,%p) - END\n", wm->modname, lpReserved );
return retv;
}
@ -832,7 +830,7 @@ HINSTANCE WINAPI LoadModule( LPCSTR name, LPVOID paramBlock )
hInstance = GetLastError();
if ( hInstance < 32 ) return hInstance;
FIXME_(module)("Strange error set by CreateProcess: %d\n", hInstance );
FIXME("Strange error set by CreateProcess: %d\n", hInstance );
return 11;
}
@ -911,8 +909,7 @@ static int get_makename_token(LPCSTR *from, LPSTR *to )
**to = 0; /* terminate output string */
TRACE_(module)("returning token len=%d, string=%s\n",
len, to_old);
TRACE("returning token len=%d, string=%s\n", len, to_old);
return len;
}
@ -951,7 +948,7 @@ static BOOL make_lpCommandLine_name( LPCSTR line, LPSTR name, int namelen,
found = FALSE;
break;
}
TRACE_(module)("checking if file exists '%s'\n", name);
TRACE("checking if file exists '%s'\n", name);
retlen = SearchPathA( NULL, name, ".exe", sizeof(buffer), buffer, &lastpart);
if ( retlen && (retlen < sizeof(buffer)) ) break;
} while (1);
@ -962,15 +959,15 @@ static BOOL make_lpCommandLine_name( LPCSTR line, LPSTR name, int namelen,
strcpy( name, buffer );
} else {
/* not enough space to return full path string */
FIXME_(module)("internal string not long enough, need %d\n",
FIXME("internal string not long enough, need %d\n",
strlen(buffer) );
}
}
/* all done, indicate end of module name and then trace and exit */
if (after) *after = from;
TRACE_(module)("%i, selected file name '%s'\n and cmdline as %s\n",
found, name, debugstr_a(from));
TRACE("%i, selected file name '%s'\n and cmdline as %s\n",
found, name, debugstr_a(from));
return found;
}
@ -1027,11 +1024,11 @@ static BOOL make_lpApplicationName_name( LPCSTR line, LPSTR name, int namelen)
} while (1);
if (!SearchPathA( NULL, buffer, ".exe", namelen, name, NULL )) {
TRACE_(module)("file not found '%s'\n", buffer );
TRACE("file not found '%s'\n", buffer );
return FALSE;
}
TRACE_(module)("selected as file name '%s'\n", name );
TRACE("selected as file name '%s'\n", name );
return TRUE;
}
@ -1095,58 +1092,58 @@ BOOL WINAPI CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine,
/* Warn if unsupported features are used */
if (dwCreationFlags & DETACHED_PROCESS)
FIXME_(module)("(%s,...): DETACHED_PROCESS ignored\n", name);
FIXME("(%s,...): DETACHED_PROCESS ignored\n", name);
if (dwCreationFlags & CREATE_NEW_CONSOLE)
FIXME_(module)("(%s,...): CREATE_NEW_CONSOLE ignored\n", name);
FIXME("(%s,...): CREATE_NEW_CONSOLE ignored\n", name);
if (dwCreationFlags & NORMAL_PRIORITY_CLASS)
FIXME_(module)("(%s,...): NORMAL_PRIORITY_CLASS ignored\n", name);
FIXME("(%s,...): NORMAL_PRIORITY_CLASS ignored\n", name);
if (dwCreationFlags & IDLE_PRIORITY_CLASS)
FIXME_(module)("(%s,...): IDLE_PRIORITY_CLASS ignored\n", name);
FIXME("(%s,...): IDLE_PRIORITY_CLASS ignored\n", name);
if (dwCreationFlags & HIGH_PRIORITY_CLASS)
FIXME_(module)("(%s,...): HIGH_PRIORITY_CLASS ignored\n", name);
FIXME("(%s,...): HIGH_PRIORITY_CLASS ignored\n", name);
if (dwCreationFlags & REALTIME_PRIORITY_CLASS)
FIXME_(module)("(%s,...): REALTIME_PRIORITY_CLASS ignored\n", name);
FIXME("(%s,...): REALTIME_PRIORITY_CLASS ignored\n", name);
if (dwCreationFlags & CREATE_NEW_PROCESS_GROUP)
FIXME_(module)("(%s,...): CREATE_NEW_PROCESS_GROUP ignored\n", name);
FIXME("(%s,...): CREATE_NEW_PROCESS_GROUP ignored\n", name);
if (dwCreationFlags & CREATE_UNICODE_ENVIRONMENT)
FIXME_(module)("(%s,...): CREATE_UNICODE_ENVIRONMENT ignored\n", name);
FIXME("(%s,...): CREATE_UNICODE_ENVIRONMENT ignored\n", name);
if (dwCreationFlags & CREATE_SEPARATE_WOW_VDM)
FIXME_(module)("(%s,...): CREATE_SEPARATE_WOW_VDM ignored\n", name);
FIXME("(%s,...): CREATE_SEPARATE_WOW_VDM ignored\n", name);
if (dwCreationFlags & CREATE_SHARED_WOW_VDM)
FIXME_(module)("(%s,...): CREATE_SHARED_WOW_VDM ignored\n", name);
FIXME("(%s,...): CREATE_SHARED_WOW_VDM ignored\n", name);
if (dwCreationFlags & CREATE_DEFAULT_ERROR_MODE)
FIXME_(module)("(%s,...): CREATE_DEFAULT_ERROR_MODE ignored\n", name);
FIXME("(%s,...): CREATE_DEFAULT_ERROR_MODE ignored\n", name);
if (dwCreationFlags & CREATE_NO_WINDOW)
FIXME_(module)("(%s,...): CREATE_NO_WINDOW ignored\n", name);
FIXME("(%s,...): CREATE_NO_WINDOW ignored\n", name);
if (dwCreationFlags & PROFILE_USER)
FIXME_(module)("(%s,...): PROFILE_USER ignored\n", name);
FIXME("(%s,...): PROFILE_USER ignored\n", name);
if (dwCreationFlags & PROFILE_KERNEL)
FIXME_(module)("(%s,...): PROFILE_KERNEL ignored\n", name);
FIXME("(%s,...): PROFILE_KERNEL ignored\n", name);
if (dwCreationFlags & PROFILE_SERVER)
FIXME_(module)("(%s,...): PROFILE_SERVER ignored\n", name);
FIXME("(%s,...): PROFILE_SERVER ignored\n", name);
if (lpCurrentDirectory)
FIXME_(module)("(%s,...): lpCurrentDirectory %s ignored\n",
FIXME("(%s,...): lpCurrentDirectory %s ignored\n",
name, lpCurrentDirectory);
if (lpStartupInfo->lpDesktop)
FIXME_(module)("(%s,...): lpStartupInfo->lpDesktop %s ignored\n",
FIXME("(%s,...): lpStartupInfo->lpDesktop %s ignored\n",
name, lpStartupInfo->lpDesktop);
if (lpStartupInfo->lpTitle)
FIXME_(module)("(%s,...): lpStartupInfo->lpTitle %s ignored\n",
FIXME("(%s,...): lpStartupInfo->lpTitle %s ignored\n",
name, lpStartupInfo->lpTitle);
if (lpStartupInfo->dwFlags & STARTF_USECOUNTCHARS)
FIXME_(module)("(%s,...): STARTF_USECOUNTCHARS (%ld,%ld) ignored\n",
FIXME("(%s,...): STARTF_USECOUNTCHARS (%ld,%ld) ignored\n",
name, lpStartupInfo->dwXCountChars, lpStartupInfo->dwYCountChars);
if (lpStartupInfo->dwFlags & STARTF_USEFILLATTRIBUTE)
FIXME_(module)("(%s,...): STARTF_USEFILLATTRIBUTE %lx ignored\n",
FIXME("(%s,...): STARTF_USEFILLATTRIBUTE %lx ignored\n",
name, lpStartupInfo->dwFillAttribute);
if (lpStartupInfo->dwFlags & STARTF_RUNFULLSCREEN)
FIXME_(module)("(%s,...): STARTF_RUNFULLSCREEN ignored\n", name);
FIXME("(%s,...): STARTF_RUNFULLSCREEN ignored\n", name);
if (lpStartupInfo->dwFlags & STARTF_FORCEONFEEDBACK)
FIXME_(module)("(%s,...): STARTF_FORCEONFEEDBACK ignored\n", name);
FIXME("(%s,...): STARTF_FORCEONFEEDBACK ignored\n", name);
if (lpStartupInfo->dwFlags & STARTF_FORCEOFFFEEDBACK)
FIXME_(module)("(%s,...): STARTF_FORCEOFFFEEDBACK ignored\n", name);
FIXME("(%s,...): STARTF_FORCEOFFFEEDBACK ignored\n", name);
if (lpStartupInfo->dwFlags & STARTF_USEHOTKEY)
FIXME_(module)("(%s,...): STARTF_USEHOTKEY ignored\n", name);
FIXME("(%s,...): STARTF_USEHOTKEY ignored\n", name);
/* Load file and create process */
@ -1209,7 +1206,7 @@ BOOL WINAPI CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine,
case SCS_PIF_BINARY:
case SCS_POSIX_BINARY:
case SCS_OS216_BINARY:
FIXME_(module)("Unsupported executable type: %ld\n", type );
FIXME("Unsupported executable type: %ld\n", type );
/* fall through */
default:
@ -1309,7 +1306,7 @@ DWORD WINAPI GetModuleFileNameA(
else
lstrcpynA( lpFileName, wm->short_filename, size );
TRACE_(module)("%s\n", lpFileName );
TRACE("%s\n", lpFileName );
return strlen(lpFileName);
}
@ -1388,7 +1385,7 @@ WINE_MODREF *MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD flags )
{
if(!(pwm->flags & WINE_MODREF_MARKER))
pwm->refCount++;
TRACE_(module)("Already loaded module '%s' at 0x%08x, count=%d, \n", libname, pwm->module, pwm->refCount);
TRACE("Already loaded module '%s' at 0x%08x, count=%d, \n", libname, pwm->module, pwm->refCount);
LeaveCriticalSection(&PROCESS_Current()->crit_section);
return pwm;
}
@ -1400,27 +1397,27 @@ WINE_MODREF *MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD flags )
switch(plo->loadorder[i])
{
case MODULE_LOADORDER_DLL:
TRACE_(module)("Trying native dll '%s'\n", libname);
TRACE("Trying native dll '%s'\n", libname);
pwm = PE_LoadLibraryExA(libname, flags, &err);
break;
case MODULE_LOADORDER_ELFDLL:
TRACE_(module)("Trying elfdll '%s'\n", libname);
TRACE("Trying elfdll '%s'\n", libname);
pwm = ELFDLL_LoadLibraryExA(libname, flags, &err);
break;
case MODULE_LOADORDER_SO:
TRACE_(module)("Trying so-library '%s'\n", libname);
TRACE("Trying so-library '%s'\n", libname);
pwm = ELF_LoadLibraryExA(libname, flags, &err);
break;
case MODULE_LOADORDER_BI:
TRACE_(module)("Trying built-in '%s'\n", libname);
TRACE("Trying built-in '%s'\n", libname);
pwm = BUILTIN32_LoadLibraryExA(libname, flags, &err);
break;
default:
ERR_(module)("Got invalid loadorder type %d (%s index %d)\n", plo->loadorder[i], plo->modulename, i);
ERR("Got invalid loadorder type %d (%s index %d)\n", plo->loadorder[i], plo->modulename, i);
/* Fall through */
case MODULE_LOADORDER_INVALID: /* We ignore this as it is an empty entry */
@ -1431,7 +1428,7 @@ WINE_MODREF *MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD flags )
if(pwm)
{
/* Initialize DLL just loaded */
TRACE_(module)("Loaded module '%s' at 0x%08x, \n", libname, pwm->module);
TRACE("Loaded module '%s' at 0x%08x, \n", libname, pwm->module);
/* Set the refCount here so that an attach failure will */
/* decrement the dependencies through the MODULE_FreeLibrary call. */
@ -1446,7 +1443,7 @@ WINE_MODREF *MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD flags )
break;
}
WARN_(module)("Failed to load module '%s'; error=0x%08lx, \n", libname, err);
WARN("Failed to load module '%s'; error=0x%08lx, \n", libname, err);
SetLastError(err);
LeaveCriticalSection(&PROCESS_Current()->crit_section);
return NULL;
@ -1532,7 +1529,7 @@ static void MODULE_FlushModrefs(void)
case MODULE32_BI: BUILTIN32_UnloadLibrary(wm); break;
default:
ERR_(module)("Invalid or unhandled MODREF type %d encountered (wm=%p)\n", wm->type, wm);
ERR("Invalid or unhandled MODREF type %d encountered (wm=%p)\n", wm->type, wm);
}
}
}
@ -1576,7 +1573,7 @@ static void MODULE_DecRefCount( WINE_MODREF *wm )
return;
--wm->refCount;
TRACE_(module)("(%s) refCount: %d\n", wm->modname, wm->refCount );
TRACE("(%s) refCount: %d\n", wm->modname, wm->refCount );
if ( wm->refCount == 0 )
{
@ -1597,7 +1594,7 @@ static void MODULE_DecRefCount( WINE_MODREF *wm )
*/
BOOL MODULE_FreeLibrary( WINE_MODREF *wm )
{
TRACE_(module)("(%s) - START\n", wm->modname );
TRACE("(%s) - START\n", wm->modname );
/* Recursively decrement reference counts */
MODULE_DecRefCount( wm );
@ -1612,7 +1609,7 @@ BOOL MODULE_FreeLibrary( WINE_MODREF *wm )
MODULE_FlushModrefs();
TRACE_(module)("(%s) - END\n", wm->modname );
TRACE("(%s) - END\n", wm->modname );
return TRUE;
}
@ -1660,27 +1657,25 @@ FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE hModule, LPCSTR name )
FARPROC16 ret;
if (!hModule) {
WARN_(module)("hModule may not be 0!\n");
WARN("hModule may not be 0!\n");
return (FARPROC16)0;
}
if (HIWORD(hModule))
{
WARN_(module)("hModule is Win32 handle (%08x)\n", hModule );
WARN("hModule is Win32 handle (%08x)\n", hModule );
return (FARPROC16)0;
}
hModule = GetExePtr( hModule );
if (HIWORD(name)) {
ordinal = NE_GetOrdinal( hModule, name );
TRACE_(module)("%04x '%s'\n",
hModule, name );
TRACE("%04x '%s'\n", hModule, name );
} else {
ordinal = LOWORD(name);
TRACE_(module)("%04x %04x\n",
hModule, ordinal );
TRACE("%04x %04x\n", hModule, ordinal );
}
if (!ordinal) return (FARPROC16)0;
ret = NE_GetEntryPoint( hModule, ordinal );
TRACE_(module)("returning %08x\n",(UINT)ret);
TRACE("returning %08x\n",(UINT)ret);
return ret;
}
@ -1698,20 +1693,18 @@ FARPROC16 WINAPI GetProcAddress16( HMODULE16 hModule, SEGPTR name )
if (HIWORD(name) != 0)
{
ordinal = NE_GetOrdinal( hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
TRACE_(module)("%04x '%s'\n",
hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
TRACE("%04x '%s'\n", hModule, (LPSTR)PTR_SEG_TO_LIN(name) );
}
else
{
ordinal = LOWORD(name);
TRACE_(module)("%04x %04x\n",
hModule, ordinal );
TRACE("%04x %04x\n", hModule, ordinal );
}
if (!ordinal) return (FARPROC16)0;
ret = NE_GetEntryPoint( hModule, ordinal );
TRACE_(module)("returning %08x\n", (UINT)ret );
TRACE("returning %08x\n", (UINT)ret );
return ret;
}
@ -1762,7 +1755,7 @@ FARPROC MODULE_GetProcAddress(
if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND);
return retproc;
default:
ERR_(module)("wine_modref type %d not handled.\n",wm->type);
ERR("wine_modref type %d not handled.\n",wm->type);
SetLastError(ERROR_INVALID_HANDLE);
return (FARPROC)0;
}

103
loader/pe_image.c
View File

@ -62,12 +62,12 @@
#include "snoop.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win32)
DECLARE_DEBUG_CHANNEL(delayhlp)
DECLARE_DEBUG_CHANNEL(fixup)
DECLARE_DEBUG_CHANNEL(module)
DECLARE_DEBUG_CHANNEL(relay)
DECLARE_DEBUG_CHANNEL(segment)
DECLARE_DEBUG_CHANNEL(win32)
/* convert PE image VirtualAddress to Real Address */
@ -91,15 +91,15 @@ void dump_exports( HMODULE hModule )
IMAGE_EXPORT_DIRECTORY *pe_exports = (IMAGE_EXPORT_DIRECTORY*)RVA(rva_start);
Module = (char*)RVA(pe_exports->Name);
TRACE_(win32)("*******EXPORT DATA*******\n");
TRACE_(win32)("Module name is %s, %ld functions, %ld names\n",
Module, pe_exports->NumberOfFunctions, pe_exports->NumberOfNames);
TRACE("*******EXPORT DATA*******\n");
TRACE("Module name is %s, %ld functions, %ld names\n",
Module, pe_exports->NumberOfFunctions, pe_exports->NumberOfNames);
ordinal=(u_short*) RVA(pe_exports->AddressOfNameOrdinals);
functions=function=(u_long*) RVA(pe_exports->AddressOfFunctions);
name=(u_char**) RVA(pe_exports->AddressOfNames);
TRACE_(win32)(" Ord RVA Addr Name\n" );
TRACE(" Ord RVA Addr Name\n" );
for (i=0;i<pe_exports->NumberOfFunctions;i++, function++)
{
if (!*function) continue; /* No such function */
@ -144,15 +144,15 @@ FARPROC PE_FindExportedFunction(
char * forward;
if (HIWORD(funcName))
TRACE_(win32)("(%s)\n",funcName);
TRACE("(%s)\n",funcName);
else
TRACE_(win32)("(%d)\n",(int)funcName);
TRACE("(%d)\n",(int)funcName);
if (!exports) {
/* Not a fatal problem, some apps do
* GetProcAddress(0,"RegisterPenApp") which triggers this
* case.
*/
WARN_(win32)("Module %08x(%s)/MODREF %p doesn't have a exports table.\n",wm->module,wm->modname,pem);
WARN("Module %08x(%s)/MODREF %p doesn't have a exports table.\n",wm->module,wm->modname,pem);
return NULL;
}
ordinal = (u_short*) RVA(exports->AddressOfNameOrdinals);
@ -183,8 +183,7 @@ FARPROC PE_FindExportedFunction(
} else {
int i;
if (LOWORD(funcName)-exports->Base > exports->NumberOfFunctions) {
TRACE_(win32)(" ordinal %d out of range!\n",
LOWORD(funcName));
TRACE(" ordinal %d out of range!\n", LOWORD(funcName));
return NULL;
}
addr = function[(int)funcName-exports->Base];
@ -218,7 +217,7 @@ FARPROC PE_FindExportedFunction(
module[end-forward] = 0;
if (!(wm = MODULE_FindModule( module )))
{
ERR_(win32)("module not found for forward '%s'\n", forward );
ERR("module not found for forward '%s'\n", forward );
return NULL;
}
return MODULE_GetProcAddress( wm->module, end + 1, snoop );
@ -242,7 +241,7 @@ DWORD fixup_imports( WINE_MODREF *wm )
modname = "<unknown>";
/* OK, now dump the import list */
TRACE_(win32)("Dumping imports list\n");
TRACE("Dumping imports list\n");
/* first, count the number of imported non-internal modules */
pe_imp = pem->pe_import;
@ -288,7 +287,7 @@ DWORD fixup_imports( WINE_MODREF *wm )
/* FIXME: forwarder entries ... */
if (pe_imp->u.OriginalFirstThunk != 0) { /* original MS style */
TRACE_(win32)("Microsoft style imports used\n");
TRACE("Microsoft style imports used\n");
import_list =(PIMAGE_THUNK_DATA) RVA(pe_imp->u.OriginalFirstThunk);
thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
@ -296,23 +295,23 @@ DWORD fixup_imports( WINE_MODREF *wm )
if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal)) {
int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
TRACE_(win32)("--- Ordinal %s,%d\n", name, ordinal);
TRACE("--- Ordinal %s,%d\n", name, ordinal);
thunk_list->u1.Function=MODULE_GetProcAddress(
wmImp->module, (LPCSTR)ordinal, TRUE
);
if (!thunk_list->u1.Function) {
ERR_(win32)("No implementation for %s.%d, setting to 0xdeadbeef\n",
ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
name, ordinal);
thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
} else { /* import by name */
pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
TRACE_(win32)("--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
TRACE("--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
thunk_list->u1.Function=MODULE_GetProcAddress(
wmImp->module, pe_name->Name, TRUE
);
if (!thunk_list->u1.Function) {
ERR_(win32)("No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
ERR("No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
name,pe_name->Hint,pe_name->Name);
thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
@ -321,31 +320,31 @@ DWORD fixup_imports( WINE_MODREF *wm )
thunk_list++;
}
} else { /* Borland style */
TRACE_(win32)("Borland style imports used\n");
TRACE("Borland style imports used\n");
thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
while (thunk_list->u1.Ordinal) {
if (IMAGE_SNAP_BY_ORDINAL(thunk_list->u1.Ordinal)) {
/* not sure about this branch, but it seems to work */
int ordinal = IMAGE_ORDINAL(thunk_list->u1.Ordinal);
TRACE_(win32)("--- Ordinal %s.%d\n",name,ordinal);
TRACE("--- Ordinal %s.%d\n",name,ordinal);
thunk_list->u1.Function=MODULE_GetProcAddress(
wmImp->module, (LPCSTR) ordinal, TRUE
);
if (!thunk_list->u1.Function) {
ERR_(win32)("No implementation for %s.%d, setting to 0xdeadbeef\n",
ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
name,ordinal);
thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
} else {
pe_name=(PIMAGE_IMPORT_BY_NAME) RVA(thunk_list->u1.AddressOfData);
TRACE_(win32)("--- %s %s.%d\n",
TRACE("--- %s %s.%d\n",
pe_name->Name,name,pe_name->Hint);
thunk_list->u1.Function=MODULE_GetProcAddress(
wmImp->module, pe_name->Name, TRUE
);
if (!thunk_list->u1.Function) {
ERR_(win32)("No implementation for %s.%d, setting to 0xdeadbeef\n",
ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
name, pe_name->Hint);
thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
@ -362,11 +361,11 @@ static int calc_vma_size( HMODULE hModule )
int i,vma_size = 0;
IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(hModule);
TRACE_(win32)("Dump of segment table\n");
TRACE_(win32)(" Name VSz Vaddr SzRaw Fileadr *Reloc *Lineum #Reloc #Linum Char\n");
TRACE("Dump of segment table\n");
TRACE(" Name VSz Vaddr SzRaw Fileadr *Reloc *Lineum #Reloc #Linum Char\n");
for (i = 0; i< PE_HEADER(hModule)->FileHeader.NumberOfSections; i++)
{
TRACE_(win32)("%8s: %4.4lx %8.8lx %8.8lx %8.8lx %8.8lx %8.8lx %4.4x %4.4x %8.8lx\n",
TRACE("%8s: %4.4lx %8.8lx %8.8lx %8.8lx %8.8lx %8.8lx %4.4x %4.4x %8.8lx\n",
pe_seg->Name,
pe_seg->Misc.VirtualSize,
pe_seg->VirtualAddress,
@ -420,13 +419,13 @@ static void do_relocations( unsigned int load_addr, IMAGE_BASE_RELOCATION *r )
/* FIXME: if this is an exported address, fire up enhanced logic */
break;
case IMAGE_REL_BASED_HIGHADJ:
FIXME_(win32)("Don't know what to do with IMAGE_REL_BASED_HIGHADJ\n");
FIXME("Don't know what to do with IMAGE_REL_BASED_HIGHADJ\n");
break;
case IMAGE_REL_BASED_MIPS_JMPADDR:
FIXME_(win32)("Is this a MIPS machine ???\n");
FIXME("Is this a MIPS machine ???\n");
break;
default:
FIXME_(win32)("Unknown fixup type\n");
FIXME("Unknown fixup type\n");
break;
}
}
@ -469,14 +468,14 @@ HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, WORD *version )
0, 0, NULL );
if (!mapping)
{
WARN_(win32)("CreateFileMapping error %ld\n", GetLastError() );
WARN("CreateFileMapping error %ld\n", GetLastError() );
return 0;
}
hModule = (HMODULE)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
CloseHandle( mapping );
if (!hModule)
{
WARN_(win32)("MapViewOfFile error %ld\n", GetLastError() );
WARN("MapViewOfFile error %ld\n", GetLastError() );
return 0;
}
nt = PE_HEADER( hModule );
@ -484,7 +483,7 @@ HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, WORD *version )
/* Check signature */
if ( nt->Signature != IMAGE_NT_SIGNATURE )
{
WARN_(win32)("image doesn't have PE signature, but 0x%08lx\n",
WARN("image doesn't have PE signature, but 0x%08lx\n",
nt->Signature );
goto error;
}
@ -526,7 +525,7 @@ HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, WORD *version )
/* Check file size */
if ( file_size && file_size < rawsize )
{
ERR_(win32)("PE module is too small (header: %d, filesize: %d), "
ERR("PE module is too small (header: %d, filesize: %d), "
"probably truncated download?\n",
rawsize, file_size );
goto error;
@ -535,7 +534,7 @@ HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, WORD *version )
/* Check entrypoint address */
aoep = nt->OptionalHeader.AddressOfEntryPoint;
if (aoep && (aoep < lowest_va))
FIXME_(win32)("WARNING: '%s' has an invalid entrypoint (0x%08lx) "
FIXME("WARNING: '%s' has an invalid entrypoint (0x%08lx) "
"below the first virtual address (0x%08x) "
"(possible Virus Infection or broken binary)!\n",
filename, aoep, lowest_va );
@ -585,7 +584,7 @@ HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, WORD *version )
reloc = dir->VirtualAddress;
else
{
FIXME_(win32)(
FIXME(
"FATAL: Need to relocate %s, but no relocation records present (%s). Try to run that file directly !\n",
filename,
(nt->FileHeader.Characteristics&IMAGE_FILE_RELOCS_STRIPPED)?
@ -598,7 +597,7 @@ HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, WORD *version )
* Some DLLs really check the MSB of the module handle :-/
*/
if ( nt->OptionalHeader.ImageBase & 0x80000000 )
ERR_(win32)( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
load_addr = (DWORD)VirtualAlloc( NULL, vma_size,
MEM_RESERVE | MEM_COMMIT,
@ -610,8 +609,8 @@ HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, WORD *version )
}
}
TRACE_(win32)("Load addr is %lx (base %lx), range %x\n",
load_addr, nt->OptionalHeader.ImageBase, vma_size );
TRACE("Load addr is %lx (base %lx), range %x\n",
load_addr, nt->OptionalHeader.ImageBase, vma_size );
TRACE_(segment)("Loading %s at %lx, range %x\n",
filename, load_addr, vma_size );
@ -706,38 +705,38 @@ WINE_MODREF *PE_CreateModule( HMODULE hModule,
pe_resource = (PIMAGE_RESOURCE_DIRECTORY)RVA(dir->VirtualAddress);
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_EXCEPTION;
if (dir->Size) FIXME_(win32)("Exception directory ignored\n" );
if (dir->Size) FIXME("Exception directory ignored\n" );
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_SECURITY;
if (dir->Size) FIXME_(win32)("Security directory ignored\n" );
if (dir->Size) FIXME("Security directory ignored\n" );
/* IMAGE_DIRECTORY_ENTRY_BASERELOC handled in PE_LoadImage */
/* IMAGE_DIRECTORY_ENTRY_DEBUG handled by debugger */
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_DEBUG;
if (dir->Size) TRACE_(win32)("Debug directory ignored\n" );
if (dir->Size) TRACE("Debug directory ignored\n" );
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_COPYRIGHT;
if (dir->Size) FIXME_(win32)("Copyright string ignored\n" );
if (dir->Size) FIXME("Copyright string ignored\n" );
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_GLOBALPTR;
if (dir->Size) FIXME_(win32)("Global Pointer (MIPS) ignored\n" );
if (dir->Size) FIXME("Global Pointer (MIPS) ignored\n" );
/* IMAGE_DIRECTORY_ENTRY_TLS handled in PE_TlsInit */
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG;
if (dir->Size) FIXME_(win32)("Load Configuration directory ignored\n" );
if (dir->Size) FIXME("Load Configuration directory ignored\n" );
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT;
if (dir->Size) TRACE_(win32)("Bound Import directory ignored\n" );
if (dir->Size) TRACE("Bound Import directory ignored\n" );
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_IAT;
if (dir->Size) TRACE_(win32)("Import Address Table directory ignored\n" );
if (dir->Size) TRACE("Import Address Table directory ignored\n" );
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT;
if (dir->Size)
{
TRACE_(win32)("Delayed import, stub calls LoadLibrary\n" );
TRACE("Delayed import, stub calls LoadLibrary\n" );
/*
* Nothing to do here.
*/
@ -762,10 +761,10 @@ WINE_MODREF *PE_CreateModule( HMODULE hModule,
}
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR;
if (dir->Size) FIXME_(win32)("Unknown directory 14 ignored\n" );
if (dir->Size) FIXME("Unknown directory 14 ignored\n" );
dir = nt->OptionalHeader.DataDirectory+15;
if (dir->Size) FIXME_(win32)("Unknown directory 15 ignored\n" );
if (dir->Size) FIXME("Unknown directory 15 ignored\n" );
/* Allocate and fill WINE_MODREF */
@ -812,7 +811,7 @@ WINE_MODREF *PE_CreateModule( HMODULE hModule,
{
if ( PROCESS_Current()->exe_modref )
FIXME_(win32)( "Trying to load second .EXE file: %s\n", filename );
FIXME( "Trying to load second .EXE file: %s\n", filename );
else
PROCESS_Current()->exe_modref = wm;
}
@ -910,7 +909,7 @@ WINE_MODREF *PE_LoadLibraryExA (LPCSTR name, DWORD flags, DWORD *err)
/* Create 32-bit MODREF */
if ( !(wm = PE_CreateModule( hModule32, filename, flags, FALSE )) )
{
ERR_(win32)( "can't load %s\n", filename );
ERR( "can't load %s\n", filename );
FreeLibrary16( hModule16 );
*err = ERROR_OUTOFMEMORY;
return NULL;
@ -989,7 +988,7 @@ BOOL PE_CreateProcess( HANDLE hFile, LPCSTR filename, LPCSTR cmd_line, LPCSTR en
*/
int PE_UnloadImage( HMODULE hModule )
{
FIXME_(win32)("stub.\n");
FIXME("stub.\n");
/* free resources, image, unmap */
return 1;
}
@ -1075,7 +1074,7 @@ void PE_InitTls( void )
cbs = _fixup_address(&(peh->OptionalHeader),delta,pdir->AddressOfCallBacks);
if (*cbs)
FIXME_(win32)("TLS Callbacks aren't going to be called\n");
FIXME("TLS Callbacks aren't going to be called\n");
}
TlsSetValue( pem->tlsindex, mem );

73
loader/resource.c
View File

@ -33,8 +33,8 @@
#include "debugstr.h"
#include "winnls.h"
DEFAULT_DEBUG_CHANNEL(resource)
DECLARE_DEBUG_CHANNEL(accel)
DECLARE_DEBUG_CHANNEL(resource)
extern WORD WINE_LanguageId;
@ -68,7 +68,7 @@ static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HANDLE hRsrc32, WORD type )
if ( !(map = (HRSRC_MAP *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(HRSRC_MAP) ) ) )
{
ERR_(resource)("Cannot allocate HRSRC map\n" );
ERR("Cannot allocate HRSRC map\n" );
return 0;
}
pModule->hRsrcMap = (LPVOID)map;
@ -87,7 +87,7 @@ static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HANDLE hRsrc32, WORD type )
(map->nAlloc + HRSRC_MAP_BLOCKSIZE)
* sizeof(HRSRC_ELEM) ) ))
{
ERR_(resource)("Cannot grow HRSRC map\n" );
ERR("Cannot grow HRSRC map\n" );
return 0;
}
map->elem = newElem;
@ -139,13 +139,14 @@ static HRSRC RES_FindResource( HMODULE hModule, LPCSTR type,
WINE_MODREF *wm = pModule && pModule->module32?
MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
TRACE_(resource)("(%08x %s, %08x%s, %08x%s, %04x, %s, %s)\n",
hModule, pModule ? (char *)NE_MODULE_NAME(pModule) : "NULL dereference",
(UINT)type, HIWORD(type)? (bUnicode? debugstr_w((LPWSTR)type) : debugstr_a(type)) : "",
(UINT)name, HIWORD(name)? (bUnicode? debugstr_w((LPWSTR)name) : debugstr_a(name)) : "",
lang,
bUnicode? "W" : "A",
bRet16? "NE" : "PE" );
TRACE("(%08x %s, %08x%s, %08x%s, %04x, %s, %s)\n",
hModule,
pModule ? (char *)NE_MODULE_NAME(pModule) : "NULL dereference",
(UINT)type, HIWORD(type)? (bUnicode? debugstr_w((LPWSTR)type) : debugstr_a(type)) : "",
(UINT)name, HIWORD(name)? (bUnicode? debugstr_w((LPWSTR)name) : debugstr_a(name)) : "",
lang,
bUnicode? "W" : "A",
bRet16? "NE" : "PE" );
if ( !pModule ) return 0;
@ -174,7 +175,7 @@ static HRSRC RES_FindResource( HMODULE hModule, LPCSTR type,
break;
default:
ERR_(resource)("unknown module type %d\n", wm->type );
ERR("unknown module type %d\n", wm->type );
break;
}
@ -230,8 +231,8 @@ static DWORD RES_SizeofResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
WINE_MODREF *wm = pModule && pModule->module32?
MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
TRACE_(resource)("(%08x %s, %08x, %s)\n",
hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
TRACE("(%08x %s, %08x, %s)\n",
hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
if ( !pModule || !hRsrc ) return 0;
@ -253,7 +254,7 @@ static DWORD RES_SizeofResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
break;
default:
ERR_(resource)("unknown module type %d\n", wm->type );
ERR("unknown module type %d\n", wm->type );
break;
}
}
@ -281,8 +282,8 @@ static HFILE RES_AccessResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
WINE_MODREF *wm = pModule && pModule->module32?
MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
TRACE_(resource)("(%08x %s, %08x, %s)\n",
hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
TRACE("(%08x %s, %08x, %s)\n",
hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
if ( !pModule || !hRsrc ) return HFILE_ERROR;
@ -294,7 +295,7 @@ static HFILE RES_AccessResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
HRSRC hRsrc32 = HIWORD(hRsrc)? hRsrc : MapHRsrc16To32( pModule, hRsrc );
#endif
FIXME_(resource)("32-bit modules not yet supported.\n" );
FIXME("32-bit modules not yet supported.\n" );
hFile = HFILE_ERROR;
/* If we need to return a 16-bit file handle, convert it */
@ -329,8 +330,8 @@ static HGLOBAL RES_LoadResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
WINE_MODREF *wm = pModule && pModule->module32?
MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
TRACE_(resource)("(%08x %s, %08x, %s)\n",
hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
TRACE("(%08x %s, %08x, %s)\n",
hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
if ( !pModule || !hRsrc ) return 0;
@ -352,7 +353,7 @@ static HGLOBAL RES_LoadResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
break;
default:
ERR_(resource)("unknown module type %d\n", wm->type );
ERR("unknown module type %d\n", wm->type );
break;
}
@ -388,14 +389,14 @@ static LPVOID RES_LockResource( HGLOBAL handle, BOOL bRet16 )
{
LPVOID bits = NULL;
TRACE_(resource)("(%08x, %s)\n", handle, bRet16? "NE" : "PE" );
TRACE("(%08x, %s)\n", handle, bRet16? "NE" : "PE" );
if ( HIWORD( handle ) )
{
/* 32-bit memory handle */
if ( bRet16 )
FIXME_(resource)("can't return SEGPTR to 32-bit resource %08x.\n", handle );
FIXME("can't return SEGPTR to 32-bit resource %08x.\n", handle );
else
bits = (LPVOID)handle;
}
@ -422,7 +423,7 @@ static BOOL RES_FreeResource( HGLOBAL handle )
{
HGLOBAL retv = handle;
TRACE_(resource)("(%08x)\n", handle );
TRACE("(%08x)\n", handle );
if ( HIWORD( handle ) )
{
@ -862,8 +863,8 @@ INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
int string_num;
int i;
TRACE_(resource)("inst=%04x id=%04x buff=%08x len=%d\n",
instance, resource_id, (int) buffer, buflen);
TRACE("inst=%04x id=%04x buff=%08x len=%d\n",
instance, resource_id, (int) buffer, buflen);
hrsrc = FindResource16( instance, (SEGPTR)((resource_id>>4)+1), RT_STRING16 );
if (!hrsrc) return 0;
@ -875,7 +876,7 @@ INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
for (i = 0; i < string_num; i++)
p += *p + 1;
TRACE_(resource)("strlen = %d\n", (int)*p );
TRACE("strlen = %d\n", (int)*p );
if (buffer == NULL) return *p;
i = MIN(buflen - 1, *p);
@ -887,11 +888,11 @@ INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
buffer[0] = '\0';
return 0;
}
WARN_(resource)("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
WARN("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
}
FreeResource16( hmem );
TRACE_(resource)("'%s' loaded !\n", buffer);
TRACE("'%s' loaded !\n", buffer);
return i;
}
@ -909,8 +910,8 @@ INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
resource_id = (UINT)(-((INT)resource_id));
TRACE_(resource)("instance = %04x, id = %04x, buffer = %08x, "
"length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
TRACE("instance = %04x, id = %04x, buffer = %08x, "
"length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
/* Use bits 4 - 19 (incremented by 1) as resourceid, mask out
* 20 - 31. */
@ -925,7 +926,7 @@ INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
for (i = 0; i < string_num; i++)
p += *p + 1;
TRACE_(resource)("strlen = %d\n", (int)*p );
TRACE("strlen = %d\n", (int)*p );
if (buffer == NULL) return *p;
i = MIN(buflen - 1, *p);
@ -938,11 +939,11 @@ INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
return 0;
}
#if 0
WARN_(resource)("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
WARN("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
#endif
}
TRACE_(resource)("%s loaded !\n", debugstr_w(buffer));
TRACE("%s loaded !\n", debugstr_w(buffer));
return i;
}
@ -1006,7 +1007,7 @@ INT WINAPI LoadMessageA( HMODULE instance, UINT id, WORD lang,
PMESSAGE_RESOURCE_ENTRY mre;
int i,slen;
TRACE_(resource)("instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
TRACE("instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
/*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
hrsrc = FindResourceExW(instance,RT_MESSAGELISTW,(LPWSTR)1,lang);
@ -1033,7 +1034,7 @@ INT WINAPI LoadMessageA( HMODULE instance, UINT id, WORD lang,
mre = (PMESSAGE_RESOURCE_ENTRY)(((char*)mre)+(mre->Length));
}
slen=mre->Length;
TRACE_(resource)(" - strlen=%d\n",slen);
TRACE(" - strlen=%d\n",slen);
i = MIN(buflen - 1, slen);
if (buffer == NULL)
return slen;
@ -1047,7 +1048,7 @@ INT WINAPI LoadMessageA( HMODULE instance, UINT id, WORD lang,
}
}
if (buffer)
TRACE_(resource)("'%s' copied !\n", buffer);
TRACE("'%s' copied !\n", buffer);
return i;
}

71
loader/task.c
View File

@ -37,8 +37,8 @@
#include "services.h"
#include "server.h"
DEFAULT_DEBUG_CHANNEL(task)
DECLARE_DEBUG_CHANNEL(relay)
DECLARE_DEBUG_CHANNEL(task)
DECLARE_DEBUG_CHANNEL(toolhelp)
/* Min. number of thunks allocated when creating a new segment */
@ -254,10 +254,10 @@ void TASK_CallToStart(void)
EDI_reg(&context) = pTask->hInstance;
ESI_reg(&context) = pTask->hPrevInstance;
TRACE_(task)("Starting main program: cs:ip=%04lx:%04lx ds=%04lx ss:sp=%04x:%04x\n",
CS_reg(&context), EIP_reg(&context), DS_reg(&context),
SELECTOROF(pTask->teb->cur_stack),
OFFSETOF(pTask->teb->cur_stack) );
TRACE("Starting main program: cs:ip=%04lx:%04lx ds=%04lx ss:sp=%04x:%04x\n",
CS_reg(&context), EIP_reg(&context), DS_reg(&context),
SELECTOROF(pTask->teb->cur_stack),
OFFSETOF(pTask->teb->cur_stack) );
Callbacks->CallRegisterShortProc( &context, 0 );
}
@ -382,7 +382,7 @@ BOOL TASK_Create( NE_MODULE *pModule, UINT16 cmdShow)
/* Enter task handle into thread and process */
pTask->teb->htask16 = pTask->teb->process->task = hTask;
TRACE_(task)("module='%s' cmdline='%s' task=%04x\n", name, cmd_line, hTask );
TRACE("module='%s' cmdline='%s' task=%04x\n", name, cmd_line, hTask );
/* Add the task to the linked list */
@ -448,7 +448,7 @@ void TASK_KillTask( HTASK16 hTask )
return;
}
TRACE_(task)("Killing task %04x\n", hTask );
TRACE("Killing task %04x\n", hTask );
#ifdef MZ_SUPPORTED
{
@ -468,7 +468,7 @@ void TASK_KillTask( HTASK16 hTask )
if (nTaskCount <= 1)
{
TRACE_(task)("this is the last task, exiting\n" );
TRACE("this is the last task, exiting\n" );
ExitKernel16();
}
@ -572,8 +572,8 @@ void TASK_Reschedule(void)
/* Check what we need to do */
hOldTask = GetCurrentTask();
pOldTask = (TDB *)GlobalLock16( hOldTask );
TRACE_(task)( "entered with hCurrentTask %04x by hTask %04x (pid %ld)\n",
hCurrentTask, hOldTask, (long) getpid() );
TRACE( "entered with hCurrentTask %04x by hTask %04x (pid %ld)\n",
hCurrentTask, hOldTask, (long) getpid() );
if ( pOldTask && THREAD_IsWin16( NtCurrentTeb() ) )
{
@ -624,8 +624,7 @@ void TASK_Reschedule(void)
{
pNewTask = (TDB *)GlobalLock16( hNewTask );
TRACE_(task)( "\ttask = %04x, events = %i\n",
hNewTask, pNewTask->nEvents );
TRACE( "\ttask = %04x, events = %i\n", hNewTask, pNewTask->nEvents );
if (pNewTask->nEvents) break;
hNewTask = pNewTask->hNext;
@ -636,7 +635,7 @@ void TASK_Reschedule(void)
/* If we are still the task with highest priority, just return ... */
if ( mode == MODE_YIELD && hNewTask == hCurrentTask )
{
TRACE_(task)("returning to the current task (%04x)\n", hCurrentTask );
TRACE("returning to the current task (%04x)\n", hCurrentTask );
SYSLEVEL_LeaveWin16Lock();
/* Allow Win32 threads to thunk down even while a Win16 task is
@ -649,14 +648,14 @@ void TASK_Reschedule(void)
/* If no task to yield to found, suspend 16-bit scheduler ... */
if ( mode == MODE_YIELD && !hNewTask )
{
TRACE_(task)("No currently active task\n");
TRACE("No currently active task\n");
hCurrentTask = 0;
}
/* If we found a task to wake up, do it ... */
if ( (mode == MODE_YIELD || mode == MODE_WAKEUP) && hNewTask )
{
TRACE_(task)("Switching to task %04x (%.8s)\n",
TRACE("Switching to task %04x (%.8s)\n",
hNewTask, pNewTask->module_name );
pNewTask->priority++;
@ -761,7 +760,7 @@ BOOL16 WINAPI WaitEvent16( HTASK16 hTask )
if ( !THREAD_IsWin16( NtCurrentTeb() ) )
{
FIXME_(task)("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel);
FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel);
return TRUE;
}
@ -791,7 +790,7 @@ void WINAPI PostEvent16( HTASK16 hTask )
if ( !THREAD_IsWin16( pTask->teb ) )
{
FIXME_(task)("called for Win32 thread (%04x)!\n", pTask->teb->teb_sel );
FIXME("called for Win32 thread (%04x)!\n", pTask->teb->teb_sel );
return;
}
@ -853,7 +852,7 @@ void WINAPI OldYield16(void)
if ( !THREAD_IsWin16( NtCurrentTeb() ) )
{
FIXME_(task)("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel);
FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel);
return;
}
@ -882,16 +881,16 @@ void WINAPI DirectedYield16( HTASK16 hTask )
if ( !THREAD_IsWin16( NtCurrentTeb() ) )
{
FIXME_(task)("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel);
FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel);
return;
}
TRACE_(task)("%04x: DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
TRACE("%04x: DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
pCurTask->hYieldTo = hTask;
OldYield16();
TRACE_(task)("%04x: back from DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
TRACE("%04x: back from DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
}
/***********************************************************************
@ -913,7 +912,7 @@ HTASK16 WINAPI KERNEL_490( HTASK16 someTask )
{
if ( !someTask ) return 0;
FIXME_(task)("(%04x): stub\n", someTask );
FIXME("(%04x): stub\n", someTask );
return 0;
}
@ -926,12 +925,12 @@ FARPROC16 WINAPI MakeProcInstance16( FARPROC16 func, HANDLE16 hInstance )
SEGPTR thunkaddr;
if (!func) {
ERR_(task)("Ouch ! MakeProcInstance called with func == NULL !\n");
ERR("Ouch ! MakeProcInstance called with func == NULL !\n");
return (FARPROC16)0; /* Windows seems to do the same */
}
if ( GetTaskDS16() !=hInstance )
{
ERR_(task)("Problem with hInstance? Got %04x, using %04x instead\n",
ERR("Problem with hInstance? Got %04x, using %04x instead\n",
hInstance,GetTaskDS16());
hInstance = GetTaskDS16();
}
@ -941,12 +940,12 @@ FARPROC16 WINAPI MakeProcInstance16( FARPROC16 func, HANDLE16 hInstance )
thunk = PTR_SEG_TO_LIN( thunkaddr );
lfunc = PTR_SEG_TO_LIN( func );
TRACE_(task)("(%08lx,%04x): got thunk %08lx\n",
(DWORD)func, hInstance, (DWORD)thunkaddr );
TRACE("(%08lx,%04x): got thunk %08lx\n",
(DWORD)func, hInstance, (DWORD)thunkaddr );
if (((lfunc[0]==0x8c) && (lfunc[1]==0xd8)) ||
((lfunc[0]==0x1e) && (lfunc[1]==0x58))
) {
FIXME_(task)("thunk would be useless for %p, overwriting with nop;nop;\n", func );
FIXME("thunk would be useless for %p, overwriting with nop;nop;\n", func );
lfunc[0]=0x90; /* nop */
lfunc[1]=0x90; /* nop */
}
@ -965,7 +964,7 @@ FARPROC16 WINAPI MakeProcInstance16( FARPROC16 func, HANDLE16 hInstance )
*/
void WINAPI FreeProcInstance16( FARPROC16 func )
{
TRACE_(task)("(%08lx)\n", (DWORD)func );
TRACE("(%08lx)\n", (DWORD)func );
TASK_FreeThunk( GetCurrentTask(), (SEGPTR)func );
}
@ -1185,7 +1184,7 @@ HANDLE WINAPI GetFastQueue16( void )
Callout.InitThreadInput16( 0, THREAD_IsWin16(teb)? 4 : 5 );
if (!teb->queue)
FIXME_(task)("(): should initialize thread-local queue, expect failure!\n" );
FIXME("(): should initialize thread-local queue, expect failure!\n" );
return (HANDLE)teb->queue;
}
@ -1202,9 +1201,9 @@ void WINAPI SwitchStackTo16( WORD seg, WORD ptr, WORD top )
if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
if (!(pData = (INSTANCEDATA *)GlobalLock16( seg ))) return;
TRACE_(task)("old=%04x:%04x new=%04x:%04x\n",
SELECTOROF( pTask->teb->cur_stack ),
OFFSETOF( pTask->teb->cur_stack ), seg, ptr );
TRACE("old=%04x:%04x new=%04x:%04x\n",
SELECTOROF( pTask->teb->cur_stack ),
OFFSETOF( pTask->teb->cur_stack ), seg, ptr );
/* Save the old stack */
@ -1247,11 +1246,11 @@ void WINAPI SwitchStackBack16( CONTEXT86 *context )
return;
if (!pData->old_ss_sp)
{
WARN_(task)("No previous SwitchStackTo\n" );
WARN("No previous SwitchStackTo\n" );
return;
}
TRACE_(task)("restoring stack %04x:%04x\n",
SELECTOROF(pData->old_ss_sp), OFFSETOF(pData->old_ss_sp) );
TRACE("restoring stack %04x:%04x\n",
SELECTOROF(pData->old_ss_sp), OFFSETOF(pData->old_ss_sp) );
oldFrame = CURRENT_STACK16;
@ -1480,7 +1479,7 @@ void TASK_CallTaskSignalProc( UINT16 uCode, HANDLE16 hTaskOrModule )
WORD WINAPI SetSigHandler16( FARPROC16 newhandler, FARPROC16* oldhandler,
UINT16 *oldmode, UINT16 newmode, UINT16 flag )
{
FIXME_(task)("(%p,%p,%p,%d,%d), unimplemented.\n",
FIXME("(%p,%p,%p,%d,%d), unimplemented.\n",
newhandler,oldhandler,oldmode,newmode,flag );
if (flag != 1) return 0;

6
memory/instr.c
View File

@ -13,7 +13,7 @@
#include "selectors.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(int)
DEFAULT_DEBUG_CHANNEL(int)
DECLARE_DEBUG_CHANNEL(io)
#ifdef __i386__
@ -75,7 +75,7 @@ static BOOL INSTR_ReplaceSelector( CONTEXT86 *context, WORD *sel )
return TRUE;
}
if (!IS_SELECTOR_SYSTEM(*sel) && !IS_SELECTOR_FREE(*sel))
ERR_(int)("Got protection fault on valid selector, maybe your kernel is too old?\n" );
ERR("Got protection fault on valid selector, maybe your kernel is too old?\n" );
return FALSE; /* Can't replace selector, crashdump */
}
@ -672,7 +672,7 @@ BOOL INSTR_EmulateInstruction( CONTEXT86 *context )
case 0xcd: /* int <XX> */
if (long_op)
{
ERR_(int)("int xx from 32-bit code is not supported.\n");
ERR("int xx from 32-bit code is not supported.\n");
break; /* Unable to emulate it */
}
else

2
memory/local.c
View File

@ -27,8 +27,8 @@
#include "debugtools.h"
#include "callback.h"
DECLARE_DEBUG_CHANNEL(heap)
DEFAULT_DEBUG_CHANNEL(local)
DECLARE_DEBUG_CHANNEL(heap)
typedef struct
{

80
misc/registry.c
View File

@ -112,7 +112,7 @@ static void REGISTRY_Init(void) {
HKEY hkey;
char buf[200];
TRACE_(reg)("(void)\n");
TRACE("(void)\n");
RegCreateKeyA(HKEY_DYN_DATA,"PerfStats\\StatData",&hkey);
RegCloseKey(hkey);
@ -231,7 +231,7 @@ static void SHELL_SaveRegistryBranch(HKEY hkey)
/* FIXME: does this check apply to all keys written below ? */
if (!(home = getenv( "HOME" )))
ERR_(reg)("Failed to get homedirectory of UID %ld.\n",(long) getuid());
ERR("Failed to get homedirectory of UID %ld.\n",(long) getuid());
/* HKEY_LOCAL_MACHINE contains the HKEY_CLASSES_ROOT branch */
if (hkey == HKEY_CLASSES_ROOT) hkey = HKEY_LOCAL_MACHINE;
@ -295,7 +295,7 @@ static void SHELL_SaveRegistryBranch(HKEY hkey)
}
break;
default:
ERR_(reg)("unknown/invalid key handle !\n");
ERR("unknown/invalid key handle !\n");
break;
}
}
@ -311,7 +311,7 @@ void SHELL_SaveRegistry( void )
HKEY hkey;
int all;
TRACE_(reg)("(void)\n");
TRACE("(void)\n");
all=0;
if (RegOpenKeyA(HKEY_CURRENT_USER,KEY_REGISTRY,&hkey)!=ERROR_SUCCESS)
@ -458,7 +458,7 @@ static char* _wine_read_USTRING( char *buf, LPWSTR *str )
continue;
}
if (*s!='u') {
WARN_(reg)("Non unicode escape sequence \\%c found in |%s|\n",*s,buf);
WARN("Non unicode escape sequence \\%c found in |%s|\n",*s,buf);
*ws++='\\';
*ws++=*s++;
} else {
@ -468,7 +468,7 @@ static char* _wine_read_USTRING( char *buf, LPWSTR *str )
s++;
memcpy(xbuf,s,4);xbuf[4]='\0';
if (!sscanf(xbuf,"%x",&wc))
WARN_(reg)("Strange escape sequence %s found in |%s|\n",xbuf,buf);
WARN("Strange escape sequence %s found in |%s|\n",xbuf,buf);
s+=4;
*ws++ =(unsigned short)wc;
}
@ -496,7 +496,7 @@ static int _wine_loadsubkey( FILE *F, HKEY hkey, int level, char **buf, int *buf
char *s;
LPWSTR name;
TRACE_(reg)("(%p,%x,%d,%s,%d)\n", F, hkey, level, debugstr_a(*buf), *buflen);
TRACE("(%p,%x,%d,%s,%d)\n", F, hkey, level, debugstr_a(*buf), *buflen);
/* Good. We already got a line here ... so parse it */
subkey = 0;
@ -508,7 +508,7 @@ static int _wine_loadsubkey( FILE *F, HKEY hkey, int level, char **buf, int *buf
}
if (i>level) {
if (!subkey) {
WARN_(reg)("Got a subhierarchy without resp. key?\n");
WARN("Got a subhierarchy without resp. key?\n");
return 0;
}
if (!_wine_loadsubkey(F,subkey,level+1,buf,buflen))
@ -535,19 +535,19 @@ static int _wine_loadsubkey( FILE *F, HKEY hkey, int level, char **buf, int *buf
int len,lastmodified,type;
if (*s!='=') {
WARN_(reg)("Unexpected character: %c\n",*s);
WARN("Unexpected character: %c\n",*s);
break;
}
s++;
if (2!=sscanf(s,"%d,%d,",&type,&lastmodified)) {
WARN_(reg)("Haven't understood possible value in |%s|, skipping.\n",*buf);
WARN("Haven't understood possible value in |%s|, skipping.\n",*buf);
break;
}
/* skip the 2 , */
s=strchr(s,',');s++;
s=strchr(s,',');
if (!s++) {
WARN_(reg)("Haven't understood possible value in |%s|, skipping.\n",*buf);
WARN("Haven't understood possible value in |%s|, skipping.\n",*buf);
break;
}
if (type == REG_SZ || type == REG_EXPAND_SZ) {
@ -624,7 +624,7 @@ static int _wine_loadsubreg( FILE *F, HKEY hkey, const char *fn )
}
else
{
TRACE_(reg)("Old format (%d) registry found, ignoring it. (buf was %s).\n",ver,buf);
TRACE("Old format (%d) registry found, ignoring it. (buf was %s).\n",ver,buf);
free(buf);
return 0;
}
@ -649,11 +649,11 @@ static void _wine_loadreg( HKEY hkey, char *fn )
{
FILE *F;
TRACE_(reg)("(%x,%s)\n",hkey,debugstr_a(fn));
TRACE("(%x,%s)\n",hkey,debugstr_a(fn));
F = fopen(fn,"rb");
if (F==NULL) {
WARN_(reg)("Couldn't open %s for reading: %s\n",fn,strerror(errno) );
WARN("Couldn't open %s for reading: %s\n",fn,strerror(errno) );
return;
}
_wine_loadsubreg(F,hkey,fn);
@ -709,7 +709,7 @@ static void _copy_registry( HKEY from, HKEY to )
name_len = sizeof(name);
if (RegEnumValueW( from, index++, name, &name_len,
NULL, &type, data, &len ) != ERROR_SUCCESS) break;
RegSetValueExW( to, name, 0, type, (LPCWSTR)data, len );
RegSetValueExW( to, name, 0, type, data, len );
}
/* copy subkeys */
@ -1017,7 +1017,7 @@ static void _w95_loadreg( char* fn, HKEY hkey )
OFSTRUCT ofs;
BY_HANDLE_FILE_INFORMATION hfdinfo;
TRACE_(reg)("Loading Win95 registry database '%s'\n",fn);
TRACE("Loading Win95 registry database '%s'\n",fn);
hfd=OpenFile(fn,&ofs,OF_READ);
if (hfd==HFILE_ERROR)
return;
@ -1025,7 +1025,7 @@ static void _w95_loadreg( char* fn, HKEY hkey )
if (4!=_lread(hfd,magic,4))
return;
if (strcmp(magic,"CREG")) {
WARN_(reg)("%s is not a w95 registry.\n",fn);
WARN("%s is not a w95 registry.\n",fn);
return;
}
if (4!=_lread(hfd,&version,4))
@ -1037,7 +1037,7 @@ static void _w95_loadreg( char* fn, HKEY hkey )
if (4!=_lread(hfd,magic,4))
return;
if (strcmp(magic,"RGKN")) {
WARN_(reg)("second IFF header not RGKN, but %s\n", magic);
WARN("second IFF header not RGKN, but %s\n", magic);
return;
}
@ -1199,7 +1199,7 @@ __w31_dumptree( unsigned short idx,
}
}
} else {
TRACE_(reg)("strange: no directory key name, idx=%04x\n", idx);
TRACE("strange: no directory key name, idx=%04x\n", idx);
}
__w31_dumptree(dir->child_idx,txt,tab,head,subkey,lastmodified,level+1);
idx=dir->sibling_idx;
@ -1221,7 +1221,7 @@ void _w31_loadreg(void) {
BY_HANDLE_FILE_INFORMATION hfinfo;
time_t lastmodified;
TRACE_(reg)("(void)\n");
TRACE("(void)\n");
hf = OpenFile("reg.dat",&ofs,OF_READ);
if (hf==HFILE_ERROR)
@ -1229,12 +1229,12 @@ void _w31_loadreg(void) {
/* read & dump header */
if (sizeof(head)!=_lread(hf,&head,sizeof(head))) {
ERR_(reg)("reg.dat is too short.\n");
ERR("reg.dat is too short.\n");
_lclose(hf);
return;
}
if (memcmp(head.cookie, "SHCC3.10", sizeof(head.cookie))!=0) {
ERR_(reg)("reg.dat has bad signature.\n");
ERR("reg.dat has bad signature.\n");
_lclose(hf);
return;
}
@ -1243,7 +1243,7 @@ void _w31_loadreg(void) {
/* read and dump index table */
tab = xmalloc(len);
if (len!=_lread(hf,tab,len)) {
ERR_(reg)("couldn't read %d bytes.\n",len);
ERR("couldn't read %d bytes.\n",len);
free(tab);
_lclose(hf);
return;
@ -1252,14 +1252,14 @@ void _w31_loadreg(void) {
/* read text */
txt = xmalloc(head.textsize);
if (-1==_llseek(hf,head.textoff,SEEK_SET)) {
ERR_(reg)("couldn't seek to textblock.\n");
ERR("couldn't seek to textblock.\n");
free(tab);
free(txt);
_lclose(hf);
return;
}
if (head.textsize!=_lread(hf,txt,head.textsize)) {
ERR_(reg)("textblock too short (%d instead of %ld).\n",len,head.textsize);
ERR("textblock too short (%d instead of %ld).\n",len,head.textsize);
free(tab);
free(txt);
_lclose(hf);
@ -1267,7 +1267,7 @@ void _w31_loadreg(void) {
}
if (!GetFileInformationByHandle(hf,&hfinfo)) {
ERR_(reg)("GetFileInformationByHandle failed?.\n");
ERR("GetFileInformationByHandle failed?.\n");
free(tab);
free(txt);
_lclose(hf);
@ -1292,7 +1292,7 @@ void SHELL_LoadRegistry( void )
char *fn, *home;
HKEY hkey;
TRACE_(reg)("(void)\n");
TRACE("(void)\n");
REGISTRY_Init();
@ -1335,7 +1335,7 @@ void SHELL_LoadRegistry( void )
* Load the user saved registries
*/
if (!(home = getenv( "HOME" )))
WARN_(reg)("Failed to get homedirectory of UID %ld.\n",(long) getuid());
WARN("Failed to get homedirectory of UID %ld.\n",(long) getuid());
else if (PROFILE_GetWineIniBool("registry", "LoadHomeRegistryFiles", 1))
{
/*
@ -1407,7 +1407,7 @@ void SHELL_LoadRegistry( void )
* in order to copy HKU\.Default\* onto HKEY_CURRENT_USER
*/
if (RegCreateKeyA(HKEY_USERS,".Default",&hkey) != ERROR_SUCCESS)
WARN_(reg)("Could not create global user default key\n");
WARN("Could not create global user default key\n");
else
_copy_registry( hkey, HKEY_CURRENT_USER );
RegCloseKey(hkey);
@ -1502,14 +1502,14 @@ DWORD WINAPI RegFlushKey( HKEY hkey )
LONG WINAPI RegConnectRegistryW( LPCWSTR lpMachineName, HKEY hKey,
LPHKEY phkResult )
{
TRACE_(reg)("(%s,%x,%p): stub\n",debugstr_w(lpMachineName),hKey,phkResult);
TRACE("(%s,%x,%p): stub\n",debugstr_w(lpMachineName),hKey,phkResult);
if (!lpMachineName || !*lpMachineName) {
/* Use the local machine name */
return RegOpenKey16( hKey, "", phkResult );
}
FIXME_(reg)("Cannot connect to %s\n",debugstr_w(lpMachineName));
FIXME("Cannot connect to %s\n",debugstr_w(lpMachineName));
return ERROR_BAD_NETPATH;
}
@ -1546,7 +1546,7 @@ LONG WINAPI RegGetKeySecurity( HKEY hkey,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
LPDWORD lpcbSecurityDescriptor )
{
TRACE_(reg)("(%x,%ld,%p,%ld)\n",hkey,SecurityInformation,pSecurityDescriptor,
TRACE("(%x,%ld,%p,%ld)\n",hkey,SecurityInformation,pSecurityDescriptor,
lpcbSecurityDescriptor?*lpcbSecurityDescriptor:0);
/* FIXME: Check for valid SecurityInformation values */
@ -1554,7 +1554,7 @@ LONG WINAPI RegGetKeySecurity( HKEY hkey,
if (*lpcbSecurityDescriptor < sizeof(SECURITY_DESCRIPTOR))
return ERROR_INSUFFICIENT_BUFFER;
FIXME_(reg)("(%x,%ld,%p,%ld): stub\n",hkey,SecurityInformation,
FIXME("(%x,%ld,%p,%ld): stub\n",hkey,SecurityInformation,
pSecurityDescriptor,lpcbSecurityDescriptor?*lpcbSecurityDescriptor:0);
return ERROR_SUCCESS;
@ -1575,7 +1575,7 @@ LONG WINAPI RegNotifyChangeKeyValue( HKEY hkey, BOOL fWatchSubTree,
DWORD fdwNotifyFilter, HANDLE hEvent,
BOOL fAsync )
{
FIXME_(reg)("(%x,%i,%ld,%x,%i): stub\n",hkey,fWatchSubTree,fdwNotifyFilter,
FIXME("(%x,%i,%ld,%x,%i): stub\n",hkey,fWatchSubTree,fdwNotifyFilter,
hEvent,fAsync);
return ERROR_SUCCESS;
}
@ -1590,7 +1590,7 @@ LONG WINAPI RegNotifyChangeKeyValue( HKEY hkey, BOOL fWatchSubTree,
*/
LONG WINAPI RegUnLoadKeyW( HKEY hkey, LPCWSTR lpSubKey )
{
FIXME_(reg)("(%x,%s): stub\n",hkey, debugstr_w(lpSubKey));
FIXME("(%x,%s): stub\n",hkey, debugstr_w(lpSubKey));
return ERROR_SUCCESS;
}
@ -1619,7 +1619,7 @@ LONG WINAPI RegUnLoadKeyA( HKEY hkey, LPCSTR lpSubKey )
LONG WINAPI RegSetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInfo,
PSECURITY_DESCRIPTOR pSecurityDesc )
{
TRACE_(reg)("(%x,%ld,%p)\n",hkey,SecurityInfo,pSecurityDesc);
TRACE("(%x,%ld,%p)\n",hkey,SecurityInfo,pSecurityDesc);
/* It seems to perform this check before the hkey check */
if ((SecurityInfo & OWNER_SECURITY_INFORMATION) ||
@ -1633,7 +1633,7 @@ LONG WINAPI RegSetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInfo,
if (!pSecurityDesc)
return ERROR_INVALID_PARAMETER;
FIXME_(reg)(":(%x,%ld,%p): stub\n",hkey,SecurityInfo,pSecurityDesc);
FIXME(":(%x,%ld,%p): stub\n",hkey,SecurityInfo,pSecurityDesc);
return ERROR_SUCCESS;
}
@ -1649,13 +1649,13 @@ LONG WINAPI RegSetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInfo,
*/
LONG WINAPI RegRestoreKeyW( HKEY hkey, LPCWSTR lpFile, DWORD dwFlags )
{
TRACE_(reg)("(%x,%s,%ld)\n",hkey,debugstr_w(lpFile),dwFlags);
TRACE("(%x,%s,%ld)\n",hkey,debugstr_w(lpFile),dwFlags);
/* It seems to do this check before the hkey check */
if (!lpFile || !*lpFile)
return ERROR_INVALID_PARAMETER;
FIXME_(reg)("(%x,%s,%ld): stub\n",hkey,debugstr_w(lpFile),dwFlags);
FIXME("(%x,%s,%ld): stub\n",hkey,debugstr_w(lpFile),dwFlags);
/* Check for file existence */
@ -1688,7 +1688,7 @@ LONG WINAPI RegRestoreKeyA( HKEY hkey, LPCSTR lpFile, DWORD dwFlags )
LONG WINAPI RegReplaceKeyW( HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpNewFile,
LPCWSTR lpOldFile )
{
FIXME_(reg)("(%x,%s,%s,%s): stub\n", hkey, debugstr_w(lpSubKey),
FIXME("(%x,%s,%s,%s): stub\n", hkey, debugstr_w(lpSubKey),
debugstr_w(lpNewFile),debugstr_w(lpOldFile));
return ERROR_SUCCESS;
}

15
msdos/dosmem.c
View File

@ -18,7 +18,7 @@
#include "task.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(dosmem)
DEFAULT_DEBUG_CHANNEL(dosmem)
DECLARE_DEBUG_CHANNEL(selector)
HANDLE16 DOSMEM_BiosDataSeg; /* BIOS data segment at 0x40:0 */
@ -422,7 +422,7 @@ BOOL DOSMEM_Init(HMODULE16 hModule)
PAGE_EXECUTE_READWRITE );
if (!DOSMEM_dosmem)
{
WARN_(dosmem)("Could not allocate DOS memory.\n" );
WARN("Could not allocate DOS memory.\n" );
return FALSE;
}
DOSMEM_BiosDataSeg = GLOBAL_CreateBlock(GMEM_FIXED,DOSMEM_dosmem+0x400,
@ -489,7 +489,7 @@ LPVOID DOSMEM_GetBlock(HMODULE16 hModule, UINT size, UINT16* pseg)
#ifdef __DOSMEM_DEBUG__
if( (dm->size & DM_BLOCK_DEBUG) != DM_BLOCK_DEBUG )
{
WARN_(dosmem)("MCB overrun! [prev = 0x%08x]\n", 4 + (UINT)prev);
WARN("MCB overrun! [prev = 0x%08x]\n", 4 + (UINT)prev);
return NULL;
}
prev = dm;
@ -671,7 +671,7 @@ UINT DOSMEM_Available(HMODULE16 hModule)
#ifdef __DOSMEM_DEBUG__
if( (dm->size & DM_BLOCK_DEBUG) != DM_BLOCK_DEBUG )
{
WARN_(dosmem)("MCB overrun! [prev = 0x%08x]\n", 4 + (UINT)prev);
WARN("MCB overrun! [prev = 0x%08x]\n", 4 + (UINT)prev);
return NULL;
}
prev = dm;
@ -733,8 +733,7 @@ LPVOID DOSMEM_MapRealToLinear(DWORD x)
LPVOID lin;
lin=DOSMEM_MemoryBase(0)+(x&0xffff)+(((x&0xffff0000)>>16)*16);
TRACE_(selector)("(0x%08lx) returns 0x%p.\n",
x,lin );
TRACE_(selector)("(0x%08lx) returns 0x%p.\n", x, lin );
return lin;
}
@ -752,9 +751,7 @@ WORD DOSMEM_AllocSelector(WORD realsel)
GMEM_FIXED,DOSMEM_dosmem+realsel*16,0x10000,
hModule,FALSE,FALSE,FALSE,NULL
);
TRACE_(selector)("(0x%04x) returns 0x%04x.\n",
realsel,sel
);
TRACE_(selector)("(0x%04x) returns 0x%04x.\n", realsel,sel);
return sel;
}

46
objects/bitmap.c
View File

@ -19,7 +19,7 @@
#include "monitor.h"
#include "wine/winuser16.h"
DECLARE_DEBUG_CHANNEL(bitmap)
DEFAULT_DEBUG_CHANNEL(bitmap)
DECLARE_DEBUG_CHANNEL(resource)
BITMAP_DRIVER *BITMAP_Driver = NULL;
@ -54,7 +54,7 @@ INT BITMAP_GetWidthBytes( INT bmWidth, INT bpp )
return 2 * ((bmWidth+3) >> 2);
default:
WARN_(bitmap)("Unknown depth %d, please report.\n", bpp );
WARN("Unknown depth %d, please report.\n", bpp );
}
return -1;
}
@ -115,7 +115,7 @@ HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
/* Check parameters */
if (!height || !width) return 0;
if (planes != 1) {
FIXME_(bitmap)("planes = %d\n", planes);
FIXME("planes = %d\n", planes);
return 0;
}
if (height < 0) height = -height;
@ -125,7 +125,7 @@ HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
if (!hbitmap) return 0;
TRACE_(bitmap)("%dx%d, %d colors returning %08x\n", width, height,
TRACE("%dx%d, %d colors returning %08x\n", width, height,
1 << (planes*bpp), hbitmap);
bmp = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
@ -177,10 +177,10 @@ HBITMAP WINAPI CreateCompatibleBitmap( HDC hdc, INT width, INT height)
HBITMAP hbmpRet = 0;
DC *dc;
TRACE_(bitmap)("(%04x,%d,%d) = \n", hdc, width, height );
TRACE("(%04x,%d,%d) = \n", hdc, width, height );
if (!(dc = DC_GetDCPtr( hdc ))) return 0;
if ((width >= 0x10000) || (height >= 0x10000)) {
FIXME_(bitmap)("got bad width %d or height %d, please look for reason\n",
FIXME("got bad width %d or height %d, please look for reason\n",
width, height );
} else {
/* MS doc says if width or height is 0, return 1-by-1 pixel, monochrome bitmap */
@ -191,7 +191,7 @@ HBITMAP WINAPI CreateCompatibleBitmap( HDC hdc, INT width, INT height)
if(dc->funcs->pCreateBitmap)
dc->funcs->pCreateBitmap( hbmpRet );
}
TRACE_(bitmap)("\t\t%04x\n", hbmpRet);
TRACE("\t\t%04x\n", hbmpRet);
GDI_HEAP_UNLOCK(hdc);
return hbmpRet;
}
@ -253,7 +253,7 @@ LONG WINAPI GetBitmapBits(
return bmp->bitmap.bmWidthBytes * bmp->bitmap.bmHeight;
if (count < 0) {
WARN_(bitmap)("(%ld): Negative number of bytes passed???\n", count );
WARN("(%ld): Negative number of bytes passed???\n", count );
count = -count;
}
@ -263,31 +263,31 @@ LONG WINAPI GetBitmapBits(
count = height * bmp->bitmap.bmWidthBytes;
if (count == 0)
{
WARN_(bitmap)("Less then one entire line requested\n");
WARN("Less then one entire line requested\n");
GDI_HEAP_UNLOCK( hbitmap );
return 0;
}
TRACE_(bitmap)("(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, height );
TRACE("(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, height );
if(bmp->DDBitmap) {
TRACE_(bitmap)("Calling device specific BitmapBits\n");
TRACE("Calling device specific BitmapBits\n");
if(bmp->DDBitmap->funcs->pBitmapBits)
ret = bmp->DDBitmap->funcs->pBitmapBits(hbitmap, bits, count,
DDB_GET);
else {
ERR_(bitmap)("BitmapBits == NULL??\n");
ERR("BitmapBits == NULL??\n");
ret = 0;
}
} else {
if(!bmp->bitmap.bmBits) {
WARN_(bitmap)("Bitmap is empty\n");
WARN("Bitmap is empty\n");
ret = 0;
} else {
memcpy(bits, bmp->bitmap.bmBits, count);
@ -329,7 +329,7 @@ LONG WINAPI SetBitmapBits(
return 0;
if (count < 0) {
WARN_(bitmap)("(%ld): Negative number of bytes passed???\n", count );
WARN("(%ld): Negative number of bytes passed???\n", count );
count = -count;
}
@ -338,18 +338,18 @@ LONG WINAPI SetBitmapBits(
if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
count = height * bmp->bitmap.bmWidthBytes;
TRACE_(bitmap)("(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, height );
TRACE("(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, height );
if(bmp->DDBitmap) {
TRACE_(bitmap)("Calling device specific BitmapBits\n");
TRACE("Calling device specific BitmapBits\n");
if(bmp->DDBitmap->funcs->pBitmapBits)
ret = bmp->DDBitmap->funcs->pBitmapBits(hbitmap, (void *) bits,
count, DDB_SET);
else {
ERR_(bitmap)("BitmapBits == NULL??\n");
ERR("BitmapBits == NULL??\n");
ret = 0;
}
@ -358,7 +358,7 @@ LONG WINAPI SetBitmapBits(
if(!bmp->bitmap.bmBits) /* Alloc enough for entire bitmap */
bmp->bitmap.bmBits = HeapAlloc( GetProcessHeap(), 0, count );
if(!bmp->bitmap.bmBits) {
WARN_(bitmap)("Unable to allocate bit buffer\n");
WARN("Unable to allocate bit buffer\n");
ret = 0;
} else {
memcpy(bmp->bitmap.bmBits, bits, count);
@ -684,7 +684,7 @@ INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer )
}
else
{
FIXME_(bitmap)("not implemented for DIBs: count %d\n", count);
FIXME("not implemented for DIBs: count %d\n", count);
return 0;
}
}

39
objects/clipping.c
View File

@ -10,7 +10,7 @@
#include "debugtools.h"
#include "wine/winuser16.h"
DECLARE_DEBUG_CHANNEL(clipping)
DEFAULT_DEBUG_CHANNEL(clipping)
DECLARE_DEBUG_CHANNEL(region)
#define UPDATE_DIRTY_DC(dc) \
@ -84,7 +84,7 @@ INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return ERROR;
TRACE_(clipping)("%04x %04x %d\n", hdc, hrgn, fnMode );
TRACE("%04x %04x %d\n", hdc, hrgn, fnMode );
if (!hrgn)
{
@ -96,7 +96,7 @@ INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
}
else
{
FIXME_(clipping)("Unimplemented: hrgn NULL in mode: %d\n", fnMode);
FIXME("Unimplemented: hrgn NULL in mode: %d\n", fnMode);
return ERROR;
}
}
@ -132,7 +132,7 @@ INT16 WINAPI SelectVisRgn16( HDC16 hdc, HRGN16 hrgn )
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc || !hrgn) return ERROR;
TRACE_(clipping)("%04x %04x\n", hdc, hrgn );
TRACE("%04x %04x\n", hdc, hrgn );
dc->w.flags &= ~DC_DIRTY;
@ -161,7 +161,7 @@ INT WINAPI OffsetClipRgn( HDC hdc, INT x, INT y )
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return ERROR;
TRACE_(clipping)("%04x %d,%d\n", hdc, x, y );
TRACE("%04x %d,%d\n", hdc, x, y );
if(dc->funcs->pOffsetClipRgn)
ret = dc->funcs->pOffsetClipRgn( dc, x, y );
@ -182,7 +182,7 @@ INT16 WINAPI OffsetVisRgn16( HDC16 hdc, INT16 x, INT16 y )
INT16 retval;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return ERROR;
TRACE_(clipping)("%04x %d,%d\n", hdc, x, y );
TRACE("%04x %d,%d\n", hdc, x, y );
retval = OffsetRgn( dc->w.hVisRgn, x, y );
CLIPPING_UpdateGCRegion( dc );
GDI_HEAP_UNLOCK( hdc );
@ -222,7 +222,7 @@ INT CLIPPING_IntersectClipRect( DC * dc, INT left, INT top,
dc->w.hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
CombineRgn( dc->w.hClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
}
else WARN_(clipping)("No hClipRgn and flags are %x\n",flags);
else WARN("No hClipRgn and flags are %x\n",flags);
}
ret = CombineRgn( newRgn, dc->w.hClipRgn, newRgn,
@ -258,8 +258,7 @@ INT WINAPI ExcludeClipRect( HDC hdc, INT left, INT top,
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return ERROR;
TRACE_(clipping)("%04x %dx%d,%dx%d\n",
hdc, left, top, right, bottom );
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
if(dc->funcs->pExcludeClipRect)
ret = dc->funcs->pExcludeClipRect( dc, left, top, right, bottom );
@ -296,8 +295,7 @@ INT WINAPI IntersectClipRect( HDC hdc, INT left, INT top,
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return ERROR;
TRACE_(clipping)("%04x %dx%d,%dx%d\n",
hdc, left, top, right, bottom );
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
if(dc->funcs->pIntersectClipRect)
ret = dc->funcs->pIntersectClipRect( dc, left, top, right, bottom );
@ -372,8 +370,7 @@ INT16 WINAPI ExcludeVisRect16( HDC16 hdc, INT16 left, INT16 top,
top = YLPTODP( dc, top );
bottom = YLPTODP( dc, bottom );
TRACE_(clipping)("%04x %dx%d,%dx%d\n",
hdc, left, top, right, bottom );
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, TRUE );
}
@ -393,8 +390,7 @@ INT16 WINAPI IntersectVisRect16( HDC16 hdc, INT16 left, INT16 top,
top = YLPTODP( dc, top );
bottom = YLPTODP( dc, bottom );
TRACE_(clipping)("%04x %dx%d,%dx%d\n",
hdc, left, top, right, bottom );
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, FALSE );
}
@ -417,7 +413,7 @@ BOOL WINAPI PtVisible( HDC hdc, INT x, INT y )
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return ERROR;
TRACE_(clipping)("%04x %d,%d\n", hdc, x, y );
TRACE("%04x %d,%d\n", hdc, x, y );
if (!dc->w.hGCClipRgn) return FALSE;
if( dc->w.flags & DC_DIRTY ) UPDATE_DIRTY_DC(dc);
@ -436,8 +432,8 @@ BOOL16 WINAPI RectVisible16( HDC16 hdc, const RECT16* rect )
RECT16 tmpRect;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
TRACE_(clipping)("%04x %d,%dx%d,%d\n",
hdc, rect->left, rect->top, rect->right, rect->bottom );
TRACE("%04x %d,%dx%d,%d\n",
hdc, rect->left, rect->top, rect->right, rect->bottom );
if (!dc->w.hGCClipRgn) return FALSE;
/* copy rectangle to avoid overwriting by LPtoDP */
tmpRect = *rect;
@ -469,8 +465,7 @@ INT16 WINAPI GetClipBox16( HDC16 hdc, LPRECT16 rect )
ret = GetRgnBox16( dc->w.hGCClipRgn, rect );
OffsetRect16( rect, -dc->w.DCOrgX, -dc->w.DCOrgY );
DPtoLP16( hdc, (LPPOINT16)rect, 2 );
TRACE_(clipping)("%d,%d-%d,%d\n",
rect->left,rect->top,rect->right,rect->bottom );
TRACE("%d,%d-%d,%d\n", rect->left,rect->top,rect->right,rect->bottom );
return ret;
}
@ -523,7 +518,7 @@ HRGN16 WINAPI SaveVisRgn16( HDC16 hdc )
RGNOBJ *obj, *copyObj;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
TRACE_(clipping)("%04x\n", hdc );
TRACE("%04x\n", hdc );
if (!dc->w.hVisRgn)
{
ERR_(region)("hVisRgn is zero. Please report this.\n" );
@ -575,7 +570,7 @@ INT16 WINAPI RestoreVisRgn16( HDC16 hdc )
GDI_HEAP_UNLOCK( hdc );
return ERROR;
}
TRACE_(clipping)("%04x\n", hdc );
TRACE("%04x\n", hdc );
if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );

139
objects/font.c
View File

@ -16,7 +16,7 @@
#include "winerror.h"
#include "dc.h"
DECLARE_DEBUG_CHANNEL(font)
DEFAULT_DEBUG_CHANNEL(font)
DECLARE_DEBUG_CHANNEL(gdi)
#define ENUM_UNICODE 0x00000001
@ -319,25 +319,24 @@ HFONT16 WINAPI CreateFontIndirect16( const LOGFONT16 *font )
fontPtr = (FONTOBJ *) GDI_HEAP_LOCK( hFont );
memcpy( &fontPtr->logfont, font, sizeof(LOGFONT16) );
TRACE_(font)("(%i %i %i %i) '%s' %s %s => %04x\n",
font->lfHeight, font->lfWidth,
font->lfEscapement, font->lfOrientation,
font->lfFaceName ? font->lfFaceName : "NULL",
font->lfWeight > 400 ? "Bold" : "",
font->lfItalic ? "Italic" : "",
hFont);
TRACE("(%i %i %i %i) '%s' %s %s => %04x\n",
font->lfHeight, font->lfWidth,
font->lfEscapement, font->lfOrientation,
font->lfFaceName ? font->lfFaceName : "NULL",
font->lfWeight > 400 ? "Bold" : "",
font->lfItalic ? "Italic" : "", hFont);
if (font->lfEscapement != font->lfOrientation) {
/* this should really depend on whether GM_ADVANCED is set */
fontPtr->logfont.lfOrientation = fontPtr->logfont.lfEscapement;
WARN_(font)(
"orientation angle %f set to escapement angle %f for new font %04x\n",
font->lfOrientation/10., font->lfEscapement/10., hFont);
WARN("orientation angle %f set to "
"escapement angle %f for new font %04x\n",
font->lfOrientation/10., font->lfEscapement/10., hFont);
}
GDI_HEAP_UNLOCK( hFont );
}
}
else WARN_(font)("(NULL) => NULL\n");
else WARN("(NULL) => NULL\n");
return hFont;
}
@ -375,8 +374,7 @@ HFONT16 WINAPI CreateFont16(INT16 height, INT16 width, INT16 esc, INT16 orient,
{
LOGFONT16 logfont;
TRACE_(font)("('%s',%d,%d)\n",
(name ? name : "(null)") , height, width);
TRACE("('%s',%d,%d)\n", (name ? name : "(null)") , height, width);
logfont.lfHeight = height;
logfont.lfWidth = width;
@ -877,9 +875,8 @@ BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
!dc->funcs->pGetTextExtentPoint( dc, str, count, size ))
return FALSE;
TRACE_(font)("(%08x %s %d %p): returning %d,%d\n",
hdc, debugstr_an (str, count), count,
size, size->cx, size->cy );
TRACE("(%08x %s %d %p): returning %d,%d\n",
hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
return TRUE;
}
@ -922,7 +919,7 @@ BOOL WINAPI GetTextExtentPoint32W(
BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
LPSIZE size )
{
TRACE_(font)("not bug compatible.\n");
TRACE("not bug compatible.\n");
return GetTextExtentPoint32A( hdc, str, count, size );
}
@ -932,7 +929,7 @@ BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
LPSIZE size )
{
TRACE_(font)("not bug compatible.\n");
TRACE("not bug compatible.\n");
return GetTextExtentPoint32W( hdc, str, count, size );
}
@ -972,8 +969,8 @@ BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
size->cx = extent;
*lpnFit = nFit;
TRACE_(font)("(%08x '%.*s' %d) returning %d %d %d\n",
hdc,count,str,maxExt,nFit, size->cx,size->cy);
TRACE("(%08x '%.*s' %d) returning %d %d %d\n",
hdc,count,str,maxExt,nFit, size->cx,size->cy);
return TRUE;
}
@ -1049,26 +1046,26 @@ BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
metrics->tmMaxCharWidth = WDPTOLP(metrics->tmMaxCharWidth);
metrics->tmOverhang = WDPTOLP(metrics->tmOverhang);
TRACE_(font)("text metrics:\n"
" Weight = %03li\t FirstChar = %03i\t AveCharWidth = %li\n"
" Italic = % 3i\t LastChar = %03i\t\t MaxCharWidth = %li\n"
" UnderLined = %01i\t DefaultChar = %03i\t Overhang = %li\n"
" StruckOut = %01i\t BreakChar = %03i\t CharSet = %i\n"
" PitchAndFamily = %02x\n"
" --------------------\n"
" InternalLeading = %li\n"
" Ascent = %li\n"
" Descent = %li\n"
" Height = %li\n",
metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
metrics->tmPitchAndFamily,
metrics->tmInternalLeading,
metrics->tmAscent,
metrics->tmDescent,
metrics->tmHeight );
TRACE("text metrics:\n"
" Weight = %03li\t FirstChar = %03i\t AveCharWidth = %li\n"
" Italic = % 3i\t LastChar = %03i\t\t MaxCharWidth = %li\n"
" UnderLined = %01i\t DefaultChar = %03i\t Overhang = %li\n"
" StruckOut = %01i\t BreakChar = %03i\t CharSet = %i\n"
" PitchAndFamily = %02x\n"
" --------------------\n"
" InternalLeading = %li\n"
" Ascent = %li\n"
" Descent = %li\n"
" Height = %li\n",
metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
metrics->tmPitchAndFamily,
metrics->tmInternalLeading,
metrics->tmAscent,
metrics->tmDescent,
metrics->tmHeight );
return TRUE;
}
@ -1100,7 +1097,7 @@ UINT16 WINAPI GetOutlineTextMetrics16(
UINT16 cbData, /* [in] Size of metric data array */
LPOUTLINETEXTMETRIC16 lpOTM) /* [out] Address of metric data array */
{
FIXME_(font)("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
FIXME("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
return 0;
}
@ -1183,7 +1180,7 @@ UINT WINAPI GetOutlineTextMetricsW(
UINT cbData, /* [in] Size of metric data array */
LPOUTLINETEXTMETRICW lpOTM) /* [out] Address of metric data array */
{
FIXME_(font)("(%d,%d,%p): stub\n", hdc, cbData, lpOTM);
FIXME("(%d,%d,%p): stub\n", hdc, cbData, lpOTM);
return 0;
}
@ -1284,7 +1281,7 @@ DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
if(dc->funcs->pSetMapperFlags)
ret = dc->funcs->pSetMapperFlags( dc, dwFlag );
else
FIXME_(font)("(0x%04x, 0x%08lx): stub - harmless\n", hDC, dwFlag);
FIXME("(0x%04x, 0x%08lx): stub - harmless\n", hDC, dwFlag);
GDI_HEAP_UNLOCK( hDC );
return ret;
}
@ -1294,8 +1291,7 @@ DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
*/
BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
{
FIXME_(font)("(%04x, %p): -- Empty Stub !\n",
hdc, pAspectRatio);
FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
return FALSE;
}
@ -1304,8 +1300,7 @@ BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
*/
BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
{
FIXME_(font)("(%04x, %p): -- Empty Stub !\n",
hdc, pAspectRatio);
FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
return FALSE;
}
@ -1354,7 +1349,7 @@ BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
LPABC abc )
{
/* No TrueType fonts in Wine so far */
FIXME_(font)("(%04x,%04x,%04x,%p): stub\n", hdc, firstChar, lastChar, abc);
FIXME("(%04x,%04x,%04x,%p): stub\n", hdc, firstChar, lastChar, abc);
return FALSE;
}
@ -1366,7 +1361,7 @@ DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
LPVOID lpBuffer, const MAT2 *lpmat2 )
{
FIXME_(font)("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
return (DWORD)-1; /* failure */
}
@ -1379,7 +1374,7 @@ DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
LPGLYPHMETRICS lpgm, DWORD cbBuffer,
LPVOID lpBuffer, const MAT2 *lpmat2 )
{
FIXME_(font)("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
return (DWORD)-1; /* failure */
}
@ -1391,7 +1386,7 @@ DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
LPGLYPHMETRICS lpgm, DWORD cbBuffer,
LPVOID lpBuffer, const MAT2 *lpmat2 )
{
FIXME_(font)("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
return (DWORD)-1; /* failure */
}
@ -1419,7 +1414,7 @@ BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
* enumbered with EnumFonts/EnumFontFamilies
* lpszCurrentPath can be NULL
*/
FIXME_(font)("(%ld,%s,%s,%s): stub\n",
FIXME("(%ld,%s,%s,%s): stub\n",
fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
return FALSE; /* create failed */
}
@ -1432,7 +1427,7 @@ BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
LPCWSTR lpszFontFile,
LPCWSTR lpszCurrentPath )
{
FIXME_(font)("(%ld,%p,%p,%p): stub\n",
FIXME("(%ld,%p,%p,%p): stub\n",
fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
return FALSE; /* create failed */
}
@ -1467,8 +1462,7 @@ INT16 WINAPI GetKerningPairs16( HDC16 hDC, INT16 cPairs,
{
/* At this time kerning is ignored (set to 0) */
int i;
FIXME_(font)("(%x,%d,%p): almost empty stub!\n",
hDC, cPairs, lpKerningPairs);
FIXME("(%x,%d,%p): almost empty stub!\n", hDC, cPairs, lpKerningPairs);
for (i = 0; i < cPairs; i++)
lpKerningPairs[i].iKernAmount = 0;
return 0;
@ -1483,8 +1477,7 @@ DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
LPKERNINGPAIR lpKerningPairs )
{
int i;
FIXME_(font)("(%x,%ld,%p): almost empty stub!\n",
hDC, cPairs, lpKerningPairs);
FIXME("(%x,%ld,%p): almost empty stub!\n", hDC, cPairs, lpKerningPairs);
for (i = 0; i < cPairs; i++)
lpKerningPairs[i].iKernAmount = 0;
return 0;
@ -1548,7 +1541,7 @@ BOOL WINAPI TranslateCharsetInfo(
*/
DWORD WINAPI GetFontLanguageInfo(HDC hdc) {
/* return value 0 is correct for most cases anyway */
FIXME_(font)("(%x):stub!\n", hdc);
FIXME("(%x):stub!\n", hdc);
return 0;
}
@ -1557,7 +1550,7 @@ DWORD WINAPI GetFontLanguageInfo(HDC hdc) {
*/
DWORD WINAPI GetFontLanguageInfo16(HDC16 hdc) {
/* return value 0 is correct for most cases anyway */
FIXME_(font)("(%x):stub!\n",hdc);
FIXME("(%x):stub!\n",hdc);
return 0;
}
@ -1580,8 +1573,7 @@ DWORD WINAPI GetFontLanguageInfo16(HDC16 hdc) {
DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
LPVOID buffer, DWORD length)
{
FIXME_(font)("(%x,%ld,%ld,%p,%ld): stub\n",
hdc, table, offset, buffer, length);
FIXME("(%x,%ld,%ld,%p,%ld): stub\n", hdc, table, offset, buffer, length);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return GDI_ERROR;
}
@ -1610,18 +1602,19 @@ GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
DWORD ret=0;
SIZE size;
TRACE_(font)("%s 0x%08x 0x%08x 0x%08lx:stub!\n",
debugstr_a(lpString), uCount, nMaxExtent, dwFlags);
TRACE("%s 0x%08x 0x%08x 0x%08lx:stub!\n",
debugstr_a(lpString), uCount, nMaxExtent, dwFlags);
TRACE_(font)("lpOrder=%p lpDx=%p lpCaretPos=%p lpClass=%p lpOutString=%p lpGlyphs=%p\n",
lpResults->lpOrder, lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
lpResults->lpOutString, lpResults->lpGlyphs);
TRACE("lpOrder=%p lpDx=%p lpCaretPos=%p lpClass=%p "
"lpOutString=%p lpGlyphs=%p\n",
lpResults->lpOrder, lpResults->lpDx, lpResults->lpCaretPos,
lpResults->lpClass, lpResults->lpOutString, lpResults->lpGlyphs);
if(dwFlags) FIXME_(font)("flags 0x%08lx ignored\n", dwFlags);
if(lpResults->lpOrder) FIXME_(font)("reordering not implemented\n");
if(lpResults->lpCaretPos) FIXME_(font)("caret positions not implemented\n");
if(lpResults->lpClass) FIXME_(font)("classes not implemented\n");
if(lpResults->lpGlyphs) FIXME_(font)("glyphs not implemented\n");
if(dwFlags) FIXME("flags 0x%08lx ignored\n", dwFlags);
if(lpResults->lpOrder) FIXME("reordering not implemented\n");
if(lpResults->lpCaretPos) FIXME("caret positions not implemented\n");
if(lpResults->lpClass) FIXME("classes not implemented\n");
if(lpResults->lpGlyphs) FIXME("glyphs not implemented\n");
/* copy will do if the GCP_REORDER flag is not set */
if(lpResults->lpOutString)
@ -1654,7 +1647,7 @@ GetCharacterPlacementW(HDC hdc, LPCWSTR lpString, INT uCount,
DWORD dwFlags)
{
/* return value 0 is correct for most cases anyway */
FIXME_(font)(":stub!\n");
FIXME(":stub!\n");
return 0;
}

86
ole/ole2nls.c
View File

@ -19,8 +19,8 @@
#include "crtdll.h"
#include "main.h"
DEFAULT_DEBUG_CHANNEL(ole)
DECLARE_DEBUG_CHANNEL(file)
DECLARE_DEBUG_CHANNEL(ole)
DECLARE_DEBUG_CHANNEL(string)
DECLARE_DEBUG_CHANNEL(win32)
@ -690,7 +690,7 @@ INT WINAPI GetLocaleInfoA(LCID lcid,LCTYPE LCType,LPSTR buf,INT len)
int found,i;
int lang=0;
TRACE_(ole)("(lcid=0x%lx,lctype=0x%lx,%p,%x)\n",lcid,LCType,buf,len);
TRACE("(lcid=0x%lx,lctype=0x%lx,%p,%x)\n",lcid,LCType,buf,len);
if (len && (! buf) ) {
SetLastError(ERROR_INSUFFICIENT_BUFFER);
@ -722,7 +722,7 @@ INT WINAPI GetLocaleInfoA(LCID lcid,LCTYPE LCType,LPSTR buf,INT len)
i++;
}
if (!retString) {
FIXME_(ole)("Unkown LC type %lX\n",LCType);
FIXME("Unkown LC type %lX\n",LCType);
return 0;
}
@ -752,7 +752,7 @@ INT WINAPI GetLocaleInfoA(LCID lcid,LCTYPE LCType,LPSTR buf,INT len)
}
if(!found) {
ERR_(ole)("'%s' not supported for your language (%04X).\n",
ERR("'%s' not supported for your language (%04X).\n",
retString,(WORD)lcid);
SetLastError(ERROR_INVALID_PARAMETER);
return 0;
@ -800,7 +800,7 @@ INT WINAPI GetLocaleInfoW(LCID lcid,LCTYPE LCType,LPWSTR wbuf,INT len)
*/
BOOL16 WINAPI SetLocaleInfoA(DWORD lcid, DWORD lctype, LPCSTR data)
{
FIXME_(ole)("(%ld,%ld,%s): stub\n",lcid,lctype,data);
FIXME("(%ld,%ld,%s): stub\n",lcid,lctype,data);
return TRUE;
}
@ -1479,7 +1479,7 @@ BOOL WINAPI GetStringTypeExA(LCID locale,DWORD dwInfoType,LPCSTR src,
return TRUE;
default:
ERR_(ole)("Unknown dwInfoType:%ld\n",dwInfoType);
ERR("Unknown dwInfoType:%ld\n",dwInfoType);
return FALSE;
}
}
@ -1512,10 +1512,10 @@ BOOL WINAPI GetStringTypeExW(LCID locale,DWORD dwInfoType,LPCWSTR src,
switch (dwInfoType) {
case CT_CTYPE2:
FIXME_(ole)("CT_CTYPE2 not supported.\n");
FIXME("CT_CTYPE2 not supported.\n");
return FALSE;
case CT_CTYPE3:
FIXME_(ole)("CT_CTYPE3 not supported.\n");
FIXME("CT_CTYPE3 not supported.\n");
return FALSE;
default:break;
}
@ -2091,7 +2091,7 @@ INT WINAPI LCMapStringA(
if ( ((dstlen!=0) && (dststr==NULL)) || (srcstr==NULL) )
{
ERR_(ole)("(src=%s,dest=%s): Invalid NULL string\n", srcstr, dststr);
ERR("(src=%s,dest=%s): Invalid NULL string\n", srcstr, dststr);
SetLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@ -2329,7 +2329,7 @@ INT WINAPI LCMapStringW(
if ( ((dstlen!=0) && (dststr==NULL)) || (srcstr==NULL) )
{
ERR_(ole)("(src=%p,dst=%p): Invalid NULL string\n", srcstr, dststr);
ERR("(src=%p,dst=%p): Invalid NULL string\n", srcstr, dststr);
SetLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@ -2406,18 +2406,18 @@ UINT WINAPI CompareStringA(
int len1,len2;
int result;
LPSTR sk1,sk2;
TRACE_(ole)("%s and %s\n",
TRACE("%s and %s\n",
debugstr_a (s1), debugstr_a (s2));
if ( (s1==NULL) || (s2==NULL) )
{
ERR_(ole)("(s1=%s,s2=%s): Invalid NULL string\n", s1, s2);
ERR("(s1=%s,s2=%s): Invalid NULL string\n", s1, s2);
SetLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if(fdwStyle & NORM_IGNORESYMBOLS)
FIXME_(ole)("IGNORESYMBOLS not supported\n");
FIXME("IGNORESYMBOLS not supported\n");
mapstring_flags = LCMAP_SORTKEY | fdwStyle ;
len1 = LCMapStringA(lcid,mapstring_flags,s1,l1,NULL,0);
@ -2431,7 +2431,7 @@ UINT WINAPI CompareStringA(
if ( (!LCMapStringA(lcid,mapstring_flags,s1,l1,sk1,len1))
|| (!LCMapStringA(lcid,mapstring_flags,s2,l2,sk2,len2)) )
{
ERR_(ole)("Bug in LCmapString32A.\n");
ERR("Bug in LCmapString32A.\n");
result = 0;
}
else
@ -2462,9 +2462,9 @@ UINT WINAPI CompareStringW(DWORD lcid, DWORD fdwStyle,
{
int len,ret;
if(fdwStyle & NORM_IGNORENONSPACE)
FIXME_(ole)("IGNORENONSPACE not supprted\n");
FIXME("IGNORENONSPACE not supprted\n");
if(fdwStyle & NORM_IGNORESYMBOLS)
FIXME_(ole)("IGNORESYMBOLS not supported\n");
FIXME("IGNORESYMBOLS not supported\n");
/* Is strcmp defaulting to string sort or to word sort?? */
/* FIXME: Handle NORM_STRINGSORT */
@ -2486,7 +2486,7 @@ UINT WINAPI CompareStringW(DWORD lcid, DWORD fdwStyle,
*/
BOOL16 WINAPI RegisterNLSInfoChanged16(LPVOID/*FIXME*/ lpNewNLSInfo)
{
FIXME_(ole)("Fully implemented, but doesn't effect anything.\n");
FIXME("Fully implemented, but doesn't effect anything.\n");
if (!lpNewNLSInfo)
{
@ -2560,13 +2560,13 @@ static INT OLE_GetFormatA(LCID locale,
const char ** dgfmt = _dgfmt - 1;
/* report, for debugging */
TRACE_(ole)("(0x%lx,0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt=%p \'%s\' , %p, len=%d)\n",
TRACE("(0x%lx,0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt=%p \'%s\' , %p, len=%d)\n",
locale, flags, tflags,
xtime->wDay, xtime->wHour, xtime->wMinute, xtime->wSecond,
_format, _format, date, datelen);
if(datelen == 0) {
FIXME_(ole)("datelen = 0, returning 255\n");
FIXME("datelen = 0, returning 255\n");
return 255;
}
@ -2652,17 +2652,17 @@ static INT OLE_GetFormatA(LCID locale,
sprintf(buf, "%d", xtime->wYear);
} else if (count == 3) {
strcpy(buf, "yyy");
WARN_(ole)("unknown format, c=%c, n=%d\n", type, count);
WARN("unknown format, c=%c, n=%d\n", type, count);
} else {
sprintf(buf, dgfmt[count], xtime->wYear % 100);
}
} else if (type == 'g') {
if (count == 2) {
FIXME_(ole)("LOCALE_ICALENDARTYPE unimp.\n");
FIXME("LOCALE_ICALENDARTYPE unimp.\n");
strcpy(buf, "AD");
} else {
strcpy(buf, "g");
WARN_(ole)("unknown format, c=%c, n=%d\n", type, count);
WARN("unknown format, c=%c, n=%d\n", type, count);
}
} else if (type == 'h') {
/* gives us hours 1:00 -- 12:00 */
@ -2701,7 +2701,7 @@ static INT OLE_GetFormatA(LCID locale,
strncat(date, buf, datelen - outpos);
date[datelen - 1] = '\0';
SetLastError(ERROR_INSUFFICIENT_BUFFER);
WARN_(ole)("insufficient buffer\n");
WARN("insufficient buffer\n");
return 0;
}
@ -2745,7 +2745,7 @@ static INT OLE_GetFormatA(LCID locale,
if (outpos > datelen-1) outpos = datelen-1;
date[outpos] = '\0';
TRACE_(ole)("OLE_GetFormatA returns string '%s', len %d\n",
TRACE("OLE_GetFormatA returns string '%s', len %d\n",
date, outpos);
return outpos;
}
@ -2773,14 +2773,14 @@ static INT OLE_GetFormatW(LCID locale, DWORD flags, DWORD tflags,
argarr[2] = arg2;
/* make a debug report */
TRACE_(ole)("args: 0x%lx, 0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt:%s (at %p), "
TRACE("args: 0x%lx, 0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt:%s (at %p), "
"%p with max len %d\n",
locale, flags, tflags,
xtime->wDay, xtime->wHour, xtime->wMinute, xtime->wSecond,
debugstr_w(format), format, output, outlen);
if(outlen == 0) {
FIXME_(ole)("outlen = 0, returning 255\n");
FIXME("outlen = 0, returning 255\n");
return 255;
}
@ -2861,7 +2861,7 @@ static INT OLE_GetFormatW(LCID locale, DWORD flags, DWORD tflags,
}
} else if (type == 'g') {
if (count == 2) {
FIXME_(ole)("LOCALE_ICALENDARTYPE unimplemented\n");
FIXME("LOCALE_ICALENDARTYPE unimplemented\n");
lstrcpynAtoW(buf, "AD", 5);
} else {
/* Win API sez we copy it verbatim */
@ -2940,7 +2940,7 @@ static INT OLE_GetFormatW(LCID locale, DWORD flags, DWORD tflags,
if (Overflow) {
SetLastError(ERROR_INSUFFICIENT_BUFFER);
WARN_(ole)(" buffer overflow\n");
WARN(" buffer overflow\n");
};
/* final string terminator and sanity check */
@ -2948,7 +2948,7 @@ static INT OLE_GetFormatW(LCID locale, DWORD flags, DWORD tflags,
if (outpos > outlen-1) outpos = outlen-1;
output[outpos] = '0';
TRACE_(ole)(" returning %s\n", debugstr_w(output));
TRACE(" returning %s\n", debugstr_w(output));
return (!Overflow) ? outlen : 0;
@ -2989,7 +2989,7 @@ INT WINAPI GetDateFormatA(LCID locale,DWORD flags,
LCID thislocale;
INT ret;
TRACE_(ole)("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",
TRACE("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",
locale,flags,xtime,format,date,datelen);
if (!locale) {
@ -3026,7 +3026,7 @@ INT WINAPI GetDateFormatA(LCID locale,DWORD flags,
date, datelen);
TRACE_(ole)(
TRACE(
"GetDateFormat32A() returning %d, with data=%s\n",
ret, date);
return ret;
@ -3047,7 +3047,7 @@ INT WINAPI GetDateFormatW(LCID locale,DWORD flags,
{
unsigned short datearr[] = {'1','9','9','4','-','1','-','1',0};
FIXME_(ole)("STUB (should call OLE_GetFormatW)\n");
FIXME("STUB (should call OLE_GetFormatW)\n");
lstrcpynW(date, datearr, datelen);
return ( datelen < 9) ? datelen : 9;
@ -3060,7 +3060,7 @@ INT WINAPI GetDateFormatW(LCID locale,DWORD flags,
BOOL WINAPI EnumDateFormatsA(
DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale, DWORD dwFlags)
{
FIXME_(ole)("Only US English supported\n");
FIXME("Only US English supported\n");
if(!lpDateFmtEnumProc)
{
@ -3085,7 +3085,7 @@ BOOL WINAPI EnumDateFormatsA(
if(!(*lpDateFmtEnumProc)("dd MMMM, yyyy")) return TRUE;
return TRUE;
default:
FIXME_(ole)("Unknown date format (%ld)\n", dwFlags);
FIXME("Unknown date format (%ld)\n", dwFlags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -3097,7 +3097,7 @@ BOOL WINAPI EnumDateFormatsA(
BOOL WINAPI EnumDateFormatsW(
DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags)
{
FIXME_(ole)("(%p, %ld, %ld): stub\n", lpDateFmtEnumProc, Locale, dwFlags);
FIXME("(%p, %ld, %ld): stub\n", lpDateFmtEnumProc, Locale, dwFlags);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
@ -3108,7 +3108,7 @@ BOOL WINAPI EnumDateFormatsW(
BOOL WINAPI EnumTimeFormatsA(
TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags)
{
FIXME_(ole)("Only US English supported\n");
FIXME("Only US English supported\n");
if(!lpTimeFmtEnumProc)
{
@ -3118,7 +3118,7 @@ BOOL WINAPI EnumTimeFormatsA(
if(dwFlags)
{
FIXME_(ole)("Unknown time format (%ld)\n", dwFlags);
FIXME("Unknown time format (%ld)\n", dwFlags);
}
if(!(*lpTimeFmtEnumProc)("h:mm:ss tt")) return TRUE;
@ -3135,7 +3135,7 @@ BOOL WINAPI EnumTimeFormatsA(
BOOL WINAPI EnumTimeFormatsW(
TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags)
{
FIXME_(ole)("(%p,%ld,%ld): stub\n", lpTimeFmtEnumProc, Locale, dwFlags);
FIXME("(%p,%ld,%ld): stub\n", lpTimeFmtEnumProc, Locale, dwFlags);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
@ -3217,12 +3217,12 @@ GetTimeFormatA(LCID locale, /* in */
DWORD thisflags=LOCALE_STIMEFORMAT; /* standart timeformat */
INT ret;
TRACE_(ole)("GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,xtime,format,timestr,timelen);
TRACE("GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,xtime,format,timestr,timelen);
thislocale = OLE2NLS_CheckLocale ( locale );
if ( flags & (TIME_NOTIMEMARKER | TIME_FORCE24HOURFORMAT ))
{ FIXME_(ole)("TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
{ FIXME("TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
}
flags &= (TIME_NOSECONDS | TIME_NOMINUTESORSECONDS); /* mask for OLE_GetFormatA*/
@ -3270,13 +3270,13 @@ GetTimeFormatW(LCID locale, /* in */
DWORD thisflags=LOCALE_STIMEFORMAT; /* standart timeformat */
INT ret;
TRACE_(ole)("GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,
TRACE("GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,
xtime,debugstr_w(format),timestr,timelen);
thislocale = OLE2NLS_CheckLocale ( locale );
if ( flags & (TIME_NOTIMEMARKER | TIME_FORCE24HOURFORMAT ))
{ FIXME_(ole)("TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
{ FIXME("TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
}
flags &= (TIME_NOSECONDS | TIME_NOMINUTESORSECONDS); /* mask for OLE_GetFormatA*/
@ -3311,6 +3311,6 @@ GetTimeFormatW(LCID locale, /* in */
BOOL WINAPI EnumCalendarInfoA(
CALINFO_ENUMPROCA calinfoproc,LCID locale,CALID calendar,CALTYPE caltype
) {
FIXME_(ole)("(%p,0x%04lx,0x%08lx,0x%08lx),stub!\n",calinfoproc,locale,calendar,caltype);
FIXME("(%p,0x%04lx,0x%08lx,0x%08lx),stub!\n",calinfoproc,locale,calendar,caltype);
return FALSE;
}

20
scheduler/critsection.c
View File

@ -40,7 +40,7 @@ void WINAPI DeleteCriticalSection( CRITICAL_SECTION *crit )
if (crit->LockSemaphore)
{
if (crit->RecursionCount) /* Should not happen */
ERR_(win32)("Deleting owned critical section (%p)\n", crit );
ERR("Deleting owned critical section (%p)\n", crit );
crit->LockCount = -1;
crit->RecursionCount = 0;
@ -61,13 +61,13 @@ void WINAPI EnterCriticalSection( CRITICAL_SECTION *crit )
if (!crit->LockSemaphore)
{
FIXME_(win32)("entering uninitialized section(%p)?\n",crit);
FIXME("entering uninitialized section(%p)?\n",crit);
InitializeCriticalSection(crit);
}
if ( crit->Reserved && crit->Reserved != GetCurrentProcessId() )
{
FIXME_(win32)("Crst %p belongs to process %ld, current is %ld!\n",
crit, crit->Reserved, GetCurrentProcessId() );
FIXME("Crst %p belongs to process %ld, current is %ld!\n",
crit, crit->Reserved, GetCurrentProcessId() );
return;
}
if (InterlockedIncrement( &crit->LockCount ))
@ -86,11 +86,11 @@ void WINAPI EnterCriticalSection( CRITICAL_SECTION *crit )
res = WaitForSingleObject( crit->LockSemaphore, 5000L );
if ( res == WAIT_TIMEOUT )
{
ERR_(win32)("Critical section %p wait timed out, retrying (60 sec)\n", crit );
ERR("Critical section %p wait timed out, retrying (60 sec)\n", crit );
res = WaitForSingleObject( crit->LockSemaphore, 60000L );
if ( res == WAIT_TIMEOUT && TRACE_ON(relay) )
{
ERR_(win32)("Critical section %p wait timed out, retrying (5 min)\n", crit );
ERR("Critical section %p wait timed out, retrying (5 min)\n", crit );
res = WaitForSingleObject( crit->LockSemaphore, 300000L );
}
}
@ -173,8 +173,8 @@ void WINAPI ReinitializeCriticalSection( CRITICAL_SECTION *crit )
else if ( crit->Reserved && crit->Reserved != GetCurrentProcessId() )
{
FIXME_(win32)("(%p) called for %08lx first, %08lx now: making global\n",
crit, crit->Reserved, GetCurrentProcessId() );
FIXME("(%p) called for %08lx first, %08lx now: making global\n",
crit, crit->Reserved, GetCurrentProcessId() );
MakeCriticalSectionGlobal( crit );
}
@ -191,8 +191,8 @@ void WINAPI UninitializeCriticalSection( CRITICAL_SECTION *crit )
if ( crit->Reserved ) /* not global */
DeleteCriticalSection( crit );
else
FIXME_(win32)("(%p) for %08lx: Crst is global, don't know whether to delete\n",
crit, GetCurrentProcessId() );
FIXME("(%p) for %08lx: Crst is global, don't know whether to delete\n",
crit, GetCurrentProcessId() );
}
}

6
scheduler/debugger.c
View File

@ -11,7 +11,7 @@
#include "server.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(debugstr)
DEFAULT_DEBUG_CHANNEL(debugstr)
/**********************************************************************
* DEBUG_SendEvent
@ -258,7 +258,7 @@ void WINAPI OutputDebugStringA( LPCSTR str )
DEBUG_SendEvent( OUTPUT_DEBUG_STRING_EVENT, &event, sizeof(event) );
}
TRACE_(debugstr)("%s\n", str);
TRACE("%s\n", str);
}
@ -276,7 +276,7 @@ void WINAPI OutputDebugStringW( LPCWSTR str )
DEBUG_SendEvent( OUTPUT_DEBUG_STRING_EVENT, &event, sizeof(event) );
}
TRACE_(debugstr)("%s\n", debugstr_w(str));
TRACE("%s\n", debugstr_w(str));
}

12
scheduler/process.c
View File

@ -27,7 +27,7 @@
#include "callback.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(process)
DEFAULT_DEBUG_CHANNEL(process)
DECLARE_DEBUG_CHANNEL(relay)
DECLARE_DEBUG_CHANNEL(win32)
@ -604,7 +604,7 @@ PDB *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env,
switch ( WaitForMultipleObjects( 2, handles, FALSE, INFINITE ) )
{
default:
ERR_(process)( "WaitForMultipleObjects failed\n" );
ERR( "WaitForMultipleObjects failed\n" );
break;
case 0:
@ -994,7 +994,7 @@ DWORD WINAPI GetProcessFlags( DWORD processid )
BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess,DWORD minset,
DWORD maxset)
{
FIXME_(process)("(0x%08x,%ld,%ld): stub - harmless\n",hProcess,minset,maxset);
FIXME("(0x%08x,%ld,%ld): stub - harmless\n",hProcess,minset,maxset);
if(( minset == -1) && (maxset == -1)) {
/* Trim the working set to zero */
/* Swap the process out of physical RAM */
@ -1008,7 +1008,7 @@ BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess,DWORD minset,
BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess,LPDWORD minset,
LPDWORD maxset)
{
FIXME_(process)("(0x%08x,%p,%p): stub\n",hProcess,minset,maxset);
FIXME("(0x%08x,%p,%p): stub\n",hProcess,minset,maxset);
/* 32 MB working set size */
if (minset) *minset = 32*1024*1024;
if (maxset) *maxset = 32*1024*1024;
@ -1036,7 +1036,7 @@ BOOL WINAPI SetProcessShutdownParameters(DWORD level,DWORD flags)
shutdown_priority = level;
else
{
ERR_(process)("invalid priority level 0x%08lx\n", level);
ERR("invalid priority level 0x%08lx\n", level);
return FALSE;
}
return TRUE;
@ -1059,7 +1059,7 @@ BOOL WINAPI GetProcessShutdownParameters( LPDWORD lpdwLevel,
*/
BOOL WINAPI SetProcessPriorityBoost(HANDLE hprocess,BOOL disableboost)
{
FIXME_(process)("(%d,%d): stub\n",hprocess,disableboost);
FIXME("(%d,%d): stub\n",hprocess,disableboost);
/* Say we can do it. I doubt the program will notice that we don't. */
return TRUE;
}

2
win32/kernel32.c
View File

@ -26,8 +26,8 @@
#include "syslevel.h"
#include "winerror.h"
DECLARE_DEBUG_CHANNEL(dosmem)
DECLARE_DEBUG_CHANNEL(thunk)
DECLARE_DEBUG_CHANNEL(dosmem)
DECLARE_DEBUG_CHANNEL(win32)

46
win32/newfns.c
View File

@ -16,8 +16,8 @@ at a later date. */
#include "debugtools.h"
#include "debugstr.h"
DEFAULT_DEBUG_CHANNEL(win32)
DECLARE_DEBUG_CHANNEL(debug)
DECLARE_DEBUG_CHANNEL(win32)
/****************************************************************************
@ -60,10 +60,9 @@ HANDLE WINAPI CreateNamedPipeA (LPCSTR lpName, DWORD dwOpenMode,
DWORD nDefaultTimeOut,
LPSECURITY_ATTRIBUTES lpSecurityAttributes)
{
FIXME_(win32)("(Name=%s, OpenMode=%#08lx, dwPipeMode=%#08lx, MaxInst=%ld, OutBSize=%ld, InBuffSize=%ld, DefTimeOut=%ld, SecAttr=%p): stub\n",
debugstr_a(lpName), dwOpenMode, dwPipeMode, nMaxInstances,
nOutBufferSize, nInBufferSize, nDefaultTimeOut,
lpSecurityAttributes);
FIXME("(Name=%s, OpenMode=%#08lx, dwPipeMode=%#08lx, MaxInst=%ld, OutBSize=%ld, InBuffSize=%ld, DefTimeOut=%ld, SecAttr=%p): stub\n",
debugstr_a(lpName), dwOpenMode, dwPipeMode, nMaxInstances,
nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes);
/* if (nMaxInstances > PIPE_UNLIMITED_INSTANCES) {
SetLastError (ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
@ -82,10 +81,9 @@ HANDLE WINAPI CreateNamedPipeW (LPCWSTR lpName, DWORD dwOpenMode,
DWORD nDefaultTimeOut,
LPSECURITY_ATTRIBUTES lpSecurityAttributes)
{
FIXME_(win32)("(Name=%s, OpenMode=%#08lx, dwPipeMode=%#08lx, MaxInst=%ld, OutBSize=%ld, InBuffSize=%ld, DefTimeOut=%ld, SecAttr=%p): stub\n",
debugstr_w(lpName), dwOpenMode, dwPipeMode, nMaxInstances,
nOutBufferSize, nInBufferSize, nDefaultTimeOut,
lpSecurityAttributes);
FIXME("(Name=%s, OpenMode=%#08lx, dwPipeMode=%#08lx, MaxInst=%ld, OutBSize=%ld, InBuffSize=%ld, DefTimeOut=%ld, SecAttr=%p): stub\n",
debugstr_w(lpName), dwOpenMode, dwPipeMode, nMaxInstances,
nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes);
SetLastError (ERROR_UNKNOWN);
return INVALID_HANDLE_VALUE;
@ -128,7 +126,7 @@ BOOL WINAPI SetSystemPowerState(BOOL suspend_or_hibernate,
HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa)
{
FIXME_(win32)("(%s,%ld,%ld,%p): stub\n", debugstr_a(lpName),
FIXME("(%s,%ld,%ld,%p): stub\n", debugstr_a(lpName),
nMaxMessageSize, lReadTimeout, sa);
return 1;
}
@ -150,7 +148,7 @@ HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
{
FIXME_(win32)("(%s,%ld,%ld,%p): stub\n", debugstr_w(lpName),
FIXME("(%s,%ld,%ld,%p): stub\n", debugstr_w(lpName),
nMaxMessageSize, lReadTimeout, sa);
return 1;
}
@ -174,7 +172,7 @@ BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
LPDWORD lpNextSize, LPDWORD lpMessageCount,
LPDWORD lpReadTimeout )
{
FIXME_(win32)("(%04x): stub\n",hMailslot);
FIXME("(%04x): stub\n",hMailslot);
if (lpMaxMessageSize) *lpMaxMessageSize = (DWORD)NULL;
if (lpNextSize) *lpNextSize = (DWORD)NULL;
if (lpMessageCount) *lpMessageCount = (DWORD)NULL;
@ -193,7 +191,7 @@ DWORD WINAPI GetCompressedFileSizeA(
LPCSTR lpFileName,
LPDWORD lpFileSizeHigh)
{
FIXME_(win32)("(...): stub\n");
FIXME("(...): stub\n");
return 0xffffffff;
}
@ -209,7 +207,7 @@ DWORD WINAPI GetCompressedFileSizeW(
LPCWSTR lpFileName, /* [in] Pointer to name of file */
LPDWORD lpFileSizeHigh) /* [out] Receives high-order doubleword of size */
{
FIXME_(win32)("(%s,%p): stub\n",debugstr_w(lpFileName),lpFileSizeHigh);
FIXME("(%s,%p): stub\n",debugstr_w(lpFileName),lpFileSizeHigh);
return 0xffffffff;
}
@ -226,7 +224,7 @@ DWORD WINAPI GetCompressedFileSizeW(
*/
DWORD WINAPI GetProcessWindowStation(void)
{
FIXME_(win32)("(void): stub\n");
FIXME("(void): stub\n");
return 1;
}
@ -246,7 +244,7 @@ DWORD WINAPI GetProcessWindowStation(void)
*/
DWORD WINAPI GetThreadDesktop( DWORD dwThreadId )
{
FIXME_(win32)("(%lx): stub\n",dwThreadId);
FIXME("(%lx): stub\n",dwThreadId);
return 1;
}
@ -260,7 +258,7 @@ DWORD WINAPI GetThreadDesktop( DWORD dwThreadId )
*/
VOID WINAPI SetDebugErrorLevel( DWORD dwLevel )
{
FIXME_(win32)("(%ld): stub\n", dwLevel);
FIXME("(%ld): stub\n", dwLevel);
}
@ -286,13 +284,13 @@ BOOL WINAPI SetComputerNameA( LPCSTR lpComputerName )
*/
BOOL WINAPI SetComputerNameW( LPCWSTR lpComputerName )
{
FIXME_(win32)("(%s): stub\n", debugstr_w(lpComputerName));
FIXME("(%s): stub\n", debugstr_w(lpComputerName));
return TRUE;
}
BOOL WINAPI EnumPortsA(LPSTR name,DWORD level,LPBYTE ports,DWORD bufsize,LPDWORD bufneeded,LPDWORD bufreturned) {
FIXME_(win32)("(%s,%ld,%p,%ld,%p,%p), stub!\n",name,level,ports,bufsize,bufneeded,bufreturned);
FIXME("(%s,%ld,%p,%ld,%p,%p), stub!\n",name,level,ports,bufsize,bufneeded,bufreturned);
return FALSE;
}
@ -301,7 +299,7 @@ BOOL WINAPI EnumPortsA(LPSTR name,DWORD level,LPBYTE ports,DWORD bufsize,LPDWORD
*
*/
BOOL WINAPI IsDebuggerPresent() {
FIXME_(win32)(" ... no debuggers yet, returning FALSE.\n");
FIXME(" ... no debuggers yet, returning FALSE.\n");
return FALSE;
}
@ -316,7 +314,7 @@ BOOL WINAPI IsDebuggerPresent() {
HANDLE WINAPI OpenDesktopA( LPCSTR lpszDesktop, DWORD dwFlags,
BOOL fInherit, DWORD dwDesiredAccess )
{
FIXME_(win32)("(%s,%lx,%i,%lx): stub\n",debugstr_a(lpszDesktop),dwFlags,
FIXME("(%s,%lx,%i,%lx): stub\n",debugstr_a(lpszDesktop),dwFlags,
fInherit,dwDesiredAccess);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@ -327,14 +325,14 @@ HANDLE WINAPI OpenDesktopA( LPCSTR lpszDesktop, DWORD dwFlags,
BOOL WINAPI SetUserObjectInformationA( HANDLE hObj, int nIndex,
LPVOID pvInfo, DWORD nLength )
{
FIXME_(win32)("(%x,%d,%p,%lx): stub\n",hObj,nIndex,pvInfo,nLength);
FIXME("(%x,%d,%p,%lx): stub\n",hObj,nIndex,pvInfo,nLength);
return TRUE;
}
BOOL WINAPI SetThreadDesktop( HANDLE hDesktop )
{
FIXME_(win32)("(%x): stub\n",hDesktop);
FIXME("(%x): stub\n",hDesktop);
return TRUE;
}
@ -342,7 +340,7 @@ HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle,
HANDLE hExistingCompletionPort, DWORD dwCompletionKey,
DWORD dwNumberOfConcurrentThreads)
{
FIXME_(win32)("(%04x, %04x, %08lx, %08lx): stub.\n", hFileHandle, hExistingCompletionPort, dwCompletionKey, dwNumberOfConcurrentThreads);
FIXME("(%04x, %04x, %08lx, %08lx): stub.\n", hFileHandle, hExistingCompletionPort, dwCompletionKey, dwNumberOfConcurrentThreads);
return (HANDLE)NULL;
}

14
windows/keyboard.c
View File

@ -25,8 +25,8 @@
#include "struct32.h"
#include "winerror.h"
DEFAULT_DEBUG_CHANNEL(keyboard)
DECLARE_DEBUG_CHANNEL(event)
DECLARE_DEBUG_CHANNEL(keyboard)
/**********************************************************************/
@ -137,7 +137,7 @@ void KEYBOARD_SendEvent( BYTE bVk, BYTE bScan, DWORD dwFlags,
*/
WORD WINAPI SetSpeed16(WORD unused)
{
FIXME_(keyboard)("(%04x): stub\n",unused);
FIXME("(%04x): stub\n", unused);
return 0xffff;
}
@ -146,7 +146,7 @@ WORD WINAPI SetSpeed16(WORD unused)
*/
VOID WINAPI ScreenSwitchEnable16(WORD unused)
{
FIXME_(keyboard)("(%04x): stub\n",unused);
FIXME("(%04x): stub\n", unused);
}
/**********************************************************************
@ -154,7 +154,7 @@ VOID WINAPI ScreenSwitchEnable16(WORD unused)
*/
DWORD WINAPI OemKeyScan(WORD wOemChar)
{
TRACE_(keyboard)("*OemKeyScan (%d)\n",wOemChar);
TRACE("*OemKeyScan (%d)\n", wOemChar);
return wOemChar;
}
@ -187,7 +187,7 @@ WORD WINAPI VkKeyScan16(CHAR cChar)
*/
INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
{
TRACE_(keyboard)("(%d)\n",nTypeFlag);
TRACE("(%d)\n", nTypeFlag);
switch(nTypeFlag)
{
case 0: /* Keyboard type */
@ -200,7 +200,7 @@ INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
return 12; /* We're doing an 101 for now, so return 12 F-keys */
break;
default:
WARN_(keyboard)("Unknown type\n");
WARN("Unknown type\n");
return 0; /* The book says 0 here, so 0 */
}
}
@ -220,7 +220,7 @@ UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
*/
INT16 WINAPI GetKBCodePage16(void)
{
TRACE_(keyboard)("(void)\n");
TRACE("(void)\n");
return 850;
}

59
windows/message.c
View File

@ -29,8 +29,8 @@
#include "struct32.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(msg)
DECLARE_DEBUG_CHANNEL(key)
DECLARE_DEBUG_CHANNEL(msg)
DECLARE_DEBUG_CHANNEL(sendmsg)
#define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
@ -1343,8 +1343,8 @@ BOOL16 WINAPI GetMessage16( SEGPTR msg, HWND16 hwnd, UINT16 first, UINT16 last)
STRUCT32_MSG32to16( &msg32, lpmsg );
TRACE_(msg)("message %04x, hwnd %04x, filter(%04x - %04x)\n", lpmsg->message,
hwnd, first, last );
TRACE("message %04x, hwnd %04x, filter(%04x - %04x)\n",
lpmsg->message, hwnd, first, last );
return ret;
}
@ -1389,7 +1389,7 @@ BOOL WINAPI GetMessageA(MSG* lpmsg,HWND hwnd,UINT min,UINT max)
{
MSG_PeekMessage( lpmsg, hwnd, min, max, PM_REMOVE, FALSE );
TRACE_(msg)("message %04x, hwnd %04x, filter(%04x - %04x)\n", lpmsg->message,
TRACE("message %04x, hwnd %04x, filter(%04x - %04x)\n", lpmsg->message,
hwnd, min, max );
HOOK_CallHooksA( WH_GETMESSAGE, HC_ACTION, 0, (LPARAM)lpmsg );
@ -1433,7 +1433,8 @@ BOOL WINAPI GetMessageW(
{
BOOL bRet = GetMessageA(lpmsg, hwnd, min, max);
if (bRet)
FIXME_(sendmsg)("(%s) unicode<->ascii\n", SPY_GetMsgName(lpmsg->message));
FIXME_(sendmsg)("(%s) unicode<->ascii\n",
SPY_GetMsgName(lpmsg->message));
return bRet;
}
@ -1470,19 +1471,19 @@ BOOL WINAPI PostMessageA( HWND hwnd, UINT message, WPARAM wParam,
if (hwnd == HWND_BROADCAST)
{
WND *pDesktop = WIN_GetDesktop();
TRACE_(msg)("HWND_BROADCAST !\n");
TRACE("HWND_BROADCAST !\n");
for (wndPtr=WIN_LockWndPtr(pDesktop->child); wndPtr; WIN_UpdateWndPtr(&wndPtr,wndPtr->next))
{
if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
{
TRACE_(msg)("BROADCAST Message to hWnd=%04x m=%04X w=%04X l=%08lX !\n",
wndPtr->hwndSelf, message, wParam, lParam);
TRACE("BROADCAST Message to hWnd=%04x m=%04X w=%04X l=%08lX !\n",
wndPtr->hwndSelf, message, wParam, lParam);
PostMessageA( wndPtr->hwndSelf, message, wParam, lParam );
}
}
WIN_ReleaseDesktop();
TRACE_(msg)("End of HWND_BROADCAST !\n");
TRACE("End of HWND_BROADCAST !\n");
return TRUE;
}
@ -1580,22 +1581,22 @@ static LRESULT MSG_SendMessage( HWND hwnd, UINT msg, WPARAM wParam,
}
WIN_ReleaseDesktop();
TRACE_(msg)("HWND_BROADCAST !\n");
TRACE("HWND_BROADCAST !\n");
for (ppWnd = list; *ppWnd; ppWnd++)
{
WIN_UpdateWndPtr(&wndPtr,*ppWnd);
if (!IsWindow(wndPtr->hwndSelf)) continue;
if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
{
TRACE_(msg)("BROADCAST Message to hWnd=%04x m=%04X w=%04lX l=%08lX !\n",
wndPtr->hwndSelf, msg, (DWORD)wParam, lParam);
TRACE("BROADCAST Message to hWnd=%04x m=%04X w=%04lX l=%08lX !\n",
wndPtr->hwndSelf, msg, (DWORD)wParam, lParam);
MSG_SendMessage( wndPtr->hwndSelf, msg, wParam, lParam,
timeout, flags, pRes);
}
}
WIN_ReleaseWndPtr(wndPtr);
WIN_ReleaseWinArray(list);
TRACE_(msg)("End of HWND_BROADCAST !\n");
TRACE("End of HWND_BROADCAST !\n");
return 1;
}
@ -1628,7 +1629,7 @@ static LRESULT MSG_SendMessage( HWND hwnd, UINT msg, WPARAM wParam,
if (!(wndPtr = WIN_FindWndPtr( hwnd )))
{
WARN_(msg)("invalid hwnd %04x\n", hwnd );
WARN("invalid hwnd %04x\n", hwnd );
return 0;
}
if (QUEUE_IsExitingQueue(wndPtr->hmemTaskQ))
@ -2082,7 +2083,7 @@ static BOOL MSG_DoTranslateMessage( UINT message, HWND hwnd,
BYTE wp[2];
if (message != WM_MOUSEMOVE && message != WM_TIMER)
TRACE_(msg)("(%s, %04X, %08lX)\n",
TRACE("(%s, %04X, %08lX)\n",
SPY_GetMsgName(message), wParam, lParam );
if(message >= WM_KEYFIRST && message <= WM_KEYLAST)
TRACE_(key)("(%s, %04X, %08lX)\n",
@ -2214,7 +2215,7 @@ LONG WINAPI DispatchMessage16( const MSG16* msg )
if (painting && wndPtr &&
(wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
{
ERR_(msg)("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
ERR("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
msg->hwnd);
wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
/* Validate the update region to avoid infinite WM_PAINT loop */
@ -2292,7 +2293,7 @@ LONG WINAPI DispatchMessageA( const MSG* msg )
if (painting && wndPtr &&
(wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
{
ERR_(msg)("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
ERR("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
msg->hwnd);
wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
/* Validate the update region to avoid infinite WM_PAINT loop */
@ -2366,7 +2367,7 @@ LONG WINAPI DispatchMessageW( const MSG* msg )
if (painting && wndPtr &&
(wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
{
ERR_(msg)("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
ERR("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
msg->hwnd);
wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
/* Validate the update region to avoid infinite WM_PAINT loop */
@ -2383,7 +2384,7 @@ END:
*/
WORD WINAPI RegisterWindowMessage16( SEGPTR str )
{
TRACE_(msg)("%08lx\n", (DWORD)str );
TRACE("%08lx\n", (DWORD)str );
return GlobalAddAtom16( str );
}
@ -2393,7 +2394,7 @@ WORD WINAPI RegisterWindowMessage16( SEGPTR str )
*/
WORD WINAPI RegisterWindowMessageA( LPCSTR str )
{
TRACE_(msg)("%s\n", str );
TRACE("%s\n", str );
return GlobalAddAtomA( str );
}
@ -2403,7 +2404,7 @@ WORD WINAPI RegisterWindowMessageA( LPCSTR str )
*/
WORD WINAPI RegisterWindowMessageW( LPCWSTR str )
{
TRACE_(msg)("%p\n", str );
TRACE("%p\n", str );
return GlobalAddAtomW( str );
}
@ -2484,7 +2485,7 @@ LONG WINAPI BroadcastSystemMessage(
*/
BOOL WINAPI SendNotifyMessageA(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{ BOOL ret = TRUE;
FIXME_(msg)("(%04x,%08x,%08x,%08lx) not complete\n",
FIXME("(%04x,%08x,%08x,%08lx) not complete\n",
hwnd, msg, wParam, lParam);
if ( GetCurrentThreadId() == GetWindowThreadProcessId ( hwnd, NULL))
@ -2505,7 +2506,7 @@ BOOL WINAPI SendNotifyMessageA(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
*/
BOOL WINAPI SendNotifyMessageW(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{ BOOL ret = TRUE;
FIXME_(msg)("(%04x,%08x,%08x,%08lx) not complete\n",
FIXME("(%04x,%08x,%08x,%08lx) not complete\n",
hwnd, msg, wParam, lParam);
if ( GetCurrentThreadId() == GetWindowThreadProcessId ( hwnd, NULL))
@ -2527,11 +2528,11 @@ BOOL WINAPI SendMessageCallbackA(
HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,
FARPROC lpResultCallBack,DWORD dwData)
{
FIXME_(msg)("(0x%04x,0x%04x,0x%08x,0x%08lx,%p,0x%08lx),stub!\n",
hWnd,Msg,wParam,lParam,lpResultCallBack,dwData);
FIXME("(0x%04x,0x%04x,0x%08x,0x%08lx,%p,0x%08lx),stub!\n",
hWnd,Msg,wParam,lParam,lpResultCallBack,dwData);
if ( hWnd == HWND_BROADCAST)
{ PostMessageA( hWnd, Msg, wParam, lParam);
FIXME_(msg)("Broadcast: Callback will not be called!\n");
FIXME("Broadcast: Callback will not be called!\n");
return TRUE;
}
(lpResultCallBack)( hWnd, Msg, dwData, SendMessageA ( hWnd, Msg, wParam, lParam ));
@ -2547,11 +2548,11 @@ BOOL WINAPI SendMessageCallbackW(
HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,
FARPROC lpResultCallBack,DWORD dwData)
{
FIXME_(msg)("(0x%04x,0x%04x,0x%08x,0x%08lx,%p,0x%08lx),stub!\n",
hWnd,Msg,wParam,lParam,lpResultCallBack,dwData);
FIXME("(0x%04x,0x%04x,0x%08x,0x%08lx,%p,0x%08lx),stub!\n",
hWnd,Msg,wParam,lParam,lpResultCallBack,dwData);
if ( hWnd == HWND_BROADCAST)
{ PostMessageW( hWnd, Msg, wParam, lParam);
FIXME_(msg)("Broadcast: Callback will not be called!\n");
FIXME("Broadcast: Callback will not be called!\n");
return TRUE;
}
(lpResultCallBack)( hWnd, Msg, dwData, SendMessageA ( hWnd, Msg, wParam, lParam ));

60
windows/nonclient.c
View File

@ -28,7 +28,7 @@
#include "cache.h"
#include "bitmap.h"
DECLARE_DEBUG_CHANNEL(nonclient)
DEFAULT_DEBUG_CHANNEL(nonclient)
DECLARE_DEBUG_CHANNEL(shell)
BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
@ -115,7 +115,7 @@ static void NC_AdjustRect( LPRECT16 rect, DWORD style, BOOL menu,
DWORD exStyle )
{
if (TWEAK_WineLook > WIN31_LOOK)
ERR_(nonclient)("Called in Win95 mode. Aiee! Please report this.\n" );
ERR("Called in Win95 mode. Aiee! Please report this.\n" );
if(style & WS_ICONIC) return;
/* Decide if the window will be managed (see CreateWindowEx) */
@ -340,8 +340,8 @@ DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
{
RECT rc = *rect;
TRACE_(nonclient)("(%08x,%08x,%p,%08x,%08x,\"%s\",%08x)\n",
hwnd, hdc, rect, hFont, hIcon, str, uFlags);
TRACE("(%08x,%08x,%p,%08x,%08x,\"%s\",%08x)\n",
hwnd, hdc, rect, hFont, hIcon, str, uFlags);
/* drawing background */
if (uFlags & DC_INBUTTON) {
@ -426,7 +426,7 @@ DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
/* drawing focus ??? */
if (uFlags & 0x2000)
FIXME_(nonclient)("undocumented flag (0x2000)!\n");
FIXME("undocumented flag (0x2000)!\n");
return 0;
}
@ -486,9 +486,9 @@ BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
TRACE_(nonclient)("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
rect->left, rect->top, rect->right, rect->bottom,
style, menu, exStyle );
TRACE("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
rect->left, rect->top, rect->right, rect->bottom,
style, menu, exStyle );
if (TWEAK_WineLook == WIN31_LOOK)
NC_AdjustRect( rect, style, menu, exStyle );
@ -543,11 +543,10 @@ LONG NC_HandleNCCalcSize( WND *pWnd, RECT *winRect )
winRect->bottom -= tmpRect.bottom;
if (HAS_MENU(pWnd)) {
TRACE_(nonclient)("Calling "
"GetMenuBarHeight with HWND 0x%x, width %d, "
"at (%d, %d).\n", pWnd->hwndSelf,
winRect->right - winRect->left,
-tmpRect.left, -tmpRect.top );
TRACE("Calling GetMenuBarHeight with HWND 0x%x, width %d, "
"at (%d, %d).\n", pWnd->hwndSelf,
winRect->right - winRect->left,
-tmpRect.left, -tmpRect.top );
winRect->top +=
MENU_GetMenuBarHeight( pWnd->hwndSelf,
@ -665,8 +664,7 @@ static LONG NC_DoNCHitTest (WND *wndPtr, POINT16 pt )
{
RECT16 rect;
TRACE_(nonclient)("hwnd=%04x pt=%d,%d\n",
wndPtr->hwndSelf, pt.x, pt.y );
TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
GetWindowRect16 (wndPtr->hwndSelf, &rect );
if (!PtInRect16( &rect, pt )) return HTNOWHERE;
@ -801,8 +799,7 @@ NC_DoNCHitTest95 (WND *wndPtr, POINT16 pt )
{
RECT16 rect;
TRACE_(nonclient)("hwnd=%04x pt=%d,%d\n",
wndPtr->hwndSelf, pt.x, pt.y );
TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
GetWindowRect16 (wndPtr->hwndSelf, &rect );
if (!PtInRect16( &rect, pt )) return HTNOWHERE;
@ -1280,7 +1277,7 @@ static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
INT width, height;
if (TWEAK_WineLook != WIN31_LOOK)
ERR_(nonclient)("Called in Win95 mode. Aiee! Please report this.\n" );
ERR("Called in Win95 mode. Aiee! Please report this.\n" );
if (dlgFrame)
{
@ -1651,7 +1648,7 @@ static void NC_DoNCPaint( WND* wndPtr, HRGN clip, BOOL suppress_menupaint )
active = wndPtr->flags & WIN_NCACTIVATED;
TRACE_(nonclient)("%04x %d\n", hwnd, active );
TRACE("%04x %d\n", hwnd, active );
if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
@ -1766,12 +1763,13 @@ static void NC_DoNCPaint95(
active = wndPtr->flags & WIN_NCACTIVATED;
TRACE_(nonclient)("%04x %d\n", hwnd, active );
TRACE("%04x %d\n", hwnd, active );
/* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in the call to
* GetDCEx implying that it is allowed not to use it either. However, the suggested
* GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN) will cause clipRgn to be deleted
* after ReleaseDC(). Now, how is the "system" supposed to tell what happened?
/* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
the call to GetDCEx implying that it is allowed not to use it either.
However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
will cause clipRgn to be deleted after ReleaseDC().
Now, how is the "system" supposed to tell what happened?
*/
if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
@ -1837,15 +1835,14 @@ static void NC_DoNCPaint95(
RECT r = rect;
r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
TRACE_(nonclient)("Calling DrawMenuBar with "
"rect (%d, %d)-(%d, %d)\n", r.left, r.top,
r.right, r.bottom);
TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
r.left, r.top, r.right, r.bottom);
rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
}
TRACE_(nonclient)("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
rect.left, rect.top, rect.right, rect.bottom );
TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
rect.left, rect.top, rect.right, rect.bottom );
if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
@ -2715,8 +2712,7 @@ LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt )
POINT pt32;
UINT16 uCommand = wParam & 0xFFF0;
TRACE_(nonclient)("Handling WM_SYSCOMMAND %x %d,%d\n",
wParam, pt.x, pt.y );
TRACE("Handling WM_SYSCOMMAND %x %d,%d\n", wParam, pt.x, pt.y );
if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
@ -2781,7 +2777,7 @@ LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt )
case SC_ARRANGE:
case SC_NEXTWINDOW:
case SC_PREVWINDOW:
FIXME_(nonclient)("unimplemented!\n");
FIXME("unimplemented!\n");
break;
}
WIN_ReleaseWndPtr(wndPtr);

18
windows/painting.c
View File

@ -14,8 +14,8 @@
#include "wine/winuser16.h"
#include "cache.h"
DEFAULT_DEBUG_CHANNEL(win)
DECLARE_DEBUG_CHANNEL(nonclient)
DECLARE_DEBUG_CHANNEL(win)
/* client rect in window coordinates */
@ -294,7 +294,7 @@ HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
HideCaret( hwnd );
TRACE_(win)("hrgnUpdate = %04x, \n", hrgnUpdate);
TRACE("hrgnUpdate = %04x, \n", hrgnUpdate);
if (GetClassWord16(wndPtr->hwndSelf, GCW_STYLE) & CS_PARENTDC)
{
@ -314,11 +314,11 @@ HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
/* ReleaseDC() in EndPaint() will delete the region */
}
TRACE_(win)("hdc = %04x\n", lps->hdc);
TRACE("hdc = %04x\n", lps->hdc);
if (!lps->hdc)
{
WARN_(win)("GetDCEx() failed in BeginPaint(), hwnd=%04x\n", hwnd);
WARN("GetDCEx() failed in BeginPaint(), hwnd=%04x\n", hwnd);
WIN_ReleaseWndPtr(wndPtr);
return 0;
}
@ -336,7 +336,7 @@ HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
IntersectRect16(&lps->rcPaint, &clientRect, &clipRect);
TRACE_(win)("box = (%i,%i - %i,%i)\n", lps->rcPaint.left, lps->rcPaint.top,
TRACE("box = (%i,%i - %i,%i)\n", lps->rcPaint.left, lps->rcPaint.top,
lps->rcPaint.right, lps->rcPaint.bottom );
if (wndPtr->flags & WIN_NEEDS_ERASEBKGND)
@ -546,7 +546,7 @@ static void RDW_UpdateRgns( WND* wndPtr, HRGN hRgn, UINT flags, BOOL firstRecurs
r.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
r.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
TRACE_(win)("\thwnd %04x [%04x] -> hrgn [%04x], flags [%04x]\n", wndPtr->hwndSelf, wndPtr->hrgnUpdate, hRgn, flags );
TRACE("\thwnd %04x [%04x] -> hrgn [%04x], flags [%04x]\n", wndPtr->hwndSelf, wndPtr->hrgnUpdate, hRgn, flags );
if( flags & RDW_INVALIDATE )
{
@ -735,7 +735,7 @@ static HRGN RDW_Paint( WND* wndPtr, HRGN hrgn, UINT flags, UINT ex )
/* Erase/update the window itself ... */
TRACE_(win)("\thwnd %04x [%04x] -> hrgn [%04x], flags [%04x]\n", hWnd, wndPtr->hrgnUpdate, hrgn, flags );
TRACE("\thwnd %04x [%04x] -> hrgn [%04x], flags [%04x]\n", hWnd, wndPtr->hrgnUpdate, hrgn, flags );
/*
* Check if this window should delay it's processing of WM_NCPAINT.
@ -840,7 +840,7 @@ BOOL PAINT_RedrawWindow( HWND hwnd, const RECT *rectUpdate,
if( hrgnUpdate )
{
GetRgnBox( hrgnUpdate, &r );
TRACE_(win)( "%04x (%04x) NULL %04x box (%i,%i-%i,%i) flags=%04x, exflags=%04x\n",
TRACE( "%04x (%04x) NULL %04x box (%i,%i-%i,%i) flags=%04x, exflags=%04x\n",
hwnd, wndPtr->hrgnUpdate, hrgnUpdate, r.left, r.top, r.right, r.bottom, flags, ex);
}
else
@ -849,7 +849,7 @@ BOOL PAINT_RedrawWindow( HWND hwnd, const RECT *rectUpdate,
r = *rectUpdate;
else
SetRectEmpty( &r );
TRACE_(win)( "%04x (%04x) %s %d,%d-%d,%d %04x flags=%04x, exflags=%04x\n",
TRACE( "%04x (%04x) %s %d,%d-%d,%d %04x flags=%04x, exflags=%04x\n",
hwnd, wndPtr->hrgnUpdate, rectUpdate ? "rect" : "NULL", r.left,
r.top, r.right, r.bottom, hrgnUpdate, flags, ex );
}

80
windows/win.c
View File

@ -34,8 +34,8 @@
#include "stackframe.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win)
DECLARE_DEBUG_CHANNEL(msg)
DECLARE_DEBUG_CHANNEL(win)
/**********************************************************************/
@ -128,7 +128,7 @@ WND * WIN_FindWndPtr( HWND hwnd )
if (ptr->dwMagic != WND_MAGIC) goto error;
if (ptr->hwndSelf != hwnd)
{
ERR_(win)("Can't happen: hwnd %04x self pointer is %04x\n",hwnd, ptr->hwndSelf );
ERR("Can't happen: hwnd %04x self pointer is %04x\n",hwnd, ptr->hwndSelf );
goto error;
}
/* returns a locked pointer */
@ -186,7 +186,7 @@ void WIN_ReleaseWndPtr(WND *wndPtr)
else if(wndPtr->irefCount < 0)
{
/* This else if is useful to monitor the WIN_ReleaseWndPtr function */
ERR_(win)("forgot a Lock on %p somewhere\n",wndPtr);
ERR("forgot a Lock on %p somewhere\n",wndPtr);
}
/*unlock all WND structures for thread safeness*/
WIN_UnlockWnds();
@ -220,14 +220,14 @@ void WIN_DumpWindow( HWND hwnd )
if (!(ptr = WIN_FindWndPtr( hwnd )))
{
WARN_(win)("%04x is not a window handle\n", hwnd );
WARN("%04x is not a window handle\n", hwnd );
return;
}
if (!GetClassNameA( hwnd, className, sizeof(className ) ))
strcpy( className, "#NULL#" );
TRACE_(win)("Window %04x (%p):\n", hwnd, ptr );
TRACE("Window %04x (%p):\n", hwnd, ptr );
DPRINTF( "next=%p child=%p parent=%p owner=%p class=%p '%s'\n"
"inst=%04x taskQ=%04x updRgn=%04x active=%04x dce=%p idmenu=%08x\n"
"style=%08lx exstyle=%08lx wndproc=%08x text='%s'\n"
@ -269,7 +269,7 @@ void WIN_WalkWindows( HWND hwnd, int indent )
if (!ptr)
{
WARN_(win)("Invalid window handle %04x\n", hwnd );
WARN("Invalid window handle %04x\n", hwnd );
return;
}
@ -387,7 +387,7 @@ HWND WIN_FindWinToRepaint( HWND hwnd, HQUEUE16 hQueue )
{
if (!(pWnd->dwStyle & WS_VISIBLE))
{
TRACE_(win)("skipping window %04x\n",
TRACE("skipping window %04x\n",
pWnd->hwndSelf );
}
else if ((pWnd->hmemTaskQ == hQueue) &&
@ -421,7 +421,7 @@ HWND WIN_FindWinToRepaint( HWND hwnd, HQUEUE16 hQueue )
hwndRet = pWnd->hwndSelf;
WIN_ReleaseWndPtr(pWnd);
}
TRACE_(win)("found %04x\n",hwndRet);
TRACE("found %04x\n",hwndRet);
return hwndRet;
}
@ -437,7 +437,7 @@ static WND* WIN_DestroyWindow( WND* wndPtr )
HWND hwnd = wndPtr->hwndSelf;
WND *pWnd;
TRACE_(win)("%04x\n", wndPtr->hwndSelf );
TRACE("%04x\n", wndPtr->hwndSelf );
/* free child windows */
WIN_LockWndPtr(wndPtr->child);
@ -587,7 +587,7 @@ BOOL WIN_CreateDesktopWindow(void)
HWND hwndDesktop;
DESKTOP *pDesktop;
TRACE_(win)("Creating desktop window\n");
TRACE("Creating desktop window\n");
if (!ICONTITLE_Init() ||
@ -665,7 +665,7 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
LRESULT (CALLBACK *localSend32)(HWND, UINT, WPARAM, LPARAM);
char buffer[256];
TRACE_(win)("%s %s %08lx %08lx %d,%d %dx%d %04x %04x %08x %p\n",
TRACE("%s %s %08lx %08lx %d,%d %dx%d %04x %04x %08x %p\n",
unicode ? debugres_w((LPWSTR)cs->lpszName) : debugres_a(cs->lpszName),
unicode ? debugres_w((LPWSTR)cs->lpszClass) : debugres_a(cs->lpszClass),
cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy,
@ -678,11 +678,11 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
/* Make sure parent is valid */
if (!IsWindow( cs->hwndParent ))
{
WARN_(win)("Bad parent %04x\n", cs->hwndParent );
WARN("Bad parent %04x\n", cs->hwndParent );
return 0;
}
} else if ((cs->style & WS_CHILD) && !(cs->style & WS_POPUP)) {
WARN_(win)("No parent for child window\n" );
WARN("No parent for child window\n" );
return 0; /* WS_CHILD needs a parent, but WS_POPUP doesn't */
}
@ -690,7 +690,7 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
if (!(classPtr = CLASS_FindClassByAtom( classAtom, win32?cs->hInstance:GetExePtr(cs->hInstance) )))
{
GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
WARN_(win)("Bad class '%s'\n", buffer );
WARN("Bad class '%s'\n", buffer );
return 0;
}
@ -765,7 +765,7 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
if (!(hwnd = USER_HEAP_ALLOC( sizeof(*wndPtr) + classPtr->cbWndExtra
- sizeof(wndPtr->wExtra) )))
{
TRACE_(win)("out of memory\n" );
TRACE("out of memory\n" );
return 0;
}
@ -839,7 +839,7 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
: HOOK_CallHooksA(WH_CBT, HCBT_CREATEWND, hwnd, (LPARAM)&cbtc);
if (ret)
{
TRACE_(win)("CBT-hook returned 0\n");
TRACE("CBT-hook returned 0\n");
wndPtr->pDriver->pFinalize(wndPtr);
USER_HEAP_FREE( hwnd );
retvalue = 0;
@ -958,7 +958,7 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
/* send it anyway */
if (((wndPtr->rectClient.right-wndPtr->rectClient.left) <0)
||((wndPtr->rectClient.bottom-wndPtr->rectClient.top)<0))
WARN_(win)("sending bogus WM_SIZE message 0x%08lx\n",
WARN("sending bogus WM_SIZE message 0x%08lx\n",
MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
wndPtr->rectClient.bottom-wndPtr->rectClient.top));
SendMessageA( hwnd, WM_SIZE, SIZE_RESTORED,
@ -1004,7 +1004,7 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
if (!(wndPtr->dwStyle & WS_CHILD) && !wndPtr->owner)
HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWCREATED, hwnd, 0 );
TRACE_(win)("created window %04x\n", hwnd);
TRACE("created window %04x\n", hwnd);
retvalue = hwnd;
goto end;
}
@ -1013,7 +1013,7 @@ static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
/* Abort window creation */
WARN_(win)("aborted by WM_xxCREATE!\n");
WARN("aborted by WM_xxCREATE!\n");
WIN_ReleaseWndPtr(WIN_DestroyWindow( wndPtr ));
retvalue = 0;
end:
@ -1149,11 +1149,11 @@ HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className,
if (HIWORD(className))
{
LPSTR cn = HEAP_strdupWtoA( GetProcessHeap(), 0, className );
WARN_(win)("Bad class name '%s'\n",cn);
WARN("Bad class name '%s'\n",cn);
HeapFree( GetProcessHeap(), 0, cn );
}
else
WARN_(win)("Bad class name %p\n", className );
WARN("Bad class name %p\n", className );
return 0;
}
@ -1276,7 +1276,7 @@ static void WIN_SendDestroyMsg( WND* pWnd )
WIN_CheckFocus(pWnd);
}
else
WARN_(win)("\tdestroyed itself while in WM_DESTROY!\n");
WARN("\tdestroyed itself while in WM_DESTROY!\n");
}
@ -1297,7 +1297,7 @@ BOOL WINAPI DestroyWindow( HWND hwnd )
WND * wndPtr;
BOOL retvalue;
TRACE_(win)("(%04x)\n", hwnd);
TRACE("(%04x)\n", hwnd);
/* Initialization */
@ -1571,7 +1571,7 @@ HWND16 WINAPI FindWindowEx16( HWND16 parent, HWND16 child,
{
ATOM atom = 0;
TRACE_(win)("%04x %04x '%s' '%s'\n", parent,
TRACE("%04x %04x '%s' '%s'\n", parent,
child, HIWORD(className)?(char *)PTR_SEG_TO_LIN(className):"",
title ? title : "");
@ -1687,7 +1687,7 @@ HWND16 WINAPI GetDesktopWindow16(void)
HWND WINAPI GetDesktopWindow(void)
{
if (pWndDesktop) return pWndDesktop->hwndSelf;
ERR_(win)( "You need the -desktop option when running with native USER\n" );
ERR( "You need the -desktop option when running with native USER\n" );
ExitProcess(1);
return 0;
}
@ -1722,7 +1722,7 @@ BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable )
WND *wndPtr;
BOOL retvalue;
TRACE_(win)("EnableWindow32: ( %x, %d )\n", hwnd, enable);
TRACE("EnableWindow32: ( %x, %d )\n", hwnd, enable);
if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
if (enable && (wndPtr->dwStyle & WS_DISABLED))
@ -1827,7 +1827,7 @@ WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
{
if (offset + sizeof(WORD) > wndPtr->class->cbWndExtra)
{
WARN_(win)("Invalid offset %d\n", offset );
WARN("Invalid offset %d\n", offset );
retvalue = 0;
goto end;
}
@ -1838,7 +1838,7 @@ WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
{
case GWW_ID:
if (HIWORD(wndPtr->wIDmenu))
WARN_(win)("GWW_ID: discards high bits of 0x%08x!\n",
WARN("GWW_ID: discards high bits of 0x%08x!\n",
wndPtr->wIDmenu);
retvalue = (WORD)wndPtr->wIDmenu;
goto end;
@ -1847,12 +1847,12 @@ WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
goto end;
case GWW_HINSTANCE:
if (HIWORD(wndPtr->hInstance))
WARN_(win)("GWW_HINSTANCE: discards high bits of 0x%08x!\n",
WARN("GWW_HINSTANCE: discards high bits of 0x%08x!\n",
wndPtr->hInstance);
retvalue = (WORD)wndPtr->hInstance;
goto end;
default:
WARN_(win)("Invalid offset %d\n", offset );
WARN("Invalid offset %d\n", offset );
retvalue = 0;
goto end;
}
@ -1882,7 +1882,7 @@ WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
{
if (offset + sizeof(WORD) > wndPtr->class->cbWndExtra)
{
WARN_(win)("Invalid offset %d\n", offset );
WARN("Invalid offset %d\n", offset );
retval = 0;
goto end;
}
@ -1895,7 +1895,7 @@ WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
case GWW_HWNDPARENT: retval = SetParent( hwnd, newval );
goto end;
default:
WARN_(win)("Invalid offset %d\n", offset );
WARN("Invalid offset %d\n", offset );
retval = 0;
goto end;
}
@ -1921,7 +1921,7 @@ static LONG WIN_GetWindowLong( HWND hwnd, INT offset, WINDOWPROCTYPE type )
{
if (offset + sizeof(LONG) > wndPtr->class->cbWndExtra)
{
WARN_(win)("Invalid offset %d\n", offset );
WARN("Invalid offset %d\n", offset );
retvalue = 0;
goto end;
}
@ -1952,7 +1952,7 @@ static LONG WIN_GetWindowLong( HWND hwnd, INT offset, WINDOWPROCTYPE type )
case GWL_HINSTANCE: retvalue = wndPtr->hInstance;
goto end;
default:
WARN_(win)("Unknown offset %d\n", offset );
WARN("Unknown offset %d\n", offset );
}
retvalue = 0;
end:
@ -1979,7 +1979,7 @@ static LONG WIN_SetWindowLong( HWND hwnd, INT offset, LONG newval,
WND * wndPtr = WIN_FindWndPtr( hwnd );
STYLESTRUCT style;
TRACE_(win)("%x=%p %x %lx %x\n",hwnd, wndPtr, offset, newval, type);
TRACE("%x=%p %x %lx %x\n",hwnd, wndPtr, offset, newval, type);
if (!wndPtr)
{
@ -1992,7 +1992,7 @@ static LONG WIN_SetWindowLong( HWND hwnd, INT offset, LONG newval,
{
if (offset + sizeof(LONG) > wndPtr->class->cbWndExtra)
{
WARN_(win)("Invalid offset %d\n", offset );
WARN("Invalid offset %d\n", offset );
/* Is this the right error? */
SetLastError( ERROR_OUTOFMEMORY );
@ -2051,7 +2051,7 @@ static LONG WIN_SetWindowLong( HWND hwnd, INT offset, LONG newval,
goto end;
default:
WARN_(win)("Invalid offset %d\n", offset );
WARN("Invalid offset %d\n", offset );
/* Don't think this is right error but it should do */
SetLastError( ERROR_OUTOFMEMORY );
@ -2219,7 +2219,7 @@ INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount )
*/
INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount )
{
FIXME_(win)("(0x%08x,%p,0x%x),stub!\n",hwnd,lpString,nMaxCount);
FIXME("(0x%08x,%p,0x%x),stub!\n",hwnd,lpString,nMaxCount);
return GetWindowTextW(hwnd,lpString,nMaxCount);
}
@ -2982,7 +2982,7 @@ BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert )
{
WND *wndPtr = WIN_FindWndPtr(hWnd);
TRACE_(win)("%04x\n", hWnd);
TRACE("%04x\n", hWnd);
if (!wndPtr) return FALSE;
@ -3027,7 +3027,7 @@ HWND16 WINAPI SetSysModalWindow16( HWND16 hWnd )
{
HWND hWndOldModal = hwndSysModal;
hwndSysModal = hWnd;
FIXME_(win)("EMPTY STUB !! SetSysModalWindow(%04x) !\n", hWnd);
FIXME("EMPTY STUB !! SetSysModalWindow(%04x) !\n", hWnd);
return hWndOldModal;
}

125
windows/x11drv/event.c
View File

@ -38,7 +38,7 @@
#include "windef.h"
#include "x11drv.h"
DECLARE_DEBUG_CHANNEL(event)
DEFAULT_DEBUG_CHANNEL(event)
DECLARE_DEBUG_CHANNEL(win)
/* X context to associate a hwnd to an X window */
@ -163,7 +163,7 @@ static void CALLBACK EVENT_ProcessAllEvents( ULONG_PTR arg )
{
XEvent event;
TRACE_(event)( "called (thread %lx).\n", GetCurrentThreadId() );
TRACE( "called (thread %lx).\n", GetCurrentThreadId() );
EnterCriticalSection( &X11DRV_CritSection );
while ( XPending( display ) )
@ -205,12 +205,12 @@ static void EVENT_ProcessEvent( XEvent *event )
{
HWND hWnd;
TRACE_(event)( "called.\n" );
TRACE( "called.\n" );
switch (event->type)
{
case SelectionNotify: /* all of these should be caught by XCheckTypedWindowEvent() */
FIXME_(event)("Got SelectionNotify - must not happen!\n");
FIXME("Got SelectionNotify - must not happen!\n");
/* fall through */
/* We get all these because of StructureNotifyMask.
@ -250,11 +250,11 @@ static void EVENT_ProcessEvent( XEvent *event )
if ( !hWnd && event->xany.window != X11DRV_GetXRootWindow()
&& event->type != PropertyNotify )
ERR_(event)("Got event %s for unknown Window %08lx\n",
event_names[event->type], event->xany.window );
ERR("Got event %s for unknown Window %08lx\n",
event_names[event->type], event->xany.window );
else
TRACE_(event)("Got event %s for hwnd %04x\n",
event_names[event->type], hWnd );
TRACE("Got event %s for hwnd %04x\n",
event_names[event->type], hWnd );
switch(event->type)
{
@ -389,11 +389,11 @@ static void EVENT_ProcessEvent( XEvent *event )
break;
default:
WARN_(event)("Unprocessed event %s for hwnd %04x\n",
WARN("Unprocessed event %s for hwnd %04x\n",
event_names[event->type], hWnd );
break;
}
TRACE_(event)( "returns.\n" );
TRACE( "returns.\n" );
}
/***********************************************************************
@ -450,7 +450,7 @@ static Window __get_top_decoration( Window w, Window ancestor )
TSXQueryTree( display, w, &root, &parent, &children, &total );
if( children ) TSXFree( children );
} while( parent && parent != ancestor );
TRACE_(event)("\t%08x -> %08x\n", (unsigned)prev, (unsigned)w );
TRACE("\t%08x -> %08x\n", (unsigned)prev, (unsigned)w );
return ( parent ) ? w : 0 ;
}
@ -886,7 +886,7 @@ static Atom EVENT_SelectionRequest_TARGETS( Window requestor, Atom target, Atom
BOOL bHavePixmap;
int xRc;
TRACE_(event)("Request for %s\n", TSXGetAtomName(display, target));
TRACE("Request for %s\n", TSXGetAtomName(display, target));
/*
* Count the number of items we wish to expose as selection targets.
@ -940,7 +940,7 @@ static Atom EVENT_SelectionRequest_TARGETS( Window requestor, Atom target, Atom
if (targets[i])
{
char *itemFmtName = TSXGetAtomName(display, targets[i]);
TRACE_(event)("\tAtom# %d: Type %s\n", i, itemFmtName);
TRACE("\tAtom# %d: Type %s\n", i, itemFmtName);
TSXFree(itemFmtName);
}
}
@ -948,14 +948,14 @@ static Atom EVENT_SelectionRequest_TARGETS( Window requestor, Atom target, Atom
#endif
/* Update the X property */
TRACE_(event)("\tUpdating property %s...", TSXGetAtomName(display, rprop));
TRACE("\tUpdating property %s...", TSXGetAtomName(display, rprop));
/* We may want to consider setting the type to xaTargets instead,
* in case some apps expect this instead of XA_ATOM */
xRc = TSXChangeProperty(display, requestor, rprop,
XA_ATOM, 32, PropModeReplace,
(unsigned char *)targets, cTargets);
TRACE_(event)("(Rc=%d)\n", xRc);
TRACE("(Rc=%d)\n", xRc);
HeapFree( GetProcessHeap(), 0, targets );
@ -981,7 +981,7 @@ static Atom EVENT_SelectionRequest_STRING( Window requestor, Atom target, Atom r
* windows clipboard format ID.
*/
itemFmtName = TSXGetAtomName(display, target);
TRACE_(event)("Request for %s (wFormat=%x %s)\n",
TRACE("Request for %s (wFormat=%x %s)\n",
itemFmtName, CF_TEXT, CLIPBOARD_GetFormatName(CF_TEXT));
TSXFree(itemFmtName);
@ -1007,11 +1007,11 @@ static Atom EVENT_SelectionRequest_STRING( Window requestor, Atom target, Atom r
lpstr[j]='\0';
/* Update the X property */
TRACE_(event)("\tUpdating property %s...\n", TSXGetAtomName(display, rprop));
TRACE("\tUpdating property %s...\n", TSXGetAtomName(display, rprop));
xRc = TSXChangeProperty(display, requestor, rprop,
XA_STRING, 8, PropModeReplace,
lpstr, j);
TRACE_(event)("(Rc=%d)\n", xRc);
TRACE("(Rc=%d)\n", xRc);
GlobalUnlock16(hText);
HeapFree( GetProcessHeap(), 0, lpstr );
@ -1042,14 +1042,14 @@ static Atom EVENT_SelectionRequest_PIXMAP( Window requestor, Atom target, Atom r
*/
itemFmtName = TSXGetAtomName(display, target);
wFormat = X11DRV_CLIPBOARD_MapPropertyToFormat(itemFmtName);
TRACE_(event)("Request for %s (wFormat=%x %s)\n",
TRACE("Request for %s (wFormat=%x %s)\n",
itemFmtName, wFormat, CLIPBOARD_GetFormatName( wFormat));
TSXFree(itemFmtName);
hClipData = GetClipboardData(wFormat);
if ( !hClipData )
{
TRACE_(event)("Could not retrieve a Pixmap compatible format from clipboard!\n");
TRACE("Could not retrieve a Pixmap compatible format from clipboard!\n");
rprop = None; /* Fail the request */
goto END;
}
@ -1075,22 +1075,21 @@ static Atom EVENT_SelectionRequest_PIXMAP( Window requestor, Atom target, Atom r
}
else
{
FIXME_(event)("%s to PIXMAP conversion not yet implemented!\n",
FIXME("%s to PIXMAP conversion not yet implemented!\n",
CLIPBOARD_GetFormatName(wFormat));
rprop = None;
goto END;
}
TRACE_(event)("\tUpdating property %s on Window %ld with %s %ld...\n",
TSXGetAtomName(display, rprop), (long)requestor,
TSXGetAtomName(display, target),
pixmap);
TRACE("\tUpdating property %s on Window %ld with %s %ld...\n",
TSXGetAtomName(display, rprop), (long)requestor,
TSXGetAtomName(display, target), pixmap);
/* Store the Pixmap handle in the property */
xRc = TSXChangeProperty(display, requestor, rprop, target,
32, PropModeReplace,
(unsigned char *)&pixmap, 1);
TRACE_(event)("(Rc=%d)\n", xRc);
TRACE("(Rc=%d)\n", xRc);
/* Enable the code below if you want to handle destroying Pixmap resources
* in response to property notify events. Clients like XPaint don't
@ -1102,8 +1101,8 @@ static Atom EVENT_SelectionRequest_PIXMAP( Window requestor, Atom target, Atom r
* pixmap when the client deletes the property atom.
*/
xRc = TSXGetWindowAttributes(display, requestor, &win_attr_src);
TRACE_(event)("Turning on PropertyChangeEvent notifications from window %ld\n",
(long)requestor);
TRACE("Turning on PropertyChangeEvent notifications from window %ld\n",
(long)requestor);
win_attr.event_mask = win_attr_src.your_event_mask | PropertyChangeMask;
TSXChangeWindowAttributes(display, requestor, CWEventMask, &win_attr);
@ -1139,8 +1138,8 @@ static Atom EVENT_SelectionRequest_WCF( Window requestor, Atom target, Atom rpro
*/
itemFmtName = TSXGetAtomName(display, target);
wFormat = X11DRV_CLIPBOARD_MapPropertyToFormat(itemFmtName);
TRACE_(event)("Request for %s (wFormat=%x %s)\n",
itemFmtName, wFormat, CLIPBOARD_GetFormatName( wFormat));
TRACE("Request for %s (wFormat=%x %s)\n",
itemFmtName, wFormat, CLIPBOARD_GetFormatName( wFormat));
TSXFree(itemFmtName);
hClipData = GetClipboardData16(wFormat);
@ -1149,19 +1148,19 @@ static Atom EVENT_SelectionRequest_WCF( Window requestor, Atom target, Atom rpro
{
cBytes = GlobalSize16(hClipData);
TRACE_(event)("\tUpdating property %s, %d bytes...\n",
TSXGetAtomName(display, rprop), cBytes);
TRACE("\tUpdating property %s, %d bytes...\n",
TSXGetAtomName(display, rprop), cBytes);
xRc = TSXChangeProperty(display, requestor, rprop,
target, 8, PropModeReplace,
(unsigned char *)lpClipData, cBytes);
TRACE_(event)("(Rc=%d)\n", xRc);
TRACE("(Rc=%d)\n", xRc);
GlobalUnlock16(hClipData);
}
else
{
TRACE_(event)("\tCould not retrieve native format!\n");
TRACE("\tCould not retrieve native format!\n");
rprop = None; /* Fail the request */
}
@ -1204,13 +1203,14 @@ static Atom EVENT_SelectionRequest_MULTIPLE( HWND hWnd, XSelectionRequestEvent *
* (target,property) atom pairs.
*/
if(TSXGetWindowProperty(display, pevent->requestor, rprop,
0, 0x3FFF, False, AnyPropertyType, &atype, &aformat,
&cTargetPropList, &remain, (unsigned char**)&targetPropList) != Success)
TRACE_(event)("\tCouldn't read MULTIPLE property\n");
0, 0x3FFF, False, AnyPropertyType, &atype,&aformat,
&cTargetPropList, &remain,
(unsigned char**)&targetPropList) != Success)
TRACE("\tCouldn't read MULTIPLE property\n");
else
{
TRACE_(event)("\tType %s,Format %d,nItems %ld, Remain %ld\n",
TSXGetAtomName(display,atype),aformat,cTargetPropList,remain);
TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n",
TSXGetAtomName(display, atype), aformat, cTargetPropList, remain);
/*
* Make sure we got what we expect.
@ -1233,14 +1233,15 @@ static Atom EVENT_SelectionRequest_MULTIPLE( HWND hWnd, XSelectionRequestEvent *
char *propName = TSXGetAtomName(display, targetPropList[i+1]);
XSelectionRequestEvent event;
TRACE_(event)("MULTIPLE(%d): Target='%s' Prop='%s'\n", i/2, targetName, propName);
TRACE("MULTIPLE(%d): Target='%s' Prop='%s'\n",
i/2, targetName, propName);
TSXFree(targetName);
TSXFree(propName);
/* We must have a non "None" property to service a MULTIPLE target atom */
if ( !targetPropList[i+1] )
{
TRACE_(event)("\tMULTIPLE(%d): Skipping target with empty property!", i);
TRACE("\tMULTIPLE(%d): Skipping target with empty property!", i);
continue;
}
@ -1341,7 +1342,7 @@ END:
if(couldOpen) CloseClipboard();
if( rprop == None)
TRACE_(event)("\tRequest ignored\n");
TRACE("\tRequest ignored\n");
/* reply to sender
* SelectionNotify should be sent only at the end of a MULTIPLE request
@ -1355,7 +1356,7 @@ END:
result.property = rprop;
result.target = event->target;
result.time = event->time;
TRACE_(event)("Sending SelectionNotify event...\n");
TRACE("Sending SelectionNotify event...\n");
TSXSendEvent(display,event->requestor,False,NoEventMask,(XEvent*)&result);
}
}
@ -1379,14 +1380,14 @@ static void EVENT_SelectionClear( HWND hWnd, XSelectionClearEvent *event )
static void EVENT_PropertyNotify( XPropertyEvent *event )
{
/* Check if we have any resources to free */
TRACE_(event)("Received PropertyNotify event: ");
TRACE("Received PropertyNotify event: ");
switch(event->state)
{
case PropertyDelete:
{
TRACE_(event)("\tPropertyDelete for atom %s on window %ld\n",
TSXGetAtomName(event->display, event->atom), (long)event->window);
TRACE("\tPropertyDelete for atom %s on window %ld\n",
TSXGetAtomName(event->display, event->atom), (long)event->window);
if (X11DRV_CLIPBOARD_IsSelectionowner())
X11DRV_CLIPBOARD_FreeResources( event->atom );
@ -1395,8 +1396,8 @@ static void EVENT_PropertyNotify( XPropertyEvent *event )
case PropertyNewValue:
{
TRACE_(event)("\tPropertyNewValue for atom %s on window %ld\n\n",
TSXGetAtomName(event->display, event->atom), (long)event->window);
TRACE("\tPropertyNewValue for atom %s on window %ld\n\n",
TSXGetAtomName(event->display, event->atom), (long)event->window);
break;
}
@ -1571,8 +1572,8 @@ static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
AnyPropertyType, &u.atom_aux, &u.i,
&data_length, &aux_long, &p_data);
if (aux_long)
WARN_(event)("property too large, truncated!\n");
TRACE_(event)("urls=%s\n", p_data);
WARN("property too large, truncated!\n");
TRACE("urls=%s\n", p_data);
if( !aux_long && p_data) { /* don't bother if > 64K */
/* calculate length */
@ -1645,13 +1646,13 @@ static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
if (strncmp(p,"file:",5) == 0 ) {
INT len = GetShortPathNameA( p+5, p_drop, 65535 );
if (len) {
TRACE_(event)("drop file %s as %s\n", p+5, p_drop);
TRACE("drop file %s as %s\n", p+5, p_drop);
p_drop += len+1;
} else {
WARN_(event)("can't convert file %s to dos name \n", p+5);
WARN("can't convert file %s to dos name \n", p+5);
}
} else {
WARN_(event)("unknown mime type %s\n", p);
WARN("unknown mime type %s\n", p);
}
if (next) {
*next = '\n';
@ -1720,12 +1721,12 @@ static void EVENT_ClientMessage( HWND hWnd, XClientMessageEvent *event )
dndSelection, 0, 65535, FALSE,
AnyPropertyType, &u.atom, &u.i,
&u.l, &u.l, &p_data);
TRACE_(event)("message_type=%ld, data=%ld,%ld,%ld,%ld,%ld, msg=%s\n",
TRACE("message_type=%ld, data=%ld,%ld,%ld,%ld,%ld, msg=%s\n",
event->message_type, event->data.l[0], event->data.l[1],
event->data.l[2], event->data.l[3], event->data.l[4],
p_data);
#endif
TRACE_(event)("unrecognized ClientMessage\n" );
TRACE("unrecognized ClientMessage\n" );
}
}
}
@ -1842,22 +1843,22 @@ static HANDLE shm_event = 0, shm_read = 0;
static void EVENT_ShmCompletion( XShmCompletionEvent *event )
{
TRACE_(event)("Got ShmCompletion for drawable %ld (time %ld)\n", event->drawable, GetTickCount() );
TRACE("Got ShmCompletion for drawable %ld (time %ld)\n", event->drawable, GetTickCount() );
if (event->drawable == shm_draw) {
HANDLE event = shm_event;
shm_draw = 0;
SetEvent(event);
TRACE_(event)("Event object triggered\n" );
} else ERR_(event)("Got ShmCompletion for unknown drawable %ld\n", event->drawable );
TRACE("Event object triggered\n" );
} else ERR("Got ShmCompletion for unknown drawable %ld\n", event->drawable );
}
int X11DRV_EVENT_PrepareShmCompletion( Drawable dw )
{
if (shm_draw) {
ERR_(event)("Multiple ShmCompletion requests not implemented\n");
ERR("Multiple ShmCompletion requests not implemented\n");
return 0;
}
TRACE_(event)("Preparing ShmCompletion (%d) wait for drawable %ld (time %ld)\n", ShmCompletionType, dw, GetTickCount() );
TRACE("Preparing ShmCompletion (%d) wait for drawable %ld (time %ld)\n", ShmCompletionType, dw, GetTickCount() );
shm_draw = dw;
if (!shm_event)
/* use manual reset just in case */
@ -1870,7 +1871,7 @@ int X11DRV_EVENT_PrepareShmCompletion( Drawable dw )
void X11DRV_EVENT_WaitShmCompletion( int compl )
{
if (!compl) return;
TRACE_(event)("Waiting for ShmCompletion (%d) (thread %lx) (time %ld)\n", ShmCompletionType, GetCurrentThreadId(), GetTickCount() );
TRACE("Waiting for ShmCompletion (%d) (thread %lx) (time %ld)\n", ShmCompletionType, GetCurrentThreadId(), GetTickCount() );
/* already triggered? */
if ( WaitForSingleObject( compl, 0 ) != WAIT_OBJECT_0 ) {
/* nope, may need to poll X event queue, in case the service thread is blocked */
@ -1887,7 +1888,7 @@ void X11DRV_EVENT_WaitShmCompletion( int compl )
} while ( WaitForMultipleObjects(2, hnd, FALSE, INFINITE) > WAIT_OBJECT_0 );
}
ResetEvent(compl); /* manual reset */
TRACE_(event)("Wait complete (time %ld)\n", GetTickCount() );
TRACE("Wait complete (time %ld)\n", GetTickCount() );
}
#endif /* defined(HAVE_LIBXXSHM) */

103
windows/x11drv/keyboard.c
View File

@ -30,8 +30,8 @@
#include "winnls.h"
#include "x11drv.h"
DEFAULT_DEBUG_CHANNEL(keyboard)
DECLARE_DEBUG_CHANNEL(key)
DECLARE_DEBUG_CHANNEL(keyboard)
DECLARE_DEBUG_CHANNEL(x11drv)
DECLARE_DEBUG_CHANNEL(dinput)
@ -433,7 +433,7 @@ static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, INT event_x,
don't treat it. It's from the same key press. Then the state goes to ON.
And from there, a 'release' event will switch off the toggle key. */
*State=FALSE;
TRACE_(keyboard)("INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey,pKeyStateTable[vkey]);
TRACE("INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey,pKeyStateTable[vkey]);
} else
{
down = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0);
@ -442,7 +442,7 @@ static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, INT event_x,
{
if (Evtype!=KeyPress)
{
TRACE_(keyboard)("ON + KeyRelease => generating DOWN and UP messages.\n");
TRACE("ON + KeyRelease => generating DOWN and UP messages.\n");
KEYBOARD_SendEvent( vkey, scan, down,
event_x, event_y, event_time );
KEYBOARD_SendEvent( vkey, scan, up,
@ -454,7 +454,7 @@ static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, INT event_x,
else /* it was OFF */
if (Evtype==KeyPress)
{
TRACE_(keyboard)("OFF + Keypress => generating DOWN and UP messages.\n");
TRACE("OFF + Keypress => generating DOWN and UP messages.\n");
KEYBOARD_SendEvent( vkey, scan, down,
event_x, event_y, event_time );
KEYBOARD_SendEvent( vkey, scan, up,
@ -476,14 +476,14 @@ static void KEYBOARD_UpdateOneState ( int vkey, int state )
/* Do something if internal table state != X state for keycode */
if (((pKeyStateTable[vkey] & 0x80)!=0) != state)
{
TRACE_(keyboard)("Adjusting state for vkey %#.2x. State before %#.2x \n",
TRACE("Adjusting state for vkey %#.2x. State before %#.2x \n",
vkey, pKeyStateTable[vkey]);
/* Fake key being pressed inside wine */
KEYBOARD_SendEvent( vkey, 0, state? 0 : KEYEVENTF_KEYUP,
0, 0, GetTickCount() );
TRACE_(keyboard)("State after %#.2x \n",pKeyStateTable[vkey]);
TRACE("State after %#.2x \n",pKeyStateTable[vkey]);
}
}
@ -505,9 +505,9 @@ void X11DRV_KEYBOARD_UpdateState ( void )
char keys_return[32];
TRACE_(keyboard)("called\n");
TRACE("called\n");
if (!TSXQueryKeymap(display, keys_return)) {
ERR_(keyboard)("Error getting keymap !");
ERR("Error getting keymap !");
return;
}
@ -566,15 +566,15 @@ void X11DRV_KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
if (!ksname)
ksname = "No Name";
TRACE_(key)("%s : keysym=%lX (%s), ascii chars=%u / %X / '%s'\n",
(event->type == KeyPress) ? "KeyPress" : "KeyRelease",
keysym, ksname, ascii_chars, Str[0] & 0xff, Str);
(event->type == KeyPress) ? "KeyPress" : "KeyRelease",
keysym, ksname, ascii_chars, Str[0] & 0xff, Str);
}
vkey = EVENT_event_to_vkey(event);
if (force_extended) vkey |= 0x100;
TRACE_(key)("keycode 0x%x converted to vkey 0x%x\n",
event->keycode, vkey);
event->keycode, vkey);
if (vkey)
{
@ -585,16 +585,16 @@ void X11DRV_KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
event_time );
break;
case VK_CAPITAL:
TRACE_(keyboard)("Caps Lock event. (type %d). State before : %#.2x\n",event->type,pKeyStateTable[vkey]);
TRACE("Caps Lock event. (type %d). State before : %#.2x\n",event->type,pKeyStateTable[vkey]);
KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, event->type, event_x, event_y,
event_time );
TRACE_(keyboard)("State after : %#.2x\n",pKeyStateTable[vkey]);
TRACE("State after : %#.2x\n",pKeyStateTable[vkey]);
break;
default:
/* Adjust the NUMLOCK state if it has been changed outside wine */
if (!(pKeyStateTable[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
{
TRACE_(keyboard)("Adjusting NumLock state. \n");
TRACE("Adjusting NumLock state. \n");
KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyPress, event_x, event_y,
event_time );
KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyRelease, event_x, event_y,
@ -603,7 +603,7 @@ void X11DRV_KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
/* Adjust the CAPSLOCK state if it has been changed outside wine */
if (!(pKeyStateTable[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
{
TRACE_(keyboard)("Adjusting Caps Lock state.\n");
TRACE("Adjusting Caps Lock state.\n");
KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyPress, event_x, event_y,
event_time );
KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyRelease, event_x, event_y,
@ -648,11 +648,11 @@ X11DRV_KEYBOARD_DetectLayout (void)
syms = keysyms_per_keycode;
if (syms > 4) {
WARN_(keyboard)("%d keysyms per keycode not supported, set to 4", syms);
WARN("%d keysyms per keycode not supported, set to 4", syms);
syms = 4;
}
for (current = 0; main_key_tab[current].lang; current++) {
TRACE_(keyboard)("Attempting to match against layout %04x\n",
TRACE("Attempting to match against layout %04x\n",
main_key_tab[current].lang);
match = 0;
mismatch = 0;
@ -703,7 +703,7 @@ X11DRV_KEYBOARD_DetectLayout (void)
}
}
}
TRACE_(keyboard)("matches=%d, mismatches=%d, score=%d\n",
TRACE("matches=%d, mismatches=%d, score=%d\n",
match, mismatch, score);
if ((score > max_score) ||
((score == max_score) && (seq > max_seq))) {
@ -716,7 +716,7 @@ X11DRV_KEYBOARD_DetectLayout (void)
}
/* we're done, report results if necessary */
if (!ismatch) {
FIXME_(keyboard)(
FIXME(
"Your keyboard layout was not found!\n"
"Instead using closest match (%04x) for scancode mapping.\n"
"Please define your layout in windows/x11drv/keyboard.c and submit them\n"
@ -724,7 +724,7 @@ X11DRV_KEYBOARD_DetectLayout (void)
"See documentation/keyboard for more information.\n",
main_key_tab[kbd_layout].lang);
}
TRACE_(keyboard)("detected layout is %04x\n", main_key_tab[kbd_layout].lang);
TRACE("detected layout is %04x\n", main_key_tab[kbd_layout].lang);
}
/**********************************************************************
@ -889,16 +889,16 @@ void X11DRV_KEYBOARD_Init(void)
{
case 0xc1 : OEMvkey=0xdb; break;
case 0xe5 : OEMvkey=0xe9; break;
case 0xf6 : OEMvkey=0xf5; WARN_(keyboard)("No more OEM vkey available!\n");
case 0xf6 : OEMvkey=0xf5; WARN("No more OEM vkey available!\n");
}
vkey = OEMvkey;
if (TRACE_ON(keyboard))
{
TRACE_(keyboard)("OEM specific virtual key %X assigned to keycode %X:\n",
TRACE("OEM specific virtual key %X assigned to keycode %X:\n",
OEMvkey, e2.keycode);
TRACE_(keyboard)("(");
TRACE("(");
for (i = 0; i < keysyms_per_keycode; i += 1)
{
char *ksname;
@ -960,8 +960,8 @@ WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar)
keycode = TSXKeysymToKeycode(display, keysym | 0xFE00);
}
TRACE_(keyboard)("VkKeyScan '%c'(%#lx, %lu): got keycode %#.2x\n",
cChar,keysym,keysym,keycode);
TRACE("VkKeyScan '%c'(%#lx, %lu): got keycode %#.2x\n",
cChar,keysym,keysym,keycode);
if (keycode)
{
@ -969,12 +969,12 @@ WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar)
if (TSXKeycodeToKeysym(display,keycode,i)==keysym) index=i;
switch (index) {
case -1 :
WARN_(keyboard)("Keysym %lx not found while parsing the keycode table\n",keysym); break;
WARN("Keysym %lx not found while parsing the keycode table\n",keysym); break;
case 0 : break;
case 1 : highbyte = 0x0100; break;
case 2 : highbyte = 0x0600; break;
case 3 : highbyte = 0x0700; break;
default : ERR_(keyboard)("index %d found by XKeycodeToKeysym. please report! \n",index);
default : ERR("index %d found by XKeycodeToKeysym. please report! \n",index);
}
/*
index : 0 adds 0x0000
@ -984,7 +984,7 @@ WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar)
index : 3 adds 0x0700 (ctrl+alt+shift)
*/
}
TRACE_(keyboard)(" ... returning %#.2x\n", keyc2vkey[keycode]+highbyte);
TRACE(" ... returning %#.2x\n", keyc2vkey[keycode]+highbyte);
return keyc2vkey[keycode]+highbyte; /* keycode -> (keyc2vkey) vkey */
}
@ -993,10 +993,9 @@ WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar)
*/
UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
{
#define returnMVK(value) { TRACE_(keyboard)("returning 0x%x.\n",value); return value; }
#define returnMVK(value) { TRACE("returning 0x%x.\n",value); return value; }
TRACE_(keyboard)("MapVirtualKey wCode=0x%x wMapType=%d ... \n",
wCode,wMapType);
TRACE("MapVirtualKey wCode=0x%x wMapType=%d ... \n", wCode,wMapType);
switch(wMapType) {
case 0: { /* vkey-code to scan-code */
/* let's do vkey -> keycode -> scan */
@ -1004,7 +1003,7 @@ UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
for (keyc=min_keycode; keyc<=max_keycode; keyc++)
if ((keyc2vkey[keyc] & 0xFF) == wCode)
returnMVK (keyc2scan[keyc] & 0xFF);
TRACE_(keyboard)("returning no scan-code.\n");
TRACE("returning no scan-code.\n");
return 0; }
case 1: { /* scan-code to vkey-code */
@ -1013,7 +1012,7 @@ UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
for (keyc=min_keycode; keyc<=max_keycode; keyc++)
if ((keyc2scan[keyc] & 0xFF) == (wCode & 0xFF))
returnMVK (keyc2vkey[keyc] & 0xFF);
TRACE_(keyboard)("returning no vkey-code.\n");
TRACE("returning no vkey-code.\n");
return 0; }
case 2: { /* vkey-code to unshifted ANSI code */
@ -1049,26 +1048,25 @@ UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
if (!e.keycode)
{
WARN_(keyboard)("Unknown virtual key %X !!! \n", wCode);
WARN("Unknown virtual key %X !!! \n", wCode);
return 0; /* whatever */
}
TRACE_(keyboard)("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
if (TSXLookupString(&e, s, 2, &keysym, NULL))
returnMVK (*s);
TRACE_(keyboard)("returning no ANSI.\n");
TRACE("returning no ANSI.\n");
return 0;
}
case 3: /* **NT only** scan-code to vkey-code but distinguish between */
/* left and right */
FIXME_(keyboard)(" stub for NT\n");
FIXME(" stub for NT\n");
return 0;
default: /* reserved */
WARN_(keyboard)("Unknown wMapType %d !\n",
wMapType);
WARN("Unknown wMapType %d !\n", wMapType);
return 0;
}
return 0;
@ -1111,8 +1109,7 @@ INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize)
}
ansi = X11DRV_KEYBOARD_MapVirtualKey(vkey, 2);
TRACE_(keyboard)("scan 0x%04x, vkey 0x%04x, ANSI 0x%04x\n",
scanCode, vkey, ansi);
TRACE("scan 0x%04x, vkey 0x%04x, ANSI 0x%04x\n", scanCode, vkey, ansi);
/* first get the name of the "regular" keys which is the Upper case
value of the keycap imprint. */
@ -1152,8 +1149,8 @@ INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize)
{
keys = TSXKeycodeToKeysym(display, keyc, 0);
name = TSXKeysymToString(keys);
TRACE_(keyboard)("found scan=%04x keyc=%04x keysym=%04x string=%s\n",
scanCode, keyc, (int)keys, name);
TRACE("found scan=%04x keyc=%04x keysym=%04x string=%s\n",
scanCode, keyc, (int)keys, name);
if (lpBuffer && nSize && name)
{
strncpy(lpBuffer, name, nSize);
@ -1163,7 +1160,7 @@ INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize)
/* Finally issue FIXME for unknown keys */
FIXME_(keyboard)("(%08lx,%p,%d): unsupported key, vkey=%04x, ansi=%04x\n",lParam,lpBuffer,nSize,vkey,ansi);
FIXME("(%08lx,%p,%d): unsupported key, vkey=%04x, ansi=%04x\n",lParam,lpBuffer,nSize,vkey,ansi);
if (lpBuffer && nSize)
*lpBuffer = 0;
return 0;
@ -1243,7 +1240,7 @@ static char KEYBOARD_MapDeadKeysym(KeySym keysym)
return 's';
*/
}
TRACE_(keyboard)("no character for dead keysym 0x%08lx\n",keysym);
TRACE("no character for dead keysym 0x%08lx\n",keysym);
return 0;
}
@ -1278,12 +1275,12 @@ INT16 X11DRV_KEYBOARD_ToAscii(
if (scanCode==0) {
/* This happens when doing Alt+letter : a fake 'down arrow' key press
event is generated by windows. Just ignore it. */
TRACE_(keyboard)("scanCode=0, doing nothing\n");
TRACE("scanCode=0, doing nothing\n");
return 0;
}
if (scanCode & 0x8000)
{
TRACE_(keyboard)("Key UP, doing nothing\n" );
TRACE("Key UP, doing nothing\n" );
return 0;
}
e.display = display;
@ -1325,10 +1322,10 @@ INT16 X11DRV_KEYBOARD_ToAscii(
if (!e.keycode)
{
WARN_(keyboard)("Unknown virtual key %X !!! \n",virtKey);
WARN("Unknown virtual key %X !!! \n",virtKey);
return virtKey; /* whatever */
}
else TRACE_(keyboard)("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
else TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
ret = TSXLookupString(&e, (LPVOID)lpChar, 2, &keysym, &cs);
if (ret == 0)
@ -1351,10 +1348,10 @@ INT16 X11DRV_KEYBOARD_ToAscii(
ksname = "No Name";
if ((keysym >> 8) != 0xff)
{
ERR_(keyboard)("Please report: no char for keysym %04lX (%s) :\n",
keysym, ksname);
ERR_(keyboard)("(virtKey=%X,scanCode=%X,keycode=%X,state=%X)\n",
virtKey, scanCode, e.keycode, e.state);
ERR("Please report: no char for keysym %04lX (%s) :\n",
keysym, ksname);
ERR("(virtKey=%X,scanCode=%X,keycode=%X,state=%X)\n",
virtKey, scanCode, e.keycode, e.state);
}
}
}