system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-04 17:45:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

kernel32: Win64 printf format warning fixes.

Browse source
This commit is contained in:
Michael Stefaniuc 2006-10-12 22:56:29 +02:00 committed by Alexandre Julliard
parent 6276e456fa
commit 8c38b88068
47 changed files with 283 additions and 283 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
dlls/kernel32/Makefile.in
View file

@ -1,4 +1,4 @@
EXTRADEFS = -D_KERNEL32_ -DWINE_NO_LONG_AS_INT
EXTRADEFS = -D_KERNEL32_
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@

16
dlls/kernel32/actctx.c
View file

@ -51,7 +51,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(actctx);
*/
HANDLE WINAPI CreateActCtxA(PCACTCTXA pActCtx)
{
FIXME("%p %08lx\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
FIXME("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
if (!pActCtx)
return INVALID_HANDLE_VALUE;
@ -69,7 +69,7 @@ HANDLE WINAPI CreateActCtxA(PCACTCTXA pActCtx)
*/
HANDLE WINAPI CreateActCtxW(PCACTCTXW pActCtx)
{
FIXME("%p %08lx\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
FIXME("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
if (!pActCtx)
return INVALID_HANDLE_VALUE;
@ -100,7 +100,7 @@ BOOL WINAPI ActivateActCtx(HANDLE hActCtx, ULONG_PTR *ulCookie)
*/
BOOL WINAPI DeactivateActCtx(DWORD dwFlags, ULONG_PTR ulCookie)
{
FIXME("%08lx %08lx\n", dwFlags, ulCookie);
FIXME("%08x %08lx\n", dwFlags, ulCookie);
if (ulCookie != ACTCTX_FAKE_COOKIE)
return FALSE;
return TRUE;
@ -160,7 +160,7 @@ BOOL WINAPI FindActCtxSectionStringA(DWORD dwFlags, const GUID* lpExtGuid,
ULONG ulId, LPCSTR lpSearchStr,
PACTCTX_SECTION_KEYED_DATA pInfo)
{
FIXME("%08lx %s %lu %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
FIXME("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
ulId, debugstr_a(lpSearchStr), pInfo);
SetLastError( ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
@ -175,7 +175,7 @@ BOOL WINAPI FindActCtxSectionStringW(DWORD dwFlags, const GUID* lpExtGuid,
ULONG ulId, LPCWSTR lpSearchStr,
PACTCTX_SECTION_KEYED_DATA pInfo)
{
FIXME("%08lx %s %lu %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
FIXME("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
ulId, debugstr_w(lpSearchStr), pInfo);
if (lpExtGuid)
@ -187,7 +187,7 @@ BOOL WINAPI FindActCtxSectionStringW(DWORD dwFlags, const GUID* lpExtGuid,
if (dwFlags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
{
FIXME("unknown dwFlags %08lx\n", dwFlags);
FIXME("unknown dwFlags %08x\n", dwFlags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -219,7 +219,7 @@ BOOL WINAPI FindActCtxSectionGuid(DWORD dwFlags, const GUID* lpExtGuid,
ULONG ulId, const GUID* lpSearchGuid,
PACTCTX_SECTION_KEYED_DATA pInfo)
{
FIXME("%08lx %s %lu %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
FIXME("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
ulId, debugstr_guid(lpSearchGuid), pInfo);
SetLastError( ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
@ -234,7 +234,7 @@ BOOL WINAPI QueryActCtxW(DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInst,
ULONG ulClass, PVOID pvBuff, SIZE_T cbBuff,
SIZE_T *pcbLen)
{
FIXME("%08lx %p %p %lu %p %ld %p\n", dwFlags, hActCtx,
FIXME("%08x %p %p %u %p %ld %p\n", dwFlags, hActCtx,
pvSubInst, ulClass, pvBuff, cbBuff, pcbLen);
/* this makes Adobe Photoshop 7.0 happy */
SetLastError( ERROR_CALL_NOT_IMPLEMENTED);

4
dlls/kernel32/change.c
View file

@ -67,7 +67,7 @@ HANDLE WINAPI FindFirstChangeNotificationW( LPCWSTR lpPathName, BOOL bWatchSubtr
NTSTATUS status;
HANDLE handle = INVALID_HANDLE_VALUE;
TRACE( "%s %d %lx\n", debugstr_w(lpPathName), bWatchSubtree, dwNotifyFilter );
TRACE( "%s %d %x\n", debugstr_w(lpPathName), bWatchSubtree, dwNotifyFilter );
if (!RtlDosPathNameToNtPathName_U( lpPathName, &nt_name, NULL, NULL ))
{
@ -156,7 +156,7 @@ BOOL WINAPI ReadDirectoryChangesW( HANDLE handle, LPVOID buffer, DWORD len, BOOL
NTSTATUS status;
BOOL ret = TRUE;
TRACE("%p %p %08lx %d %08lx %p %p %p\n", handle, buffer, len, subtree, filter,
TRACE("%p %p %08x %d %08x %p %p %p\n", handle, buffer, len, subtree, filter,
returned, overlapped, completion );
if (!overlapped)

12
dlls/kernel32/comm.c
View file

@ -753,14 +753,14 @@ BOOL WINAPI GetCommMask(HANDLE handle, LPDWORD evtmask)
*/
BOOL WINAPI SetCommMask(HANDLE handle, DWORD evtmask)
{
TRACE("handle %p, mask %lx\n", handle, evtmask);
TRACE("handle %p, mask %x\n", handle, evtmask);
return DeviceIoControl(handle, IOCTL_SERIAL_SET_WAIT_MASK,
&evtmask, sizeof(evtmask), NULL, 0, NULL, NULL);
}
static void dump_dcb(const DCB* lpdcb)
{
TRACE("bytesize=%d baudrate=%ld fParity=%d Parity=%d stopbits=%d\n",
TRACE("bytesize=%d baudrate=%d fParity=%d Parity=%d stopbits=%d\n",
lpdcb->ByteSize, lpdcb->BaudRate, lpdcb->fParity, lpdcb->Parity,
(lpdcb->StopBits == ONESTOPBIT) ? 1 :
(lpdcb->StopBits == TWOSTOPBITS) ? 2 : 0);
@ -1323,7 +1323,7 @@ BOOL WINAPI SetDefaultCommConfigW(
HMODULE hConfigModule;
BOOL r = FALSE;
TRACE("(%p %p %lx)\n",lpszDevice, lpCommConfig, dwSize);
TRACE("(%p %p %x)\n",lpszDevice, lpCommConfig, dwSize);
hConfigModule = LoadLibraryW(lpszSerialUI);
if(!hConfigModule)
@ -1357,7 +1357,7 @@ BOOL WINAPI SetDefaultCommConfigA(
LPWSTR lpDeviceW = NULL;
DWORD len;
TRACE("(%s %p %lx)\n",debugstr_a(lpszDevice),lpCommConfig,dwSize);
TRACE("(%s %p %x)\n",debugstr_a(lpszDevice),lpCommConfig,dwSize);
if (lpszDevice)
{
@ -1398,7 +1398,7 @@ BOOL WINAPI GetDefaultCommConfigW(
return FALSE;
}
TRACE("(%s %p %ld)\n", debugstr_w(lpszName), lpCC, *lpdwSize );
TRACE("(%s %p %d)\n", debugstr_w(lpszName), lpCC, *lpdwSize );
if (*lpdwSize < sizeof(COMMCONFIG)) {
*lpdwSize = sizeof(COMMCONFIG);
return FALSE;
@ -1438,7 +1438,7 @@ BOOL WINAPI GetDefaultCommConfigA(
BOOL ret = FALSE;
UNICODE_STRING lpszNameW;
TRACE("(%s,%p,%ld)\n",lpszName,lpCC,*lpdwSize);
TRACE("(%s,%p,%d)\n",lpszName,lpCC,*lpdwSize);
if(lpszName) RtlCreateUnicodeStringFromAsciiz(&lpszNameW,lpszName);
else lpszNameW.Buffer = NULL;

10
dlls/kernel32/computername.c
View file

@ -276,7 +276,7 @@ void COMPUTERNAME_Init (void)
}
NtClose( hsubkey );
TRACE(" ComputerName: %s (%lu)\n", debugstr_w ( computer_name ), len / sizeof(WCHAR));
TRACE(" ComputerName: %s (%u)\n", debugstr_w ( computer_name ), len / sizeof(WCHAR));
RtlInitUnicodeString( &nameW, ActiveComputerNameW );
if ( ( st = NtCreateKey( &hsubkey, KEY_ALL_ACCESS, &attr, 0, NULL, REG_OPTION_VOLATILE, NULL ) )
@ -294,7 +294,7 @@ out:
TRACE( "success\n" );
else
{
WARN( "status trying to set ComputerName: %lx\n", st );
WARN( "status trying to set ComputerName: %x\n", st );
SetLastError ( RtlNtStatusToDosError ( st ) );
}
}
@ -331,7 +331,7 @@ BOOL WINAPI GetComputerNameW(LPWSTR name,LPDWORD size)
goto out;
len = (len -offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data )) / sizeof (WCHAR) - 1;
TRACE ("ComputerName is %s (length %lu)\n", debugstr_w ( theName ), len);
TRACE ("ComputerName is %s (length %u)\n", debugstr_w ( theName ), len);
__TRY
{
@ -365,7 +365,7 @@ out:
else
{
SetLastError ( RtlNtStatusToDosError ( st ) );
WARN ( "Status %lu reading computer name from registry\n", st );
WARN ( "Status %u reading computer name from registry\n", st );
return FALSE;
}
}
@ -623,7 +623,7 @@ out:
else
{
SetLastError ( RtlNtStatusToDosError ( st ) );
WARN ( "status %lu\n", st );
WARN ( "status %u\n", st );
return FALSE;
}
}

40
dlls/kernel32/console.c
View file

@ -357,7 +357,7 @@ BOOL WINAPI WriteConsoleInputW( HANDLE handle, const INPUT_RECORD *buffer,
{
BOOL ret;
TRACE("(%p,%p,%ld,%p)\n", handle, buffer, count, written);
TRACE("(%p,%p,%d,%p)\n", handle, buffer, count, written);
if (written) *written = 0;
SERVER_START_REQ( write_console_input )
@ -467,7 +467,7 @@ BOOL WINAPI WriteConsoleOutputCharacterA( HANDLE hConsoleOutput, LPCSTR str, DWO
LPWSTR strW;
DWORD lenW;
TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput,
TRACE("(%p,%s,%d,%dx%d,%p)\n", hConsoleOutput,
debugstr_an(str, length), length, coord.X, coord.Y, lpNumCharsWritten);
lenW = MultiByteToWideChar( GetConsoleOutputCP(), 0, str, length, NULL, 0 );
@ -504,7 +504,7 @@ BOOL WINAPI WriteConsoleOutputAttribute( HANDLE hConsoleOutput, CONST WORD *attr
{
BOOL ret;
TRACE("(%p,%p,%ld,%dx%d,%p)\n", hConsoleOutput,attr,length,coord.X,coord.Y,lpNumAttrsWritten);
TRACE("(%p,%p,%d,%dx%d,%p)\n", hConsoleOutput,attr,length,coord.X,coord.Y,lpNumAttrsWritten);
SERVER_START_REQ( write_console_output )
{
@ -558,7 +558,7 @@ BOOL WINAPI FillConsoleOutputCharacterW( HANDLE hConsoleOutput, WCHAR ch, DWORD
{
BOOL ret;
TRACE("(%p,%s,%ld,(%dx%d),%p)\n",
TRACE("(%p,%s,%d,(%dx%d),%p)\n",
hConsoleOutput, debugstr_wn(&ch, 1), length, coord.X, coord.Y, lpNumCharsWritten);
SERVER_START_REQ( fill_console_output )
@ -599,7 +599,7 @@ BOOL WINAPI FillConsoleOutputAttribute( HANDLE hConsoleOutput, WORD attr, DWORD
{
BOOL ret;
TRACE("(%p,%d,%ld,(%dx%d),%p)\n",
TRACE("(%p,%d,%d,(%dx%d),%p)\n",
hConsoleOutput, attr, length, coord.X, coord.Y, lpNumAttrsWritten);
SERVER_START_REQ( fill_console_output )
@ -654,7 +654,7 @@ BOOL WINAPI ReadConsoleOutputCharacterW( HANDLE hConsoleOutput, LPWSTR buffer, D
{
BOOL ret;
TRACE( "(%p,%p,%ld,%dx%d,%p)\n", hConsoleOutput, buffer, count, coord.X, coord.Y, read_count );
TRACE( "(%p,%p,%d,%dx%d,%p)\n", hConsoleOutput, buffer, count, coord.X, coord.Y, read_count );
SERVER_START_REQ( read_console_output )
{
@ -682,7 +682,7 @@ BOOL WINAPI ReadConsoleOutputAttribute(HANDLE hConsoleOutput, LPWORD lpAttribute
{
BOOL ret;
TRACE("(%p,%p,%ld,%dx%d,%p)\n",
TRACE("(%p,%p,%d,%dx%d,%p)\n",
hConsoleOutput, lpAttribute, length, coord.X, coord.Y, read_count);
SERVER_START_REQ( read_console_output )
@ -982,7 +982,7 @@ DWORD WINAPI GetLargestConsoleWindowSize(HANDLE hConsoleOutput)
} x;
x.c.X = 80;
x.c.Y = 24;
TRACE("(%p), returning %dx%d (%lx)\n", hConsoleOutput, x.c.X, x.c.Y, x.w);
TRACE("(%p), returning %dx%d (%x)\n", hConsoleOutput, x.c.X, x.c.Y, x.w);
return x.w;
}
#endif /* defined(__i386__) */
@ -1047,7 +1047,7 @@ static BOOL start_console_renderer_helper(const char* appname, STARTUPINFOA*
{
if (WaitForSingleObject(hEvent, INFINITE) != WAIT_OBJECT_0) return FALSE;
TRACE("Started wineconsole pid=%08lx tid=%08lx\n",
TRACE("Started wineconsole pid=%08x tid=%08x\n",
pi.dwProcessId, pi.dwThreadId);
return TRUE;
@ -1218,7 +1218,7 @@ BOOL WINAPI ReadConsoleW(HANDLE hConsoleInput, LPVOID lpBuffer,
LPWSTR xbuf = (LPWSTR)lpBuffer;
DWORD mode;
TRACE("(%p,%p,%ld,%p,%p)\n",
TRACE("(%p,%p,%d,%p,%p)\n",
hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved);
if (!GetConsoleMode(hConsoleInput, &mode))
@ -1316,7 +1316,7 @@ BOOL WINAPI WriteConsoleOutputCharacterW( HANDLE hConsoleOutput, LPCWSTR str, DW
{
BOOL ret;
TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput,
TRACE("(%p,%s,%d,%dx%d,%p)\n", hConsoleOutput,
debugstr_wn(str, length), length, coord.X, coord.Y, lpNumCharsWritten);
SERVER_START_REQ( write_console_output )
@ -1416,7 +1416,7 @@ BOOL WINAPI SetConsoleInputExeNameA(LPCSTR name)
*/
static BOOL WINAPI CONSOLE_DefaultHandler(DWORD dwCtrlType)
{
FIXME("Terminating process %lx on event %lx\n", GetCurrentProcessId(), dwCtrlType);
FIXME("Terminating process %x on event %x\n", GetCurrentProcessId(), dwCtrlType);
ExitProcess(0);
/* should never go here */
return TRUE;
@ -1521,7 +1521,7 @@ BOOL WINAPI SetConsoleCtrlHandler(PHANDLER_ROUTINE func, BOOL add)
static WINE_EXCEPTION_FILTER(CONSOLE_CtrlEventHandler)
{
TRACE("(%lx)\n", GetExceptionCode());
TRACE("(%x)\n", GetExceptionCode());
return EXCEPTION_EXECUTE_HANDLER;
}
@ -1607,11 +1607,11 @@ BOOL WINAPI GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,
{
BOOL ret;
TRACE("(%ld, %ld)\n", dwCtrlEvent, dwProcessGroupID);
TRACE("(%d, %d)\n", dwCtrlEvent, dwProcessGroupID);
if (dwCtrlEvent != CTRL_C_EVENT && dwCtrlEvent != CTRL_BREAK_EVENT)
{
ERR("Invalid event %ld for PGID %ld\n", dwCtrlEvent, dwProcessGroupID);
ERR("Invalid event %d for PGID %d\n", dwCtrlEvent, dwProcessGroupID);
return FALSE;
}
@ -1654,7 +1654,7 @@ HANDLE WINAPI CreateConsoleScreenBuffer(DWORD dwDesiredAccess, DWORD dwShareMode
{
HANDLE ret = INVALID_HANDLE_VALUE;
TRACE("(%ld,%ld,%p,%ld,%p)\n",
TRACE("(%d,%d,%p,%d,%p)\n",
dwDesiredAccess, dwShareMode, sa, dwFlags, lpScreenBufferData);
if (dwFlags != CONSOLE_TEXTMODE_BUFFER || lpScreenBufferData != NULL)
@ -1791,7 +1791,7 @@ BOOL WINAPI SetConsoleMode(HANDLE hcon, DWORD mode)
* empty the S_EditString buffer
*/
TRACE("(%p,%lx) retval == %d\n", hcon, mode, ret);
TRACE("(%p,%x) retval == %d\n", hcon, mode, ret);
return ret;
}
@ -1920,7 +1920,7 @@ BOOL WINAPI WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumber
CONSOLE_SCREEN_BUFFER_INFO csbi;
int k, first = 0;
TRACE("%p %s %ld %p %p\n",
TRACE("%p %s %d %p %p\n",
hConsoleOutput, debugstr_wn(lpBuffer, nNumberOfCharsToWrite),
nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved);
@ -2113,7 +2113,7 @@ BOOL WINAPI GetConsoleCursorInfo(HANDLE hCon, LPCONSOLE_CURSOR_INFO cinfo)
}
SERVER_END_REQ;
TRACE("(%p) returning (%ld,%d)\n", hCon, cinfo->dwSize, cinfo->bVisible);
TRACE("(%p) returning (%d,%d)\n", hCon, cinfo->dwSize, cinfo->bVisible);
return ret;
}
@ -2132,7 +2132,7 @@ BOOL WINAPI SetConsoleCursorInfo(HANDLE hCon, LPCONSOLE_CURSOR_INFO cinfo)
{
BOOL ret;
TRACE("(%p,%ld,%d)\n", hCon, cinfo->dwSize, cinfo->bVisible);
TRACE("(%p,%d,%d)\n", hCon, cinfo->dwSize, cinfo->bVisible);
SERVER_START_REQ(set_console_output_info)
{
req->handle = console_handle_unmap(hCon);

6
dlls/kernel32/cpu.c
View file

@ -214,7 +214,7 @@ static void create_env_registry_keys( const SYSTEM_INFO *info )
RtlInitUnicodeString( &nameW, EnvironW );
if (NtCreateKey( &env_key, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) return;
sprintf( nProc, "%ld", info->dwNumberOfProcessors );
sprintf( nProc, "%d", info->dwNumberOfProcessors );
RtlMultiByteToUnicodeN( nProcW, sizeof(nProcW), NULL, nProc, strlen(nProc)+1 );
RtlInitUnicodeString( &valueW, NumProcW );
NtSetValueKey( env_key, &valueW, 0, REG_SZ, nProcW, (strlenW(nProcW)+1)*sizeof(WCHAR) );
@ -770,8 +770,8 @@ VOID WINAPI GetSystemInfo(
#else
FIXME("not yet supported on this system\n");
#endif
TRACE("<- CPU arch %d, res'd %d, pagesize %ld, minappaddr %p, maxappaddr %p,"
" act.cpumask %08lx, numcpus %ld, CPU type %ld, allocgran. %ld, CPU level %d, CPU rev %d\n",
TRACE("<- CPU arch %d, res'd %d, pagesize %d, minappaddr %p, maxappaddr %p,"
" act.cpumask %08x, numcpus %d, CPU type %d, allocgran. %d, CPU level %d, CPU rev %d\n",
si->u.s.wProcessorArchitecture, si->u.s.wReserved, si->dwPageSize,
si->lpMinimumApplicationAddress, si->lpMaximumApplicationAddress,
si->dwActiveProcessorMask, si->dwNumberOfProcessors, si->dwProcessorType,

2
dlls/kernel32/dosmem.c
View file

@ -254,6 +254,6 @@ LPVOID DOSMEM_MapRealToLinear(DWORD x)
LPVOID lin;
lin = DOSMEM_dosmem + HIWORD(x) * 16 + LOWORD(x);
TRACE_(selector)("(0x%08lx) returns %p.\n", x, lin );
TRACE_(selector)("(0x%08x) returns %p.\n", x, lin );
return lin;
}

2
dlls/kernel32/editline.c
View file

@ -809,7 +809,7 @@ WCHAR* CONSOLE_Readline(HANDLE hConsoleIn)
while (!ctx.done && !ctx.error && WCEL_Get(&ctx, &ir))
{
if (ir.EventType != KEY_EVENT) continue;
TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08lx\n",
TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08x\n",
ir.Event.KeyEvent.bKeyDown ? "Down" : "Up ", ir.Event.KeyEvent.wRepeatCount,
ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState);

4
dlls/kernel32/environ.c
View file

@ -210,7 +210,7 @@ DWORD WINAPI GetEnvironmentVariableW( LPCWSTR name, LPWSTR val, DWORD size )
NTSTATUS status;
unsigned len;
TRACE("(%s %p %lu)\n", debugstr_w(name), val, size);
TRACE("(%s %p %u)\n", debugstr_w(name), val, size);
if (!name || !*name)
{
@ -342,7 +342,7 @@ DWORD WINAPI ExpandEnvironmentStringsW( LPCWSTR src, LPWSTR dst, DWORD len )
NTSTATUS status;
DWORD res;
TRACE("(%s %p %lu)\n", debugstr_w(src), dst, len);
TRACE("(%s %p %u)\n", debugstr_w(src), dst, len);
RtlInitUnicodeString(&us_src, src);

10
dlls/kernel32/except.c
View file

@ -155,14 +155,14 @@ static int format_exception_msg( const EXCEPTION_POINTERS *ptr, char *buffer, in
len = snprintf( buffer, size, "Unhandled PIC return in vm86 mode");
break;
default:
len = snprintf( buffer, size, "Unhandled exception 0x%08lx", rec->ExceptionCode);
len = snprintf( buffer, size, "Unhandled exception 0x%08x", rec->ExceptionCode);
break;
}
if ((len<0) || (len>=size))
return -1;
#ifdef __i386__
if (ptr->ContextRecord->SegCs != wine_get_cs())
len2 = snprintf(buffer+len, size-len, " at address 0x%04lx:0x%08lx",
len2 = snprintf(buffer+len, size-len, " at address 0x%04x:0x%08x",
ptr->ContextRecord->SegCs,
(DWORD)ptr->ExceptionRecord->ExceptionAddress);
else
@ -203,7 +203,7 @@ static BOOL start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
static const WCHAR AutoW[] = {'A','u','t','o',0};
format_exception_msg( epointers, buffer, sizeof(buffer) );
MESSAGE("wine: %s (thread %04lx), starting debugger...\n", buffer, GetCurrentThreadId());
MESSAGE("wine: %s (thread %04x), starting debugger...\n", buffer, GetCurrentThreadId());
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
@ -274,7 +274,7 @@ static BOOL start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
else
{
cmdline = HeapAlloc(GetProcessHeap(), 0, 80);
sprintf(cmdline, "winedbg --auto %ld %ld",
sprintf(cmdline, "winedbg --auto %d %ld",
GetCurrentProcessId(), (ULONG_PTR)hEvent);
}
@ -322,7 +322,7 @@ static BOOL start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
FreeEnvironmentStringsA( env );
if (ret) WaitForSingleObject(hEvent, INFINITE); /* wait for debugger to come up... */
else ERR("Couldn't start debugger (%s) (%ld)\n"
else ERR("Couldn't start debugger (%s) (%d)\n"
"Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
debugstr_a(cmdline), GetLastError());
EXIT:

36
dlls/kernel32/file.c
View file

@ -365,7 +365,7 @@ BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
NTSTATUS status;
PIO_STATUS_BLOCK io_status;
TRACE("(hFile=%p, buffer=%p, bytes=%lu, ovl=%p, ovl_fn=%p)\n", hFile, buffer, bytesToRead, overlapped, lpCompletionRoutine);
TRACE("(hFile=%p, buffer=%p, bytes=%u, ovl=%p, ovl_fn=%p)\n", hFile, buffer, bytesToRead, overlapped, lpCompletionRoutine);
if (!overlapped)
{
@ -403,7 +403,7 @@ BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
HANDLE hEvent = 0;
NTSTATUS status;
TRACE("%p %p %ld %p %p\n", hFile, buffer, bytesToRead,
TRACE("%p %p %d %p %p\n", hFile, buffer, bytesToRead,
bytesRead, overlapped );
if (bytesRead) *bytesRead = 0; /* Do this before anything else */
@ -448,7 +448,7 @@ BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
NTSTATUS status;
PIO_STATUS_BLOCK io_status;
TRACE("%p %p %ld %p %p\n", hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine);
TRACE("%p %p %d %p %p\n", hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine);
if (overlapped == NULL)
{
@ -482,7 +482,7 @@ BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
IO_STATUS_BLOCK iosb;
PIO_STATUS_BLOCK piosb = &iosb;
TRACE("%p %p %ld %p %p\n", hFile, buffer, bytesToWrite, bytesWritten, overlapped );
TRACE("%p %p %d %p %p\n", hFile, buffer, bytesToWrite, bytesWritten, overlapped );
if (is_console_handle(hFile))
return WriteConsoleA(hFile, buffer, bytesToWrite, bytesWritten, NULL);
@ -507,7 +507,7 @@ BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
status = NtWriteFile(hFile, hEvent, NULL, NULL, piosb,
buffer, bytesToWrite, poffset, NULL);
if (status != STATUS_INVALID_USER_BUFFER)
FIXME("Could not access memory (%p,%ld) at first, now OK. Protected by DIBSection code?\n",
FIXME("Could not access memory (%p,%d) at first, now OK. Protected by DIBSection code?\n",
buffer, bytesToWrite);
}
@ -567,7 +567,7 @@ BOOL WINAPI GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped,
{
TRACE( "waiting on %p\n", lpOverlapped );
r = WaitForSingleObjectEx( lpOverlapped->hEvent, INFINITE, TRUE );
TRACE( "wait on %p returned %ld\n", lpOverlapped, r );
TRACE( "wait on %p returned %d\n", lpOverlapped, r );
} while ( r == WAIT_IO_COMPLETION );
}
else
@ -586,7 +586,7 @@ BOOL WINAPI GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped,
{
TRACE( "waiting on %p\n", lpOverlapped );
r = WaitForSingleObjectEx( lpOverlapped->hEvent, 0, TRUE );
TRACE( "wait on %p returned %ld\n", lpOverlapped, r );
TRACE( "wait on %p returned %d\n", lpOverlapped, r );
} while ( r == WAIT_IO_COMPLETION );
if ( r == WAIT_OBJECT_0 && lpOverlapped->hEvent )
NtSetEvent( lpOverlapped->hEvent, NULL );
@ -660,7 +660,7 @@ LONG WINAPI _hwrite( HFILE handle, LPCSTR buffer, LONG count )
{
DWORD result;
TRACE("%d %p %ld\n", handle, buffer, count );
TRACE("%d %p %d\n", handle, buffer, count );
if (!count)
{
@ -945,7 +945,7 @@ BOOL WINAPI SetFilePointerEx( HANDLE hFile, LARGE_INTEGER distance,
NTSTATUS status;
int fd;
TRACE("handle %p offset %s newpos %p origin %ld\n",
TRACE("handle %p offset %s newpos %p origin %d\n",
hFile, wine_dbgstr_longlong(distance.QuadPart), newpos, method );
if (method > FILE_END)
@ -1058,7 +1058,7 @@ BOOL WINAPI LockFile( HANDLE hFile, DWORD offset_low, DWORD offset_high,
NTSTATUS status;
LARGE_INTEGER count, offset;
TRACE( "%p %lx%08lx %lx%08lx\n",
TRACE( "%p %x%08x %x%08x\n",
hFile, offset_high, offset_low, count_high, count_low );
count.u.LowPart = count_low;
@ -1098,7 +1098,7 @@ BOOL WINAPI LockFileEx( HANDLE hFile, DWORD flags, DWORD reserved,
return FALSE;
}
TRACE( "%p %lx%08lx %lx%08lx flags %lx\n",
TRACE( "%p %x%08x %x%08x flags %x\n",
hFile, overlapped->u.s.OffsetHigh, overlapped->u.s.Offset,
count_high, count_low, flags );
@ -1297,7 +1297,7 @@ HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
return INVALID_HANDLE_VALUE;
}
TRACE("%s %s%s%s%s%s%s creation %ld attributes 0x%lx\n", debugstr_w(filename),
TRACE("%s %s%s%s%s%s%s creation %d attributes 0x%x\n", debugstr_w(filename),
(access & GENERIC_READ)?"GENERIC_READ ":"",
(access & GENERIC_WRITE)?"GENERIC_WRITE ":"",
(!access)?"QUERY_ACCESS ":"",
@ -1412,7 +1412,7 @@ HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
options, NULL, 0 );
if (status)
{
WARN("Unable to create file %s (status %lx)\n", debugstr_w(filename), status);
WARN("Unable to create file %s (status %x)\n", debugstr_w(filename), status);
ret = INVALID_HANDLE_VALUE;
/* In the case file creation was rejected due to CREATE_NEW flag
@ -1518,7 +1518,7 @@ BOOL WINAPI ReplaceFileW(LPCWSTR lpReplacedFileName,LPCWSTR lpReplacementFileNam
LPCWSTR lpBackupFileName, DWORD dwReplaceFlags,
LPVOID lpExclude, LPVOID lpReserved)
{
FIXME("(%s,%s,%s,%08lx,%p,%p) stub\n",debugstr_w(lpReplacedFileName),debugstr_w(lpReplacementFileName),
FIXME("(%s,%s,%s,%08x,%p,%p) stub\n",debugstr_w(lpReplacedFileName),debugstr_w(lpReplacementFileName),
debugstr_w(lpBackupFileName),dwReplaceFlags,lpExclude,lpReserved);
SetLastError(ERROR_UNABLE_TO_MOVE_REPLACEMENT);
return FALSE;
@ -1532,7 +1532,7 @@ BOOL WINAPI ReplaceFileA(LPCSTR lpReplacedFileName,LPCSTR lpReplacementFileName,
LPCSTR lpBackupFileName, DWORD dwReplaceFlags,
LPVOID lpExclude, LPVOID lpReserved)
{
FIXME("(%s,%s,%s,%08lx,%p,%p) stub\n",lpReplacedFileName,lpReplacementFileName,
FIXME("(%s,%s,%s,%08x,%p,%p) stub\n",lpReplacedFileName,lpReplacementFileName,
lpBackupFileName,dwReplaceFlags,lpExclude,lpReserved);
SetLastError(ERROR_UNABLE_TO_MOVE_REPLACEMENT);
return FALSE;
@ -1553,12 +1553,12 @@ HANDLE WINAPI FindFirstFileExW( LPCWSTR filename, FINDEX_INFO_LEVELS level,
IO_STATUS_BLOCK io;
NTSTATUS status;
TRACE("%s %d %p %d %p %lx\n", debugstr_w(filename), level, data, search_op, filter, flags);
TRACE("%s %d %p %d %p %x\n", debugstr_w(filename), level, data, search_op, filter, flags);
if ((search_op != FindExSearchNameMatch && search_op != FindExSearchLimitToDirectories)
|| flags != 0)
{
FIXME("options not implemented 0x%08x 0x%08lx\n", search_op, flags );
FIXME("options not implemented 0x%08x 0x%08x\n", search_op, flags );
return INVALID_HANDLE_VALUE;
}
if (level != FindExInfoStandard)
@ -1915,7 +1915,7 @@ BOOL WINAPI SetFileAttributesW( LPCWSTR name, DWORD attributes )
NTSTATUS status;
HANDLE handle;
TRACE("%s %lx\n", debugstr_w(name), attributes);
TRACE("%s %x\n", debugstr_w(name), attributes);
if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
{

2
dlls/kernel32/file16.c
View file

@ -317,7 +317,7 @@ LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
{
LONG maxlen;
TRACE("%d %08lx %ld\n", hFile, (DWORD)buffer, count );
TRACE("%d %08x %d\n", hFile, (DWORD)buffer, count );
/* Some programs pass a count larger than the allocated buffer */
maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;

8
dlls/kernel32/format_msg.c
View file

@ -148,14 +148,14 @@ DWORD WINAPI FormatMessageA(
BOOL eos = FALSE;
CHAR ch;
TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
&&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
|| (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
FIXME("line wrapping (%lu) not supported.\n", width);
FIXME("line wrapping (%u) not supported.\n", width);
from = NULL;
if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
{
@ -334,7 +334,7 @@ DWORD WINAPI FormatMessageA(
HeapFree(GetProcessHeap(),0,from);
ret = (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ? strlen(*(LPSTR*)lpBuffer) : strlen(lpBuffer);
#endif /* __i386__ */
TRACE("-- returning %ld\n", ret);
TRACE("-- returning %d\n", ret);
return ret;
}
#undef ADD_TO_T
@ -362,7 +362,7 @@ DWORD WINAPI FormatMessageW(
BOOL eos = FALSE;
WCHAR ch;
TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
&&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)

8
dlls/kernel32/global16.c
View file

@ -224,7 +224,7 @@ HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner, unsigned cha
void *ptr;
HGLOBAL16 handle;
TRACE("%ld flags=%04x\n", size, flags );
TRACE("%d flags=%04x\n", size, flags );
/* If size is 0, create a discarded block */
@ -295,7 +295,7 @@ HGLOBAL16 WINAPI GlobalReAlloc16(
GLOBALARENA *pArena, *pNewArena;
WORD sel = GlobalHandleToSel16( handle );
TRACE("%04x %ld flags=%04x\n",
TRACE("%04x %d flags=%04x\n",
handle, size, flags );
if (!handle) return 0;
@ -347,7 +347,7 @@ HGLOBAL16 WINAPI GlobalReAlloc16(
ptr = (void *)pArena->base;
oldsize = pArena->size;
TRACE("oldbase %p oldsize %08lx newsize %08lx\n", ptr,oldsize,size);
TRACE("oldbase %p oldsize %08x newsize %08x\n", ptr,oldsize,size);
if (ptr && (size == oldsize)) return handle; /* Nothing to do */
if (pArena->flags & GA_DOSMEM)
@ -475,7 +475,7 @@ HGLOBAL16 WINAPI GlobalFree16(
SEGPTR WINAPI K32WOWGlobalLock16( HGLOBAL16 handle )
{
WORD sel = GlobalHandleToSel16( handle );
TRACE("(%04x) -> %08lx\n", handle, MAKELONG( 0, sel ) );
TRACE("(%04x) -> %08x\n", handle, MAKELONG( 0, sel ) );
if (handle)
{

2
dlls/kernel32/heap.c
View file

@ -1303,7 +1303,7 @@ BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex )
memcpy(&cached_memstatus,lpmemex,sizeof(*lpmemex));
TRACE("<-- LPMEMORYSTATUSEX: dwLength %ld, dwMemoryLoad %ld, ullTotalPhys %s, ullAvailPhys %s,"
TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
" ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
lpmemex->dwLength, lpmemex->dwMemoryLoad, wine_dbgstr_longlong(lpmemex->ullTotalPhys),
wine_dbgstr_longlong(lpmemex->ullAvailPhys), wine_dbgstr_longlong(lpmemex->ullTotalPageFile),

14
dlls/kernel32/instr.c
View file

@ -388,7 +388,7 @@ static DWORD INSTR_inport( WORD port, int size, CONTEXT86 *context )
(WORD)context->SegCs, LOWORD(context->Eip));
break;
case 4:
TRACE_(io)( "0x%x < %08lx @ %04x:%04x\n", port, res,
TRACE_(io)( "0x%x < %08x @ %04x:%04x\n", port, res,
(WORD)context->SegCs, LOWORD(context->Eip));
break;
}
@ -420,7 +420,7 @@ static void INSTR_outport( WORD port, int size, DWORD val, CONTEXT86 *context )
(WORD)context->SegCs, LOWORD(context->Eip));
break;
case 4:
TRACE_(io)("0x%x > %08lx @ %04x:%04x\n", port, val,
TRACE_(io)("0x%x > %08x @ %04x:%04x\n", port, val,
(WORD)context->SegCs, LOWORD(context->Eip));
break;
}
@ -527,7 +527,7 @@ DWORD INSTR_EmulateInstruction( EXCEPTION_RECORD *rec, CONTEXT86 *context )
switch (instr[2])
{
case 0xc0:
ERR("mov eax,cr0 at 0x%08lx, EAX=0x%08lx\n",
ERR("mov eax,cr0 at 0x%08x, EAX=0x%08x\n",
context->Eip,context->Eax );
context->Eip += prefixlen+3;
return ExceptionContinueExecution;
@ -550,12 +550,12 @@ DWORD INSTR_EmulateInstruction( EXCEPTION_RECORD *rec, CONTEXT86 *context )
* bit 7: PGE Enable global pages
* bit 8: PCE Enable performance counters at IPL3
*/
ERR("mov cr4,eax at 0x%08lx\n",context->Eip);
ERR("mov cr4,eax at 0x%08x\n",context->Eip);
context->Eax = 0;
context->Eip += prefixlen+3;
return ExceptionContinueExecution;
case 0xc0: /* mov cr0, eax */
ERR("mov cr0,eax at 0x%08lx\n",context->Eip);
ERR("mov cr0,eax at 0x%08x\n",context->Eip);
context->Eax = 0x10; /* FIXME: set more bits ? */
context->Eip += prefixlen+3;
return ExceptionContinueExecution;
@ -568,12 +568,12 @@ DWORD INSTR_EmulateInstruction( EXCEPTION_RECORD *rec, CONTEXT86 *context )
switch (instr[2])
{
case 0xc8: /* mov dr1, eax */
TRACE("mov dr1,eax at 0x%08lx\n",context->Eip);
TRACE("mov dr1,eax at 0x%08x\n",context->Eip);
context->Eax = context->Dr1;
context->Eip += prefixlen+3;
return ExceptionContinueExecution;
case 0xf8: /* mov dr7, eax */
TRACE("mov dr7,eax at 0x%08lx\n",context->Eip);
TRACE("mov dr7,eax at 0x%08x\n",context->Eip);
context->Eax = 0x400;
context->Eip += prefixlen+3;
return ExceptionContinueExecution;

46
dlls/kernel32/lcformat.c
View file

@ -137,7 +137,7 @@ static WCHAR* NLS_GetLocaleString(LCID lcid, DWORD dwFlags)
}
#define GET_LOCALE_NUMBER(num, type) num = NLS_GetLocaleNumber(lcid, type|dwFlags); \
TRACE( #type ": %ld (%08lx)\n", (DWORD)num, (DWORD)num)
TRACE( #type ": %d (%08x)\n", (DWORD)num, (DWORD)num)
#define GET_LOCALE_STRING(str, type) str = NLS_GetLocaleString(lcid, type|dwFlags); \
TRACE( #type ": '%s'\n", debugstr_w(str))
@ -175,7 +175,7 @@ static const NLS_FORMAT_NODE *NLS_GetFormats(LCID lcid, DWORD dwFlags)
dwFlags &= LOCALE_NOUSEROVERRIDE;
TRACE("(0x%04lx,0x%08lx)\n", lcid, dwFlags);
TRACE("(0x%04x,0x%08x)\n", lcid, dwFlags);
/* See if we have already cached the locales number format */
while (node && (node->lcid != lcid || node->dwFlags != dwFlags) && node->next)
@ -311,7 +311,7 @@ BOOL NLS_IsUnicodeOnlyLcid(LCID lcid)
case LANG_MARATHI:
case LANG_PUNJABI:
case LANG_SANSKRIT:
TRACE("lcid 0x%08lx: langid 0x%4x is Unicode Only\n", lcid, PRIMARYLANGID(lcid));
TRACE("lcid 0x%08x: langid 0x%4x is Unicode Only\n", lcid, PRIMARYLANGID(lcid));
return TRUE;
default:
return FALSE;
@ -609,7 +609,7 @@ NLS_GetDateTimeFormatW_InvalidFlags:
if (szAdd == buff && buff[0] == '\0')
{
/* We have a numeric value to add */
sprintf(buffA, "%.*ld", count, dwVal);
sprintf(buffA, "%.*d", count, dwVal);
MultiByteToWideChar(CP_ACP, 0, buffA, -1, buff, sizeof(buff)/sizeof(WCHAR));
}
@ -676,7 +676,7 @@ static INT NLS_GetDateTimeFormatA(LCID lcid, DWORD dwFlags,
WCHAR szFormat[128], szOut[128];
INT iRet;
TRACE("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n", lcid, dwFlags, lpTime,
TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n", lcid, dwFlags, lpTime,
debugstr_a(lpFormat), lpStr, cchOut);
if (NLS_IsUnicodeOnlyLcid(lcid))
@ -761,7 +761,7 @@ GetDateTimeFormatA_InvalidParameter:
INT WINAPI GetDateFormatA( LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
LPCSTR lpFormat, LPSTR lpDateStr, INT cchOut)
{
TRACE("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
debugstr_a(lpFormat), lpDateStr, cchOut);
return NLS_GetDateTimeFormatA(lcid, dwFlags | DATE_DATEVARSONLY, lpTime,
@ -777,7 +777,7 @@ INT WINAPI GetDateFormatA( LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
INT WINAPI GetDateFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
LPCWSTR lpFormat, LPWSTR lpDateStr, INT cchOut)
{
TRACE("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n", lcid, dwFlags, lpTime,
TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n", lcid, dwFlags, lpTime,
debugstr_w(lpFormat), lpDateStr, cchOut);
return NLS_GetDateTimeFormatW(lcid, dwFlags|DATE_DATEVARSONLY, lpTime,
@ -828,7 +828,7 @@ INT WINAPI GetDateFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
INT WINAPI GetTimeFormatA(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
LPCSTR lpFormat, LPSTR lpTimeStr, INT cchOut)
{
TRACE("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
debugstr_a(lpFormat), lpTimeStr, cchOut);
return NLS_GetDateTimeFormatA(lcid, dwFlags|TIME_TIMEVARSONLY, lpTime,
@ -843,7 +843,7 @@ INT WINAPI GetTimeFormatA(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
INT WINAPI GetTimeFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME* lpTime,
LPCWSTR lpFormat, LPWSTR lpTimeStr, INT cchOut)
{
TRACE("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
TRACE("(0x%04x,0x%08x,%p,%s,%p,%d)\n",lcid, dwFlags, lpTime,
debugstr_w(lpFormat), lpTimeStr, cchOut);
return NLS_GetDateTimeFormatW(lcid, dwFlags|TIME_TIMEVARSONLY, lpTime,
@ -887,7 +887,7 @@ INT WINAPI GetNumberFormatA(LCID lcid, DWORD dwFlags,
const NUMBERFMTW *pfmt = NULL;
INT iRet;
TRACE("(0x%04lx,0x%08lx,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_a(lpszValue),
TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_a(lpszValue),
lpFormat, lpNumberStr, cchOut);
if (NLS_IsUnicodeOnlyLcid(lcid))
@ -966,7 +966,7 @@ INT WINAPI GetNumberFormatW(LCID lcid, DWORD dwFlags,
DWORD dwState = 0, dwDecimals = 0, dwGroupCount = 0, dwCurrentGroupCount = 0;
INT iRet;
TRACE("(0x%04lx,0x%08lx,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_w(lpszValue),
TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_w(lpszValue),
lpFormat, lpNumberStr, cchOut);
if (!lpszValue || cchOut < 0 || (cchOut > 0 && !lpNumberStr) ||
@ -1227,7 +1227,7 @@ INT WINAPI GetCurrencyFormatA(LCID lcid, DWORD dwFlags,
const CURRENCYFMTW *pfmt = NULL;
INT iRet;
TRACE("(0x%04lx,0x%08lx,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_a(lpszValue),
TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_a(lpszValue),
lpFormat, lpCurrencyStr, cchOut);
if (NLS_IsUnicodeOnlyLcid(lcid))
@ -1332,7 +1332,7 @@ INT WINAPI GetCurrencyFormatW(LCID lcid, DWORD dwFlags,
DWORD dwState = 0, dwDecimals = 0, dwGroupCount = 0, dwCurrentGroupCount = 0, dwFmt;
INT iRet;
TRACE("(0x%04lx,0x%08lx,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_w(lpszValue),
TRACE("(0x%04x,0x%08x,%s,%p,%p,%d)\n", lcid, dwFlags, debugstr_w(lpszValue),
lpFormat, lpCurrencyStr, cchOut);
if (!lpszValue || cchOut < 0 || (cchOut > 0 && !lpCurrencyStr) ||
@ -1621,7 +1621,7 @@ BOOL WINAPI EnumDateFormatsExA(DATEFMT_ENUMPROCEXA proc, LCID lcid, DWORD flags)
break;
default:
FIXME("Unknown date format (%ld)\n", flags);
FIXME("Unknown date format (%d)\n", flags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -1664,7 +1664,7 @@ BOOL WINAPI EnumDateFormatsExW(DATEFMT_ENUMPROCEXW proc, LCID lcid, DWORD flags)
break;
default:
FIXME("Unknown date format (%ld)\n", flags);
FIXME("Unknown date format (%d)\n", flags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -1706,7 +1706,7 @@ BOOL WINAPI EnumDateFormatsA(DATEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
break;
default:
FIXME("Unknown date format (%ld)\n", flags);
FIXME("Unknown date format (%d)\n", flags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -1745,7 +1745,7 @@ BOOL WINAPI EnumDateFormatsW(DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)
break;
default:
FIXME("Unknown date format (%ld)\n", flags);
FIXME("Unknown date format (%d)\n", flags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -1776,7 +1776,7 @@ BOOL WINAPI EnumTimeFormatsA(TIMEFMT_ENUMPROCA proc, LCID lcid, DWORD flags)
break;
default:
FIXME("Unknown time format (%ld)\n", flags);
FIXME("Unknown time format (%d)\n", flags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -1804,7 +1804,7 @@ BOOL WINAPI EnumTimeFormatsW(TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags)
break;
default:
FIXME("Unknown time format (%ld)\n", flags);
FIXME("Unknown time format (%d)\n", flags);
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@ -1956,7 +1956,7 @@ NLS_EnumCalendarInfoAW_Cleanup:
BOOL WINAPI EnumCalendarInfoA( CALINFO_ENUMPROCA calinfoproc,LCID locale,
CALID calendar,CALTYPE caltype )
{
TRACE("(%p,0x%08lx,0x%08lx,0x%08lx)\n", calinfoproc, locale, calendar, caltype);
TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, FALSE, FALSE);
}
@ -1968,7 +1968,7 @@ BOOL WINAPI EnumCalendarInfoA( CALINFO_ENUMPROCA calinfoproc,LCID locale,
BOOL WINAPI EnumCalendarInfoW( CALINFO_ENUMPROCW calinfoproc,LCID locale,
CALID calendar,CALTYPE caltype )
{
TRACE("(%p,0x%08lx,0x%08lx,0x%08lx)\n", calinfoproc, locale, calendar, caltype);
TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, TRUE, FALSE);
}
@ -1980,7 +1980,7 @@ BOOL WINAPI EnumCalendarInfoW( CALINFO_ENUMPROCW calinfoproc,LCID locale,
BOOL WINAPI EnumCalendarInfoExA( CALINFO_ENUMPROCEXA calinfoproc,LCID locale,
CALID calendar,CALTYPE caltype )
{
TRACE("(%p,0x%08lx,0x%08lx,0x%08lx)\n", calinfoproc, locale, calendar, caltype);
TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, FALSE, TRUE);
}
@ -1992,6 +1992,6 @@ BOOL WINAPI EnumCalendarInfoExA( CALINFO_ENUMPROCEXA calinfoproc,LCID locale,
BOOL WINAPI EnumCalendarInfoExW( CALINFO_ENUMPROCEXW calinfoproc,LCID locale,
CALID calendar,CALTYPE caltype )
{
TRACE("(%p,0x%08lx,0x%08lx,0x%08lx)\n", calinfoproc, locale, calendar, caltype);
TRACE("(%p,0x%08x,0x%08x,0x%08x)\n", calinfoproc, locale, calendar, caltype);
return NLS_EnumCalendarInfoAW(calinfoproc, locale, calendar, caltype, TRUE, TRUE);
}

60
dlls/kernel32/locale.c
View file

@ -310,11 +310,11 @@ void LOCALE_InitRegistry(void)
NtClose( hkey );
return;
}
TRACE( "updating registry, locale changed %s -> %08lx\n", debugstr_w(szValueText), lcid );
TRACE( "updating registry, locale changed %s -> %08x\n", debugstr_w(szValueText), lcid );
}
else TRACE( "updating registry, locale changed none -> %08lx\n", lcid );
else TRACE( "updating registry, locale changed none -> %08x\n", lcid );
sprintf( buffer, "%08lx", lcid );
sprintf( buffer, "%08x", lcid );
/* Note: '9' constant below is strlen(buffer) + 1 */
RtlMultiByteToUnicodeN( bufferW, sizeof(bufferW), NULL, buffer, 9 );
NtSetValueKey( hkey, &nameW, 0, REG_SZ, bufferW, 9 * sizeof(WCHAR) );
@ -863,7 +863,7 @@ INT WINAPI GetLocaleInfoA( LCID lcid, LCTYPE lctype, LPSTR buffer, INT len )
WCHAR *bufferW;
INT lenW, ret;
TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d)\n", lcid, lctype, buffer, len );
TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d)\n", lcid, lctype, buffer, len );
if (len < 0 || (len && !buffer))
{
@ -935,7 +935,7 @@ INT WINAPI GetLocaleInfoW( LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len )
lcflags = lctype & LOCALE_LOCALEINFOFLAGSMASK;
lctype &= 0xffff;
TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d)\n", lcid, lctype, buffer, len );
TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d)\n", lcid, lctype, buffer, len );
/* first check for overrides in the registry */
@ -1022,7 +1022,7 @@ INT WINAPI GetLocaleInfoW( LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len )
}
HeapFree( GetProcessHeap(), 0, tmp );
TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning number %d\n",
TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning number %d\n",
lcid, lctype, buffer, len, number );
}
else
@ -1030,7 +1030,7 @@ INT WINAPI GetLocaleInfoW( LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len )
memcpy( buffer, p + 1, *p * sizeof(WCHAR) );
if (lctype != LOCALE_FONTSIGNATURE) buffer[ret-1] = 0;
TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning %d %s\n",
TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning %d %s\n",
lcid, lctype, buffer, len, ret, debugstr_w(buffer) );
}
return ret;
@ -1123,11 +1123,11 @@ BOOL WINAPI SetLocaleInfoW( LCID lcid, LCTYPE lctype, LPCWSTR data )
if (lcid != GetUserDefaultLCID())
{
/* Windows does not check that the lcid matches the current lcid */
WARN("locale 0x%08lx isn't the current locale (0x%08lx), setting anyway!\n",
WARN("locale 0x%08x isn't the current locale (0x%08x), setting anyway!\n",
lcid, GetUserDefaultLCID());
}
TRACE("setting %lx (%s) to %s\n", lctype, debugstr_w(value), debugstr_w(data) );
TRACE("setting %x (%s) to %s\n", lctype, debugstr_w(value), debugstr_w(data) );
/* FIXME: should check that data to set is sane */
@ -1700,7 +1700,7 @@ LCID WINAPI GetThreadLocale(void)
*/
BOOL WINAPI SetThreadLocale( LCID lcid )
{
TRACE("(0x%04lX)\n", lcid);
TRACE("(0x%04X)\n", lcid);
lcid = ConvertDefaultLocale(lcid);
@ -1840,7 +1840,7 @@ static BOOL CALLBACK enum_lang_proc_w( HMODULE hModule, LPCWSTR type,
*/
BOOL WINAPI EnumSystemLocalesA( LOCALE_ENUMPROCA lpfnLocaleEnum, DWORD dwFlags )
{
TRACE("(%p,%08lx)\n", lpfnLocaleEnum, dwFlags);
TRACE("(%p,%08x)\n", lpfnLocaleEnum, dwFlags);
EnumResourceLanguagesA( kernel32_handle, (LPSTR)RT_STRING,
(LPCSTR)LOCALE_ILANGUAGE, enum_lang_proc_a,
(LONG_PTR)lpfnLocaleEnum);
@ -1855,7 +1855,7 @@ BOOL WINAPI EnumSystemLocalesA( LOCALE_ENUMPROCA lpfnLocaleEnum, DWORD dwFlags )
*/
BOOL WINAPI EnumSystemLocalesW( LOCALE_ENUMPROCW lpfnLocaleEnum, DWORD dwFlags )
{
TRACE("(%p,%08lx)\n", lpfnLocaleEnum, dwFlags);
TRACE("(%p,%08x)\n", lpfnLocaleEnum, dwFlags);
EnumResourceLanguagesW( kernel32_handle, (LPWSTR)RT_STRING,
(LPCWSTR)LOCALE_ILANGUAGE, enum_lang_proc_w,
(LONG_PTR)lpfnLocaleEnum);
@ -1996,7 +1996,7 @@ BOOL WINAPI GetStringTypeA( LCID locale, DWORD type, LPCSTR src, INT count, LPWO
if (!(cp = get_lcid_codepage( locale )))
{
FIXME("For locale %04lx using current ANSI code page\n", locale);
FIXME("For locale %04x using current ANSI code page\n", locale);
cp = GetACP();
}
@ -2078,7 +2078,7 @@ INT WINAPI LCMapStringW(LCID lcid, DWORD flags, LPCWSTR src, INT srclen,
if (srclen < 0) srclen = strlenW(src);
TRACE("(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
TRACE("(0x%04x,0x%08x,%s,%d,%p,%d)\n",
lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
return wine_get_sortkey(flags, src, srclen, (char *)dst, dstlen);
@ -2093,7 +2093,7 @@ INT WINAPI LCMapStringW(LCID lcid, DWORD flags, LPCWSTR src, INT srclen,
if (srclen < 0) srclen = strlenW(src) + 1;
TRACE("(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
TRACE("(0x%04x,0x%08x,%s,%d,%p,%d)\n",
lcid, flags, debugstr_wn(src, srclen), srclen, dst, dstlen);
if (!dst) /* return required string length */
@ -2647,7 +2647,7 @@ static BOOL NLS_RegEnumSubKey(HANDLE hKey, UINT ulIndex, LPWSTR szKeyName,
return FALSE;
}
TRACE("info->Name %s info->NameLength %ld\n", debugstr_w(info->Name), info->NameLength);
TRACE("info->Name %s info->NameLength %d\n", debugstr_w(info->Name), info->NameLength);
memcpy( szKeyName, info->Name, info->NameLength);
szKeyName[info->NameLength / sizeof(WCHAR)] = '\0';
@ -2672,7 +2672,7 @@ static BOOL NLS_RegEnumValue(HANDLE hKey, UINT ulIndex,
return FALSE;
}
TRACE("info->Name %s info->DataLength %ld\n", debugstr_w(info->Name), info->DataLength);
TRACE("info->Name %s info->DataLength %d\n", debugstr_w(info->Name), info->DataLength);
memcpy( szValueName, info->Name, info->NameLength);
szValueName[info->NameLength / sizeof(WCHAR)] = '\0';
@ -2873,7 +2873,7 @@ BOOL WINAPI EnumSystemLanguageGroupsA(LANGUAGEGROUP_ENUMPROCA pLangGrpEnumProc,
{
ENUMLANGUAGEGROUP_CALLBACKS procs;
TRACE("(%p,0x%08lX,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
TRACE("(%p,0x%08X,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
procs.procA = pLangGrpEnumProc;
procs.procW = NULL;
@ -2893,7 +2893,7 @@ BOOL WINAPI EnumSystemLanguageGroupsW(LANGUAGEGROUP_ENUMPROCW pLangGrpEnumProc,
{
ENUMLANGUAGEGROUP_CALLBACKS procs;
TRACE("(%p,0x%08lX,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
TRACE("(%p,0x%08X,0x%08lX)\n", pLangGrpEnumProc, dwFlags, lParam);
procs.procA = NULL;
procs.procW = pLangGrpEnumProc;
@ -3003,7 +3003,7 @@ static BOOL NLS_EnumLanguageGroupLocales(ENUMLANGUAGEGROUPLOCALE_CALLBACKS *lpPr
{
lgrpid = strtoulW( szValue, NULL, 16 );
TRACE("lcid %s, grpid %ld (%smatched)\n", debugstr_w(szNumber),
TRACE("lcid %s, grpid %d (%smatched)\n", debugstr_w(szNumber),
lgrpid, lgrpid == lpProcs->lgrpid ? "" : "not ");
if (lgrpid == lpProcs->lgrpid)
@ -3075,7 +3075,7 @@ BOOL WINAPI EnumLanguageGroupLocalesA(LANGGROUPLOCALE_ENUMPROCA pLangGrpLcEnumPr
{
ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
TRACE("(%p,0x%08lX,0x%08lX,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
TRACE("(%p,0x%08X,0x%08X,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
callbacks.procA = pLangGrpLcEnumProc;
callbacks.procW = NULL;
@ -3096,7 +3096,7 @@ BOOL WINAPI EnumLanguageGroupLocalesW(LANGGROUPLOCALE_ENUMPROCW pLangGrpLcEnumPr
{
ENUMLANGUAGEGROUPLOCALE_CALLBACKS callbacks;
TRACE("(%p,0x%08lX,0x%08lX,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
TRACE("(%p,0x%08X,0x%08X,0x%08lX)\n", pLangGrpLcEnumProc, lgrpid, dwFlags, lParam);
callbacks.procA = NULL;
callbacks.procW = pLangGrpLcEnumProc;
@ -3130,7 +3130,7 @@ BOOL WINAPI EnumSystemGeoID(GEOCLASS geoclass, GEOID reserved, GEO_ENUMPROC pGeo
HANDLE hKey;
ULONG ulIndex = 0;
TRACE("(0x%08lX,0x%08lX,%p)\n", geoclass, reserved, pGeoEnumProc);
TRACE("(0x%08X,0x%08X,%p)\n", geoclass, reserved, pGeoEnumProc);
if (geoclass != GEOCLASS_NATION || reserved || !pGeoEnumProc)
{
@ -3150,7 +3150,7 @@ BOOL WINAPI EnumSystemGeoID(GEOCLASS geoclass, GEOID reserved, GEO_ENUMPROC pGeo
{
if (NLS_RegGetDword( hSubKey, szCountryCodeValueName, &dwGeoId ))
{
TRACE("Got geoid %ld\n", dwGeoId);
TRACE("Got geoid %d\n", dwGeoId);
if (!pGeoEnumProc( dwGeoId ))
bContinue = FALSE;
@ -3194,7 +3194,7 @@ BOOL WINAPI InvalidateNLSCache(void)
*/
GEOID WINAPI GetUserGeoID( GEOCLASS GeoClass )
{
FIXME("%ld\n",GeoClass);
FIXME("%d\n",GeoClass);
return GEOID_NOT_AVAILABLE;
}
@ -3203,7 +3203,7 @@ GEOID WINAPI GetUserGeoID( GEOCLASS GeoClass )
*/
BOOL WINAPI SetUserGeoID( GEOID GeoID )
{
FIXME("%ld\n",GeoID);
FIXME("%d\n",GeoID);
return FALSE;
}
@ -3246,7 +3246,7 @@ BOOL WINAPI EnumUILanguagesA(UILANGUAGE_ENUMPROCA pUILangEnumProc, DWORD dwFlags
{
ENUM_UILANG_CALLBACK enum_uilang;
TRACE("%p, %lx, %lx\n", pUILangEnumProc, dwFlags, lParam);
TRACE("%p, %x, %lx\n", pUILangEnumProc, dwFlags, lParam);
if(!pUILangEnumProc) {
SetLastError(ERROR_INVALID_PARAMETER);
@ -3274,7 +3274,7 @@ BOOL WINAPI EnumUILanguagesW(UILANGUAGE_ENUMPROCW pUILangEnumProc, DWORD dwFlags
{
ENUM_UILANG_CALLBACK enum_uilang;
TRACE("%p, %lx, %lx\n", pUILangEnumProc, dwFlags, lParam);
TRACE("%p, %x, %lx\n", pUILangEnumProc, dwFlags, lParam);
if(!pUILangEnumProc) {
@ -3299,13 +3299,13 @@ BOOL WINAPI EnumUILanguagesW(UILANGUAGE_ENUMPROCW pUILangEnumProc, DWORD dwFlags
INT WINAPI GetGeoInfoW(GEOID GeoId, GEOTYPE GeoType, LPWSTR lpGeoData,
int cchData, LANGID language)
{
FIXME("%ld %ld %p %d %d\n", GeoId, GeoType, lpGeoData, cchData, language);
FIXME("%d %d %p %d %d\n", GeoId, GeoType, lpGeoData, cchData, language);
return 0;
}
INT WINAPI GetGeoInfoA(GEOID GeoId, GEOTYPE GeoType, LPSTR lpGeoData,
int cchData, LANGID language)
{
FIXME("%ld %ld %p %d %d\n", GeoId, GeoType, lpGeoData, cchData, language);
FIXME("%d %d %p %d %d\n", GeoId, GeoType, lpGeoData, cchData, language);
return 0;
}

2
dlls/kernel32/lzexpand.c
View file

@ -416,7 +416,7 @@ LONG WINAPI LZSeek( HFILE fd, LONG off, INT type )
struct lzstate *lzs;
LONG newwanted;
TRACE("(%d,%ld,%d)\n",fd,off,type);
TRACE("(%d,%d,%d)\n",fd,off,type);
/* not compressed? just use normal _llseek() */
if (!(lzs = GET_LZ_STATE(fd))) return _llseek(fd,off,type);
newwanted = lzs->realwanted;

2
dlls/kernel32/module.c
View file

@ -526,7 +526,7 @@ BOOL WINAPI GetModuleHandleExW( DWORD flags, LPCWSTR name, HMODULE *module )
if ((flags & GET_MODULE_HANDLE_EX_FLAG_PIN) ||
!(flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
FIXME( "should update refcount, flags %lx\n", flags );
FIXME( "should update refcount, flags %x\n", flags );
if (module) *module = ret;
return TRUE;

2
dlls/kernel32/ne_module.c
View file

@ -1323,7 +1323,7 @@ DWORD NE_StartTask(void)
/* Now call 16-bit entry point */
TRACE("Starting main program: cs:ip=%04lx:%04lx ds=%04lx ss:sp=%04x:%04x\n",
TRACE("Starting main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
context.SegCs, context.Eip, context.SegDs,
SELECTOROF(NtCurrentTeb()->WOW32Reserved),
OFFSETOF(NtCurrentTeb()->WOW32Reserved) );

4
dlls/kernel32/ne_segment.c
View file

@ -552,7 +552,7 @@ static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum)
if (entry->segnum == segnum)
{
pFunc = ((BYTE *)pSeg+entry->offs);
TRACE("pFunc: %p, *(DWORD *)pFunc: %08lx, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
TRACE("pFunc: %p, *(DWORD *)pFunc: %08x, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
if (*(pFunc+2) == 0x90)
{
if (*(WORD *)pFunc == 0x581e) /* push ds, pop ax */
@ -697,7 +697,7 @@ static BOOL NE_InitDLL( NE_MODULE *pModule )
context.Ebp = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + (WORD)&((STACK16FRAME*)0)->bp;
pModule->ne_csip = 0; /* Don't initialize it twice */
TRACE_(dll)("Calling LibMain for %.*s, cs:ip=%04lx:%04lx ds=%04lx di=%04x cx=%04x\n",
TRACE_(dll)("Calling LibMain for %.*s, cs:ip=%04x:%04x ds=%04x di=%04x cx=%04x\n",
*((BYTE*)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1,
context.SegCs, context.Eip, context.SegDs,

6
dlls/kernel32/path.c
View file

@ -309,7 +309,7 @@ DWORD WINAPI GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath, DWORD longlen
return 0;
}
TRACE("%s,%p,%ld\n", debugstr_w(shortpath), longpath, longlen);
TRACE("%s,%p,%d\n", debugstr_w(shortpath), longpath, longlen);
if (shortpath[0] == '\\' && shortpath[1] == '\\')
{
@ -580,7 +580,7 @@ DWORD WINAPI GetTempPathW( DWORD count, LPWSTR path )
WCHAR tmp_path[MAX_PATH];
UINT ret;
TRACE("%lu,%p\n", count, path);
TRACE("%u,%p\n", count, path);
if (!(ret = GetEnvironmentVariableW( tmp, tmp_path, MAX_PATH )))
if (!(ret = GetEnvironmentVariableW( temp, tmp_path, MAX_PATH )))
@ -994,7 +994,7 @@ BOOL WINAPI MoveFileExW( LPCWSTR source, LPCWSTR dest, DWORD flag )
HANDLE source_handle = 0, dest_handle;
ANSI_STRING source_unix, dest_unix;
TRACE("(%s,%s,%04lx)\n", debugstr_w(source), debugstr_w(dest), flag);
TRACE("(%s,%s,%04x)\n", debugstr_w(source), debugstr_w(dest), flag);
if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
return add_boot_rename_entry( source, dest, flag );

2
dlls/kernel32/powermgnt.c
View file

@ -95,7 +95,7 @@ EXECUTION_STATE WINAPI SetThreadExecutionState(EXECUTION_STATE flags)
ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED | ES_USER_PRESENT;
EXECUTION_STATE old = current;
WARN("(0x%lx): stub, harmless.\n", flags);
WARN("(0x%x): stub, harmless.\n", flags);
if (!(current & ES_CONTINUOUS) || (flags & ES_CONTINUOUS))
current = flags;

20
dlls/kernel32/process.c
View file

@ -814,7 +814,7 @@ static void start_process( void *arg )
nt->OptionalHeader.AddressOfEntryPoint);
if (TRACE_ON(relay))
DPRINTF( "%04lx:Starting process %s (entryproc=%p)\n", GetCurrentThreadId(),
DPRINTF( "%04x:Starting process %s (entryproc=%p)\n", GetCurrentThreadId(),
debugstr_w(peb->ProcessParameters->ImagePathName.Buffer), entry );
SetLastError( 0 ); /* clear error code */
@ -1614,7 +1614,7 @@ BOOL WINAPI CreateProcessW( LPCWSTR app_name, LPWSTR cmd_line, LPSECURITY_ATTRIB
CREATE_NEW_PROCESS_GROUP | CREATE_SEPARATE_WOW_VDM | CREATE_SHARED_WOW_VDM |
CREATE_DEFAULT_ERROR_MODE | CREATE_NO_WINDOW |
PROFILE_USER | PROFILE_KERNEL | PROFILE_SERVER))
WARN("(%s,...): ignoring some flags in %lx\n", debugstr_w(name), flags);
WARN("(%s,...): ignoring some flags in %x\n", debugstr_w(name), flags);
if (cur_dir)
{
@ -1817,7 +1817,7 @@ UINT WINAPI WinExec( LPCSTR lpCmdLine, UINT nCmdShow )
{
/* Give 30 seconds to the app to come up */
if (wait_input_idle( info.hProcess, 30000 ) == WAIT_FAILED)
WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
WARN("WaitForInputIdle failed: Error %d\n", GetLastError() );
ret = 33;
/* Close off the handles */
CloseHandle( info.hThread );
@ -1875,7 +1875,7 @@ HINSTANCE WINAPI LoadModule( LPCSTR name, LPVOID paramBlock )
{
/* Give 30 seconds to the app to come up */
if (wait_input_idle( info.hProcess, 30000 ) == WAIT_FAILED)
WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
WARN("WaitForInputIdle failed: Error %d\n", GetLastError() );
hInstance = (HINSTANCE)33;
/* Close off the handles */
CloseHandle( info.hThread );
@ -2157,11 +2157,11 @@ DWORD WINAPI GetProcessDword( DWORD dwProcessID, INT offset )
DWORD x, y;
STARTUPINFOW siw;
TRACE("(%ld, %d)\n", dwProcessID, offset );
TRACE("(%d, %d)\n", dwProcessID, offset );
if (dwProcessID && dwProcessID != GetCurrentProcessId())
{
ERR("%d: process %lx not accessible\n", offset, dwProcessID);
ERR("%d: process %x not accessible\n", offset, dwProcessID);
return 0;
}
@ -2223,11 +2223,11 @@ DWORD WINAPI GetProcessDword( DWORD dwProcessID, INT offset )
*/
void WINAPI SetProcessDword( DWORD dwProcessID, INT offset, DWORD value )
{
TRACE("(%ld, %d)\n", dwProcessID, offset );
TRACE("(%d, %d)\n", dwProcessID, offset );
if (dwProcessID && dwProcessID != GetCurrentProcessId())
{
ERR("%d: process %lx not accessible\n", offset, dwProcessID);
ERR("%d: process %x not accessible\n", offset, dwProcessID);
return;
}
@ -2470,7 +2470,7 @@ HANDLE WINAPI ConvertToGlobalHandle(HANDLE hSrc)
*/
BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context)
{
FIXME("(%p,%ld), stub. In case this got called by WSOCK32/WS2_32: "
FIXME("(%p,%d), stub. In case this got called by WSOCK32/WS2_32: "
"the external WINSOCK DLLs won't work with WINE, don't use them.\n",hnd,context);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
@ -2675,7 +2675,7 @@ BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T minset,
*/
BOOL WINAPI SetProcessShutdownParameters(DWORD level, DWORD flags)
{
FIXME("(%08lx, %08lx): partial stub.\n", level, flags);
FIXME("(%08x, %08x): partial stub.\n", level, flags);
shutdown_flags = flags;
shutdown_priority = level;
return TRUE;

8
dlls/kernel32/profile.c
View file

@ -333,7 +333,7 @@ static PROFILESECTION *PROFILE_Load(HANDLE hFile, ENCODING * pEncoding)
if (!ReadFile(hFile, pBuffer, dwFileSize, &dwFileSize, NULL))
{
HeapFree(GetProcessHeap(), 0, pBuffer);
WARN("Error %ld reading file\n", GetLastError());
WARN("Error %d reading file\n", GetLastError());
return NULL;
}
len = dwFileSize;
@ -670,7 +670,7 @@ static BOOL PROFILE_FlushFile(void)
if (hFile == INVALID_HANDLE_VALUE)
{
WARN("could not save profile file %s (error was %ld)\n", debugstr_w(CurProfile->filename), GetLastError());
WARN("could not save profile file %s (error was %d)\n", debugstr_w(CurProfile->filename), GetLastError());
return FALSE;
}
@ -757,7 +757,7 @@ static BOOL PROFILE_Open( LPCWSTR filename )
if ((hFile == INVALID_HANDLE_VALUE) && (GetLastError() != ERROR_FILE_NOT_FOUND))
{
WARN("Error %ld opening file %s\n", GetLastError(), debugstr_w(buffer));
WARN("Error %d opening file %s\n", GetLastError(), debugstr_w(buffer));
return FALSE;
}
@ -1330,7 +1330,7 @@ INT WINAPI GetPrivateProfileSectionW( LPCWSTR section, LPWSTR buffer,
{
int ret = 0;
TRACE("(%s, %p, %ld, %s)\n", debugstr_w(section), buffer, len, debugstr_w(filename));
TRACE("(%s, %p, %d, %s)\n", debugstr_w(section), buffer, len, debugstr_w(filename));
RtlEnterCriticalSection( &PROFILE_CritSect );

8
dlls/kernel32/relay16.c
View file

@ -418,7 +418,7 @@ int relay_call_from_16( void *entry_point, unsigned char *args16, CONTEXT86 *con
if (!TRACE_ON(relay) || !RELAY_ShowDebugmsgRelay( module, ordinal, func ))
return relay_call_from_16_no_debug( entry_point, args16, context, call );
DPRINTF( "%04lx:Call %s.%d: %s(",GetCurrentThreadId(), module, ordinal, func );
DPRINTF( "%04x:Call %s.%d: %s(",GetCurrentThreadId(), module, ordinal, func );
/* look for the ret instruction */
for (j = 0; j < sizeof(call->ret)/sizeof(call->ret[0]); j++)
@ -534,7 +534,7 @@ int relay_call_from_16( void *entry_point, unsigned char *args16, CONTEXT86 *con
if (!j) /* register function */
{
args32[nb_args++] = (int)context;
DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08x\n",
(WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
(WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
(WORD)context->SegEs, context->EFlags );
@ -546,12 +546,12 @@ int relay_call_from_16( void *entry_point, unsigned char *args16, CONTEXT86 *con
SYSLEVEL_CheckNotLevel( 2 );
DPRINTF( "%04lx:Ret %s.%d: %s() ",GetCurrentThreadId(), module, ordinal, func );
DPRINTF( "%04x:Ret %s.%d: %s() ",GetCurrentThreadId(), module, ordinal, func );
if (!j) /* register function */
{
DPRINTF("retval=none ret=%04x:%04x ds=%04x\n",
(WORD)context->SegCs, LOWORD(context->Eip), (WORD)context->SegDs);
DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08x\n",
(WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
(WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
(WORD)context->SegEs, context->EFlags );

2
dlls/kernel32/resource.c
View file

@ -834,7 +834,7 @@ BOOL WINAPI UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName,
QUEUEDRESOURCE *current_resource = NULL;
BOOL ret = FALSE;
TRACE("%p %s %s %08x %p %ld\n",hUpdate,debugstr_w(lpType),debugstr_w(lpName),wLanguage,lpData,cbData);
TRACE("%p %s %s %08x %p %d\n",hUpdate,debugstr_w(lpType),debugstr_w(lpName),wLanguage,lpData,cbData);
if(!(current_updates = GlobalLock(hUpdate)))
{

2
dlls/kernel32/resource16.c
View file

@ -873,7 +873,7 @@ HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
NE_MODULE *pModule = NE_GetPtr( hModule );
if (!pModule || !pModule->ne_rsrctab || !hRsrc) return 0;
TRACE("module=%04x res=%04x size=%ld\n", hModule, hRsrc, size );
TRACE("module=%04x res=%04x size=%d\n", hModule, hRsrc, size );
sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);

6
dlls/kernel32/snoop16.c
View file

@ -260,7 +260,7 @@ void WINAPI SNOOP16_Entry(FARPROC proc, LPBYTE args, CONTEXT86 *context) {
dll=dll->next;
}
if (!dll) {
FIXME("entrypoint 0x%08lx not found\n",entry);
FIXME("entrypoint 0x%08x not found\n",entry);
return; /* oops */
}
while (*rets) {
@ -291,7 +291,7 @@ void WINAPI SNOOP16_Entry(FARPROC proc, LPBYTE args, CONTEXT86 *context) {
context->SegCs = HIWORD(fun->origfun);
DPRINTF("%04lx:CALL %s.%ld: %s(",GetCurrentThreadId(), dll->name,ordinal,fun->name);
DPRINTF("%04x:CALL %s.%d: %s(",GetCurrentThreadId(), dll->name,ordinal,fun->name);
if (fun->nrofargs>0) {
max = fun->nrofargs;
if (max>16) max=16;
@ -320,7 +320,7 @@ void WINAPI SNOOP16_Return(FARPROC proc, LPBYTE args, CONTEXT86 *context) {
}
context->Eip = LOWORD(ret->origreturn);
context->SegCs = HIWORD(ret->origreturn);
DPRINTF("%04lx:RET %s.%ld: %s(",
DPRINTF("%04x:RET %s.%d: %s(",
GetCurrentThreadId(),ret->dll->name,ret->ordinal,
ret->dll->funs[ret->ordinal].name);
if (ret->args) {

4
dlls/kernel32/stress.c
View file

@ -30,7 +30,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(stress);
*/
INT16 WINAPI AllocDiskSpace(LONG lLeft, UINT16 uDrive)
{
FIXME("(%d, %ld) - stub\n",
FIXME("(%d, %d) - stub\n",
uDrive, lLeft);
return 1;
@ -64,7 +64,7 @@ BOOL16 WINAPI AllocGDIMem(UINT16 uLeft)
*/
BOOL16 WINAPI AllocMem(DWORD dwLeft)
{
FIXME("(%ld) - stub\n", dwLeft);
FIXME("(%d) - stub\n", dwLeft);
return 1;
}

36
dlls/kernel32/sync.c
View file

@ -270,7 +270,7 @@ BOOL WINAPI RegisterWaitForSingleObject(PHANDLE phNewWaitObject, HANDLE hObject,
WAITORTIMERCALLBACK Callback, PVOID Context,
ULONG dwMilliseconds, ULONG dwFlags)
{
FIXME("%p %p %p %p %ld %ld\n",
FIXME("%p %p %p %p %d %d\n",
phNewWaitObject,hObject,Callback,Context,dwMilliseconds,dwFlags);
return FALSE;
}
@ -282,7 +282,7 @@ HANDLE WINAPI RegisterWaitForSingleObjectEx( HANDLE hObject,
WAITORTIMERCALLBACK Callback, PVOID Context,
ULONG dwMilliseconds, ULONG dwFlags )
{
FIXME("%p %p %p %ld %ld\n",
FIXME("%p %p %p %d %d\n",
hObject,Callback,Context,dwMilliseconds,dwFlags);
return 0;
}
@ -317,7 +317,7 @@ DWORD WINAPI SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn
NTSTATUS status;
LARGE_INTEGER timeout, *ptimeout = NULL;
TRACE("%p %p %ld %d\n", hObjectToSignal,
TRACE("%p %p %d %d\n", hObjectToSignal,
hObjectToWaitOn, dwMilliseconds, bAlertable);
if (dwMilliseconds != INFINITE)
@ -1133,7 +1133,7 @@ HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
IO_STATUS_BLOCK iosb;
LARGE_INTEGER timeout;
TRACE("(%s, %#08lx, %#08lx, %ld, %ld, %ld, %ld, %p)\n",
TRACE("(%s, %#08x, %#08x, %d, %d, %d, %d, %p)\n",
debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
nOutBufferSize, nInBufferSize, nDefaultTimeOut, sa );
@ -1197,7 +1197,7 @@ BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
#ifdef FIONREAD
int avail=0, fd, ret, flags;
TRACE("(%p,%p,%lu,%p,%p,%p)\n", hPipe, lpvBuffer, cbBuffer, lpcbRead, lpcbAvail, lpcbMessage);
TRACE("(%p,%p,%u,%p,%p,%p)\n", hPipe, lpvBuffer, cbBuffer, lpcbRead, lpcbAvail, lpcbMessage);
ret = wine_server_handle_to_fd( hPipe, FILE_READ_DATA, &fd, &flags );
if (ret)
@ -1307,7 +1307,7 @@ BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
ULONG sz_pipe_wait;
HANDLE pipe_dev;
TRACE("%s 0x%08lx\n",debugstr_w(name),nTimeOut);
TRACE("%s 0x%08x\n",debugstr_w(name),nTimeOut);
if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
return FALSE;
@ -1436,7 +1436,7 @@ BOOL WINAPI TransactNamedPipe(
BOOL r;
DWORD count;
TRACE("%p %p %ld %p %ld %p %p\n",
TRACE("%p %p %d %p %d %p %p\n",
handle, lpInput, dwInputSize, lpOutput,
dwOutputSize, lpBytesRead, lpOverlapped);
@ -1495,7 +1495,7 @@ BOOL WINAPI GetNamedPipeHandleStateA(
LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
LPSTR lpUsername, DWORD nUsernameMaxSize)
{
FIXME("%p %p %p %p %p %p %ld\n",
FIXME("%p %p %p %p %p %p %d\n",
hNamedPipe, lpState, lpCurInstances,
lpMaxCollectionCount, lpCollectDataTimeout,
lpUsername, nUsernameMaxSize);
@ -1511,7 +1511,7 @@ BOOL WINAPI GetNamedPipeHandleStateW(
LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
LPWSTR lpUsername, DWORD nUsernameMaxSize)
{
FIXME("%p %p %p %p %p %p %ld\n",
FIXME("%p %p %p %p %p %p %d\n",
hNamedPipe, lpState, lpCurInstances,
lpMaxCollectionCount, lpCollectDataTimeout,
lpUsername, nUsernameMaxSize);
@ -1528,7 +1528,7 @@ BOOL WINAPI SetNamedPipeHandleState(
{
/* should be a fixme, but this function is called a lot by the RPC
* runtime, and it slows down InstallShield a fair bit. */
WARN("stub: %p %p/%ld %p %p\n",
WARN("stub: %p %p/%d %p %p\n",
hNamedPipe, lpMode, lpMode ? *lpMode : 0, lpMaxCollectionCount, lpCollectDataTimeout);
return FALSE;
}
@ -1545,7 +1545,7 @@ BOOL WINAPI CallNamedPipeA(
LPWSTR str = NULL;
BOOL ret;
TRACE("%s %p %ld %p %ld %p %ld\n",
TRACE("%s %p %d %p %d %p %d\n",
debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
lpOutput, dwOutputSize, lpBytesRead, nTimeout);
@ -1571,7 +1571,7 @@ BOOL WINAPI CallNamedPipeW(
LPVOID lpOutput, DWORD lpOutputSize,
LPDWORD lpBytesRead, DWORD nTimeout)
{
FIXME("%s %p %ld %p %ld %p %ld\n",
FIXME("%s %p %d %p %d %p %d\n",
debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
lpOutput, lpOutputSize, lpBytesRead, nTimeout);
return FALSE;
@ -1657,7 +1657,7 @@ HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
HANDLE handle;
LPWSTR name = NULL;
TRACE("%s %ld %ld %p\n", debugstr_a(lpName),
TRACE("%s %d %d %p\n", debugstr_a(lpName),
nMaxMessageSize, lReadTimeout, sa);
if( lpName )
@ -1700,7 +1700,7 @@ HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
IO_STATUS_BLOCK iosb;
NTSTATUS status;
TRACE("%s %ld %ld %p\n", debugstr_w(lpName),
TRACE("%s %d %d %p\n", debugstr_w(lpName),
nMaxMessageSize, lReadTimeout, sa);
if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
@ -1809,7 +1809,7 @@ BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
IO_STATUS_BLOCK iosb;
NTSTATUS status;
TRACE("%p %ld\n", hMailslot, dwReadTimeout);
TRACE("%p %d\n", hMailslot, dwReadTimeout);
info.ReadTimeout.QuadPart = dwReadTimeout * -10000;
status = NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
@ -1829,7 +1829,7 @@ BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
ULONG_PTR CompletionKey, DWORD dwNumberOfConcurrentThreads)
{
FIXME("(%p, %p, %08lx, %08lx): stub.\n",
FIXME("(%p, %p, %08lx, %08x): stub.\n",
hFileHandle, hExistingCompletionPort, CompletionKey, dwNumberOfConcurrentThreads);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
@ -1843,7 +1843,7 @@ BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOf
PULONG_PTR pCompletionKey, LPOVERLAPPED *lpOverlapped,
DWORD dwMilliseconds )
{
FIXME("(%p,%p,%p,%p,%ld), stub!\n",
FIXME("(%p,%p,%p,%p,%d), stub!\n",
CompletionPort,lpNumberOfBytesTransferred,pCompletionKey,lpOverlapped,dwMilliseconds);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
@ -1852,7 +1852,7 @@ BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOf
BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytes,
ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped)
{
FIXME("%p %ld %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
FIXME("%p %d %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}

10
dlls/kernel32/syslevel.c
View file

@ -91,7 +91,7 @@ VOID WINAPI _EnterSysLevel(SYSLEVEL *lock)
struct kernel_thread_data *thread_data = kernel_get_thread_data();
int i;
TRACE("(%p, level %d): thread %lx count before %ld\n",
TRACE("(%p, level %d): thread %x count before %d\n",
lock, lock->level, GetCurrentThreadId(), thread_data->sys_count[lock->level] );
for ( i = 3; i > lock->level; i-- )
@ -106,7 +106,7 @@ VOID WINAPI _EnterSysLevel(SYSLEVEL *lock)
thread_data->sys_count[lock->level]++;
thread_data->sys_mutex[lock->level] = lock;
TRACE("(%p, level %d): thread %lx count after %ld\n",
TRACE("(%p, level %d): thread %x count after %d\n",
lock, lock->level, GetCurrentThreadId(), thread_data->sys_count[lock->level] );
#ifdef __i386__
@ -122,12 +122,12 @@ VOID WINAPI _LeaveSysLevel(SYSLEVEL *lock)
{
struct kernel_thread_data *thread_data = kernel_get_thread_data();
TRACE("(%p, level %d): thread %lx count before %ld\n",
TRACE("(%p, level %d): thread %x count before %d\n",
lock, lock->level, GetCurrentThreadId(), thread_data->sys_count[lock->level] );
if ( thread_data->sys_count[lock->level] <= 0 || thread_data->sys_mutex[lock->level] != lock )
{
ERR("(%p, level %d): Invalid state: count %ld mutex %p.\n",
ERR("(%p, level %d): Invalid state: count %d mutex %p.\n",
lock, lock->level, thread_data->sys_count[lock->level],
thread_data->sys_mutex[lock->level] );
}
@ -139,7 +139,7 @@ VOID WINAPI _LeaveSysLevel(SYSLEVEL *lock)
RtlLeaveCriticalSection( &lock->crst );
TRACE("(%p, level %d): thread %lx count after %ld\n",
TRACE("(%p, level %d): thread %x count after %d\n",
lock, lock->level, GetCurrentThreadId(), thread_data->sys_count[lock->level] );
}

26
dlls/kernel32/tape.c
View file

@ -51,7 +51,7 @@ static DWORD set_error_from_status( NTSTATUS status )
BOOL WINAPI BackupRead( HANDLE file, LPBYTE buffer, DWORD to_read,
LPDWORD read, BOOL abort, BOOL security, LPVOID *context )
{
FIXME( "(%p, %p, %ld, %p, %d, %d, %p)\n", file, buffer,
FIXME( "(%p, %p, %d, %p, %d, %d, %p)\n", file, buffer,
to_read, read, abort, security, context );
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
@ -66,7 +66,7 @@ BOOL WINAPI BackupRead( HANDLE file, LPBYTE buffer, DWORD to_read,
BOOL WINAPI BackupSeek( HANDLE file, DWORD seek_low, DWORD seek_high,
LPDWORD seeked_low, LPDWORD seeked_high, LPVOID *context )
{
FIXME( "(%p, %ld, %ld, %p, %p, %p)\n", file, seek_low,
FIXME( "(%p, %d, %d, %p, %p, %p)\n", file, seek_low,
seek_high, seeked_low, seeked_high, context );
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
@ -81,7 +81,7 @@ BOOL WINAPI BackupSeek( HANDLE file, DWORD seek_low, DWORD seek_high,
BOOL WINAPI BackupWrite( HANDLE file, LPBYTE buffer, DWORD to_write,
LPDWORD written, BOOL abort, BOOL security, LPVOID *context )
{
FIXME( "(%p, %p, %ld, %p, %d, %d, %p)\n", file, buffer,
FIXME( "(%p, %p, %d, %p, %d, %d, %p)\n", file, buffer,
to_write, written, abort, security, context );
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
@ -100,7 +100,7 @@ DWORD WINAPI CreateTapePartition( HANDLE device, DWORD method,
TAPE_CREATE_PARTITION part;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %ld, %ld)\n", device, method, count, size );
TRACE( "(%p, %d, %d, %d)\n", device, method, count, size );
part.Method = method;
part.Count = count;
@ -124,7 +124,7 @@ DWORD WINAPI EraseTape( HANDLE device, DWORD type, BOOL immediate )
TAPE_ERASE erase;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %d)\n", device, type, immediate );
TRACE( "(%p, %d, %d)\n", device, type, immediate );
erase.Type = type;
erase.Immediate = immediate;
@ -147,7 +147,7 @@ DWORD WINAPI GetTapeParameters( HANDLE device, DWORD operation,
NTSTATUS status = STATUS_INVALID_PARAMETER;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %p, %p)\n", device, operation, size, info );
TRACE( "(%p, %d, %p, %p)\n", device, operation, size, info );
switch (operation)
{
@ -160,7 +160,7 @@ DWORD WINAPI GetTapeParameters( HANDLE device, DWORD operation,
IOCTL_TAPE_GET_MEDIA_PARAMS, NULL, 0, info, *size );
break;
default:
ERR( "Unhandled operation: 0x%08lx\n", operation );
ERR( "Unhandled operation: 0x%08x\n", operation );
}
return set_error_from_status( status );
@ -179,7 +179,7 @@ DWORD WINAPI GetTapePosition( HANDLE device, DWORD type, LPDWORD partition,
TAPE_GET_POSITION in, out;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %p, %p, %p)\n", device, type, partition, offset_low,
TRACE( "(%p, %d, %p, %p, %p)\n", device, type, partition, offset_low,
offset_high );
memset( &in, 0, sizeof(TAPE_GET_POSITION) );
@ -230,7 +230,7 @@ DWORD WINAPI PrepareTape( HANDLE device, DWORD operation, BOOL immediate )
TAPE_PREPARE prep;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %d)\n", device, operation, immediate );
TRACE( "(%p, %d, %d)\n", device, operation, immediate );
prep.Operation = operation;
prep.Immediate = immediate;
@ -252,7 +252,7 @@ DWORD WINAPI SetTapeParameters( HANDLE device, DWORD operation, LPVOID info )
NTSTATUS status = STATUS_INVALID_PARAMETER;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %p)\n", device, operation, info );
TRACE( "(%p, %d, %p)\n", device, operation, info );
switch (operation)
{
@ -267,7 +267,7 @@ DWORD WINAPI SetTapeParameters( HANDLE device, DWORD operation, LPVOID info )
NULL, 0 );
break;
default:
ERR( "Unhandled operation: 0x%08lx\n", operation );
ERR( "Unhandled operation: 0x%08x\n", operation );
}
return set_error_from_status( status );
@ -286,7 +286,7 @@ DWORD WINAPI SetTapePosition( HANDLE device, DWORD method, DWORD partition,
TAPE_SET_POSITION pos;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %ld, %ld, %ld, %d)\n", device, method, partition,
TRACE( "(%p, %d, %d, %d, %d, %d)\n", device, method, partition,
offset_low, offset_high, immediate );
pos.Method = method;
@ -314,7 +314,7 @@ DWORD WINAPI WriteTapemark( HANDLE device, DWORD type, DWORD count,
TAPE_WRITE_MARKS marks;
IO_STATUS_BLOCK io;
TRACE( "(%p, %ld, %ld, %d)\n", device, type, count, immediate );
TRACE( "(%p, %d, %d, %d)\n", device, type, count, immediate );
marks.Type = type;
marks.Count = count;

6
dlls/kernel32/task.c
View file

@ -687,7 +687,7 @@ BOOL16 WINAPI WaitEvent16( HTASK16 hTask )
if (pTask->flags & TDBF_WIN32)
{
FIXME("called for Win32 thread (%04lx)!\n", GetCurrentThreadId());
FIXME("called for Win32 thread (%04x)!\n", GetCurrentThreadId());
return TRUE;
}
@ -726,7 +726,7 @@ void WINAPI PostEvent16( HTASK16 hTask )
if (pTask->flags & TDBF_WIN32)
{
FIXME("called for Win32 thread (%04lx)!\n", (DWORD)pTask->teb->ClientId.UniqueThread );
FIXME("called for Win32 thread (%04x)!\n", (DWORD)pTask->teb->ClientId.UniqueThread );
return;
}
@ -885,7 +885,7 @@ FARPROC16 WINAPI MakeProcInstance16( FARPROC16 func, HANDLE16 hInstance )
thunk = MapSL( thunkaddr );
lfunc = MapSL( (SEGPTR)func );
TRACE("(%p,%04x): got thunk %08lx\n", func, hInstance, thunkaddr );
TRACE("(%p,%04x): got thunk %08x\n", func, hInstance, thunkaddr );
if (((lfunc[0]==0x8c) && (lfunc[1]==0xd8)) || /* movw %ds, %ax */
((lfunc[0]==0x1e) && (lfunc[1]==0x58)) /* pushw %ds, popw %ax */
) {

8
dlls/kernel32/thread.c
View file

@ -69,7 +69,7 @@ static void CALLBACK THREAD_Start( void *ptr )
RtlFreeHeap( GetProcessHeap(), 0, info );
if (TRACE_ON(relay))
DPRINTF("%04lx:Starting thread (entryproc=%p)\n", GetCurrentThreadId(), func );
DPRINTF("%04x:Starting thread (entryproc=%p)\n", GetCurrentThreadId(), func );
__TRY
{
@ -506,7 +506,7 @@ BOOL WINAPI QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, U
{
NTSTATUS status;
TRACE("(%p,%p,0x%08lx)\n", Function, Context, Flags);
TRACE("(%p,%p,0x%08x)\n", Function, Context, Flags);
status = RtlQueueWorkItem( Function, Context, Flags );
@ -568,7 +568,7 @@ BOOL WINAPI GetThreadTimes(
*/
VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
{
FIXME("(0x%08lx,%d): stub\n", threadId, boost);
FIXME("(0x%08x,%d): stub\n", threadId, boost);
}
@ -577,7 +577,7 @@ VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
*/
VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
{
FIXME("(0x%08lx,%d): stub\n", threadId, boost);
FIXME("(0x%08x,%d): stub\n", threadId, boost);
}

42
dlls/kernel32/thunk.c
View file

@ -305,14 +305,14 @@ static LPVOID _loadthunk(LPCSTR module, LPCSTR func, LPCSTR module32,
if (TD32 && TD16->checksum != TD32->checksum)
{
ERR("(%s, %s, %s): Wrong checksum %08lx (should be %08lx)\n",
ERR("(%s, %s, %s): Wrong checksum %08x (should be %08x)\n",
module, func, module32, TD16->checksum, TD32->checksum);
return 0;
}
if (!TD32 && checksum && checksum != *(LPDWORD)TD16)
{
ERR("(%s, %s, %s): Wrong checksum %08lx (should be %08lx)\n",
ERR("(%s, %s, %s): Wrong checksum %08x (should be %08x)\n",
module, func, module32, *(LPDWORD)TD16, checksum);
return 0;
}
@ -355,14 +355,14 @@ UINT WINAPI ThunkConnect32(
{
directionSL = TRUE;
TRACE("SL01 thunk %s (%p) <- %s (%s), Reason: %ld\n",
TRACE("SL01 thunk %s (%p) <- %s (%s), Reason: %d\n",
module32, TD, module16, thunkfun16, dwReason);
}
else if (!strncmp(TD->magic, "LS01", 4))
{
directionSL = FALSE;
TRACE("LS01 thunk %s (%p) -> %s (%s), Reason: %ld\n",
TRACE("LS01 thunk %s (%p) -> %s (%s), Reason: %d\n",
module32, TD, module16, thunkfun16, dwReason);
}
else
@ -401,7 +401,7 @@ UINT WINAPI ThunkConnect32(
tdb->next = SL32->data->targetDB; /* FIXME: not thread-safe! */
SL32->data->targetDB = tdb;
TRACE("Process %08lx allocated TargetDB entry for ThunkDataSL %p\n",
TRACE("Process %08x allocated TargetDB entry for ThunkDataSL %p\n",
GetCurrentProcessId(), SL32->data);
}
else
@ -1057,9 +1057,9 @@ DWORD WINAPIV SSCall(
if(TRACE_ON(thunk))
{
DPRINTF("(%ld,0x%08lx,%p,[",nr,flags,fun);
DPRINTF("(%d,0x%08x,%p,[",nr,flags,fun);
for (i=0;i<nr/4;i++)
DPRINTF("0x%08lx,",args[i]);
DPRINTF("0x%08x,",args[i]);
DPRINTF("])\n");
}
switch (nr) {
@ -1090,12 +1090,12 @@ DWORD WINAPIV SSCall(
case 48: ret = fun(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
break;
default:
WARN("Unsupported nr of arguments, %ld\n",nr);
WARN("Unsupported nr of arguments, %d\n",nr);
ret = 0;
break;
}
TRACE(" returning %ld ...\n",ret);
TRACE(" returning %d ...\n",ret);
return ret;
}
@ -1182,7 +1182,7 @@ void WINAPI
FreeSLCallback(
DWORD x /* [in] 16 bit callback (segmented pointer?) */
) {
FIXME("(0x%08lx): stub\n",x);
FIXME("(0x%08x): stub\n",x);
}
@ -1269,7 +1269,7 @@ void WINAPI __regs_K32Thk1632Prolog( CONTEXT86 *context )
WORD stackSel = SELECTOROF(frame32->frame16);
DWORD stackBase = GetSelectorBase(stackSel);
TRACE("before SYSTHUNK hack: EBP: %08lx ESP: %08lx cur_stack: %p\n",
TRACE("before SYSTHUNK hack: EBP: %08x ESP: %08x cur_stack: %p\n",
context->Ebp, context->Esp, NtCurrentTeb()->WOW32Reserved);
memset(frame16, '\0', sizeof(STACK16FRAME));
@ -1282,7 +1282,7 @@ void WINAPI __regs_K32Thk1632Prolog( CONTEXT86 *context )
context->Esp = (DWORD)stack32 + 4;
context->Ebp = context->Esp + argSize;
TRACE("after SYSTHUNK hack: EBP: %08lx ESP: %08lx cur_stack: %p\n",
TRACE("after SYSTHUNK hack: EBP: %08x ESP: %08x cur_stack: %p\n",
context->Ebp, context->Esp, NtCurrentTeb()->WOW32Reserved);
}
@ -1315,7 +1315,7 @@ void WINAPI __regs_K32Thk1632Epilog( CONTEXT86 *context )
DWORD nArgsPopped = context->Esp - (DWORD)stack32;
TRACE("before SYSTHUNK hack: EBP: %08lx ESP: %08lx cur_stack: %p\n",
TRACE("before SYSTHUNK hack: EBP: %08x ESP: %08x cur_stack: %p\n",
context->Ebp, context->Esp, NtCurrentTeb()->WOW32Reserved);
NtCurrentTeb()->WOW32Reserved = frame16->frame32;
@ -1323,7 +1323,7 @@ void WINAPI __regs_K32Thk1632Epilog( CONTEXT86 *context )
context->Esp = (DWORD)stack16 + nArgsPopped;
context->Ebp = frame16->ebp;
TRACE("after SYSTHUNK hack: EBP: %08lx ESP: %08lx cur_stack: %p\n",
TRACE("after SYSTHUNK hack: EBP: %08x ESP: %08x cur_stack: %p\n",
context->Ebp, context->Esp, NtCurrentTeb()->WOW32Reserved);
}
}
@ -1374,14 +1374,14 @@ UINT WINAPI ThunkConnect16(
{
directionSL = TRUE;
TRACE("SL01 thunk %s (%p) -> %s (%s), Reason: %ld\n",
TRACE("SL01 thunk %s (%p) -> %s (%s), Reason: %d\n",
module16, TD, module32, thunkfun32, dwReason);
}
else if (!strncmp(TD->magic, "LS01", 4))
{
directionSL = FALSE;
TRACE("LS01 thunk %s (%p) <- %s (%s), Reason: %ld\n",
TRACE("LS01 thunk %s (%p) <- %s (%s), Reason: %d\n",
module16, TD, module32, thunkfun32, dwReason);
}
else
@ -1551,7 +1551,7 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
DWORD targetNr = LOWORD(context->Ecx) / 4;
struct SLTargetDB *tdb;
TRACE("Process %08lx calling target %ld of ThunkDataSL %p\n",
TRACE("Process %08x calling target %d of ThunkDataSL %p\n",
GetCurrentProcessId(), targetNr, td);
for (tdb = td->targetDB; tdb; tdb = tdb->next)
@ -1572,7 +1572,7 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
{
context->Edx = tdb->targetTable[targetNr];
TRACE("Call target is %08lx\n", context->Edx);
TRACE("Call target is %08x\n", context->Edx);
}
else
{
@ -1583,7 +1583,7 @@ void WINAPI C16ThkSL01(CONTEXT86 *context)
context->SegCs = stack[3];
context->Esp += td->apiDB[targetNr].nrArgBytes + 4;
ERR("Process %08lx did not ThunkConnect32 %s to %s\n",
ERR("Process %08x did not ThunkConnect32 %s to %s\n",
GetCurrentProcessId(), td->pszDll32, td->pszDll16);
}
}
@ -2157,7 +2157,7 @@ void WINAPI HouseCleanLogicallyDeadHandles(void)
*/
BOOL WINAPI _KERNEL32_100(HANDLE threadid,DWORD exitcode,DWORD x)
{
FIXME("(%p,%ld,0x%08lx): stub\n",threadid,exitcode,x);
FIXME("(%p,%d,0x%08x): stub\n",threadid,exitcode,x);
return TRUE;
}
@ -2170,7 +2170,7 @@ BOOL WINAPI _KERNEL32_100(HANDLE threadid,DWORD exitcode,DWORD x)
*/
DWORD WINAPI _KERNEL32_99(DWORD x)
{
FIXME("(0x%08lx): stub\n",x);
FIXME("(0x%08x): stub\n",x);
return 1;
}

16
dlls/kernel32/time.c
View file

@ -370,7 +370,7 @@ BOOL WINAPI SetSystemTime( const SYSTEMTIME *systime )
BOOL WINAPI SetSystemTimeAdjustment( DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled )
{
/* Fake function for now... */
FIXME("(%08lx,%d): stub !\n", dwTimeAdjustment, bTimeAdjustmentDisabled);
FIXME("(%08x,%d): stub !\n", dwTimeAdjustment, bTimeAdjustmentDisabled);
return TRUE;
}
@ -649,16 +649,16 @@ int WINAPI GetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType,
* for the CALTYPES not requiring GetLocaleInfoA */
switch (CalType & ~(CAL_NOUSEROVERRIDE|CAL_RETURN_NUMBER|CAL_USE_CP_ACP)) {
case CAL_ICALINTVALUE:
FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
FIXME("Unimplemented caltype %d\n", CalType & 0xffff);
return E_FAIL;
case CAL_SCALNAME:
FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
FIXME("Unimplemented caltype %d\n", CalType & 0xffff);
return E_FAIL;
case CAL_IYEAROFFSETRANGE:
FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
FIXME("Unimplemented caltype %d\n", CalType & 0xffff);
return E_FAIL;
case CAL_SERASTRING:
FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
FIXME("Unimplemented caltype %d\n", CalType & 0xffff);
return E_FAIL;
case CAL_SSHORTDATE:
return GetLocaleInfoW(Locale, LOCALE_SSHORTDATE, lpCalData, cchData);
@ -749,7 +749,7 @@ int WINAPI GetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType,
case CAL_ITWODIGITYEARMAX:
if (lpValue) *lpValue = CALINFO_MAX_YEAR;
break;
default: MESSAGE("Unknown caltype %ld\n",CalType & 0xffff);
default: MESSAGE("Unknown caltype %d\n",CalType & 0xffff);
return E_FAIL;
}
return 0;
@ -761,7 +761,7 @@ int WINAPI GetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType,
*/
int WINAPI SetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData)
{
FIXME("(%08lx,%08lx,%08lx,%s): stub\n",
FIXME("(%08x,%08x,%08x,%s): stub\n",
Locale, Calendar, CalType, debugstr_a(lpCalData));
return 0;
}
@ -773,7 +773,7 @@ int WINAPI SetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR
*/
int WINAPI SetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData)
{
FIXME("(%08lx,%08lx,%08lx,%s): stub\n",
FIXME("(%08x,%08x,%08x,%s): stub\n",
Locale, Calendar, CalType, debugstr_w(lpCalData));
return 0;
}

12
dlls/kernel32/toolhelp.c
View file

@ -297,10 +297,10 @@ HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
ULONG num_pcs, num_thd, num_mod;
HANDLE hSnapShot = 0;
TRACE("%lx,%lx\n", flags, process );
TRACE("%x,%x\n", flags, process );
if (!(flags & (TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)))
{
FIXME("flags %lx not implemented\n", flags );
FIXME("flags %x not implemented\n", flags );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return INVALID_HANDLE_VALUE;
}
@ -356,7 +356,7 @@ static BOOL next_thread( HANDLE hSnapShot, LPTHREADENTRY32 lpte, BOOL first )
if (lpte->dwSize < sizeof(THREADENTRY32))
{
SetLastError( ERROR_INSUFFICIENT_BUFFER );
WARN("Result buffer too small (%ld)\n", lpte->dwSize);
WARN("Result buffer too small (%d)\n", lpte->dwSize);
return FALSE;
}
if ((snap = MapViewOfFile( hSnapShot, FILE_MAP_ALL_ACCESS, 0, 0, 0 )))
@ -411,7 +411,7 @@ static BOOL process_next( HANDLE hSnapShot, LPPROCESSENTRY32W lppe,
if (lppe->dwSize < sz)
{
SetLastError( ERROR_INSUFFICIENT_BUFFER );
WARN("Result buffer too small (%ld)\n", lppe->dwSize);
WARN("Result buffer too small (%d)\n", lppe->dwSize);
return FALSE;
}
if ((snap = MapViewOfFile( hSnapShot, FILE_MAP_ALL_ACCESS, 0, 0, 0 )))
@ -501,7 +501,7 @@ static BOOL module_nextW( HANDLE hSnapShot, LPMODULEENTRY32W lpme, BOOL first )
if (lpme->dwSize < sizeof (MODULEENTRY32W))
{
SetLastError( ERROR_INSUFFICIENT_BUFFER );
WARN("Result buffer too small (was: %ld)\n", lpme->dwSize);
WARN("Result buffer too small (was: %d)\n", lpme->dwSize);
return FALSE;
}
if ((snap = MapViewOfFile( hSnapShot, FILE_MAP_ALL_ACCESS, 0, 0, 0 )))
@ -553,7 +553,7 @@ static BOOL module_nextA( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
if (lpme->dwSize < sizeof(MODULEENTRY32))
{
SetLastError( ERROR_INSUFFICIENT_BUFFER );
WARN("Result buffer too small (was: %ld)\n", lpme->dwSize);
WARN("Result buffer too small (was: %d)\n", lpme->dwSize);
return FALSE;
}

2
dlls/kernel32/toolhelp16.c
View file

@ -74,7 +74,7 @@ BOOL16 WINAPI NotifyRegister16( HTASK16 htask, FARPROC16 lpfnCallback,
{
int i;
FIXME("(%x,%lx,%x), semi-stub.\n",
FIXME("(%x,%x,%x), semi-stub.\n",
htask, (DWORD)lpfnCallback, wFlags );
if (!htask) htask = GetCurrentTask();
for (i=0;i<nrofnotifys;i++)

2
dlls/kernel32/utthunk.c
View file

@ -320,6 +320,6 @@ VOID WINAPI UTUnRegister( HMODULE hModule )
*/
WORD WINAPI UTInit16( DWORD x1, DWORD x2, DWORD x3, DWORD x4 )
{
FIXME("(%08lx, %08lx, %08lx, %08lx): stub\n", x1, x2, x3, x4 );
FIXME("(%08x, %08x, %08x, %08x): stub\n", x1, x2, x3, x4 );
return 0;
}

4
dlls/kernel32/version.c
View file

@ -152,7 +152,7 @@ BOOL WINAPI GetVersionExA(OSVERSIONINFOA *v)
if (v->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA) &&
v->dwOSVersionInfoSize != sizeof(OSVERSIONINFOEXA))
{
WARN("wrong OSVERSIONINFO size from app (got: %ld)\n",
WARN("wrong OSVERSIONINFO size from app (got: %d)\n",
v->dwOSVersionInfoSize );
return FALSE;
}
@ -187,7 +187,7 @@ BOOL WINAPI GetVersionExW( OSVERSIONINFOW *info )
if (info->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW) &&
info->dwOSVersionInfoSize != sizeof(OSVERSIONINFOEXW))
{
WARN("wrong OSVERSIONINFO size from app (got: %ld)\n",
WARN("wrong OSVERSIONINFO size from app (got: %d)\n",
info->dwOSVersionInfoSize);
return FALSE;
}

14
dlls/kernel32/volume.c
View file

@ -524,7 +524,7 @@ BOOL WINAPI GetVolumeInformationW( LPCWSTR root, LPWSTR label, DWORD label_len,
if (serial) *serial = VOLUME_GetSuperblockSerial( type, superblock );
goto fill_fs_info;
}
else TRACE( "cannot open device %s: err %ld\n", debugstr_w(device), GetLastError() );
else TRACE( "cannot open device %s: err %d\n", debugstr_w(device), GetLastError() );
/* we couldn't open the device, fallback to default strategy */
@ -689,7 +689,7 @@ BOOL WINAPI SetVolumeLabelW( LPCWSTR root, LPCWSTR label )
}
else
{
TRACE( "cannot open device %s: err %ld\n", debugstr_w(device), GetLastError() );
TRACE( "cannot open device %s: err %d\n", debugstr_w(device), GetLastError() );
if (GetLastError() == ERROR_ACCESS_DENIED) return FALSE;
}
@ -752,7 +752,7 @@ BOOL WINAPI SetVolumeLabelA(LPCSTR root, LPCSTR volname)
*/
BOOL WINAPI GetVolumeNameForVolumeMountPointW(LPCWSTR str, LPWSTR dst, DWORD size)
{
FIXME("(%s, %p, %lx): stub\n", debugstr_w(str), dst, size);
FIXME("(%s, %p, %x): stub\n", debugstr_w(str), dst, size);
return 0;
}
@ -766,13 +766,13 @@ BOOL WINAPI DefineDosDeviceW( DWORD flags, LPCWSTR devname, LPCWSTR targetpath )
BOOL ret = FALSE;
char *path = NULL, *target, *p;
TRACE("%lx, %s, %s\n", flags, debugstr_w(devname), debugstr_w(targetpath));
TRACE("%x, %s, %s\n", flags, debugstr_w(devname), debugstr_w(targetpath));
if (!(flags & DDD_REMOVE_DEFINITION))
{
if (!(flags & DDD_RAW_TARGET_PATH))
{
FIXME( "(0x%08lx,%s,%s) DDD_RAW_TARGET_PATH flag not set, not supported yet\n",
FIXME( "(0x%08x,%s,%s) DDD_RAW_TARGET_PATH flag not set, not supported yet\n",
flags, debugstr_w(devname), debugstr_w(targetpath) );
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
@ -1340,7 +1340,7 @@ BOOL WINAPI GetDiskFreeSpaceA( LPCSTR root, LPDWORD cluster_sectors,
*/
BOOL WINAPI GetVolumePathNameA(LPCSTR filename, LPSTR volumepathname, DWORD buflen)
{
FIXME("(%s, %p, %ld), stub!\n", debugstr_a(filename), volumepathname, buflen);
FIXME("(%s, %p, %d), stub!\n", debugstr_a(filename), volumepathname, buflen);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
@ -1350,7 +1350,7 @@ BOOL WINAPI GetVolumePathNameA(LPCSTR filename, LPSTR volumepathname, DWORD bufl
*/
BOOL WINAPI GetVolumePathNameW(LPCWSTR filename, LPWSTR volumepathname, DWORD buflen)
{
FIXME("(%s, %p, %ld), stub!\n", debugstr_w(filename), volumepathname, buflen);
FIXME("(%s, %p, %d), stub!\n", debugstr_w(filename), volumepathname, buflen);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}

4
dlls/kernel32/vxd.c
View file

@ -301,7 +301,7 @@ void WINAPI __regs_VxDCall( DWORD service, CONTEXT86 *context )
if (proc) context->Eax = proc( service, context );
else
{
FIXME( "Unknown/unimplemented VxD (%08lx)\n", service);
FIXME( "Unknown/unimplemented VxD (%08x)\n", service);
context->Eax = 0xffffffff; /* FIXME */
}
}
@ -342,7 +342,7 @@ BOOL WINAPI DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
{
NTSTATUS status;
TRACE( "(%p,%lx,%p,%ld,%p,%ld,%p,%p)\n",
TRACE( "(%p,%x,%p,%d,%p,%d,%p,%p)\n",
hDevice,dwIoControlCode,lpvInBuffer,cbInBuffer,
lpvOutBuffer,cbOutBuffer,lpcbBytesReturned,lpOverlapped );

6
dlls/kernel32/win87em.c
View file

@ -101,7 +101,7 @@ static void WIN87_Init( CONTEXT86 *context )
*/
void WINAPI WIN87_fpmath( CONTEXT86 *context )
{
TRACE("(cs:eip=%x:%lx es=%x bx=%04x ax=%04x dx=%04x)\n",
TRACE("(cs:eip=%x:%x es=%x bx=%04x ax=%04x dx=%04x)\n",
(WORD)context->SegCs, context->Eip,
(WORD)context->SegEs, (WORD)context->Ebx,
(WORD)context->Eax, (WORD)context->Edx );
@ -164,7 +164,7 @@ void WINAPI WIN87_fpmath( CONTEXT86 *context )
__asm__ __volatile__("fist %0;wait" : "=m" (dw) : : "memory");
__asm__ __volatile__("fldcw %0" : : "m" (save));
#endif
TRACE("On top of stack is %ld\n",dw);
TRACE("On top of stack is %d\n",dw);
}
break;
@ -178,7 +178,7 @@ void WINAPI WIN87_fpmath( CONTEXT86 *context )
*/
/* FIXME: could someone who really understands asm() fix this please? --AJ */
/* __asm__("fistp %0;wait" : "=m" (dw) : : "memory"); */
TRACE("On top of stack was %ld\n",dw);
TRACE("On top of stack was %d\n",dw);
context->Eax = (context->Eax & ~0xffff) | LOWORD(dw);
context->Edx = (context->Edx & ~0xffff) | HIWORD(dw);
}

26
dlls/kernel32/wowthunk.c
View file

@ -570,7 +570,7 @@ BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
DWORD count = cbArgs / sizeof(WORD);
WORD * wstack = (WORD *)stack;
DPRINTF("%04lx:CallTo16(func=%04lx:%04x,ds=%04lx",
DPRINTF("%04x:CallTo16(func=%04x:%04x,ds=%04x",
GetCurrentThreadId(),
context->SegCs, LOWORD(context->Eip), context->SegDs );
while (count) DPRINTF( ",%04x", wstack[--count] );
@ -629,7 +629,7 @@ BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
if (TRACE_ON(relay))
{
DPRINTF("%04lx:RetFrom16() ss:sp=%04x:%04x ",
DPRINTF("%04x:RetFrom16() ss:sp=%04x:%04x ",
GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->WOW32Reserved),
OFFSETOF(NtCurrentTeb()->WOW32Reserved));
DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x bp=%04x sp=%04x\n",
@ -647,7 +647,7 @@ BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
DWORD count = cbArgs / sizeof(WORD);
WORD * wstack = (WORD *)stack;
DPRINTF("%04lx:CallTo16(func=%04x:%04x,ds=%04x",
DPRINTF("%04x:CallTo16(func=%04x:%04x,ds=%04x",
GetCurrentThreadId(), HIWORD(vpfn16), LOWORD(vpfn16),
SELECTOROF(NtCurrentTeb()->WOW32Reserved) );
while (count) DPRINTF( ",%04x", wstack[--count] );
@ -674,7 +674,7 @@ BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
if (TRACE_ON(relay))
{
DPRINTF("%04lx:RetFrom16() ss:sp=%04x:%04x retval=%08lx\n",
DPRINTF("%04x:RetFrom16() ss:sp=%04x:%04x retval=%08x\n",
GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->WOW32Reserved),
OFFSETOF(NtCurrentTeb()->WOW32Reserved), ret);
SYSLEVEL_CheckNotLevel( 2 );
@ -830,14 +830,14 @@ static DWORD WOW_CallProc32W16( FARPROC proc32, DWORD nrofargs, DWORD *args )
break;
default:
/* FIXME: should go up to 32 arguments */
ERR("Unsupported number of arguments %ld, please report.\n",nrofargs);
ERR("Unsupported number of arguments %d, please report.\n",nrofargs);
ret = 0;
break;
}
RestoreThunkLock( mutex_count );
TRACE("returns %08lx\n",ret);
TRACE("returns %08x\n",ret);
return ret;
}
@ -849,7 +849,7 @@ DWORD WINAPIV CallProc32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32,
DWORD args[32];
unsigned int i;
TRACE("(%ld,%ld,%p args[",nrofargs,argconvmask,proc32);
TRACE("(%d,%d,%p args[",nrofargs,argconvmask,proc32);
for (i=0;i<nrofargs;i++)
{
@ -858,14 +858,14 @@ DWORD WINAPIV CallProc32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32,
SEGPTR ptr = VA_ARG16( valist, SEGPTR );
/* pascal convention, have to reverse the arguments order */
args[nrofargs - i - 1] = (DWORD)MapSL(ptr);
TRACE("%08lx(%p),",ptr,MapSL(ptr));
TRACE("%08x(%p),",ptr,MapSL(ptr));
}
else
{
DWORD arg = VA_ARG16( valist, DWORD );
/* pascal convention, have to reverse the arguments order */
args[nrofargs - i - 1] = arg;
TRACE("%ld,", arg);
TRACE("%d,", arg);
}
}
TRACE("])\n");
@ -884,7 +884,7 @@ DWORD WINAPIV CallProcEx32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32
DWORD args[32];
unsigned int i;
TRACE("(%ld,%ld,%p args[",nrofargs,argconvmask,proc32);
TRACE("(%d,%d,%p args[",nrofargs,argconvmask,proc32);
for (i=0;i<nrofargs;i++)
{
@ -892,13 +892,13 @@ DWORD WINAPIV CallProcEx32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32
{
SEGPTR ptr = VA_ARG16( valist, SEGPTR );
args[i] = (DWORD)MapSL(ptr);
TRACE("%08lx(%p),",ptr,MapSL(ptr));
TRACE("%08x(%p),",ptr,MapSL(ptr));
}
else
{
DWORD arg = VA_ARG16( valist, DWORD );
args[i] = arg;
TRACE("%ld,", arg);
TRACE("%d,", arg);
}
}
TRACE("])\n");
@ -924,6 +924,6 @@ DWORD WINAPIV WOW16Call(WORD x, WORD y, WORD z, VA_LIST16 args)
}
calladdr = VA_ARG16(args,DWORD);
stack16_pop( 3*sizeof(WORD) + x + sizeof(DWORD) );
DPRINTF(") calling address was 0x%08lx\n",calladdr);
DPRINTF(") calling address was 0x%08x\n",calladdr);
return 0;
}