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

kernelbase: Enable compilation with long types. 

Signed-off-by: Eric Pouech <eric.pouech@gmail.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Eric Pouech 2022-02-11 08:41:29 +01:00 committed by Alexandre Julliard
parent a0fee49db2
commit 2dcfe06442
17 changed files with 328 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/kernelbase/Makefile.in
View File

@ -1,4 +1,4 @@
EXTRADEFS = -DWINE_NO_LONG_TYPES -DWINBASEAPI=
EXTRADEFS = -DWINBASEAPI=
MODULE = kernelbase.dll
IMPORTLIB = kernelbase
IMPORTS = uuid ntdll winecrt0

42
dlls/kernelbase/console.c
View File

@ -72,7 +72,7 @@ struct ctrl_handler
static BOOL WINAPI default_ctrl_handler( DWORD type )
{
FIXME( "Terminating process %x on event %x\n", GetCurrentProcessId(), type );
FIXME( "Terminating process %lx on event %lx\n", GetCurrentProcessId(), type );
RtlExitUserProcess( 0 );
return TRUE;
}
@ -285,7 +285,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH AttachConsole( DWORD pid )
{
BOOL ret;
TRACE( "(%x)\n", pid );
TRACE( "(%lx)\n", pid );
RtlEnterCriticalSection( &console_section );
@ -383,7 +383,7 @@ BOOL WINAPI AllocConsole(void)
if (!init_console_std_handles( !(app_si.dwFlags & STARTF_USESTDHANDLES) )) goto error;
RtlGetCurrentPeb()->ProcessParameters->ConsoleHandle = console;
TRACE( "Started conhost pid=%08x tid=%08x\n", pi.dwProcessId, pi.dwThreadId );
TRACE( "Started conhost pid=%08lx tid=%08lx\n", pi.dwProcessId, pi.dwThreadId );
CloseHandle( server );
RtlLeaveCriticalSection( &console_section );
@ -413,7 +413,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateConsoleScreenBuffer( DWORD access, DWORD s
HANDLE handle;
NTSTATUS status;
TRACE( "(%x,%x,%p,%x,%p)\n", access, share, sa, flags, data );
TRACE( "(%lx,%lx,%p,%lx,%p)\n", access, share, sa, flags, data );
if (flags != CONSOLE_TEXTMODE_BUFFER || data)
{
@ -478,7 +478,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH FillConsoleOutputAttribute( HANDLE handle, WORD at
{
struct condrv_fill_output_params params;
TRACE( "(%p,%d,%d,(%dx%d),%p)\n", handle, attr, length, coord.X, coord.Y, written );
TRACE( "(%p,%d,%ld,(%dx%d),%p)\n", handle, attr, length, coord.X, coord.Y, written );
if (!written)
{
@ -521,7 +521,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH FillConsoleOutputCharacterW( HANDLE handle, WCHAR
{
struct condrv_fill_output_params params;
TRACE( "(%p,%s,%d,(%dx%d),%p)\n", handle, debugstr_wn(&ch, 1), length, coord.X, coord.Y, written );
TRACE( "(%p,%s,%ld,(%dx%d),%p)\n", handle, debugstr_wn(&ch, 1), length, coord.X, coord.Y, written );
if (!written)
{
@ -573,11 +573,11 @@ BOOL WINAPI DECLSPEC_HOTPATCH GenerateConsoleCtrlEvent( DWORD event, DWORD group
{
struct condrv_ctrl_event ctrl_event;
TRACE( "(%d, %x)\n", event, group );
TRACE( "(%ld, %lx)\n", event, group );
if (event != CTRL_C_EVENT && event != CTRL_BREAK_EVENT)
{
ERR( "Invalid event %d for PGID %x\n", event, group );
ERR( "Invalid event %ld for PGID %lx\n", event, group );
return FALSE;
}
@ -620,7 +620,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetConsoleCursorInfo( HANDLE handle, CONSOLE_CURSO
info->dwSize = condrv_info.cursor_size;
info->bVisible = condrv_info.cursor_visible;
TRACE("(%p) returning (%d,%d)\n", handle, info->dwSize, info->bVisible);
TRACE("(%p) returning (%ld,%d)\n", handle, info->dwSize, info->bVisible);
return TRUE;
}
@ -835,7 +835,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH ReadConsoleOutputAttribute( HANDLE handle, WORD *a
struct condrv_output_params params;
BOOL ret;
TRACE( "(%p,%p,%d,%dx%d,%p)\n", handle, attr, length, coord.X, coord.Y, count );
TRACE( "(%p,%p,%ld,%dx%d,%p)\n", handle, attr, length, coord.X, coord.Y, count );
if (!count)
{
@ -895,7 +895,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH ReadConsoleOutputCharacterW( HANDLE handle, LPWSTR
struct condrv_output_params params;
BOOL ret;
TRACE( "(%p,%p,%d,%dx%d,%p)\n", handle, buffer, length, coord.X, coord.Y, count );
TRACE( "(%p,%p,%ld,%dx%d,%p)\n", handle, buffer, length, coord.X, coord.Y, count );
if (!count)
{
@ -1117,7 +1117,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetConsoleCursorInfo( HANDLE handle, CONSOLE_CURSO
{
struct condrv_output_info_params params = { SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM };
TRACE( "(%p,%d,%d)\n", handle, info->dwSize, info->bVisible);
TRACE( "(%p,%ld,%d)\n", handle, info->dwSize, info->bVisible);
params.info.cursor_size = info->dwSize;
params.info.cursor_visible = info->bVisible;
@ -1180,7 +1180,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetConsoleInputExeNameW( LPCWSTR name )
*/
BOOL WINAPI DECLSPEC_HOTPATCH SetConsoleMode( HANDLE handle, DWORD mode )
{
TRACE( "(%p,%x)\n", handle, mode );
TRACE( "(%p,%lx)\n", handle, mode );
return console_ioctl( handle, IOCTL_CONDRV_SET_MODE, &mode, sizeof(mode), NULL, 0, NULL );
}
@ -1402,7 +1402,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteConsoleInputA( HANDLE handle, const INPUT_REC
BOOL WINAPI DECLSPEC_HOTPATCH WriteConsoleInputW( HANDLE handle, const INPUT_RECORD *buffer,
DWORD count, DWORD *written )
{
TRACE( "(%p,%p,%d,%p)\n", handle, buffer, count, written );
TRACE( "(%p,%p,%ld,%p)\n", handle, buffer, count, written );
if (count > 0 && !buffer)
{
@ -1515,7 +1515,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteConsoleOutputAttribute( HANDLE handle, const
size_t size;
BOOL ret;
TRACE( "(%p,%p,%d,%dx%d,%p)\n", handle, attr, length, coord.X, coord.Y, written );
TRACE( "(%p,%p,%ld,%dx%d,%p)\n", handle, attr, length, coord.X, coord.Y, written );
if ((length > 0 && !attr) || !written)
{
@ -1547,7 +1547,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteConsoleOutputCharacterA( HANDLE handle, LPCST
LPWSTR strW = NULL;
DWORD lenW = 0;
TRACE( "(%p,%s,%d,%dx%d,%p)\n", handle, debugstr_an(str, length), length, coord.X, coord.Y, written );
TRACE( "(%p,%s,%ld,%dx%d,%p)\n", handle, debugstr_an(str, length), length, coord.X, coord.Y, written );
if (length > 0)
{
@ -1582,7 +1582,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteConsoleOutputCharacterW( HANDLE handle, LPCWS
size_t size;
BOOL ret;
TRACE( "(%p,%s,%d,%dx%d,%p)\n", handle, debugstr_wn(str, length), length, coord.X, coord.Y, written );
TRACE( "(%p,%s,%ld,%dx%d,%p)\n", handle, debugstr_wn(str, length), length, coord.X, coord.Y, written );
if ((length > 0 && !str) || !written)
{
@ -1626,7 +1626,7 @@ BOOL WINAPI ReadConsoleW( HANDLE handle, void *buffer, DWORD length, DWORD *coun
{
BOOL ret;
TRACE( "(%p,%p,%d,%p,%p)\n", handle, buffer, length, count, reserved );
TRACE( "(%p,%p,%ld,%p,%p)\n", handle, buffer, length, count, reserved );
if (length > INT_MAX)
{
@ -1649,7 +1649,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteConsoleA( HANDLE handle, const void *buffer,
{
BOOL ret;
TRACE( "(%p,%s,%d,%p,%p)\n", handle, debugstr_an(buffer, length), length, written, reserved );
TRACE( "(%p,%s,%ld,%p,%p)\n", handle, debugstr_an(buffer, length), length, written, reserved );
ret = console_ioctl( handle, IOCTL_CONDRV_WRITE_FILE, (void *)buffer, length, NULL, 0, NULL );
if (written) *written = ret ? length : 0;
@ -1665,7 +1665,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteConsoleW( HANDLE handle, const void *buffer,
{
BOOL ret;
TRACE( "(%p,%s,%d,%p,%p)\n", handle, debugstr_wn(buffer, length), length, written, reserved );
TRACE( "(%p,%s,%ld,%p,%p)\n", handle, debugstr_wn(buffer, length), length, written, reserved );
ret = console_ioctl( handle, IOCTL_CONDRV_WRITE_CONSOLE, (void *)buffer,
length * sizeof(WCHAR), NULL, 0, NULL );
@ -1760,7 +1760,7 @@ HRESULT WINAPI CreatePseudoConsole( COORD size, HANDLE input, HANDLE output, DWO
HANDLE signal = NULL;
WCHAR pipe_name[64];
TRACE( "(%u,%u) %p %p %x %p\n", size.X, size.Y, input, output, flags, ret );
TRACE( "(%u,%u) %p %p %lx %p\n", size.X, size.Y, input, output, flags, ret );
if (!size.X || !size.Y || !ret) return E_INVALIDARG;

38
dlls/kernelbase/debug.c
View File

@ -366,14 +366,14 @@ static void format_exception_msg( const EXCEPTION_POINTERS *ptr, char *buffer, i
len = snprintf( buffer, size, "Unimplemented function %s.%s called",
(char *)rec->ExceptionInformation[0], (char *)rec->ExceptionInformation[1] );
else
len = snprintf( buffer, size, "Unimplemented function %s.%ld called",
len = snprintf( buffer, size, "Unimplemented function %s.%Id called",
(char *)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
break;
case EXCEPTION_WINE_ASSERTION:
len = snprintf( buffer, size, "Assertion failed" );
break;
default:
len = snprintf( buffer, size, "Unhandled exception 0x%08x in thread %x",
len = snprintf( buffer, size, "Unhandled exception 0x%08lx in thread %lx",
rec->ExceptionCode, GetCurrentThreadId());
break;
}
@ -400,7 +400,7 @@ static BOOL start_debugger( EXCEPTION_POINTERS *epointers, HANDLE event )
char buffer[256];
format_exception_msg( epointers, buffer, sizeof(buffer) );
MESSAGE( "wine: %s (thread %04x), starting debugger...\n", buffer, GetCurrentThreadId() );
MESSAGE( "wine: %s (thread %04lx), starting debugger...\n", buffer, GetCurrentThreadId() );
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
@ -525,7 +525,7 @@ static BOOL start_debugger( EXCEPTION_POINTERS *epointers, HANDLE event )
WaitForMultipleObjects( 2, handles, FALSE, INFINITE );
CloseHandle( info.hProcess );
}
else ERR( "Couldn't start debugger %s (%d)\n"
else ERR( "Couldn't start debugger %s (%ld)\n"
"Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
debugstr_w(cmdline), GetLastError() );
exit:
@ -671,7 +671,7 @@ HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerGetFlags( HANDLE process, DWORD *flags
HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerRegisterFile( const WCHAR *file, WER_REGISTER_FILE_TYPE type,
DWORD flags )
{
FIXME( "(%s, %d, %d) stub\n", debugstr_w(file), type, flags );
FIXME( "(%s, %d, %ld) stub\n", debugstr_w(file), type, flags );
return E_NOTIMPL;
}
@ -681,7 +681,7 @@ HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerRegisterFile( const WCHAR *file, WER_R
*/
HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerRegisterMemoryBlock( void *block, DWORD size )
{
FIXME( "(%p %d) stub\n", block, size );
FIXME( "(%p %ld) stub\n", block, size );
return E_NOTIMPL;
}
@ -701,7 +701,7 @@ HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerRegisterRuntimeExceptionModule( const
*/
HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerSetFlags( DWORD flags )
{
FIXME("(%d) stub\n", flags);
FIXME("(%ld) stub\n", flags);
return S_OK;
}
@ -894,7 +894,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH EmptyWorkingSet( HANDLE process )
*/
BOOL WINAPI EnumDeviceDrivers( void **image_base, DWORD count, DWORD *needed )
{
FIXME( "(%p, %d, %p): stub\n", image_base, count, needed );
FIXME( "(%p, %ld, %p): stub\n", image_base, count, needed );
if (needed) *needed = 0;
return TRUE;
}
@ -1002,7 +1002,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumProcessModules( HANDLE process, HMODULE *modul
BOOL WINAPI EnumProcessModulesEx( HANDLE process, HMODULE *module, DWORD count,
DWORD *needed, DWORD filter )
{
FIXME( "(%p, %p, %d, %p, %d) semi-stub\n", process, module, count, needed, filter );
FIXME( "(%p, %p, %ld, %p, %ld) semi-stub\n", process, module, count, needed, filter );
return EnumProcessModules( process, module, count, needed );
}
@ -1050,7 +1050,7 @@ BOOL WINAPI EnumProcesses( DWORD *ids, DWORD count, DWORD *used )
*/
DWORD WINAPI DECLSPEC_HOTPATCH GetDeviceDriverBaseNameA( void *image_base, char *name, DWORD size )
{
FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
FIXME( "(%p, %p, %ld): stub\n", image_base, name, size );
if (name && size) name[0] = 0;
return 0;
}
@ -1062,7 +1062,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetDeviceDriverBaseNameA( void *image_base, char
*/
DWORD WINAPI DECLSPEC_HOTPATCH GetDeviceDriverBaseNameW( void *image_base, WCHAR *name, DWORD size )
{
FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
FIXME( "(%p, %p, %ld): stub\n", image_base, name, size );
if (name && size) name[0] = 0;
return 0;
}
@ -1074,7 +1074,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetDeviceDriverBaseNameW( void *image_base, WCHAR
*/
DWORD WINAPI DECLSPEC_HOTPATCH GetDeviceDriverFileNameA( void *image_base, char *name, DWORD size )
{
FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
FIXME( "(%p, %p, %ld): stub\n", image_base, name, size );
if (name && size) name[0] = 0;
return 0;
}
@ -1086,7 +1086,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetDeviceDriverFileNameA( void *image_base, char
*/
DWORD WINAPI DECLSPEC_HOTPATCH GetDeviceDriverFileNameW( void *image_base, WCHAR *name, DWORD size )
{
FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
FIXME( "(%p, %p, %ld): stub\n", image_base, name, size );
if (name && size) name[0] = 0;
return 0;
}
@ -1163,7 +1163,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetModuleBaseNameA( HANDLE process, HMODULE modul
if (!(name_w = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR) * size ))) return 0;
len = GetModuleBaseNameW( process, module, name_w, size );
TRACE( "%d, %s\n", len, debugstr_w(name_w) );
TRACE( "%ld, %s\n", len, debugstr_w(name_w) );
if (len)
{
ret = WideCharToMultiByte( CP_ACP, 0, name_w, len, name, size, NULL, NULL );
@ -1220,7 +1220,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetModuleFileNameExA( HANDLE process, HMODULE mod
WCHAR *ptr;
DWORD len;
TRACE( "(process=%p, module=%p, %p, %d)\n", process, module, name, size );
TRACE( "(process=%p, module=%p, %p, %ld)\n", process, module, name, size );
if (!name || !size)
{
@ -1352,7 +1352,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetPerformanceInfo( PPERFORMANCE_INFORMATION info,
DWORD info_size;
NTSTATUS status;
TRACE( "(%p, %d)\n", info, size );
TRACE( "(%p, %ld)\n", info, size );
if (size < sizeof(*info))
{
@ -1469,7 +1469,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetProcessMemoryInfo( HANDLE process, PROCESS_MEMO
*/
BOOL WINAPI DECLSPEC_HOTPATCH GetWsChanges( HANDLE process, PSAPI_WS_WATCH_INFORMATION *info, DWORD size )
{
TRACE( "(%p, %p, %d)\n", process, info, size );
TRACE( "(%p, %p, %ld)\n", process, info, size );
return set_ntstatus( NtQueryInformationProcess( process, ProcessWorkingSetWatch, info, size, NULL ));
}
@ -1504,7 +1504,7 @@ BOOL WINAPI /* DECLSPEC_HOTPATCH */ InitializeProcessForWsWatch( HANDLE process
*/
BOOL WINAPI DECLSPEC_HOTPATCH QueryWorkingSet( HANDLE process, void *buffer, DWORD size )
{
TRACE( "(%p, %p, %d)\n", process, buffer, size );
TRACE( "(%p, %p, %ld)\n", process, buffer, size );
return set_ntstatus( NtQueryVirtualMemory( process, NULL, MemoryWorkingSetInformation,
buffer, size, NULL ));
}
@ -1516,7 +1516,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH QueryWorkingSet( HANDLE process, void *buffer, DWO
*/
BOOL WINAPI QueryWorkingSetEx( HANDLE process, void *buffer, DWORD size )
{
TRACE( "(%p, %p, %d)\n", process, buffer, size );
TRACE( "(%p, %p, %ld)\n", process, buffer, size );
return set_ntstatus( NtQueryVirtualMemory( process, NULL, MemoryWorkingSetExInformation,
buffer, size, NULL ));
}

80
dlls/kernelbase/file.c
View File

@ -516,7 +516,7 @@ BOOL WINAPI CopyFileExW( const WCHAR *source, const WCHAR *dest, LPPROGRESS_ROUT
return FALSE;
}
TRACE("%s -> %s, %x\n", debugstr_w(source), debugstr_w(dest), flags);
TRACE("%s -> %s, %lx\n", debugstr_w(source), debugstr_w(dest), flags);
if ((h1 = CreateFileW( source, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL, OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
@ -682,10 +682,10 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateFile2( LPCWSTR name, DWORD access, DWORD s
DWORD attributes = params ? params->dwFileAttributes : 0;
DWORD flags = params ? params->dwFileFlags : 0;
FIXME( "(%s %x %x %x %p), partial stub\n", debugstr_w(name), access, sharing, creation, params );
FIXME( "(%s %lx %lx %lx %p), partial stub\n", debugstr_w(name), access, sharing, creation, params );
if (attributes & ~attributes_mask) FIXME( "unsupported attributes %#x\n", attributes );
if (flags & ~flags_mask) FIXME( "unsupported flags %#x\n", flags );
if (attributes & ~attributes_mask) FIXME( "unsupported attributes %#lx\n", attributes );
if (flags & ~flags_mask) FIXME( "unsupported flags %#lx\n", flags );
attributes &= attributes_mask;
flags &= flags_mask;
@ -763,7 +763,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileW( LPCWSTR filename, DWORD access, DWO
return INVALID_HANDLE_VALUE;
}
TRACE( "%s %s%s%s%s%s%s%s creation %d attributes 0x%x\n", debugstr_w(filename),
TRACE( "%s %s%s%s%s%s%s%s creation %ld attributes 0x%lx\n", debugstr_w(filename),
(access & GENERIC_READ) ? "GENERIC_READ " : "",
(access & GENERIC_WRITE) ? "GENERIC_WRITE " : "",
(access & GENERIC_EXECUTE) ? "GENERIC_EXECUTE " : "",
@ -831,7 +831,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileW( LPCWSTR filename, DWORD access, DWO
if (vxd_open && (ret = vxd_open( vxd_name, access, sa ))) goto done;
}
WARN("Unable to create file %s (status %x)\n", debugstr_w(filename), status);
WARN("Unable to create file %s (status %lx)\n", debugstr_w(filename), status);
ret = INVALID_HANDLE_VALUE;
/* In the case file creation was rejected due to CREATE_NEW flag
@ -938,7 +938,7 @@ done:
*/
BOOLEAN WINAPI /* DECLSPEC_HOTPATCH */ CreateSymbolicLinkW( LPCWSTR link, LPCWSTR target, DWORD flags )
{
FIXME( "(%s %s %d): stub\n", debugstr_w(link), debugstr_w(target), flags );
FIXME( "(%s %s %ld): stub\n", debugstr_w(link), debugstr_w(target), flags );
return TRUE;
}
@ -1029,7 +1029,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstChangeNotificationW( LPCWSTR path, BOOL
NTSTATUS status;
HANDLE handle = INVALID_HANDLE_VALUE;
TRACE( "%s %d %x\n", debugstr_w(path), subtree, filter );
TRACE( "%s %d %lx\n", debugstr_w(path), subtree, filter );
if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
{
@ -1120,11 +1120,11 @@ HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileExW( LPCWSTR filename, FINDEX_INFO_
NTSTATUS status;
DWORD size, device = 0;
TRACE( "%s %d %p %d %p %x\n", debugstr_w(filename), level, data, search_op, filter, flags );
TRACE( "%s %d %p %d %p %lx\n", debugstr_w(filename), level, data, search_op, filter, flags );
if (flags & ~FIND_FIRST_EX_LARGE_FETCH)
{
FIXME("flags not implemented 0x%08x\n", flags );
FIXME("flags not implemented 0x%08lx\n", flags );
}
if (search_op != FindExSearchNameMatch && search_op != FindExSearchLimitToDirectories)
{
@ -1300,7 +1300,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileW( const WCHAR *filename, WIN32_FIN
*/
HANDLE WINAPI FindFirstStreamW( const WCHAR *filename, STREAM_INFO_LEVELS level, void *data, DWORD flags )
{
FIXME("(%s, %d, %p, %x): stub!\n", debugstr_w(filename), level, data, flags);
FIXME("(%s, %d, %p, %lx): stub!\n", debugstr_w(filename), level, data, flags);
SetLastError( ERROR_HANDLE_EOF );
return INVALID_HANDLE_VALUE;
}
@ -1683,7 +1683,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetFinalPathNameByHandleA( HANDLE file, LPSTR pat
WCHAR *str;
DWORD result, len;
TRACE( "(%p,%p,%d,%x)\n", file, path, count, flags);
TRACE( "(%p,%p,%ld,%lx)\n", file, path, count, flags);
len = GetFinalPathNameByHandleW(file, NULL, 0, flags);
if (len == 0) return 0;
@ -1729,11 +1729,11 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetFinalPathNameByHandleW( HANDLE file, LPWSTR pa
ULONG dummy;
WCHAR *ptr;
TRACE( "(%p,%p,%d,%x)\n", file, path, count, flags );
TRACE( "(%p,%p,%ld,%lx)\n", file, path, count, flags );
if (flags & ~(FILE_NAME_OPENED | VOLUME_NAME_GUID | VOLUME_NAME_NONE | VOLUME_NAME_NT))
{
WARN("Unknown flags: %x\n", flags);
WARN("Unknown flags: %lx\n", flags);
SetLastError( ERROR_INVALID_PARAMETER );
return 0;
}
@ -1846,7 +1846,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetFinalPathNameByHandleW( HANDLE file, LPWSTR pa
else
{
/* Windows crashes here, but we prefer returning ERROR_INVALID_PARAMETER */
WARN("Invalid combination of flags: %x\n", flags);
WARN("Invalid combination of flags: %lx\n", flags);
SetLastError( ERROR_INVALID_PARAMETER );
}
return result;
@ -1930,7 +1930,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetLongPathNameW( LPCWSTR shortpath, LPWSTR longp
LPCWSTR p;
HANDLE handle;
TRACE("%s,%p,%u\n", debugstr_w(shortpath), longpath, longlen);
TRACE("%s,%p,%lu\n", debugstr_w(shortpath), longpath, longlen);
if (!shortpath)
{
@ -2037,7 +2037,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetShortPathNameW( LPCWSTR longpath, LPWSTR short
LPCWSTR p;
DWORD sp = 0, lp = 0, tmplen, buf_len;
TRACE( "%s,%p,%u\n", debugstr_w(longpath), shortpath, shortlen );
TRACE( "%s,%p,%lu\n", debugstr_w(longpath), shortpath, shortlen );
if (!longpath)
{
@ -2438,7 +2438,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH MoveFileWithProgressW( const WCHAR *source, const
HANDLE source_handle = 0;
ULONG size;
TRACE( "(%s,%s,%p,%p,%04x)\n", debugstr_w(source), debugstr_w(dest), progress, param, flag );
TRACE( "(%s,%s,%p,%p,%04lx)\n", debugstr_w(source), debugstr_w(dest), progress, param, flag );
if (flag & MOVEFILE_DELAY_UNTIL_REBOOT) return add_boot_rename_entry( source, dest, flag );
@ -2540,10 +2540,10 @@ BOOL WINAPI DECLSPEC_HOTPATCH ReplaceFileW( const WCHAR *replaced, const WCHAR *
OBJECT_ATTRIBUTES attr;
FILE_BASIC_INFORMATION info;
TRACE( "%s %s %s 0x%08x %p %p\n", debugstr_w(replaced), debugstr_w(replacement), debugstr_w(backup),
TRACE( "%s %s %s 0x%08lx %p %p\n", debugstr_w(replaced), debugstr_w(replacement), debugstr_w(backup),
flags, exclude, reserved );
if (flags) FIXME("Ignoring flags %x\n", flags);
if (flags) FIXME("Ignoring flags %lx\n", flags);
/* First two arguments are mandatory */
if (!replaced || !replacement)
@ -2811,7 +2811,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetFileAttributesW( LPCWSTR name, DWORD attributes
NTSTATUS status;
HANDLE handle;
TRACE( "%s %x\n", debugstr_w(name), attributes );
TRACE( "%s %lx\n", debugstr_w(name), attributes );
if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
{
@ -2965,7 +2965,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetFileInformationByHandleEx( HANDLE handle, FILE_
case FileAlignmentInfo:
case FileIdExtdDirectoryInfo:
case FileIdExtdDirectoryRestartInfo:
FIXME( "%p, %u, %p, %u\n", handle, class, info, size );
FIXME( "%p, %u, %p, %lu\n", handle, class, info, size );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
@ -3123,7 +3123,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetOverlappedResultEx( HANDLE file, OVERLAPPED *ov
NTSTATUS status;
DWORD ret;
TRACE( "(%p %p %p %u %d)\n", file, overlapped, result, timeout, alertable );
TRACE( "(%p %p %p %lu %d)\n", file, overlapped, result, timeout, alertable );
status = overlapped->Internal;
if (status == STATUS_PENDING)
@ -3159,7 +3159,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH LockFile( HANDLE file, DWORD offset_low, DWORD off
{
LARGE_INTEGER count, offset;
TRACE( "%p %x%08x %x%08x\n", file, offset_high, offset_low, count_high, count_low );
TRACE( "%p %lx%08lx %lx%08lx\n", file, offset_high, offset_low, count_high, count_low );
count.u.LowPart = count_low;
count.u.HighPart = count_high;
@ -3184,7 +3184,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH LockFileEx( HANDLE file, DWORD flags, DWORD reserv
return FALSE;
}
TRACE( "%p %x%08x %x%08x flags %x\n",
TRACE( "%p %lx%08lx %lx%08lx flags %lx\n",
file, overlapped->u.s.OffsetHigh, overlapped->u.s.Offset, count_high, count_low, flags );
count.u.LowPart = count_low;
@ -3259,7 +3259,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH ReOpenFile( HANDLE handle, DWORD access, DWORD s
NTSTATUS status;
HANDLE file;
TRACE("handle %p, access %#x, sharing %#x, attributes %#x.\n", handle, access, sharing, attributes);
TRACE("handle %p, access %#lx, sharing %#lx, attributes %#lx.\n", handle, access, sharing, attributes);
if (attributes & 0x7ffff) /* FILE_ATTRIBUTE_* flags are invalid */
{
@ -3307,7 +3307,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH ReadDirectoryChangesW( HANDLE handle, LPVOID buffe
NTSTATUS status;
LPVOID cvalue = NULL;
TRACE( "%p %p %08x %d %08x %p %p %p\n",
TRACE( "%p %p %08lx %d %08lx %p %p %p\n",
handle, buffer, len, subtree, filter, returned, overlapped, completion );
if (!overlapped)
@ -3355,7 +3355,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH ReadFile( HANDLE file, LPVOID buffer, DWORD count,
NTSTATUS status;
LPVOID cvalue = NULL;
TRACE( "%p %p %d %p %p\n", file, buffer, count, result, overlapped );
TRACE( "%p %p %ld %p %p\n", file, buffer, count, result, overlapped );
if (result) *result = 0;
@ -3408,7 +3408,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH ReadFileEx( HANDLE file, LPVOID buffer, DWORD coun
LARGE_INTEGER offset;
NTSTATUS status;
TRACE( "(file=%p, buffer=%p, bytes=%u, ovl=%p, ovl_fn=%p)\n",
TRACE( "(file=%p, buffer=%p, bytes=%lu, ovl=%p, ovl_fn=%p)\n",
file, buffer, count, overlapped, completion );
if (!overlapped)
@ -3438,7 +3438,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH ReadFileScatter( HANDLE file, FILE_SEGMENT_ELEMENT
LARGE_INTEGER offset;
void *cvalue = NULL;
TRACE( "(%p %p %u %p)\n", file, segments, count, overlapped );
TRACE( "(%p %p %lu %p)\n", file, segments, count, overlapped );
offset.u.LowPart = overlapped->u.s.Offset;
offset.u.HighPart = overlapped->u.s.OffsetHigh;
@ -3524,7 +3524,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetFileInformationByHandle( HANDLE file, FILE_INFO
NTSTATUS status;
IO_STATUS_BLOCK io;
TRACE( "%p %u %p %u\n", file, class, info, size );
TRACE( "%p %u %p %lu\n", file, class, info, size );
switch (class)
{
@ -3540,7 +3540,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetFileInformationByHandle( HANDLE file, FILE_INFO
case FileIdInfo:
case FileIdExtdDirectoryInfo:
case FileIdExtdDirectoryRestartInfo:
FIXME( "%p, %u, %p, %u\n", file, class, info, size );
FIXME( "%p, %u, %p, %lu\n", file, class, info, size );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
@ -3752,7 +3752,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteFile( HANDLE file, LPCVOID buffer, DWORD coun
PIO_STATUS_BLOCK piosb = &iosb;
LPVOID cvalue = NULL;
TRACE( "%p %p %d %p %p\n", file, buffer, count, result, overlapped );
TRACE( "%p %p %ld %p %p\n", file, buffer, count, result, overlapped );
if (overlapped)
{
@ -3796,7 +3796,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteFileEx( HANDLE file, LPCVOID buffer,
NTSTATUS status;
PIO_STATUS_BLOCK io;
TRACE( "%p %p %d %p %p\n", file, buffer, count, overlapped, completion );
TRACE( "%p %p %ld %p %p\n", file, buffer, count, overlapped, completion );
if (!overlapped)
{
@ -3826,7 +3826,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WriteFileGather( HANDLE file, FILE_SEGMENT_ELEMENT
LARGE_INTEGER offset;
void *cvalue = NULL;
TRACE( "%p %p %u %p\n", file, segments, count, overlapped );
TRACE( "%p %p %lu %p\n", file, segments, count, overlapped );
offset.u.LowPart = overlapped->u.s.Offset;
offset.u.HighPart = overlapped->u.s.OffsetHigh;
@ -4027,7 +4027,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SystemTimeToFileTime( const SYSTEMTIME *systime, F
static void dump_dcb( const DCB *dcb )
{
TRACE( "size=%d rate=%d fParity=%d Parity=%d stopbits=%d %sIXON %sIXOFF CTS=%d RTS=%d DSR=%d DTR=%d %sCRTSCTS\n",
TRACE( "size=%d rate=%ld fParity=%d Parity=%d stopbits=%d %sIXON %sIXOFF CTS=%d RTS=%d DSR=%d DTR=%d %sCRTSCTS\n",
dcb->ByteSize, dcb->BaudRate, dcb->fParity, dcb->Parity,
(dcb->StopBits == ONESTOPBIT) ? 1 : (dcb->StopBits == TWOSTOPBITS) ? 2 : 0,
dcb->fOutX ? "" : "~", dcb->fInX ? "" : "~",
@ -4054,7 +4054,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH ClearCommError( HANDLE handle, DWORD *errors, COMS
if (!DeviceIoControl( handle, IOCTL_SERIAL_GET_COMMSTATUS, NULL, 0, &ss, sizeof(ss), NULL, NULL ))
return FALSE;
TRACE( "status %#x,%#x, in %u, out %u, eof %d, wait %d\n", ss.Errors, ss.HoldReasons,
TRACE( "status %#lx,%#lx, in %lu, out %lu, eof %d, wait %d\n", ss.Errors, ss.HoldReasons,
ss.AmountInInQueue, ss.AmountInOutQueue, ss.EofReceived, ss.WaitForImmediate );
if (errors)
@ -4094,7 +4094,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH DeviceIoControl( HANDLE handle, DWORD code, void *
HANDLE event = 0;
NTSTATUS status;
TRACE( "(%p,%x,%p,%d,%p,%d,%p,%p)\n",
TRACE( "(%p,%lx,%p,%ld,%p,%ld,%p,%p)\n",
handle, code, in_buff, in_count, out_buff, out_count, returned, overlapped );
if (overlapped)
@ -4154,7 +4154,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetCommConfig( HANDLE handle, COMMCONFIG *config,
{
if (!config) return FALSE;
TRACE( "(%p, %p, %p %u)\n", handle, config, size, *size );
TRACE( "(%p, %p, %p %lu)\n", handle, config, size, *size );
if (*size < sizeof(COMMCONFIG))
{
@ -4304,7 +4304,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetCommBreak( HANDLE handle )
*/
BOOL WINAPI DECLSPEC_HOTPATCH SetCommConfig( HANDLE handle, COMMCONFIG *config, DWORD size )
{
TRACE( "(%p, %p, %u)\n", handle, config, size );
TRACE( "(%p, %p, %lu)\n", handle, config, size );
return SetCommState( handle, &config->dcb );
}

28
dlls/kernelbase/loader.c
View File

@ -157,7 +157,7 @@ static HMODULE load_library( const UNICODE_STRING *libname, DWORD flags )
HMODULE module;
WCHAR *load_path, *dummy;
if (flags & unsupported_flags) FIXME( "unsupported flag(s) used %#08x\n", flags );
if (flags & unsupported_flags) FIXME( "unsupported flag(s) used %#08lx\n", flags );
if (!set_ntstatus( LdrGetDllPath( libname->Buffer, flags, &load_path, &dummy ))) return 0;
@ -530,7 +530,7 @@ HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryExW( LPCWSTR name, HANDLE file, DWOR
*/
HMODULE WINAPI /* DECLSPEC_HOTPATCH */ LoadPackagedLibrary( LPCWSTR name, DWORD reserved )
{
FIXME( "semi-stub, name %s, reserved %#x.\n", debugstr_w(name), reserved );
FIXME( "semi-stub, name %s, reserved %#lx.\n", debugstr_w(name), reserved );
SetLastError( APPMODEL_ERROR_NO_PACKAGE );
return NULL;
}
@ -629,11 +629,11 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceLanguagesExA( HMODULE module, LPCSTR t
const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
TRACE( "%p %s %s %p %lx %x %d\n", module, debugstr_a(type), debugstr_a(name),
TRACE( "%p %s %s %p %Ix %lx %d\n", module, debugstr_a(type), debugstr_a(name),
func, param, flags, lang );
if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
FIXME( "unimplemented flags: %x\n", flags );
FIXME( "unimplemented flags: %lx\n", flags );
if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
if (!(flags & RESOURCE_ENUM_LN)) return ret;
@ -689,11 +689,11 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceLanguagesExW( HMODULE module, LPCWSTR
const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
TRACE( "%p %s %s %p %lx %x %d\n", module, debugstr_w(type), debugstr_w(name),
TRACE( "%p %s %s %p %Ix %lx %d\n", module, debugstr_w(type), debugstr_w(name),
func, param, flags, lang );
if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
FIXME( "unimplemented flags: %x\n", flags );
FIXME( "unimplemented flags: %lx\n", flags );
if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
if (!(flags & RESOURCE_ENUM_LN)) return ret;
@ -751,10 +751,10 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceNamesExA( HMODULE module, LPCSTR type,
const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
const IMAGE_RESOURCE_DIR_STRING_U *str;
TRACE( "%p %s %p %lx\n", module, debugstr_a(type), func, param );
TRACE( "%p %s %p %Ix\n", module, debugstr_a(type), func, param );
if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
FIXME( "unimplemented flags: %x\n", flags );
FIXME( "unimplemented flags: %lx\n", flags );
if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
if (!(flags & RESOURCE_ENUM_LN)) return ret;
@ -830,10 +830,10 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceNamesExW( HMODULE module, LPCWSTR type
const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
const IMAGE_RESOURCE_DIR_STRING_U *str;
TRACE( "%p %s %p %lx\n", module, debugstr_w(type), func, param );
TRACE( "%p %s %p %Ix\n", module, debugstr_w(type), func, param );
if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
FIXME( "unimplemented flags: %x\n", flags );
FIXME( "unimplemented flags: %lx\n", flags );
if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
if (!(flags & RESOURCE_ENUM_LN)) return ret;
@ -915,10 +915,10 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceTypesExA( HMODULE module, ENUMRESTYPEP
const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
const IMAGE_RESOURCE_DIR_STRING_U *str;
TRACE( "%p %p %lx\n", module, func, param );
TRACE( "%p %p %Ix\n", module, func, param );
if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
FIXME( "unimplemented flags: %x\n", flags );
FIXME( "unimplemented flags: %lx\n", flags );
if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
if (!(flags & RESOURCE_ENUM_LN)) return ret;
@ -968,7 +968,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceTypesExW( HMODULE module, ENUMRESTYPEP
const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
const IMAGE_RESOURCE_DIR_STRING_U *str;
TRACE( "%p %p %lx\n", module, func, param );
TRACE( "%p %p %Ix\n", module, func, param );
if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
if (!(flags & RESOURCE_ENUM_LN)) return ret;
@ -1126,7 +1126,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateActCtxW( PCACTCTXW ctx )
{
HANDLE context;
TRACE( "%p %08x\n", ctx, ctx ? ctx->dwFlags : 0 );
TRACE( "%p %08lx\n", ctx, ctx ? ctx->dwFlags : 0 );
if (!set_ntstatus( RtlCreateActivationContext( &context, ctx ))) return INVALID_HANDLE_VALUE;
return context;

62
dlls/kernelbase/locale.c
View File

@ -810,9 +810,9 @@ void init_locale(void)
if (!RegQueryValueExW( intl_key, L"Locale", NULL, NULL, (BYTE *)bufferW, &count ))
{
if (wcstoul( bufferW, NULL, 16 ) == user_lcid) return; /* already set correctly */
TRACE( "updating registry, locale changed %s -> %08x\n", debugstr_w(bufferW), user_lcid );
TRACE( "updating registry, locale changed %s -> %08lx\n", debugstr_w(bufferW), user_lcid );
}
else TRACE( "updating registry, locale changed none -> %08x\n", user_lcid );
else TRACE( "updating registry, locale changed none -> %08lx\n", user_lcid );
swprintf( bufferW, ARRAY_SIZE(bufferW), L"%08x", user_lcid );
RegSetValueExW( intl_key, L"Locale", 0, REG_SZ,
(BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
@ -2803,7 +2803,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumDateFormats( DATEFMT_ENUMPROCW proc,
lctype = LOCALE_SYEARMONTH;
break;
default:
FIXME( "unknown date format 0x%08x\n", flags );
FIXME( "unknown date format 0x%08lx\n", flags );
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
@ -2946,7 +2946,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumSystemLanguageGroups( LANGUAGEGROUP_E
if (!(flags & LGRPID_SUPPORTED) && !wcstoul( value, NULL, 10 )) continue;
if (!LoadStringW( kernel32_handle, 0x2000 + id, descr, ARRAY_SIZE(descr) )) descr[0] = 0;
TRACE( "%p: %u %s %s %x %lx\n", proc, id, debugstr_w(name), debugstr_w(descr), flags, param );
TRACE( "%p: %lu %s %s %lx %Ix\n", proc, id, debugstr_w(name), debugstr_w(descr), flags, param );
if (!unicode)
{
char nameA[10], descrA[80];
@ -2985,7 +2985,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumTimeFormats( TIMEFMT_ENUMPROCW proc,
lctype = LOCALE_SSHORTTIME;
break;
default:
FIXME( "Unknown time format %x\n", flags );
FIXME( "Unknown time format %lx\n", flags );
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
@ -3080,7 +3080,7 @@ INT WINAPI CompareStringEx( const WCHAR *locale, DWORD flags, const WCHAR *str1,
if (flags & semistub_flags)
{
if (!once++) FIXME( "semi-stub behavior for flag(s) 0x%x\n", flags & semistub_flags );
if (!once++) FIXME( "semi-stub behavior for flag(s) 0x%lx\n", flags & semistub_flags );
}
if (len1 < 0) len1 = lstrlenW(str1);
@ -3380,7 +3380,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemGeoID( GEOCLASS class, GEOID parent, GEO
{
INT i;
TRACE( "(%d, %d, %p)\n", class, parent, proc );
TRACE( "(%ld, %ld, %p)\n", class, parent, proc );
if (!proc)
{
@ -3560,7 +3560,7 @@ INT WINAPI DECLSPEC_HOTPATCH FindNLSStringEx( const WCHAR *locale, DWORD flags,
DWORD mask = flags;
int offset, inc, count;
TRACE( "%s %x %s %d %s %d %p %p %p %ld\n", wine_dbgstr_w(locale), flags,
TRACE( "%s %lx %s %d %s %d %p %p %p %Id\n", wine_dbgstr_w(locale), flags,
wine_dbgstr_w(src), srclen, wine_dbgstr_w(value), valuelen, found,
version, reserved, handle );
@ -3602,7 +3602,7 @@ INT WINAPI DECLSPEC_HOTPATCH FindStringOrdinal( DWORD flag, const WCHAR *src, IN
{
INT offset, inc, count;
TRACE( "%#x %s %d %s %d %d\n", flag, wine_dbgstr_w(src), src_size,
TRACE( "%#lx %s %d %s %d %d\n", flag, wine_dbgstr_w(src), src_size,
wine_dbgstr_w(val), val_size, ignore_case );
if (!src || !val)
@ -3736,7 +3736,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageA( DWORD flags, const void *source,
WCHAR *result, *message = NULL;
NTSTATUS status;
TRACE( "(0x%x,%p,%#x,0x%x,%p,%u,%p)\n", flags, source, msgid, langid, buffer, size, args );
TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
{
@ -3818,7 +3818,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageW( DWORD flags, const void *source,
WCHAR *message = NULL;
NTSTATUS status;
TRACE( "(0x%x,%p,%#x,0x%x,%p,%u,%p)\n", flags, source, msgid, langid, buffer, size, args );
TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
if (!buffer)
{
@ -4067,14 +4067,14 @@ INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoW( LCID lcid, CALID calendar, CALTYP
return GetLocaleInfoW( lcid, LOCALE_ICALENDARTYPE, data, count );
case CAL_SCALNAME:
FIXME( "Unimplemented caltype %d\n", calinfo );
FIXME( "Unimplemented caltype %ld\n", calinfo );
if (data) *data = 0;
return 1;
case CAL_IYEAROFFSETRANGE:
case CAL_SERASTRING:
case CAL_SABBREVERASTRING:
FIXME( "Unimplemented caltype %d\n", calinfo );
FIXME( "Unimplemented caltype %ld\n", calinfo );
return 0;
case CAL_SSHORTDATE:
@ -4151,7 +4151,7 @@ INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoW( LCID lcid, CALID calendar, CALTYP
}
break;
default:
FIXME( "Unknown caltype %d\n", calinfo );
FIXME( "Unknown caltype %ld\n", calinfo );
SetLastError( ERROR_INVALID_FLAGS );
return 0;
}
@ -4262,7 +4262,7 @@ done:
BOOL WINAPI /* DECLSPEC_HOTPATCH */ GetFileMUIInfo( DWORD flags, const WCHAR *path,
FILEMUIINFO *info, DWORD *size )
{
FIXME( "stub: %u, %s, %p, %p\n", flags, debugstr_w(path), info, size );
FIXME( "stub: %lu, %s, %p, %p\n", flags, debugstr_w(path), info, size );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
}
@ -4276,7 +4276,7 @@ BOOL WINAPI /* DECLSPEC_HOTPATCH */ GetFileMUIPath( DWORD flags, const WCHAR *fi
WCHAR *muipath, ULONG *muipathlen,
ULONGLONG *enumerator )
{
FIXME( "stub: 0x%x, %s, %s, %p, %p, %p, %p\n", flags, debugstr_w(filepath),
FIXME( "stub: 0x%lx, %s, %s, %p, %p, %p, %p\n", flags, debugstr_w(filepath),
debugstr_w(language), languagelen, muipath, muipathlen, enumerator );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
@ -4293,7 +4293,7 @@ INT WINAPI DECLSPEC_HOTPATCH GetGeoInfoW( GEOID id, GEOTYPE type, WCHAR *data, i
const WCHAR *str = bufferW;
int len;
TRACE( "%d %d %p %d %d\n", id, type, data, count, lang );
TRACE( "%ld %ld %p %d %d\n", id, type, data, count, lang );
if (!ptr)
{
@ -4332,11 +4332,11 @@ INT WINAPI DECLSPEC_HOTPATCH GetGeoInfoW( GEOID id, GEOTYPE type, WCHAR *data, i
case GEO_CURRENCYCODE:
case GEO_CURRENCYSYMBOL:
case GEO_NAME:
FIXME( "type %d is not supported\n", type );
FIXME( "type %ld is not supported\n", type );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return 0;
default:
WARN( "unrecognized type %d\n", type );
WARN( "unrecognized type %ld\n", type );
SetLastError( ERROR_INVALID_FLAGS );
return 0;
}
@ -4358,7 +4358,7 @@ INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoA( LCID lcid, LCTYPE lctype, char *buf
WCHAR *bufferW;
INT lenW, ret;
TRACE( "lcid=0x%x lctype=0x%x %p %d\n", lcid, lctype, buffer, len );
TRACE( "lcid=0x%lx lctype=0x%lx %p %d\n", lcid, lctype, buffer, len );
if (len < 0 || (len && !buffer))
{
@ -4417,7 +4417,7 @@ INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoW( LCID lcid, LCTYPE lctype, WCHAR *bu
lcid = ConvertDefaultLocale( lcid );
lctype = LOWORD(lctype);
TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d)\n", lcid, lctype, buffer, len );
TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d)\n", lcid, lctype, buffer, len );
/* first check for overrides in the registry */
@ -4510,7 +4510,7 @@ INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoW( LCID lcid, LCTYPE lctype, WCHAR *bu
}
HeapFree( GetProcessHeap(), 0, tmp );
TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning number %d\n",
TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning number %d\n",
lcid, lctype, buffer, len, number );
}
else
@ -4518,7 +4518,7 @@ INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoW( LCID lcid, LCTYPE lctype, WCHAR *bu
memcpy( buffer, p + 1, ret * sizeof(WCHAR) );
if (lctype != LOCALE_FONTSIGNATURE) buffer[ret-1] = 0;
TRACE( "(lcid=0x%x,lctype=0x%x,%p,%d) returning %d %s\n",
TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning %d %s\n",
lcid, lctype, buffer, len, ret, debugstr_w(buffer) );
}
return ret;
@ -4532,7 +4532,7 @@ INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoEx( const WCHAR *locale, LCTYPE info,
{
LCID lcid = LocaleNameToLCID( locale, 0 );
TRACE( "%s lcid=0x%x 0x%x\n", debugstr_w(locale), lcid, info );
TRACE( "%s lcid=0x%lx 0x%lx\n", debugstr_w(locale), lcid, info );
if (!lcid) return 0;
@ -4904,7 +4904,7 @@ GEOID WINAPI DECLSPEC_HOTPATCH GetUserGeoID( GEOCLASS geoclass )
name = L"Region";
break;
default:
WARN("Unknown geoclass %d\n", geoclass);
WARN("Unknown geoclass %ld\n", geoclass);
return GEOID_NOT_AVAILABLE;
}
if (!RegOpenKeyExW( intl_key, L"Geo", 0, KEY_ALL_ACCESS, &hkey ))
@ -5237,7 +5237,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH IsValidNLSVersion( NLS_FUNCTION func, const WCHAR
INT WINAPI DECLSPEC_HOTPATCH LCIDToLocaleName( LCID lcid, WCHAR *name, INT count, DWORD flags )
{
static int once;
if (flags && !once++) FIXME( "unsupported flags %x\n", flags );
if (flags && !once++) FIXME( "unsupported flags %lx\n", flags );
return GetLocaleInfoW( lcid, LOCALE_SNAME | LOCALE_NOUSEROVERRIDE, name, count );
}
@ -5259,7 +5259,7 @@ INT WINAPI DECLSPEC_HOTPATCH LCMapStringEx( const WCHAR *locale, DWORD flags, co
if (handle)
{
static int once;
if (!once++) FIXME( "unsupported lparam %lx\n", handle );
if (!once++) FIXME( "unsupported lparam %Ix\n", handle );
}
if (!src || !srclen || dstlen < 0)
@ -5299,7 +5299,7 @@ INT WINAPI DECLSPEC_HOTPATCH LCMapStringEx( const WCHAR *locale, DWORD flags, co
}
if (srclen < 0) srclen = lstrlenW(src);
TRACE( "(%s,0x%08x,%s,%d,%p,%d)\n",
TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
if ((ret = get_sortkey( flags, src, srclen, (char *)dst, dstlen ))) ret++;
@ -5324,7 +5324,7 @@ INT WINAPI DECLSPEC_HOTPATCH LCMapStringEx( const WCHAR *locale, DWORD flags, co
if (srclen < 0) srclen = lstrlenW(src) + 1;
TRACE( "(%s,0x%08x,%s,%d,%p,%d)\n",
TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
if (!dst) /* return required string length */
@ -5650,7 +5650,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetLocaleInfoW( LCID lcid, LCTYPE lctype, const WC
return FALSE;
}
TRACE( "setting %x (%s) to %s\n", lctype, debugstr_w(value->name), debugstr_w(data) );
TRACE( "setting %lx (%s) to %s\n", lctype, debugstr_w(value->name), debugstr_w(data) );
/* FIXME: should check that data to set is sane */
@ -5696,7 +5696,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetLocaleInfoW( LCID lcid, LCTYPE lctype, const WC
*/
INT WINAPI /* DECLSPEC_HOTPATCH */ SetCalendarInfoW( LCID lcid, CALID calendar, CALTYPE type, const WCHAR *data )
{
FIXME( "(%08x,%08x,%08x,%s): stub\n", lcid, calendar, type, debugstr_w(data) );
FIXME( "(%08lx,%08lx,%08lx,%s): stub\n", lcid, calendar, type, debugstr_w(data) );
return 0;
}

12
dlls/kernelbase/main.c
View File

@ -195,7 +195,7 @@ PERF_COUNTERSET_INSTANCE WINAPI *PerfCreateInstance( HANDLE handle, const GUID *
unsigned int i;
ULONG size;
FIXME( "handle %p, guid %s, name %s, id %u semi-stub.\n", handle, debugstr_guid(guid), debugstr_w(name), id );
FIXME( "handle %p, guid %s, name %s, id %lu semi-stub.\n", handle, debugstr_guid(guid), debugstr_w(name), id );
if (!prov || !guid || !name)
{
@ -274,7 +274,7 @@ ULONG WINAPI PerfSetCounterSetInfo( HANDLE handle, PERF_COUNTERSET_INFO *templat
struct counterset_template *new;
unsigned int i;
FIXME( "handle %p, template %p, size %u semi-stub.\n", handle, template, size );
FIXME( "handle %p, template %p, size %lu semi-stub.\n", handle, template, size );
if (!prov || !template) return ERROR_INVALID_PARAMETER;
if (!template->NumCounters) return ERROR_INVALID_PARAMETER;
@ -320,7 +320,7 @@ ULONG WINAPI PerfSetCounterRefValue(HANDLE provider, PERF_COUNTERSET_INSTANCE *i
struct counterset_instance *inst;
unsigned int i;
FIXME( "provider %p, instance %p, counterid %u, address %p semi-stub.\n",
FIXME( "provider %p, instance %p, counterid %lu, address %p semi-stub.\n",
provider, instance, counterid, address );
if (!prov || !instance || !address) return ERROR_INVALID_PARAMETER;
@ -438,7 +438,7 @@ HRESULT WINAPI QISearch(void *base, const QITAB *table, REFIID riid, void **obj)
for (ptr = table; ptr->piid; ++ptr)
{
TRACE("trying (offset %d) %s\n", ptr->dwOffset, debugstr_guid(ptr->piid));
TRACE("trying (offset %ld) %s\n", ptr->dwOffset, debugstr_guid(ptr->piid));
if (IsEqualIID(riid, ptr->piid))
{
unk = (IUnknown *)((BYTE *)base + ptr->dwOffset);
@ -469,7 +469,7 @@ HRESULT WINAPI GetAcceptLanguagesA(LPSTR langbuf, DWORD *buflen)
WCHAR *langbufW;
HRESULT hr;
TRACE("%p, %p, *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
TRACE("%p, %p, *%p: %ld\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
if (!langbuf || !buflen || !*buflen)
return E_FAIL;
@ -538,7 +538,7 @@ HRESULT WINAPI GetAcceptLanguagesW(WCHAR *langbuf, DWORD *buflen)
LONG lres;
DWORD len;
TRACE("%p, %p, *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
TRACE("%p, %p, *%p: %ld\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
if (!langbuf || !buflen || !*buflen)
return E_FAIL;

28
dlls/kernelbase/memory.c
View File

@ -260,7 +260,7 @@ UINT WINAPI DECLSPEC_HOTPATCH ResetWriteWatch( void *base, SIZE_T size )
*/
BOOL WINAPI DECLSPEC_HOTPATCH SetSystemFileCacheSize( SIZE_T mincache, SIZE_T maxcache, DWORD flags )
{
FIXME( "stub: %ld %ld %d\n", mincache, maxcache, flags );
FIXME( "stub: %Id %Id %ld\n", mincache, maxcache, flags );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
}
@ -329,7 +329,7 @@ LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocFromApp( void *addr, SIZE_T size,
{
LPVOID ret = addr;
TRACE_(virtual)( "addr %p, size %p, type %#x, protect %#x.\n", addr, (void *)size, type, protect );
TRACE_(virtual)( "addr %p, size %p, type %#lx, protect %#lx.\n", addr, (void *)size, type, protect );
if (protect == PAGE_EXECUTE || protect == PAGE_EXECUTE_READ || protect == PAGE_EXECUTE_READWRITE
|| protect == PAGE_EXECUTE_WRITECOPY)
@ -349,7 +349,7 @@ LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocFromApp( void *addr, SIZE_T size,
BOOL WINAPI /* DECLSPEC_HOTPATCH */ PrefetchVirtualMemory( HANDLE process, ULONG_PTR count,
WIN32_MEMORY_RANGE_ENTRY *addresses, ULONG flags )
{
FIXME( "process %p, count %p, addresses %p, flags %#x stub.\n", process, (void *)count, addresses, flags );
FIXME( "process %p, count %p, addresses %p, flags %#lx stub.\n", process, (void *)count, addresses, flags );
return TRUE;
}
@ -1079,7 +1079,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GlobalMemoryStatusEx( MEMORYSTATUSEX *status )
if (status->ullTotalPhys)
status->dwMemoryLoad = (status->ullTotalPhys - status->ullAvailPhys) / (status->ullTotalPhys / 100);
TRACE_(virtual)( "MemoryLoad %d, TotalPhys %s, AvailPhys %s, TotalPageFile %s,"
TRACE_(virtual)( "MemoryLoad %ld, TotalPhys %s, AvailPhys %s, TotalPageFile %s,"
"AvailPageFile %s, TotalVirtual %s, AvailVirtual %s\n",
status->dwMemoryLoad, wine_dbgstr_longlong(status->ullTotalPhys),
wine_dbgstr_longlong(status->ullAvailPhys), wine_dbgstr_longlong(status->ullTotalPageFile),
@ -1096,7 +1096,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GlobalMemoryStatusEx( MEMORYSTATUSEX *status )
*/
BOOL WINAPI DECLSPEC_HOTPATCH MapUserPhysicalPages( void *addr, ULONG_PTR page_count, ULONG_PTR *pages )
{
FIXME( "stub: %p %lu %p\n", addr, page_count, pages );
FIXME( "stub: %p %Iu %p\n", addr, page_count, pages );
*pages = 0;
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
@ -1114,7 +1114,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH MapUserPhysicalPages( void *addr, ULONG_PTR page_c
BOOL WINAPI DECLSPEC_HOTPATCH AllocateUserPhysicalPagesNuma( HANDLE process, ULONG_PTR *pages,
ULONG_PTR *userarray, DWORD node )
{
if (node) FIXME( "Ignoring preferred node %u\n", node );
if (node) FIXME( "Ignoring preferred node %lu\n", node );
return AllocateUserPhysicalPages( process, pages, userarray );
}
@ -1126,7 +1126,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileMappingNumaW( HANDLE file, LPSECURITY_
DWORD protect, DWORD size_high, DWORD size_low,
LPCWSTR name, DWORD node )
{
if (node) FIXME( "Ignoring preferred node %u\n", node );
if (node) FIXME( "Ignoring preferred node %lu\n", node );
return CreateFileMappingW( file, sa, protect, size_high, size_low, name );
}
@ -1177,7 +1177,7 @@ BOOL WINAPI GetSystemCpuSetInformation(SYSTEM_CPU_SET_INFORMATION *info, ULONG b
HANDLE process, ULONG flags)
{
if (flags)
FIXME("Unsupported flags %#x.\n", flags);
FIXME("Unsupported flags %#lx.\n", flags);
*return_length = 0;
@ -1191,7 +1191,7 @@ BOOL WINAPI GetSystemCpuSetInformation(SYSTEM_CPU_SET_INFORMATION *info, ULONG b
*/
BOOL WINAPI SetThreadSelectedCpuSets(HANDLE thread, const ULONG *cpu_set_ids, ULONG count)
{
FIXME( "thread %p, cpu_set_ids %p, count %u stub.\n", thread, cpu_set_ids, count );
FIXME( "thread %p, cpu_set_ids %p, count %lu stub.\n", thread, cpu_set_ids, count );
return TRUE;
}
@ -1236,7 +1236,7 @@ LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFileExNuma( HANDLE handle, DWORD access
DWORD offset_low, SIZE_T count, LPVOID addr,
DWORD node )
{
if (node) FIXME( "Ignoring preferred node %u\n", node );
if (node) FIXME( "Ignoring preferred node %lu\n", node );
return MapViewOfFileEx( handle, access, offset_high, offset_low, count, addr );
}
@ -1247,7 +1247,7 @@ LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFileExNuma( HANDLE handle, DWORD access
LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocExNuma( HANDLE process, void *addr, SIZE_T size,
DWORD type, DWORD protect, DWORD node )
{
if (node) FIXME( "Ignoring preferred node %u\n", node );
if (node) FIXME( "Ignoring preferred node %lu\n", node );
return VirtualAllocEx( process, addr, size, type, protect );
}
@ -1277,7 +1277,7 @@ BOOL WINAPI InitializeContext2( void *buffer, DWORD context_flags, CONTEXT **con
ULONG orig_length;
NTSTATUS status;
TRACE( "buffer %p, context_flags %#x, context %p, ret_length %p, compaction_mask %s.\n",
TRACE( "buffer %p, context_flags %#lx, context %p, ret_length %p, compaction_mask %s.\n",
buffer, context_flags, context, length, wine_dbgstr_longlong(compaction_mask) );
orig_length = *length;
@ -1460,7 +1460,7 @@ BOOL WINAPI GetXStateFeaturesMask( CONTEXT *context, DWORD64 *feature_mask )
*/
UINT WINAPI EnumSystemFirmwareTables( DWORD provider, void *buffer, DWORD size )
{
FIXME( "(0x%08x, %p, %d)\n", provider, buffer, size );
FIXME( "(0x%08lx, %p, %ld)\n", provider, buffer, size );
return 0;
}
@ -1473,7 +1473,7 @@ UINT WINAPI GetSystemFirmwareTable( DWORD provider, DWORD id, void *buffer, DWOR
SYSTEM_FIRMWARE_TABLE_INFORMATION *info;
ULONG buffer_size = offsetof( SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer ) + size;
TRACE( "(0x%08x, 0x%08x, %p, %d)\n", provider, id, buffer, size );
TRACE( "(0x%08lx, 0x%08lx, %p, %ld)\n", provider, id, buffer, size );
if (!(info = RtlAllocateHeap( GetProcessHeap(), 0, buffer_size )))
{

78
dlls/kernelbase/path.c
View File

@ -200,7 +200,7 @@ HRESULT WINAPI PathAllocCanonicalize(const WCHAR *path_in, DWORD flags, WCHAR **
const WCHAR *root_end;
SIZE_T buffer_size, length;
TRACE("%s %#x %p\n", debugstr_w(path_in), flags, path_out);
TRACE("%s %#lx %p\n", debugstr_w(path_in), flags, path_out);
if (!path_in || !path_out
|| ((flags & PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS) && (flags & PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS))
@ -387,7 +387,7 @@ HRESULT WINAPI PathAllocCombine(const WCHAR *path1, const WCHAR *path2, DWORD fl
BOOL add_backslash = FALSE;
HRESULT hr;
TRACE("%s %s %#x %p\n", wine_dbgstr_w(path1), wine_dbgstr_w(path2), flags, out);
TRACE("%s %s %#lx %p\n", wine_dbgstr_w(path1), wine_dbgstr_w(path2), flags, out);
if ((!path1 && !path2) || !out)
{
@ -448,7 +448,7 @@ HRESULT WINAPI PathCchAddBackslashEx(WCHAR *path, SIZE_T size, WCHAR **endptr, S
BOOL needs_termination;
SIZE_T length;
TRACE("%s, %lu, %p, %p\n", debugstr_w(path), size, endptr, remaining);
TRACE("%s, %Iu, %p, %p\n", debugstr_w(path), size, endptr, remaining);
length = lstrlenW(path);
needs_termination = size && length && path[length - 1] != '\\';
@ -483,7 +483,7 @@ HRESULT WINAPI PathCchAddExtension(WCHAR *path, SIZE_T size, const WCHAR *extens
BOOL has_dot;
HRESULT hr;
TRACE("%s %lu %s\n", wine_dbgstr_w(path), size, wine_dbgstr_w(extension));
TRACE("%s %Iu %s\n", wine_dbgstr_w(path), size, wine_dbgstr_w(extension));
if (!path || !size || size > PATHCCH_MAX_CCH || !extension) return E_INVALIDARG;
@ -521,7 +521,7 @@ HRESULT WINAPI PathCchAddExtension(WCHAR *path, SIZE_T size, const WCHAR *extens
HRESULT WINAPI PathCchAppend(WCHAR *path1, SIZE_T size, const WCHAR *path2)
{
TRACE("%s %lu %s\n", wine_dbgstr_w(path1), size, wine_dbgstr_w(path2));
TRACE("%s %Iu %s\n", wine_dbgstr_w(path1), size, wine_dbgstr_w(path2));
return PathCchAppendEx(path1, size, path2, PATHCCH_NONE);
}
@ -531,7 +531,7 @@ HRESULT WINAPI PathCchAppendEx(WCHAR *path1, SIZE_T size, const WCHAR *path2, DW
HRESULT hr;
WCHAR *result;
TRACE("%s %lu %s %#x\n", wine_dbgstr_w(path1), size, wine_dbgstr_w(path2), flags);
TRACE("%s %Iu %s %#lx\n", wine_dbgstr_w(path1), size, wine_dbgstr_w(path2), flags);
if (!path1 || !size) return E_INVALIDARG;
@ -553,7 +553,7 @@ HRESULT WINAPI PathCchAppendEx(WCHAR *path1, SIZE_T size, const WCHAR *path2, DW
HRESULT WINAPI PathCchCanonicalize(WCHAR *out, SIZE_T size, const WCHAR *in)
{
TRACE("%p %lu %s\n", out, size, wine_dbgstr_w(in));
TRACE("%p %Iu %s\n", out, size, wine_dbgstr_w(in));
/* Not X:\ and path > MAX_PATH - 4, return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) */
if (lstrlenW(in) > MAX_PATH - 4 && !(is_drive_spec( in ) && in[2] == '\\'))
@ -568,7 +568,7 @@ HRESULT WINAPI PathCchCanonicalizeEx(WCHAR *out, SIZE_T size, const WCHAR *in, D
SIZE_T length;
HRESULT hr;
TRACE("%p %lu %s %#x\n", out, size, wine_dbgstr_w(in), flags);
TRACE("%p %Iu %s %#lx\n", out, size, wine_dbgstr_w(in), flags);
if (!size) return E_INVALIDARG;
@ -614,7 +614,7 @@ HRESULT WINAPI PathCchCombineEx(WCHAR *out, SIZE_T size, const WCHAR *path1, con
WCHAR *buffer;
SIZE_T length;
TRACE("%p %s %s %#x\n", out, wine_dbgstr_w(path1), wine_dbgstr_w(path2), flags);
TRACE("%p %s %s %#lx\n", out, wine_dbgstr_w(path1), wine_dbgstr_w(path2), flags);
if (!out || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
@ -645,7 +645,7 @@ HRESULT WINAPI PathCchFindExtension(const WCHAR *path, SIZE_T size, const WCHAR
const WCHAR *lastpoint = NULL;
SIZE_T counter = 0;
TRACE("%s %lu %p\n", wine_dbgstr_w(path), size, extension);
TRACE("%s %Iu %p\n", wine_dbgstr_w(path), size, extension);
if (!path || !size || size > PATHCCH_MAX_CCH)
{
@ -716,7 +716,7 @@ HRESULT WINAPI PathCchRemoveBackslash(WCHAR *path, SIZE_T path_size)
WCHAR *path_end;
SIZE_T free_size;
TRACE("%s %lu\n", debugstr_w(path), path_size);
TRACE("%s %Iu\n", debugstr_w(path), path_size);
return PathCchRemoveBackslashEx(path, path_size, &path_end, &free_size);
}
@ -726,7 +726,7 @@ HRESULT WINAPI PathCchRemoveBackslashEx(WCHAR *path, SIZE_T path_size, WCHAR **p
const WCHAR *root_end;
SIZE_T path_length;
TRACE("%s %lu %p %p\n", debugstr_w(path), path_size, path_end, free_size);
TRACE("%s %Iu %p %p\n", debugstr_w(path), path_size, path_end, free_size);
if (!path_size || !path_end || !free_size)
{
@ -766,7 +766,7 @@ HRESULT WINAPI PathCchRemoveExtension(WCHAR *path, SIZE_T size)
WCHAR *next;
HRESULT hr;
TRACE("%s %lu\n", wine_dbgstr_w(path), size);
TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
@ -785,7 +785,7 @@ HRESULT WINAPI PathCchRemoveFileSpec(WCHAR *path, SIZE_T size)
SIZE_T length;
WCHAR *last;
TRACE("%s %lu\n", wine_dbgstr_w(path), size);
TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
@ -820,7 +820,7 @@ HRESULT WINAPI PathCchRenameExtension(WCHAR *path, SIZE_T size, const WCHAR *ext
{
HRESULT hr;
TRACE("%s %lu %s\n", wine_dbgstr_w(path), size, wine_dbgstr_w(extension));
TRACE("%s %Iu %s\n", wine_dbgstr_w(path), size, wine_dbgstr_w(extension));
hr = PathCchRemoveExtension(path, size);
if (FAILED(hr)) return hr;
@ -861,7 +861,7 @@ HRESULT WINAPI PathCchSkipRoot(const WCHAR *path, const WCHAR **root_end)
HRESULT WINAPI PathCchStripPrefix(WCHAR *path, SIZE_T size)
{
TRACE("%s %lu\n", wine_dbgstr_w(path), size);
TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
@ -889,7 +889,7 @@ HRESULT WINAPI PathCchStripToRoot(WCHAR *path, SIZE_T size)
WCHAR *segment_end;
BOOL is_unc;
TRACE("%s %lu\n", wine_dbgstr_w(path), size);
TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !*path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
@ -2361,7 +2361,7 @@ BOOL WINAPI PathRelativePathToA(char *path, const char *from, DWORD attributes_f
WCHAR pathW[MAX_PATH], fromW[MAX_PATH], toW[MAX_PATH];
BOOL ret;
TRACE("%p, %s, %#x, %s, %#x\n", path, wine_dbgstr_a(from), attributes_from, wine_dbgstr_a(to), attributes_to);
TRACE("%p, %s, %#lx, %s, %#lx\n", path, wine_dbgstr_a(from), attributes_from, wine_dbgstr_a(to), attributes_to);
if (!path || !from || !to)
return FALSE;
@ -2380,7 +2380,7 @@ BOOL WINAPI PathRelativePathToW(WCHAR *path, const WCHAR *from, DWORD attributes
WCHAR fromW[MAX_PATH], toW[MAX_PATH];
DWORD len;
TRACE("%p, %s, %#x, %s, %#x\n", path, wine_dbgstr_w(from), attributes_from, wine_dbgstr_w(to), attributes_to);
TRACE("%p, %s, %#lx, %s, %#lx\n", path, wine_dbgstr_w(from), attributes_from, wine_dbgstr_w(to), attributes_to);
if (!path || !from || !to)
return FALSE;
@ -2841,7 +2841,7 @@ HRESULT WINAPI UrlUnescapeA(char *url, char *unescaped, DWORD *unescaped_len, DW
DWORD needed;
HRESULT hr;
TRACE("%s, %p, %p, %#x\n", wine_dbgstr_a(url), unescaped, unescaped_len, flags);
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_a(url), unescaped, unescaped_len, flags);
if (!url)
return E_INVALIDARG;
@ -2906,7 +2906,7 @@ HRESULT WINAPI UrlUnescapeW(WCHAR *url, WCHAR *unescaped, DWORD *unescaped_len,
DWORD needed;
HRESULT hr;
TRACE("%s, %p, %p, %#x\n", wine_dbgstr_w(url), unescaped, unescaped_len, flags);
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_w(url), unescaped, unescaped_len, flags);
if (!url)
return E_INVALIDARG;
@ -3003,7 +3003,7 @@ HRESULT WINAPI PathCreateFromUrlW(const WCHAR *url, WCHAR *path, DWORD *pcchPath
WCHAR *tpath, *dst;
HRESULT hr = S_OK;
TRACE("%s, %p, %p, %#x\n", wine_dbgstr_w(url), path, pcchPath, dwReserved);
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_w(url), path, pcchPath, dwReserved);
if (!url || !path || !pcchPath || !*pcchPath)
return E_INVALIDARG;
@ -3124,7 +3124,7 @@ HRESULT WINAPI PathCreateFromUrlW(const WCHAR *url, WCHAR *path, DWORD *pcchPath
if (tpath != path)
heap_free(tpath);
TRACE("Returning (%u) %s\n", *pcchPath, wine_dbgstr_w(path));
TRACE("Returning (%lu) %s\n", *pcchPath, wine_dbgstr_w(path));
return hr;
}
@ -3285,7 +3285,7 @@ HRESULT WINAPI UrlEscapeW(const WCHAR *url, WCHAR *escaped, DWORD *escaped_len,
INT i, len;
HRESULT hr;
TRACE("%p, %s, %p, %p, %#x\n", url, wine_dbgstr_w(url), escaped, escaped_len, flags);
TRACE("%p, %s, %p, %p, %#lx\n", url, wine_dbgstr_w(url), escaped, escaped_len, flags);
if (!url || !escaped_len || !escaped || *escaped_len == 0)
return E_INVALIDARG;
@ -3293,7 +3293,7 @@ HRESULT WINAPI UrlEscapeW(const WCHAR *url, WCHAR *escaped, DWORD *escaped_len,
if (flags & ~(URL_ESCAPE_SPACES_ONLY | URL_ESCAPE_SEGMENT_ONLY | URL_DONT_ESCAPE_EXTRA_INFO |
URL_ESCAPE_PERCENT | URL_ESCAPE_AS_UTF8))
{
FIXME("Unimplemented flags: %08x\n", flags);
FIXME("Unimplemented flags: %08lx\n", flags);
}
dst_ptr = dst = heap_alloc(*escaped_len * sizeof(WCHAR));
@ -3470,7 +3470,7 @@ HRESULT WINAPI UrlCanonicalizeA(const char *src_url, char *canonicalized, DWORD
LPWSTR url, canonical;
HRESULT hr;
TRACE("%s, %p, %p, %#x\n", wine_dbgstr_a(src_url), canonicalized, canonicalized_len, flags);
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_a(src_url), canonicalized, canonicalized_len, flags);
if (!src_url || !canonicalized || !canonicalized_len || !*canonicalized_len)
return E_INVALIDARG;
@ -3504,7 +3504,7 @@ HRESULT WINAPI UrlCanonicalizeW(const WCHAR *src_url, WCHAR *canonicalized, DWOR
BOOL is_file_url;
INT state;
TRACE("%s, %p, %p, %#x\n", wine_dbgstr_w(src_url), canonicalized, canonicalized_len, flags);
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_w(src_url), canonicalized, canonicalized_len, flags);
if (!src_url || !canonicalized || !canonicalized_len || !*canonicalized_len)
return E_INVALIDARG;
@ -3848,7 +3848,7 @@ HRESULT WINAPI UrlApplySchemeA(const char *url, char *out, DWORD *out_len, DWORD
HRESULT hr;
DWORD len;
TRACE("%s, %p, %p:out size %d, %#x\n", wine_dbgstr_a(url), out, out_len, out_len ? *out_len : 0, flags);
TRACE("%s, %p, %p:out size %ld, %#lx\n", wine_dbgstr_a(url), out, out_len, out_len ? *out_len : 0, flags);
if (!url || !out || !out_len)
return E_INVALIDARG;
@ -3995,7 +3995,7 @@ HRESULT WINAPI UrlApplySchemeW(const WCHAR *url, WCHAR *out, DWORD *length, DWOR
DWORD res1;
HRESULT hr;
TRACE("%s, %p, %p:out size %d, %#x\n", wine_dbgstr_w(url), out, length, length ? *length : 0, flags);
TRACE("%s, %p, %p:out size %ld, %#lx\n", wine_dbgstr_w(url), out, length, length ? *length : 0, flags);
if (!url || !out || !length)
return E_INVALIDARG;
@ -4083,7 +4083,7 @@ HRESULT WINAPI UrlFixupW(const WCHAR *url, WCHAR *translatedUrl, DWORD maxChars)
{
DWORD srcLen;
FIXME("%s, %p, %d stub\n", wine_dbgstr_w(url), translatedUrl, maxChars);
FIXME("%s, %p, %ld stub\n", wine_dbgstr_w(url), translatedUrl, maxChars);
if (!url)
return E_FAIL;
@ -4298,7 +4298,7 @@ static LONG parse_url(const WCHAR *url, struct parsed_url *pl)
if (pl->query) pl->query_len = lstrlenW(pl->query);
}
SuccessExit:
TRACE("parse successful: scheme=%p(%d), user=%p(%d), pass=%p(%d), host=%p(%d), port=%p(%d), query=%p(%d)\n",
TRACE("parse successful: scheme=%p(%ld), user=%p(%ld), pass=%p(%ld), host=%p(%ld), port=%p(%ld), query=%p(%ld)\n",
pl->scheme, pl->scheme_len, pl->username, pl->username_len, pl->password, pl->password_len, pl->hostname,
pl->hostname_len, pl->port, pl->port_len, pl->query, pl->query_len);
@ -4316,7 +4316,7 @@ HRESULT WINAPI UrlGetPartW(const WCHAR *url, WCHAR *out, DWORD *out_len, DWORD p
struct parsed_url pl;
HRESULT hr;
TRACE("%s, %p, %p(%d), %#x, %#x\n", wine_dbgstr_w(url), out, out_len, *out_len, part, flags);
TRACE("%s, %p, %p(%ld), %#lx, %#lx\n", wine_dbgstr_w(url), out, out_len, *out_len, part, flags);
if (!url || !out || !out_len || !*out_len)
return E_INVALIDARG;
@ -4449,7 +4449,7 @@ HRESULT WINAPI UrlGetPartW(const WCHAR *url, WCHAR *out, DWORD *out_len, DWORD p
out[size] = 0;
*out_len = size;
}
TRACE("len=%d %s\n", *out_len, wine_dbgstr_w(out));
TRACE("len=%ld %s\n", *out_len, wine_dbgstr_w(out));
return hr;
}
@ -4608,7 +4608,7 @@ HRESULT WINAPI UrlCreateFromPathW(const WCHAR *path, WCHAR *url, DWORD *url_len,
{
HRESULT hr;
TRACE("%s, %p, %p, %#x\n", debugstr_w(path), url, url_len, reserved);
TRACE("%s, %p, %p, %#lx\n", debugstr_w(path), url, url_len, reserved);
if (reserved || !url || !url_len)
return E_INVALIDARG;
@ -4626,7 +4626,7 @@ HRESULT WINAPI UrlCombineA(const char *base, const char *relative, char *combine
DWORD len, len2;
HRESULT hr;
TRACE("%s, %s, %d, %#x\n", debugstr_a(base), debugstr_a(relative), combined_len ? *combined_len : 0, flags);
TRACE("%s, %s, %ld, %#lx\n", debugstr_a(base), debugstr_a(relative), combined_len ? *combined_len : 0, flags);
if (!base || !relative || !combined_len)
return E_INVALIDARG;
@ -4667,7 +4667,7 @@ HRESULT WINAPI UrlCombineW(const WCHAR *baseW, const WCHAR *relativeW, WCHAR *co
PARSEDURLW base, relative;
HRESULT hr;
TRACE("%s, %s, %d, %#x\n", debugstr_w(baseW), debugstr_w(relativeW), combined_len ? *combined_len : 0, flags);
TRACE("%s, %s, %ld, %#lx\n", debugstr_w(baseW), debugstr_w(relativeW), combined_len ? *combined_len : 0, flags);
if (!baseW || !relativeW || !combined_len)
return E_INVALIDARG;
@ -4915,7 +4915,7 @@ HRESULT WINAPI UrlCombineW(const WCHAR *baseW, const WCHAR *relativeW, WCHAR *co
break;
default:
FIXME("Unexpected case %d.\n", process_case);
FIXME("Unexpected case %ld.\n", process_case);
hr = E_INVALIDARG;
}
@ -4928,7 +4928,7 @@ HRESULT WINAPI UrlCombineW(const WCHAR *baseW, const WCHAR *relativeW, WCHAR *co
if (SUCCEEDED(hr) && combined)
lstrcpyW(combined, mrelative);
TRACE("return-%d len=%d, %s\n", process_case, *combined_len, debugstr_w(combined));
TRACE("return-%ld len=%ld, %s\n", process_case, *combined_len, debugstr_w(combined));
}
heap_free(preliminary);
@ -4980,7 +4980,7 @@ HRESULT WINAPI UrlHashW(const WCHAR *url, unsigned char *dest, DWORD dest_len)
{
char urlA[MAX_PATH];
TRACE("%s, %p, %d\n", debugstr_w(url), dest, dest_len);
TRACE("%s, %p, %ld\n", debugstr_w(url), dest, dest_len);
__TRY
{

22
dlls/kernelbase/process.c
View File

@ -530,7 +530,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessInternalW( HANDLE token, const WCHAR
if (flags & (IDLE_PRIORITY_CLASS | HIGH_PRIORITY_CLASS | REALTIME_PRIORITY_CLASS |
CREATE_DEFAULT_ERROR_MODE | CREATE_NO_WINDOW |
PROFILE_USER | PROFILE_KERNEL | PROFILE_SERVER))
WARN( "(%s,...): ignoring some flags in %x\n", debugstr_w(app_name), flags );
WARN( "(%s,...): ignoring some flags in %lx\n", debugstr_w(app_name), flags );
if (cur_dir)
{
@ -646,7 +646,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessInternalW( HANDLE token, const WCHAR
info->dwProcessId = HandleToUlong( rtl_info.ClientId.UniqueProcess );
info->dwThreadId = HandleToUlong( rtl_info.ClientId.UniqueThread );
if (!(flags & CREATE_SUSPENDED)) NtResumeThread( rtl_info.Thread, NULL );
TRACE( "started process pid %04x tid %04x\n", info->dwProcessId, info->dwThreadId );
TRACE( "started process pid %04lx tid %04lx\n", info->dwProcessId, info->dwThreadId );
}
done:
@ -855,7 +855,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetProcessId( HANDLE process )
BOOL WINAPI /* DECLSPEC_HOTPATCH */ GetProcessMitigationPolicy( HANDLE process, PROCESS_MITIGATION_POLICY policy,
void *buffer, SIZE_T length )
{
FIXME( "(%p, %u, %p, %lu): stub\n", process, policy, buffer, length );
FIXME( "(%p, %u, %p, %Iu): stub\n", process, policy, buffer, length );
return TRUE;
}
@ -1128,7 +1128,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetPriorityClass( HANDLE process, DWORD class )
*/
BOOL WINAPI DECLSPEC_HOTPATCH SetProcessAffinityUpdateMode( HANDLE process, DWORD flags )
{
FIXME( "(%p,0x%08x): stub\n", process, flags );
FIXME( "(%p,0x%08lx): stub\n", process, flags );
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
}
@ -1152,7 +1152,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetProcessGroupAffinity( HANDLE process, const GRO
BOOL WINAPI /* DECLSPEC_HOTPATCH */ SetProcessMitigationPolicy( PROCESS_MITIGATION_POLICY policy,
void *buffer, SIZE_T length )
{
FIXME( "(%d, %p, %lu): stub\n", policy, buffer, length );
FIXME( "(%d, %p, %Iu): stub\n", policy, buffer, length );
return TRUE;
}
@ -1172,7 +1172,7 @@ BOOL WINAPI /* DECLSPEC_HOTPATCH */ SetProcessPriorityBoost( HANDLE process, BOO
*/
BOOL WINAPI DECLSPEC_HOTPATCH SetProcessShutdownParameters( DWORD level, DWORD flags )
{
FIXME( "(%08x, %08x): partial stub.\n", level, flags );
FIXME( "(%08lx, %08lx): partial stub.\n", level, flags );
shutdown_flags = flags;
shutdown_priority = level;
return TRUE;
@ -1380,7 +1380,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH ExpandEnvironmentStringsW( LPCWSTR src, LPWSTR ds
NTSTATUS status;
DWORD res;
TRACE( "(%s %p %u)\n", debugstr_w(src), dst, len );
TRACE( "(%s %p %lu)\n", debugstr_w(src), dst, len );
RtlInitUnicodeString( &us_src, src );
@ -1553,7 +1553,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH GetEnvironmentVariableW( LPCWSTR name, LPWSTR val
NTSTATUS status;
DWORD len;
TRACE( "(%s %p %u)\n", debugstr_w(name), val, size );
TRACE( "(%s %p %lu)\n", debugstr_w(name), val, size );
RtlInitUnicodeString( &us_name, name );
us_value.Length = 0;
@ -1648,7 +1648,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH InitializeProcThreadAttributeList( struct _PROC_TH
SIZE_T needed;
BOOL ret = FALSE;
TRACE( "(%p %d %x %p)\n", list, count, flags, size );
TRACE( "(%p %ld %lx %p)\n", list, count, flags, size );
needed = FIELD_OFFSET( struct _PROC_THREAD_ATTRIBUTE_LIST, attrs[count] );
if (list && *size >= needed)
@ -1676,7 +1676,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH UpdateProcThreadAttribute( struct _PROC_THREAD_ATT
DWORD mask;
struct proc_thread_attr *entry;
TRACE( "(%p %x %08lx %p %ld %p %p)\n", list, flags, attr, value, size, prev_ret, size_ret );
TRACE( "(%p %lx %08Ix %p %Id %p %p)\n", list, flags, attr, value, size, prev_ret, size_ret );
if (list->count >= list->size)
{
@ -1744,7 +1744,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH UpdateProcThreadAttribute( struct _PROC_THREAD_ATT
default:
SetLastError( ERROR_NOT_SUPPORTED );
FIXME( "Unhandled attribute %lu\n", attr & PROC_THREAD_ATTRIBUTE_NUMBER );
FIXME( "Unhandled attribute %Iu\n", attr & PROC_THREAD_ATTRIBUTE_NUMBER );
return FALSE;
}

110
dlls/kernelbase/registry.c
View File

@ -690,7 +690,7 @@ LSTATUS WINAPI RegEnumKeyExW( HKEY hkey, DWORD index, LPWSTR name, LPDWORD name_
KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
DWORD total_size;
TRACE( "(%p,%d,%p,%p(%u),%p,%p,%p,%p)\n", hkey, index, name, name_len,
TRACE( "(%p,%ld,%p,%p(%lu),%p,%p,%p,%p)\n", hkey, index, name, name_len,
name_len ? *name_len : 0, reserved, class, class_len, ft );
if (reserved) return ERROR_INVALID_PARAMETER;
@ -754,7 +754,7 @@ LSTATUS WINAPI RegEnumKeyExA( HKEY hkey, DWORD index, LPSTR name, LPDWORD name_l
KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
DWORD total_size;
TRACE( "(%p,%d,%p,%p(%u),%p,%p,%p,%p)\n", hkey, index, name, name_len,
TRACE( "(%p,%ld,%p,%p(%lu),%p,%p,%p,%p)\n", hkey, index, name, name_len,
name_len ? *name_len : 0, reserved, class, class_len, ft );
if (reserved) return ERROR_INVALID_PARAMETER;
@ -848,7 +848,7 @@ LSTATUS WINAPI RegQueryInfoKeyW( HKEY hkey, LPWSTR class, LPDWORD class_len, LPD
KEY_FULL_INFORMATION *info = (KEY_FULL_INFORMATION *)buffer;
DWORD total_size;
TRACE( "(%p,%p,%d,%p,%p,%p,%p,%p,%p,%p,%p)\n", hkey, class, class_len ? *class_len : 0,
TRACE( "(%p,%p,%ld,%p,%p,%p,%p,%p,%p,%p,%p)\n", hkey, class, class_len ? *class_len : 0,
reserved, subkeys, max_subkey, values, max_value, max_data, security, modif );
if (class && !class_len && is_version_nt()) return ERROR_INVALID_PARAMETER;
@ -938,7 +938,7 @@ LSTATUS WINAPI RegQueryInfoKeyA( HKEY hkey, LPSTR class, LPDWORD class_len, LPDW
KEY_FULL_INFORMATION *info = (KEY_FULL_INFORMATION *)buffer;
DWORD total_size;
TRACE( "(%p,%p,%d,%p,%p,%p,%p,%p,%p,%p,%p)\n", hkey, class, class_len ? *class_len : 0,
TRACE( "(%p,%p,%ld,%p,%p,%p,%p,%p,%p,%p,%p)\n", hkey, class, class_len ? *class_len : 0,
reserved, subkeys, max_subkey, values, max_value, max_data, security, modif );
if (class && !class_len && is_version_nt()) return ERROR_INVALID_PARAMETER;
@ -1036,7 +1036,7 @@ LSTATUS WINAPI RegDeleteKeyExW( HKEY hkey, LPCWSTR name, REGSAM access, DWORD re
ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
RegCloseKey( tmp );
}
TRACE("%s ret=%08x\n", debugstr_w(name), ret);
TRACE("%s ret=%08lx\n", debugstr_w(name), ret);
return ret;
}
@ -1069,7 +1069,7 @@ LSTATUS WINAPI RegDeleteKeyExA( HKEY hkey, LPCSTR name, REGSAM access, DWORD res
ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
RegCloseKey( tmp );
}
TRACE("%s ret=%08x\n", debugstr_a(name), ret);
TRACE("%s ret=%08lx\n", debugstr_a(name), ret);
return ret;
}
@ -1175,7 +1175,7 @@ LONG WINAPI RegSetKeyValueW( HKEY hkey, LPCWSTR subkey, LPCWSTR name, DWORD type
HKEY hsubkey = NULL;
DWORD ret;
TRACE("(%p,%s,%s,%d,%p,%d)\n", hkey, debugstr_w(subkey), debugstr_w(name), type, data, len );
TRACE("(%p,%s,%s,%ld,%p,%ld)\n", hkey, debugstr_w(subkey), debugstr_w(name), type, data, len );
if (subkey && subkey[0]) /* need to create the subkey */
{
@ -1197,7 +1197,7 @@ LONG WINAPI RegSetKeyValueA( HKEY hkey, LPCSTR subkey, LPCSTR name, DWORD type,
HKEY hsubkey = NULL;
DWORD ret;
TRACE("(%p,%s,%s,%d,%p,%d)\n", hkey, debugstr_a(subkey), debugstr_a(name), type, data, len );
TRACE("(%p,%s,%s,%ld,%p,%ld)\n", hkey, debugstr_a(subkey), debugstr_a(name), type, data, len );
if (subkey && subkey[0]) /* need to create the subkey */
{
@ -1369,7 +1369,7 @@ static DWORD collect_data(struct perf_provider *provider, const WCHAR *query, vo
err = provider->pOpen(linkage);
if (err != ERROR_SUCCESS)
{
TRACE("Open(%s) error %u (%#x)\n", debugstr_w(linkage), err, err);
TRACE("Open(%s) error %lu (%#lx)\n", debugstr_w(linkage), err, err);
return err;
}
@ -1377,7 +1377,7 @@ static DWORD collect_data(struct perf_provider *provider, const WCHAR *query, vo
err = provider->pCollect((WCHAR *)query, data, size, obj_count);
if (err != ERROR_SUCCESS)
{
TRACE("Collect error %u (%#x)\n", err, err);
TRACE("Collect error %lu (%#lx)\n", err, err);
*obj_count = 0;
}
@ -1488,7 +1488,7 @@ static DWORD query_perf_data( const WCHAR *query, DWORD *type, void *data, DWORD
{
PERF_OBJECT_TYPE *obj = (PERF_OBJECT_TYPE *)data;
TRACE("Collect: obj->TotalByteLength %u, collected_size %u\n",
TRACE("Collect: obj->TotalByteLength %lu, collected_size %lu\n",
obj->TotalByteLength, collected_size);
data_size -= collected_size;
@ -1527,7 +1527,7 @@ LSTATUS WINAPI DECLSPEC_HOTPATCH RegQueryValueExW( HKEY hkey, LPCWSTR name, LPDW
KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
TRACE("(%p,%s,%p,%p,%p,%p=%d)\n",
TRACE("(%p,%s,%p,%p,%p,%p=%ld)\n",
hkey, debugstr_w(name), reserved, type, data, count,
(count && data) ? *count : 0 );
@ -1622,7 +1622,7 @@ LSTATUS WINAPI DECLSPEC_HOTPATCH RegQueryValueExA( HKEY hkey, LPCSTR name, LPDWO
KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
TRACE("(%p,%s,%p,%p,%p,%p=%d)\n",
TRACE("(%p,%s,%p,%p,%p,%p=%ld)\n",
hkey, debugstr_a(name), reserved, type, data, count, count ? *count : 0 );
if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
@ -1789,7 +1789,7 @@ LSTATUS WINAPI RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue,
PVOID pvBuf = NULL;
LONG ret;
TRACE("(%p,%s,%s,%d,%p,%p,%p=%d)\n",
TRACE("(%p,%s,%s,%ld,%p,%p,%p=%ld)\n",
hKey, debugstr_w(pszSubKey), debugstr_w(pszValue), dwFlags, pdwType,
pvData, pcbData, cbData);
@ -1894,7 +1894,7 @@ LSTATUS WINAPI RegGetValueA( HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue,
PVOID pvBuf = NULL;
LONG ret;
TRACE("(%p,%s,%s,%d,%p,%p,%p=%d)\n",
TRACE("(%p,%s,%s,%ld,%p,%p,%p=%ld)\n",
hKey, debugstr_a(pszSubKey), debugstr_a(pszValue), dwFlags,
pdwType, pvData, pcbData, cbData);
@ -2014,7 +2014,7 @@ LSTATUS WINAPI RegEnumValueW( HKEY hkey, DWORD index, LPWSTR value, LPDWORD val_
KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
TRACE("(%p,%d,%p,%p,%p,%p,%p,%p)\n",
TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
hkey, index, value, val_count, reserved, type, data, count );
if ((data && !count) || reserved || !value || !val_count)
@ -2091,7 +2091,7 @@ LSTATUS WINAPI RegEnumValueA( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_c
KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
TRACE("(%p,%d,%p,%p,%p,%p,%p,%p)\n",
TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
hkey, index, value, val_count, reserved, type, data, count );
if ((data && !count) || reserved || !value || !val_count)
@ -2399,13 +2399,13 @@ LSTATUS WINAPI RegSaveKeyExA( HKEY hkey, LPCSTR file, SECURITY_ATTRIBUTES *sa, D
*/
LSTATUS WINAPI RegRestoreKeyW( HKEY hkey, LPCWSTR lpFile, DWORD dwFlags )
{
TRACE("(%p,%s,%d)\n",hkey,debugstr_w(lpFile),dwFlags);
TRACE("(%p,%s,%ld)\n",hkey,debugstr_w(lpFile),dwFlags);
/* It seems to do this check before the hkey check */
if (!lpFile || !*lpFile)
return ERROR_INVALID_PARAMETER;
FIXME("(%p,%s,%d): stub\n",hkey,debugstr_w(lpFile),dwFlags);
FIXME("(%p,%s,%ld): stub\n",hkey,debugstr_w(lpFile),dwFlags);
/* Check for file existence */
@ -2492,7 +2492,7 @@ LSTATUS WINAPI RegUnLoadKeyA( HKEY hkey, LPCSTR lpSubKey )
LSTATUS WINAPI RegSetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInfo,
PSECURITY_DESCRIPTOR pSecurityDesc )
{
TRACE("(%p,%d,%p)\n",hkey,SecurityInfo,pSecurityDesc);
TRACE("(%p,%ld,%p)\n",hkey,SecurityInfo,pSecurityDesc);
/* It seems to perform this check before the hkey check */
if ((SecurityInfo & OWNER_SECURITY_INFORMATION) ||
@ -2531,7 +2531,7 @@ LSTATUS WINAPI RegGetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInform
PSECURITY_DESCRIPTOR pSecurityDescriptor,
LPDWORD lpcbSecurityDescriptor )
{
TRACE("(%p,%d,%p,%d)\n",hkey,SecurityInformation,pSecurityDescriptor,
TRACE("(%p,%ld,%p,%ld)\n",hkey,SecurityInformation,pSecurityDescriptor,
*lpcbSecurityDescriptor);
if (!(hkey = get_special_root_hkey( hkey, 0 ))) return ERROR_INVALID_HANDLE;
@ -2589,7 +2589,7 @@ LSTATUS WINAPI RegNotifyChangeKeyValue( HKEY hkey, BOOL fWatchSubTree,
hkey = get_special_root_hkey( hkey, 0 );
if (!hkey) return ERROR_INVALID_HANDLE;
TRACE("(%p,%i,%d,%p,%i)\n", hkey, fWatchSubTree, fdwNotifyFilter,
TRACE("(%p,%i,%ld,%p,%i)\n", hkey, fWatchSubTree, fdwNotifyFilter,
hEvent, fAsync);
status = NtNotifyChangeKey( hkey, hEvent, NULL, NULL, &iosb,
@ -2624,7 +2624,7 @@ LSTATUS WINAPI RegNotifyChangeKeyValue( HKEY hkey, BOOL fWatchSubTree,
*/
LSTATUS WINAPI RegOpenUserClassesRoot( HANDLE hToken, DWORD dwOptions, REGSAM samDesired, PHKEY phkResult )
{
FIXME("(%p, 0x%x, 0x%x, %p) semi-stub\n", hToken, dwOptions, samDesired, phkResult);
FIXME("(%p, 0x%lx, 0x%lx, %p) semi-stub\n", hToken, dwOptions, samDesired, phkResult);
*phkResult = HKEY_CLASSES_ROOT;
return ERROR_SUCCESS;
@ -2637,7 +2637,7 @@ static void dump_mui_cache(void)
TRACE("---------- MUI Cache ----------\n");
LIST_FOR_EACH_ENTRY( ent, &reg_mui_cache, struct mui_cache_entry, entry )
TRACE("entry=%p, %s,-%u [%#x] => %s\n",
TRACE("entry=%p, %s,-%lu [%#lx] => %s\n",
ent, wine_dbgstr_w(ent->file_name), ent->index, ent->locale, wine_dbgstr_w(ent->text));
}
@ -2819,8 +2819,8 @@ LSTATUS WINAPI RegLoadMUIStringW(HKEY hKey, LPCWSTR pwszValue, LPWSTR pwszBuffer
LPWSTR pwszTempBuffer = NULL, pwszExpandedBuffer = NULL;
LONG result;
TRACE("(hKey = %p, pwszValue = %s, pwszBuffer = %p, cbBuffer = %d, pcbData = %p, "
"dwFlags = %d, pwszBaseDir = %s)\n", hKey, debugstr_w(pwszValue), pwszBuffer,
TRACE("(hKey = %p, pwszValue = %s, pwszBuffer = %p, cbBuffer = %ld, pcbData = %p, "
"dwFlags = %lu, pwszBaseDir = %s)\n", hKey, debugstr_w(pwszValue), pwszBuffer,
cbBuffer, pcbData, dwFlags, debugstr_w(pwszBaseDir));
/* Parameter sanity checks. */
@ -3087,7 +3087,7 @@ cleanup:
*/
LSTATUS WINAPI RegLoadAppKeyA(const char *file, HKEY *result, REGSAM sam, DWORD options, DWORD reserved)
{
FIXME("%s %p %u %u %u: stub\n", wine_dbgstr_a(file), result, sam, options, reserved);
FIXME("%s %p %lu %lu %lu: stub\n", wine_dbgstr_a(file), result, sam, options, reserved);
if (!file || reserved)
return ERROR_INVALID_PARAMETER;
@ -3102,7 +3102,7 @@ LSTATUS WINAPI RegLoadAppKeyA(const char *file, HKEY *result, REGSAM sam, DWORD
*/
LSTATUS WINAPI RegLoadAppKeyW(const WCHAR *file, HKEY *result, REGSAM sam, DWORD options, DWORD reserved)
{
FIXME("%s %p %u %u %u: stub\n", wine_dbgstr_w(file), result, sam, options, reserved);
FIXME("%s %p %lu %lu %lu: stub\n", wine_dbgstr_w(file), result, sam, options, reserved);
if (!file || reserved)
return ERROR_INVALID_PARAMETER;
@ -3244,7 +3244,7 @@ BOOL WINAPI GetComputerNameExW( COMPUTER_NAME_FORMAT type, WCHAR *name, DWORD *l
*len = size / sizeof(WCHAR);
RegCloseKey( key );
}
TRACE("-> %lu %s\n", ret, debugstr_w(name) );
TRACE("-> %Iu %s\n", ret, debugstr_w(name) );
if (ret) SetLastError( ret );
return !ret;
}
@ -3372,7 +3372,7 @@ LONG WINAPI SHRegCreateUSKeyA(LPCSTR path, REGSAM samDesired, HUSKEY relative_ke
WCHAR *pathW;
LONG ret;
TRACE("%s, %#x, %p, %p, %#x\n", debugstr_a(path), samDesired, relative_key, new_uskey, flags);
TRACE("%s, %#lx, %p, %p, %#lx\n", debugstr_a(path), samDesired, relative_key, new_uskey, flags);
if (path)
{
@ -3426,7 +3426,7 @@ LONG WINAPI SHRegCreateUSKeyW(const WCHAR *path, REGSAM samDesired, HUSKEY relat
LONG ret = ERROR_CALL_NOT_IMPLEMENTED;
struct USKEY *ret_key;
TRACE("%s, %#x, %p, %p, %#x\n", debugstr_w(path), samDesired, relative_key, new_uskey, flags);
TRACE("%s, %#lx, %p, %p, %#lx\n", debugstr_w(path), samDesired, relative_key, new_uskey, flags);
if (!new_uskey)
return ERROR_INVALID_PARAMETER;
@ -3435,7 +3435,7 @@ LONG WINAPI SHRegCreateUSKeyW(const WCHAR *path, REGSAM samDesired, HUSKEY relat
if (flags & ~SHREGSET_FORCE_HKCU)
{
FIXME("unsupported flags 0x%08x\n", flags);
FIXME("unsupported flags 0x%08lx\n", flags);
return ERROR_SUCCESS;
}
@ -3515,7 +3515,7 @@ LONG WINAPI SHRegEnumUSValueA(HUSKEY hUSKey, DWORD index, char *value_name, DWOR
{
HKEY dokey;
TRACE("%p, %#x, %p, %p, %p, %p, %p, %#x\n", hUSKey, index, value_name, value_name_len, type, data, data_len, flags);
TRACE("%p, %#lx, %p, %p, %p, %p, %p, %#x\n", hUSKey, index, value_name, value_name_len, type, data, data_len, flags);
if ((flags == SHREGENUM_HKCU || flags == SHREGENUM_DEFAULT) && (dokey = reg_get_hkey_from_huskey(hUSKey, TRUE)))
return RegEnumValueA(dokey, index, value_name, value_name_len, NULL, type, data, data_len);
@ -3532,7 +3532,7 @@ LONG WINAPI SHRegEnumUSValueW(HUSKEY hUSKey, DWORD index, WCHAR *value_name, DWO
{
HKEY dokey;
TRACE("%p, %#x, %p, %p, %p, %p, %p, %#x\n", hUSKey, index, value_name, value_name_len, type, data, data_len, flags);
TRACE("%p, %#lx, %p, %p, %p, %p, %p, %#x\n", hUSKey, index, value_name, value_name_len, type, data, data_len, flags);
if ((flags == SHREGENUM_HKCU || flags == SHREGENUM_DEFAULT) && (dokey = reg_get_hkey_from_huskey(hUSKey, TRUE)))
return RegEnumValueW(dokey, index, value_name, value_name_len, NULL, type, data, data_len);
@ -3548,7 +3548,7 @@ LONG WINAPI SHRegEnumUSKeyA(HUSKEY hUSKey, DWORD index, char *name, DWORD *name_
{
HKEY dokey;
TRACE("%p, %d, %p, %p(%d), %d\n", hUSKey, index, name, name_len, *name_len, flags);
TRACE("%p, %ld, %p, %p(%ld), %d\n", hUSKey, index, name, name_len, *name_len, flags);
if ((flags == SHREGENUM_HKCU || flags == SHREGENUM_DEFAULT) && (dokey = reg_get_hkey_from_huskey(hUSKey, TRUE)))
return RegEnumKeyExA(dokey, index, name, name_len, 0, 0, 0, 0);
@ -3564,7 +3564,7 @@ LONG WINAPI SHRegEnumUSKeyW(HUSKEY hUSKey, DWORD index, WCHAR *name, DWORD *name
{
HKEY dokey;
TRACE("%p, %d, %p, %p(%d), %d\n", hUSKey, index, name, name_len, *name_len, flags);
TRACE("%p, %ld, %p, %p(%ld), %d\n", hUSKey, index, name, name_len, *name_len, flags);
if ((flags == SHREGENUM_HKCU || flags == SHREGENUM_DEFAULT) && (dokey = reg_get_hkey_from_huskey(hUSKey, TRUE)))
return RegEnumKeyExW(dokey, index, name, name_len, 0, 0, 0, 0);
@ -3591,7 +3591,7 @@ LONG WINAPI SHRegOpenUSKeyW(const WCHAR *path, REGSAM access_mask, HUSKEY relati
LONG ret2, ret1 = ~ERROR_SUCCESS;
struct USKEY *key;
TRACE("%s, %#x, %p, %p, %d\n", debugstr_w(path), access_mask, relative_key, uskey, ignore_hkcu);
TRACE("%s, %#lx, %p, %p, %d\n", debugstr_w(path), access_mask, relative_key, uskey, ignore_hkcu);
if (uskey)
*uskey = NULL;
@ -3627,7 +3627,7 @@ LONG WINAPI SHRegOpenUSKeyW(const WCHAR *path, REGSAM access_mask, HUSKEY relati
key->HKLMkey = 0;
if (ret1 || ret2)
TRACE("one or more opens failed: HKCU=%d HKLM=%d\n", ret1, ret2);
TRACE("one or more opens failed: HKCU=%ld HKLM=%ld\n", ret1, ret2);
if (ret1 && ret2)
{
@ -3659,7 +3659,7 @@ LONG WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, const WCHAR *value, DWORD type, vo
LONG ret = ERROR_SUCCESS;
DWORD dummy;
TRACE("%p, %s, %d, %p, %d, %#x\n", hUSKey, debugstr_w(value), type, data, data_len, flags);
TRACE("%p, %s, %ld, %p, %ld, %#lx\n", hUSKey, debugstr_w(value), type, data, data_len, flags);
__TRY
{
@ -3679,7 +3679,7 @@ LONG WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, const WCHAR *value, DWORD type, vo
/* Create the key */
ret = RegCreateKeyExW(hKey->HKCUstart, hKey->path, 0, NULL, REG_OPTION_NON_VOLATILE,
MAXIMUM_ALLOWED, NULL, &hKey->HKCUkey, NULL);
TRACE("Creating HKCU key, ret = %d\n", ret);
TRACE("Creating HKCU key, ret = %ld\n", ret);
if (ret && (flags & SHREGSET_FORCE_HKCU))
{
hKey->HKCUkey = 0;
@ -3693,7 +3693,7 @@ LONG WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, const WCHAR *value, DWORD type, vo
{
/* Doesn't exist or we are forcing: Write value */
ret = RegSetValueExW(hKey->HKCUkey, value, 0, type, data, data_len);
TRACE("Writing HKCU value, ret = %d\n", ret);
TRACE("Writing HKCU value, ret = %ld\n", ret);
}
}
}
@ -3705,7 +3705,7 @@ LONG WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, const WCHAR *value, DWORD type, vo
/* Create the key */
ret = RegCreateKeyExW(hKey->HKLMstart, hKey->path, 0, NULL, REG_OPTION_NON_VOLATILE,
MAXIMUM_ALLOWED, NULL, &hKey->HKLMkey, NULL);
TRACE("Creating HKLM key, ret = %d\n", ret);
TRACE("Creating HKLM key, ret = %ld\n", ret);
if (ret && (flags & (SHREGSET_FORCE_HKLM)))
{
hKey->HKLMkey = 0;
@ -3719,7 +3719,7 @@ LONG WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, const WCHAR *value, DWORD type, vo
{
/* Doesn't exist or we are forcing: Write value */
ret = RegSetValueExW(hKey->HKLMkey, value, 0, type, data, data_len);
TRACE("Writing HKLM value, ret = %d\n", ret);
TRACE("Writing HKLM value, ret = %ld\n", ret);
}
}
}
@ -3734,7 +3734,7 @@ LONG WINAPI SHRegSetUSValueA(const char *subkey, const char *value, DWORD type,
HUSKEY hkey;
LONG ret;
TRACE("%s, %s, %d, %p, %d, %#x\n", debugstr_a(subkey), debugstr_a(value), type, data, data_len, flags);
TRACE("%s, %s, %ld, %p, %ld, %#lx\n", debugstr_a(subkey), debugstr_a(value), type, data, data_len, flags);
if (!data)
return ERROR_INVALID_FUNCTION;
@ -3758,7 +3758,7 @@ LONG WINAPI SHRegSetUSValueW(const WCHAR *subkey, const WCHAR *value, DWORD type
HUSKEY hkey;
LONG ret;
TRACE("%s, %s, %d, %p, %d, %#x\n", debugstr_w(subkey), debugstr_w(value), type, data, data_len, flags);
TRACE("%s, %s, %ld, %p, %ld, %#lx\n", debugstr_w(subkey), debugstr_w(value), type, data, data_len, flags);
if (!data)
return ERROR_INVALID_FUNCTION;
@ -3832,14 +3832,14 @@ LONG WINAPI SHRegQueryUSValueA(HUSKEY hUSKey, const char *value, DWORD *type, vo
if (!ignore_hkcu && (dokey = reg_get_hkey_from_huskey(hUSKey, TRUE)))
{
ret = RegQueryValueExA(dokey, value, 0, type, data, data_len);
TRACE("HKCU RegQueryValue returned %d\n", ret);
TRACE("HKCU RegQueryValue returned %ld\n", ret);
}
/* If HKCU did not work and HKLM exists, then try it */
if ((ret != ERROR_SUCCESS) && (dokey = reg_get_hkey_from_huskey(hUSKey, FALSE)))
{
ret = RegQueryValueExA(dokey, value, 0, type, data, data_len);
TRACE("HKLM RegQueryValue returned %d\n", ret);
TRACE("HKLM RegQueryValue returned %ld\n", ret);
}
/* If neither worked, and default data exists, then use it */
@ -3869,14 +3869,14 @@ LONG WINAPI SHRegQueryUSValueW(HUSKEY hUSKey, const WCHAR *value, DWORD *type, v
if (!ignore_hkcu && (dokey = reg_get_hkey_from_huskey(hUSKey, TRUE)))
{
ret = RegQueryValueExW(dokey, value, 0, type, data, data_len);
TRACE("HKCU RegQueryValue returned %d\n", ret);
TRACE("HKCU RegQueryValue returned %ld\n", ret);
}
/* If HKCU did not work and HKLM exists, then try it */
if ((ret != ERROR_SUCCESS) && (dokey = reg_get_hkey_from_huskey(hUSKey, FALSE)))
{
ret = RegQueryValueExW(dokey, value, 0, type, data, data_len);
TRACE("HKLM RegQueryValue returned %d\n", ret);
TRACE("HKLM RegQueryValue returned %ld\n", ret);
}
/* If neither worked, and default data exists, then use it */
@ -3904,7 +3904,7 @@ LONG WINAPI SHRegGetUSValueA(const char *subkey, const char *value, DWORD *type,
if (!data || !data_len)
return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
TRACE("%s, %s, %d\n", debugstr_a(subkey), debugstr_a(value), *data_len);
TRACE("%s, %s, %ld\n", debugstr_a(subkey), debugstr_a(value), *data_len);
ret = SHRegOpenUSKeyA(subkey, KEY_QUERY_VALUE, 0, &myhuskey, ignore_hkcu);
if (!ret)
@ -3925,7 +3925,7 @@ LONG WINAPI SHRegGetUSValueW(const WCHAR *subkey, const WCHAR *value, DWORD *typ
if (!data || !data_len)
return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
TRACE("%s, %s, %d\n", debugstr_w(subkey), debugstr_w(value), *data_len);
TRACE("%s, %s, %ld\n", debugstr_w(subkey), debugstr_w(value), *data_len);
ret = SHRegOpenUSKeyW(subkey, KEY_QUERY_VALUE, 0, &myhuskey, ignore_hkcu);
if (!ret)
@ -3967,10 +3967,10 @@ BOOL WINAPI SHRegGetBoolUSValueA(const char *subkey, const char *value, BOOL ign
break;
}
default:
FIXME("Unsupported registry data type %d\n", type);
FIXME("Unsupported registry data type %ld\n", type);
ret = FALSE;
}
TRACE("got value (type=%d), returning %d\n", type, ret);
TRACE("got value (type=%ld), returning %d\n", type, ret);
}
else
TRACE("returning default value %d\n", ret);
@ -4008,10 +4008,10 @@ BOOL WINAPI SHRegGetBoolUSValueW(const WCHAR *subkey, const WCHAR *value, BOOL i
break;
}
default:
FIXME("Unsupported registry data type %d\n", type);
FIXME("Unsupported registry data type %ld\n", type);
ret = FALSE;
}
TRACE("got value (type=%d), returning %d\n", type, ret);
TRACE("got value (type=%ld), returning %d\n", type, ret);
}
else
TRACE("returning default value %d\n", ret);

52
dlls/kernelbase/security.c
View File

@ -195,33 +195,33 @@ static const char *debugstr_sid( PSID sid )
case 0:
return wine_dbg_sprintf("S-%d-%d", psid->Revision, auth);
case 1:
return wine_dbg_sprintf("S-%d-%d-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu", psid->Revision, auth,
psid->SubAuthority[0]);
case 2:
return wine_dbg_sprintf("S-%d-%d-%u-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu-%lu", psid->Revision, auth,
psid->SubAuthority[0], psid->SubAuthority[1]);
case 3:
return wine_dbg_sprintf("S-%d-%d-%u-%u-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu-%lu-%lu", psid->Revision, auth,
psid->SubAuthority[0], psid->SubAuthority[1], psid->SubAuthority[2]);
case 4:
return wine_dbg_sprintf("S-%d-%d-%u-%u-%u-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu-%lu-%lu-%lu", psid->Revision, auth,
psid->SubAuthority[0], psid->SubAuthority[1], psid->SubAuthority[2],
psid->SubAuthority[3]);
case 5:
return wine_dbg_sprintf("S-%d-%d-%u-%u-%u-%u-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu-%lu-%lu-%lu-%lu", psid->Revision, auth,
psid->SubAuthority[0], psid->SubAuthority[1], psid->SubAuthority[2],
psid->SubAuthority[3], psid->SubAuthority[4]);
case 6:
return wine_dbg_sprintf("S-%d-%d-%u-%u-%u-%u-%u-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu-%lu-%lu-%lu-%lu-%lu", psid->Revision, auth,
psid->SubAuthority[3], psid->SubAuthority[1], psid->SubAuthority[2],
psid->SubAuthority[0], psid->SubAuthority[4], psid->SubAuthority[5]);
case 7:
return wine_dbg_sprintf("S-%d-%d-%u-%u-%u-%u-%u-%u-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu-%lu-%lu-%lu-%lu-%lu-%lu", psid->Revision, auth,
psid->SubAuthority[0], psid->SubAuthority[1], psid->SubAuthority[2],
psid->SubAuthority[3], psid->SubAuthority[4], psid->SubAuthority[5],
psid->SubAuthority[6]);
case 8:
return wine_dbg_sprintf("S-%d-%d-%u-%u-%u-%u-%u-%u-%u-%u", psid->Revision, auth,
return wine_dbg_sprintf("S-%d-%d-%lu-%lu-%lu-%lu-%lu-%lu-%lu-%lu", psid->Revision, auth,
psid->SubAuthority[0], psid->SubAuthority[1], psid->SubAuthority[2],
psid->SubAuthority[3], psid->SubAuthority[4], psid->SubAuthority[5],
psid->SubAuthority[6], psid->SubAuthority[7]);
@ -556,7 +556,7 @@ BOOL WINAPI AdjustTokenPrivileges( HANDLE token, BOOL disable, PTOKEN_PRIVILEGES
{
NTSTATUS status;
TRACE("(%p %d %p %d %p %p)\n", token, disable, new, len, prev, ret_len );
TRACE("(%p %d %p %ld %p %p)\n", token, disable, new, len, prev, ret_len );
status = NtAdjustPrivilegesToken( token, disable, new, len, prev, ret_len );
SetLastError( RtlNtStatusToDosError( status ));
@ -624,7 +624,7 @@ BOOL WINAPI CheckTokenMembership( HANDLE token, PSID sid_to_check, PBOOL is_memb
for (i = 0; i < token_groups->GroupCount; i++)
{
TRACE("Groups[%d]: {0x%x, %s}\n", i,
TRACE("Groups[%ld]: {0x%lx, %s}\n", i,
token_groups->Groups[i].Attributes,
debugstr_sid(token_groups->Groups[i].Sid));
if ((token_groups->Groups[i].Attributes & SE_GROUP_ENABLED) &&
@ -654,7 +654,7 @@ BOOL WINAPI CreateRestrictedToken( HANDLE token, DWORD flags,
TOKEN_GROUPS *nt_disable_sids = NULL, *nt_restrict_sids = NULL;
NTSTATUS status = STATUS_NO_MEMORY;
TRACE("token %p, flags %#x, disable_sids %u %p, delete_privs %u %p, restrict_sids %u %p, ret %p\n",
TRACE("token %p, flags %#lx, disable_sids %lu %p, delete_privs %lu %p, restrict_sids %lu %p, ret %p\n",
token, flags, disable_sid_count, disable_sids, delete_priv_count, delete_privs,
restrict_sid_count, restrict_sids, ret);
@ -704,7 +704,7 @@ BOOL WINAPI DuplicateTokenEx( HANDLE token, DWORD access, LPSECURITY_ATTRIBUTES
{
OBJECT_ATTRIBUTES attr;
TRACE("%p 0x%08x 0x%08x 0x%08x %p\n", token, access, level, type, ret );
TRACE("%p 0x%08lx 0x%08x 0x%08x %p\n", token, access, level, type, ret );
InitializeObjectAttributes( &attr, NULL, (sa && sa->bInheritHandle) ? OBJ_INHERIT : 0,
NULL, sa ? sa->lpSecurityDescriptor : NULL );
@ -717,7 +717,7 @@ BOOL WINAPI DuplicateTokenEx( HANDLE token, DWORD access, LPSECURITY_ATTRIBUTES
BOOL WINAPI GetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS class,
LPVOID info, DWORD len, LPDWORD retlen )
{
TRACE("(%p, %s, %p, %d, %p):\n",
TRACE("(%p, %s, %p, %ld, %p):\n",
token,
(class == TokenUser) ? "TokenUser" :
(class == TokenGroups) ? "TokenGroups" :
@ -881,7 +881,7 @@ BOOL WINAPI SetThreadToken( PHANDLE thread, HANDLE token )
*/
BOOL WINAPI SetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS class, LPVOID info, DWORD len )
{
TRACE("(%p, %s, %p, %d)\n",
TRACE("(%p, %s, %p, %ld)\n",
token,
(class == TokenUser) ? "TokenUser" :
(class == TokenGroups) ? "TokenGroups" :
@ -927,7 +927,7 @@ BOOL WINAPI ConvertToAutoInheritPrivateObjectSecurity( PSECURITY_DESCRIPTOR pare
*/
HANDLE WINAPI CreateBoundaryDescriptorW( LPCWSTR name, ULONG flags )
{
FIXME("%s %u - stub\n", debugstr_w(name), flags);
FIXME("%s %lu - stub\n", debugstr_w(name), flags);
return NULL;
}
@ -952,7 +952,7 @@ BOOL WINAPI CreatePrivateObjectSecurityEx( PSECURITY_DESCRIPTOR parent, PSECURIT
DWORD needed, offset;
BYTE *buffer;
FIXME( "%p %p %p %p %d %u %p %p - returns fake SECURITY_DESCRIPTOR\n",
FIXME( "%p %p %p %p %d %lu %p %p - returns fake SECURITY_DESCRIPTOR\n",
parent, creator, descr, type, is_container, flags, token, mapping );
needed = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
@ -1025,7 +1025,7 @@ BOOL WINAPI GetFileSecurityW( LPCWSTR name, SECURITY_INFORMATION info,
NTSTATUS status;
DWORD access = 0;
TRACE( "(%s,%d,%p,%d,%p)\n", debugstr_w(name), info, descr, len, ret_len );
TRACE( "(%s,%ld,%p,%ld,%p)\n", debugstr_w(name), info, descr, len, ret_len );
if (info & (OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION))
access |= READ_CONTROL;
@ -1060,7 +1060,7 @@ BOOL WINAPI GetPrivateObjectSecurity( PSECURITY_DESCRIPTOR obj_descr, SECURITY_I
PACL pacl;
PSID psid;
TRACE("(%p,0x%08x,%p,0x%08x,%p)\n", obj_descr, info, ret_descr, len, ret_len );
TRACE("(%p,0x%08lx,%p,0x%08lx,%p)\n", obj_descr, info, ret_descr, len, ret_len );
if (!InitializeSecurityDescriptor(&desc, SECURITY_DESCRIPTOR_REVISION)) return FALSE;
@ -1200,7 +1200,7 @@ BOOL WINAPI SetFileSecurityW( LPCWSTR name, SECURITY_INFORMATION info, PSECURITY
DWORD access = 0;
NTSTATUS status;
TRACE( "(%s, 0x%x, %p)\n", debugstr_w(name), info, descr );
TRACE( "(%s, 0x%lx, %p)\n", debugstr_w(name), info, descr );
if (info & (OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION)) access |= WRITE_OWNER;
if (info & SACL_SECURITY_INFORMATION) access |= ACCESS_SYSTEM_SECURITY;
@ -1229,7 +1229,7 @@ BOOL WINAPI SetPrivateObjectSecurity( SECURITY_INFORMATION info, PSECURITY_DESCR
PSECURITY_DESCRIPTOR *obj_descr, PGENERIC_MAPPING mapping,
HANDLE token )
{
FIXME( "0x%08x %p %p %p %p - stub\n", info, descr, obj_descr, mapping, token );
FIXME( "0x%08lx %p %p %p %p - stub\n", info, descr, obj_descr, mapping, token );
return TRUE;
}
@ -1240,7 +1240,7 @@ BOOL WINAPI SetPrivateObjectSecurityEx( SECURITY_INFORMATION info, PSECURITY_DES
PSECURITY_DESCRIPTOR *obj_descr, ULONG flags,
PGENERIC_MAPPING mapping, HANDLE token )
{
FIXME( "0x%08x %p %p %u %p %p - stub\n", info, descr, obj_descr, flags, mapping, token );
FIXME( "0x%08lx %p %p %lu %p %p - stub\n", info, descr, obj_descr, flags, mapping, token );
return TRUE;
}
@ -1312,7 +1312,7 @@ BOOL WINAPI AccessCheckAndAuditAlarmW( LPCWSTR subsystem, LPVOID id, LPWSTR type
PGENERIC_MAPPING mapping, BOOL creation,
LPDWORD granted, LPBOOL status, LPBOOL on_close )
{
FIXME( "stub (%s,%p,%s,%s,%p,%08x,%p,%x,%p,%p,%p)\n", debugstr_w(subsystem),
FIXME( "stub (%s,%p,%s,%s,%p,%08lx,%p,%x,%p,%p,%p)\n", debugstr_w(subsystem),
id, debugstr_w(type_name), debugstr_w(name), descr, access, mapping,
creation, granted, status, on_close );
return TRUE;
@ -1522,7 +1522,7 @@ BOOL WINAPI ObjectOpenAuditAlarmW( LPCWSTR subsystem, LPVOID id, LPWSTR type, LP
DWORD granted, PPRIVILEGE_SET privs, BOOL creation,
BOOL access, LPBOOL on_close )
{
FIXME( "stub (%s,%p,%s,%s,%p,%p,0x%08x,0x%08x,%p,%x,%x,%p)\n", debugstr_w(subsystem),
FIXME( "stub (%s,%p,%s,%s,%p,%p,0x%08lx,0x%08lx,%p,%x,%x,%p)\n", debugstr_w(subsystem),
id, debugstr_w(type), debugstr_w(name), descr, token, desired, granted,
privs, creation, access, on_close );
return TRUE;
@ -1534,7 +1534,7 @@ BOOL WINAPI ObjectOpenAuditAlarmW( LPCWSTR subsystem, LPVOID id, LPWSTR type, LP
BOOL WINAPI ObjectPrivilegeAuditAlarmW( LPCWSTR subsystem, LPVOID id, HANDLE token,
DWORD desired, PPRIVILEGE_SET privs, BOOL granted )
{
FIXME( "stub (%s,%p,%p,0x%08x,%p,%x)\n", debugstr_w(subsystem), id, token, desired, privs, granted );
FIXME( "stub (%s,%p,%p,0x%08lx,%p,%x)\n", debugstr_w(subsystem), id, token, desired, privs, granted );
return TRUE;
}
@ -1553,7 +1553,7 @@ BOOL WINAPI PrivilegedServiceAuditAlarmW( LPCWSTR subsystem, LPCWSTR service, HA
*/
BOOL WINAPI SetAclInformation( PACL acl, LPVOID info, DWORD len, ACL_INFORMATION_CLASS class )
{
FIXME( "%p %p 0x%08x 0x%08x - stub\n", acl, info, len, class );
FIXME( "%p %p 0x%08lx 0x%08x - stub\n", acl, info, len, class );
return TRUE;
}
@ -1562,6 +1562,6 @@ BOOL WINAPI SetAclInformation( PACL acl, LPVOID info, DWORD len, ACL_INFORMATION
*/
BOOL WINAPI SetCachedSigningLevel( PHANDLE source, ULONG count, ULONG flags, HANDLE file )
{
FIXME( "%p %u %u %p - stub\n", source, count, flags, file );
FIXME( "%p %lu %lu %p - stub\n", source, count, flags, file );
return TRUE;
}

14
dlls/kernelbase/string.c
View File

@ -836,13 +836,13 @@ BOOL WINAPI StrToInt64ExA(const char *str, DWORD flags, LONGLONG *ret)
BOOL negative = FALSE;
LONGLONG value = 0;
TRACE("%s, %#x, %p\n", wine_dbgstr_a(str), flags, ret);
TRACE("%s, %#lx, %p\n", wine_dbgstr_a(str), flags, ret);
if (!str || !ret)
return FALSE;
if (flags > STIF_SUPPORT_HEX)
WARN("Unknown flags %#x\n", flags);
WARN("Unknown flags %#lx\n", flags);
/* Skip leading space, '+', '-' */
while (*str == ' ' || *str == '\t' || *str == '\n') str++;
@ -899,13 +899,13 @@ BOOL WINAPI StrToInt64ExW(const WCHAR *str, DWORD flags, LONGLONG *ret)
BOOL negative = FALSE;
LONGLONG value = 0;
TRACE("%s, %#x, %p\n", wine_dbgstr_w(str), flags, ret);
TRACE("%s, %#lx, %p\n", wine_dbgstr_w(str), flags, ret);
if (!str || !ret)
return FALSE;
if (flags > STIF_SUPPORT_HEX)
WARN("Unknown flags %#x.\n", flags);
WARN("Unknown flags %#lx.\n", flags);
/* Skip leading space, '+', '-' */
while (*str == ' ' || *str == '\t' || *str == '\n') str++;
@ -962,7 +962,7 @@ BOOL WINAPI StrToIntExA(const char *str, DWORD flags, INT *ret)
LONGLONG value;
BOOL res;
TRACE("%s, %#x, %p\n", wine_dbgstr_a(str), flags, ret);
TRACE("%s, %#lx, %p\n", wine_dbgstr_a(str), flags, ret);
res = StrToInt64ExA(str, flags, &value);
if (res) *ret = value;
@ -974,7 +974,7 @@ BOOL WINAPI StrToIntExW(const WCHAR *str, DWORD flags, INT *ret)
LONGLONG value;
BOOL res;
TRACE("%s, %#x, %p\n", wine_dbgstr_w(str), flags, ret);
TRACE("%s, %#lx, %p\n", wine_dbgstr_w(str), flags, ret);
res = StrToInt64ExW(str, flags, &value);
if (res) *ret = value;
@ -1415,7 +1415,7 @@ WCHAR * WINAPI StrCatBuffW(WCHAR *str, const WCHAR *cat, INT max_len)
DWORD WINAPI StrCatChainW(WCHAR *str, DWORD max_len, DWORD at, const WCHAR *cat)
{
TRACE("%s, %u, %d, %s\n", wine_dbgstr_w(str), max_len, at, wine_dbgstr_w(cat));
TRACE("%s, %lu, %ld, %s\n", wine_dbgstr_w(str), max_len, at, wine_dbgstr_w(cat));
if (at == -1)
at = lstrlenW(str);

26
dlls/kernelbase/sync.c
View File

@ -229,7 +229,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH RegisterWaitForSingleObjectEx( HANDLE handle, WA
{
HANDLE ret;
TRACE( "%p %p %p %d %d\n", handle, callback, context, timeout, flags );
TRACE( "%p %p %p %ld %ld\n", handle, callback, context, timeout, flags );
handle = normalize_std_handle( handle );
if (!set_ntstatus( RtlRegisterWait( &ret, handle, callback, context, timeout, flags ))) return NULL;
@ -246,7 +246,7 @@ DWORD WINAPI DECLSPEC_HOTPATCH SignalObjectAndWait( HANDLE signal, HANDLE wait,
NTSTATUS status;
LARGE_INTEGER time;
TRACE( "%p %p %d %d\n", signal, wait, timeout, alertable );
TRACE( "%p %p %ld %d\n", signal, wait, timeout, alertable );
status = NtSignalAndWaitForSingleObject( signal, wait, alertable, get_nt_timeout( &time, timeout ) );
if (HIWORD(status))
@ -778,7 +778,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetWaitableTimerEx( HANDLE handle, const LARGE_INT
REASON_CONTEXT *context, ULONG tolerabledelay )
{
static int once;
if (!once++) FIXME( "(%p, %p, %d, %p, %p, %p, %d) semi-stub\n",
if (!once++) FIXME( "(%p, %p, %ld, %p, %p, %p, %ld) semi-stub\n",
handle, when, period, callback, arg, context, tolerabledelay );
return SetWaitableTimer( handle, when, period, callback, arg, FALSE );
@ -1016,7 +1016,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateIoCompletionPort( HANDLE handle, HANDLE po
IO_STATUS_BLOCK iosb;
HANDLE ret = port;
TRACE( "(%p, %p, %08lx, %08x)\n", handle, port, key, threads );
TRACE( "(%p, %p, %08Ix, %08lx)\n", handle, port, key, threads );
if (!port)
{
@ -1053,7 +1053,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetQueuedCompletionStatus( HANDLE port, LPDWORD co
IO_STATUS_BLOCK iosb;
LARGE_INTEGER wait_time;
TRACE( "(%p,%p,%p,%p,%d)\n", port, count, key, overlapped, timeout );
TRACE( "(%p,%p,%p,%p,%ld)\n", port, count, key, overlapped, timeout );
*overlapped = NULL;
status = NtRemoveIoCompletion( port, key, (PULONG_PTR)overlapped, &iosb,
@ -1081,7 +1081,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetQueuedCompletionStatusEx( HANDLE port, OVERLAPP
LARGE_INTEGER time;
NTSTATUS ret;
TRACE( "%p %p %u %p %u %u\n", port, entries, count, written, timeout, alertable );
TRACE( "%p %p %lu %p %lu %u\n", port, entries, count, written, timeout, alertable );
ret = NtRemoveIoCompletionEx( port, (FILE_IO_COMPLETION_INFORMATION *)entries, count,
written, get_nt_timeout( &time, timeout ), alertable );
@ -1099,7 +1099,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetQueuedCompletionStatusEx( HANDLE port, OVERLAPP
BOOL WINAPI DECLSPEC_HOTPATCH PostQueuedCompletionStatus( HANDLE port, DWORD count,
ULONG_PTR key, LPOVERLAPPED overlapped )
{
TRACE( "%p %d %08lx %p\n", port, count, key, overlapped );
TRACE( "%p %ld %08Ix %p\n", port, count, key, overlapped );
return set_ntstatus( NtSetIoCompletion( port, key, (ULONG_PTR)overlapped, STATUS_SUCCESS, count ));
}
@ -1121,7 +1121,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH CallNamedPipeW( LPCWSTR name, LPVOID input, DWORD
BOOL ret;
DWORD mode;
TRACE( "%s %p %d %p %d %p %d\n", debugstr_w(name),
TRACE( "%s %p %ld %p %ld %p %ld\n", debugstr_w(name),
input, in_size, output, out_size, read_size, timeout );
pipe = CreateFileW( name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL );
@ -1185,7 +1185,7 @@ HANDLE WINAPI DECLSPEC_HOTPATCH CreateNamedPipeW( LPCWSTR name, DWORD open_mode,
IO_STATUS_BLOCK iosb;
LARGE_INTEGER time;
TRACE( "(%s, %#08x, %#08x, %d, %d, %d, %d, %p)\n", debugstr_w(name),
TRACE( "(%s, %#08lx, %#08lx, %ld, %ld, %ld, %ld, %p)\n", debugstr_w(name),
open_mode, pipe_mode, instances, out_buff, in_buff, timeout, sa );
if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
@ -1318,7 +1318,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetNamedPipeHandleStateW( HANDLE pipe, DWORD *stat
{
IO_STATUS_BLOCK io;
FIXME( "%p %p %p %p %p %p %d: semi-stub\n", pipe, state, instances, max_count, timeout, user, size );
FIXME( "%p %p %p %p %p %p %ld: semi-stub\n", pipe, state, instances, max_count, timeout, user, size );
if (max_count) *max_count = 0;
if (timeout) *timeout = 0;
@ -1417,7 +1417,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetNamedPipeHandleState( HANDLE pipe, LPDWORD mode
IO_STATUS_BLOCK iosb;
NTSTATUS status = STATUS_SUCCESS;
TRACE( "%p %p/%d %p %p\n", pipe, mode, mode ? *mode : 0, count, timeout );
TRACE( "%p %p/%ld %p %p\n", pipe, mode, mode ? *mode : 0, count, timeout );
if (count || timeout) FIXME( "Unsupported arguments\n" );
if (mode)
@ -1447,7 +1447,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH TransactNamedPipe( HANDLE handle, LPVOID write_buf
void *cvalue = NULL;
NTSTATUS status;
TRACE( "%p %p %u %p %u %p %p\n", handle,
TRACE( "%p %p %lu %p %lu %p %p\n", handle,
write_buf, write_size, read_buf, read_size, bytes_read, overlapped );
if (overlapped)
@ -1488,7 +1488,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH WaitNamedPipeW( LPCWSTR name, DWORD timeout )
ULONG wait_size;
HANDLE pipe_dev;
TRACE( "%s 0x%08x\n", debugstr_w(name), timeout );
TRACE( "%s 0x%08lx\n", debugstr_w(name), timeout );
if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL )) return FALSE;

2
dlls/kernelbase/thread.c
View File

@ -512,7 +512,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH SetThreadGroupAffinity( HANDLE thread, const GROUP
*/
DWORD WINAPI DECLSPEC_HOTPATCH SetThreadIdealProcessor( HANDLE thread, DWORD proc )
{
FIXME( "(%p %u): stub\n", thread, proc );
FIXME( "(%p %lu): stub\n", thread, proc );
if (proc > MAXIMUM_PROCESSORS)
{
SetLastError( ERROR_INVALID_PARAMETER );

42
dlls/kernelbase/version.c
View File

@ -248,7 +248,7 @@ done:
&& nt->OptionalHeader.MinorOperatingSystemVersion >= 3)))
{
if (current_version.dwMajorVersion > 10)
FIXME("Unsupported current_version.dwMajorVersion %u.\n", current_version.dwMajorVersion);
FIXME("Unsupported current_version.dwMajorVersion %lu.\n", current_version.dwMajorVersion);
ver = nt->OptionalHeader.MajorOperatingSystemVersion >= 10 ? NULL : &windows8_1_version_info;
}
@ -628,7 +628,7 @@ static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
{
WORD mode = LOWORD(vffi->dwFileVersionMS);
WORD ver_rev = HIWORD(vffi->dwFileVersionLS);
TRACE("fileversion=%u.%u.%u.%u (%s.major.minor.release), ",
TRACE("fileversion=%lu.%u.%u.%u (%s.major.minor.release), ",
(vffi->dwFileVersionMS),
HIBYTE(ver_rev), LOBYTE(ver_rev), LOWORD(vffi->dwFileVersionLS),
(mode == 3) ? "Usermode" : ((mode <= 2) ? "Kernelmode" : "?") );
@ -643,7 +643,7 @@ static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
HIWORD(vffi->dwProductVersionMS),LOWORD(vffi->dwProductVersionMS),
HIWORD(vffi->dwProductVersionLS),LOWORD(vffi->dwProductVersionLS));
TRACE("flagmask=0x%x, flags=0x%x %s%s%s%s%s%s\n",
TRACE("flagmask=0x%lx, flags=0x%lx %s%s%s%s%s%s\n",
vffi->dwFileFlagsMask, vffi->dwFileFlags,
(vffi->dwFileFlags & VS_FF_DEBUG) ? "DEBUG," : "",
(vffi->dwFileFlags & VS_FF_PRERELEASE) ? "PRERELEASE," : "",
@ -664,7 +664,7 @@ static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
case VOS_NT:TRACE("NT,");break;
case VOS_UNKNOWN:
default:
TRACE("UNKNOWN(0x%x),",vffi->dwFileOS&0xFFFF0000);break;
TRACE("UNKNOWN(0x%lx),",vffi->dwFileOS&0xFFFF0000);break;
}
switch (LOWORD(vffi->dwFileOS))
@ -689,7 +689,7 @@ static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
{
if(versioned_printer) /* NT3.x/NT4.0 or old w2k Driver */
TRACE(",PRINTER");
TRACE(" (subtype=0x%x)", vffi->dwFileSubtype);
TRACE(" (subtype=0x%lx)", vffi->dwFileSubtype);
}
break;
case VFT_DRV:
@ -710,7 +710,7 @@ static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
case VFT2_DRV_VERSIONED_PRINTER:TRACE("VERSIONED_PRINTER");break;
case VFT2_UNKNOWN:
default:
TRACE("UNKNOWN(0x%x)",vffi->dwFileSubtype);break;
TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype);break;
}
break;
case VFT_FONT:
@ -720,18 +720,18 @@ static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
case VFT2_FONT_RASTER:TRACE("RASTER");break;
case VFT2_FONT_VECTOR:TRACE("VECTOR");break;
case VFT2_FONT_TRUETYPE:TRACE("TRUETYPE");break;
default:TRACE("UNKNOWN(0x%x)",vffi->dwFileSubtype);break;
default:TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype);break;
}
break;
case VFT_VXD:TRACE("filetype=VXD");break;
case VFT_STATIC_LIB:TRACE("filetype=STATIC_LIB");break;
case VFT_UNKNOWN:
default:
TRACE("filetype=Unknown(0x%x)",vffi->dwFileType);break;
TRACE("filetype=Unknown(0x%lx)",vffi->dwFileType);break;
}
TRACE("\n");
TRACE("filedate=0x%x.0x%x\n",vffi->dwFileDateMS,vffi->dwFileDateLS);
TRACE("filedate=0x%lx.0x%lx\n",vffi->dwFileDateMS,vffi->dwFileDateLS);
}
/***********************************************************************
@ -758,7 +758,7 @@ DWORD WINAPI GetFileVersionInfoSizeExW( DWORD flags, LPCWSTR filename, LPDWORD r
DWORD len, offset, magic = 1;
HMODULE hModule;
TRACE("(0x%x,%s,%p)\n", flags, debugstr_w(filename), ret_handle );
TRACE("(0x%lx,%s,%p)\n", flags, debugstr_w(filename), ret_handle );
if (ret_handle) *ret_handle = 0;
@ -773,7 +773,7 @@ DWORD WINAPI GetFileVersionInfoSizeExW( DWORD flags, LPCWSTR filename, LPDWORD r
return 0;
}
if (flags & ~FILE_VER_GET_LOCALISED)
FIXME("flags 0x%x ignored\n", flags & ~FILE_VER_GET_LOCALISED);
FIXME("flags 0x%lx ignored\n", flags & ~FILE_VER_GET_LOCALISED);
if ((hModule = LoadLibraryExW( filename, 0, LOAD_LIBRARY_AS_DATAFILE )))
{
@ -846,7 +846,7 @@ DWORD WINAPI GetFileVersionInfoSizeExA( DWORD flags, LPCSTR filename, LPDWORD ha
UNICODE_STRING filenameW;
DWORD retval;
TRACE("(0x%x,%s,%p)\n", flags, debugstr_a(filename), handle );
TRACE("(0x%lx,%s,%p)\n", flags, debugstr_a(filename), handle );
if(filename)
RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
@ -870,7 +870,7 @@ BOOL WINAPI GetFileVersionInfoExW( DWORD flags, LPCWSTR filename, DWORD ignored,
HMODULE hModule;
VS_VERSION_INFO_STRUCT32* vvis = data;
TRACE("(0x%x,%s,%d,size=%d,data=%p)\n",
TRACE("(0x%lx,%s,%ld,size=%ld,data=%p)\n",
flags, debugstr_w(filename), ignored, datasize, data );
if (!data)
@ -879,7 +879,7 @@ BOOL WINAPI GetFileVersionInfoExW( DWORD flags, LPCWSTR filename, DWORD ignored,
return FALSE;
}
if (flags & ~FILE_VER_GET_LOCALISED)
FIXME("flags 0x%x ignored\n", flags & ~FILE_VER_GET_LOCALISED);
FIXME("flags 0x%lx ignored\n", flags & ~FILE_VER_GET_LOCALISED);
if ((hModule = LoadLibraryExW( filename, 0, LOAD_LIBRARY_AS_DATAFILE )))
{
@ -950,7 +950,7 @@ BOOL WINAPI GetFileVersionInfoExA( DWORD flags, LPCSTR filename, DWORD handle, D
UNICODE_STRING filenameW;
BOOL retval;
TRACE("(0x%x,%s,%d,size=%d,data=%p)\n",
TRACE("(0x%lx,%s,%ld,size=%ld,data=%p)\n",
flags, debugstr_a(filename), handle, datasize, data );
if(filename)
@ -1290,7 +1290,7 @@ DWORD WINAPI VerFindFileA( DWORD flags, LPCSTR filename, LPCSTR win_dir, LPCSTR
const char *destDir;
char winDir[MAX_PATH], systemDir[MAX_PATH];
TRACE("flags = %x filename=%s windir=%s appdir=%s curdirlen=%p(%u) destdirlen=%p(%u)\n",
TRACE("flags = %lx filename=%s windir=%s appdir=%s curdirlen=%p(%u) destdirlen=%p(%u)\n",
flags, debugstr_a(filename), debugstr_a(win_dir), debugstr_a(app_dir),
curdir_len, curdir_len ? *curdir_len : 0, dest_len, dest_len ? *dest_len : 0 );
@ -1358,7 +1358,7 @@ DWORD WINAPI VerFindFileA( DWORD flags, LPCSTR filename, LPCSTR win_dir, LPCSTR
*curdir_len = len;
}
TRACE("ret = %u (%s%s%s) curdir=%s destdir=%s\n", retval,
TRACE("ret = %lu (%s%s%s) curdir=%s destdir=%s\n", retval,
(retval & VFF_CURNEDEST) ? "VFF_CURNEDEST " : "",
(retval & VFF_FILEINUSE) ? "VFF_FILEINUSE " : "",
(retval & VFF_BUFFTOOSMALL) ? "VFF_BUFFTOOSMALL " : "",
@ -1377,7 +1377,7 @@ DWORD WINAPI VerFindFileW( DWORD flags, LPCWSTR filename, LPCWSTR win_dir, LPCWS
const WCHAR *curDir;
const WCHAR *destDir;
TRACE("flags = %x filename=%s windir=%s appdir=%s curdirlen=%p(%u) destdirlen=%p(%u)\n",
TRACE("flags = %lx filename=%s windir=%s appdir=%s curdirlen=%p(%u) destdirlen=%p(%u)\n",
flags, debugstr_w(filename), debugstr_w(win_dir), debugstr_w(app_dir),
curdir_len, curdir_len ? *curdir_len : 0, dest_len, dest_len ? *dest_len : 0 );
@ -1437,7 +1437,7 @@ DWORD WINAPI VerFindFileW( DWORD flags, LPCWSTR filename, LPCWSTR win_dir, LPCWS
*curdir_len = len;
}
TRACE("ret = %u (%s%s%s) curdir=%s destdir=%s\n", retval,
TRACE("ret = %lu (%s%s%s) curdir=%s destdir=%s\n", retval,
(retval & VFF_CURNEDEST) ? "VFF_CURNEDEST " : "",
(retval & VFF_FILEINUSE) ? "VFF_FILEINUSE " : "",
(retval & VFF_BUFFTOOSMALL) ? "VFF_BUFFTOOSMALL " : "",
@ -1486,7 +1486,7 @@ BOOL WINAPI GetVersionExA( OSVERSIONINFOA *info )
if (info->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA) &&
info->dwOSVersionInfoSize != sizeof(OSVERSIONINFOEXA))
{
WARN( "wrong OSVERSIONINFO size from app (got: %d)\n", info->dwOSVersionInfoSize );
WARN( "wrong OSVERSIONINFO size from app (got: %ld)\n", info->dwOSVersionInfoSize );
SetLastError( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
@ -1523,7 +1523,7 @@ BOOL WINAPI GetVersionExW( OSVERSIONINFOW *info )
if (info->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW) &&
info->dwOSVersionInfoSize != sizeof(OSVERSIONINFOEXW))
{
WARN( "wrong OSVERSIONINFO size from app (got: %d)\n", info->dwOSVersionInfoSize );
WARN( "wrong OSVERSIONINFO size from app (got: %ld)\n", info->dwOSVersionInfoSize );
return FALSE;
}

18
dlls/kernelbase/volume.c
View File

@ -198,7 +198,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetVolumeInformationW( LPCWSTR root, LPWSTR label,
if (status)
{
TRACE( "cannot open device %s: %x\n", debugstr_w(nt_name.Buffer), status );
TRACE( "cannot open device %s: %lx\n", debugstr_w(nt_name.Buffer), status );
if (status == STATUS_ACCESS_DENIED)
MESSAGE( "wine: Read access denied for device %s, FS volume label and serial are not available.\n", debugstr_w(nt_name.Buffer) );
status = NtOpenFile( &handle, SYNCHRONIZE, &attr, &io, 0,
@ -264,7 +264,7 @@ BOOL WINAPI GetVolumeNameForVolumeMountPointW( LPCWSTR path, LPWSTR volume, DWOR
BOOL ret = FALSE;
DWORD br;
TRACE("(%s, %p, %x)\n", debugstr_w(path), volume, size);
TRACE("(%s, %p, %lx)\n", debugstr_w(path), volume, size);
if (path[lstrlenW(path)-1] != '\\')
{
SetLastError( ERROR_INVALID_NAME );
@ -309,7 +309,7 @@ BOOL WINAPI GetVolumeNameForVolumeMountPointW( LPCWSTR path, LPWSTR volume, DWOR
/* We will then take that and get the volume name */
nonpersist_name = (WCHAR *)(input + 1);
status = read_nt_symlink( symlink_name, nonpersist_name, (i_size - sizeof(*input)) / sizeof(WCHAR) );
TRACE("read_nt_symlink got stat=%x, for %s, got <%s>\n", status,
TRACE("read_nt_symlink got stat=%lx, for %s, got <%s>\n", status,
debugstr_w(symlink_name), debugstr_w(nonpersist_name));
if (status != STATUS_SUCCESS)
{
@ -333,7 +333,7 @@ BOOL WINAPI GetVolumeNameForVolumeMountPointW( LPCWSTR path, LPWSTR volume, DWOR
goto err_ret;
/* Verify and return the data, note string is not null terminated */
TRACE("found %d matching mount points\n", output->NumberOfMountPoints);
TRACE("found %ld matching mount points\n", output->NumberOfMountPoints);
if (output->NumberOfMountPoints < 1)
{
SetLastError( ERROR_NO_VOLUME_ID );
@ -390,10 +390,10 @@ BOOL WINAPI DECLSPEC_HOTPATCH DefineDosDeviceW( DWORD flags, const WCHAR *device
NTSTATUS status;
HANDLE handle;
TRACE("%#x, %s, %s\n", flags, debugstr_w(device), debugstr_w(target));
TRACE("%#lx, %s, %s\n", flags, debugstr_w(device), debugstr_w(target));
if (flags & ~(DDD_RAW_TARGET_PATH | DDD_REMOVE_DEFINITION))
FIXME("Ignoring flags %#x.\n", flags & ~(DDD_RAW_TARGET_PATH | DDD_REMOVE_DEFINITION));
FIXME("Ignoring flags %#lx.\n", flags & ~(DDD_RAW_TARGET_PATH | DDD_REMOVE_DEFINITION));
lstrcatW( link_name, device );
RtlInitUnicodeString( &nt_name, link_name );
@ -721,7 +721,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetDiskFreeSpaceW( LPCWSTR root, LPDWORD cluster_s
if (sector_bytes) *sector_bytes = info.BytesPerSector;
if (free_clusters) *free_clusters = info.AvailableAllocationUnits.u.LowPart;
if (total_clusters) *total_clusters = info.TotalAllocationUnits.u.LowPart;
TRACE("%#08x, %#08x, %#08x, %#08x\n", info.SectorsPerAllocationUnit, info.BytesPerSector,
TRACE("%#08lx, %#08lx, %#08lx, %#08lx\n", info.SectorsPerAllocationUnit, info.BytesPerSector,
info.AvailableAllocationUnits.u.LowPart, info.TotalAllocationUnits.u.LowPart);
return TRUE;
}
@ -941,7 +941,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GetVolumePathNamesForVolumeNameW( LPCWSTR volumena
BOOL ret = FALSE;
UINT i, j;
TRACE("%s, %p, %u, %p\n", debugstr_w(volumename), volumepathname, buflen, returnlen);
TRACE("%s, %p, %lu, %p\n", debugstr_w(volumename), volumepathname, buflen, returnlen);
if (!volumename || (len = lstrlenW( volumename )) != 49)
{
@ -1112,7 +1112,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH FindNextVolumeW( HANDLE handle, LPWSTR volume, DWO
volume[1] = '\\'; /* map \??\ to \\?\ */
volume[size / sizeof(WCHAR)] = '\\'; /* Windows appends a backslash */
volume[size / sizeof(WCHAR) + 1] = 0;
TRACE( "returning entry %u %s\n", data->Size - 1, debugstr_w(volume) );
TRACE( "returning entry %lu %s\n", data->Size - 1, debugstr_w(volume) );
return TRUE;
}
SetLastError( ERROR_NO_MORE_FILES );