system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-09-02 14:33:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

ntdll: Win64 printf format warning fixes.

Browse source
This commit is contained in:
Hans Leidekker 2006-10-16 13:49:06 +02:00 committed by Alexandre Julliard
parent 9e30761951
commit f7b0ba7aa7
32 changed files with 281 additions and 277 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
dlls/ntdll/Makefile.in
View file

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

4
dlls/ntdll/atom.c
View file

@ -162,7 +162,7 @@ NTSTATUS WINAPI RtlQueryAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom, UL
*len = wlen;
}
TRACE( "%p %x -> %s (%lx)\n",
TRACE( "%p %x -> %s (%x)\n",
table, atom, len ? debugstr_wn(name, wlen / sizeof(WCHAR)) : NULL, status );
return status;
}
@ -431,7 +431,7 @@ NTSTATUS WINAPI NtQueryInformationAtom( RTL_ATOM atom, ATOM_INFORMATION_CLASS cl
}
SERVER_END_REQ;
}
TRACE( "%x -> %s (%lu)\n",
TRACE( "%x -> %s (%u)\n",
atom, debugstr_wn(abi->Name, abi->NameLength / sizeof(WCHAR)),
status );
if (psize)

10
dlls/ntdll/cdrom.c
View file

@ -1239,7 +1239,7 @@ static NTSTATUS CDROM_RawRead(int fd, const RAW_READ_INFO* raw, void* buffer, DW
int ret = STATUS_NOT_SUPPORTED;
int io = -1;
TRACE("RAW_READ_INFO: DiskOffset=%li,%li SectorCount=%li TrackMode=%i\n buffer=%p len=%li sz=%p\n",
TRACE("RAW_READ_INFO: DiskOffset=%i,%i SectorCount=%i TrackMode=%i\n buffer=%p len=%i sz=%p\n",
raw->DiskOffset.u.HighPart, raw->DiskOffset.u.LowPart, raw->SectorCount, raw->TrackMode, buffer, len, sz);
if (len < raw->SectorCount * 2352) return STATUS_BUFFER_TOO_SMALL;
@ -2016,7 +2016,7 @@ NTSTATUS CDROM_DeviceIoControl(HANDLE hDevice,
NTSTATUS status = STATUS_SUCCESS;
int fd, dev;
TRACE("%p %s %p %ld %p %ld %p\n",
TRACE("%p %s %p %d %p %d %p\n",
hDevice, iocodex(dwIoControlCode), lpInBuffer, nInBufferSize,
lpOutBuffer, nOutBufferSize, piosb);
@ -2215,10 +2215,10 @@ NTSTATUS CDROM_DeviceIoControl(HANDLE hDevice,
else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
else
{
TRACE("before in 0x%08lx out 0x%08lx\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
TRACE("before in 0x%08x out 0x%08x\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
*(PDVD_SESSION_ID)lpOutBuffer);
status = DVD_StartSession(fd, (PDVD_SESSION_ID)lpInBuffer, (PDVD_SESSION_ID)lpOutBuffer);
TRACE("before in 0x%08lx out 0x%08lx\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
TRACE("before in 0x%08x out 0x%08x\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
*(PDVD_SESSION_ID)lpOutBuffer);
}
break;
@ -2274,7 +2274,7 @@ NTSTATUS CDROM_DeviceIoControl(HANDLE hDevice,
break;
default:
FIXME("Unsupported IOCTL %lx (type=%lx access=%lx func=%lx meth=%lx)\n",
FIXME("Unsupported IOCTL %x (type=%x access=%x func=%x meth=%x)\n",
dwIoControlCode, dwIoControlCode >> 16, (dwIoControlCode >> 14) & 3,
(dwIoControlCode >> 2) & 0xFFF, dwIoControlCode & 3);
sz = 0;

4
dlls/ntdll/critsection.c
View file

@ -397,12 +397,12 @@ NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
const char *name = NULL;
if (crit->DebugInfo) name = (char *)crit->DebugInfo->Spare[0];
if (!name) name = "?";
ERR( "section %p %s wait timed out in thread %04lx, blocked by %04lx, retrying (60 sec)\n",
ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (60 sec)\n",
crit, debugstr_a(name), GetCurrentThreadId(), (DWORD)crit->OwningThread );
status = wait_semaphore( crit, 60 );
if ( status == STATUS_TIMEOUT && TRACE_ON(relay) )
{
ERR( "section %p %s wait timed out in thread %04lx, blocked by %04lx, retrying (5 min)\n",
ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (5 min)\n",
crit, debugstr_a(name), GetCurrentThreadId(), (DWORD) crit->OwningThread );
status = wait_semaphore( crit, 300 );
}

40
dlls/ntdll/debugbuffer.c
View file

@ -39,17 +39,17 @@ static void dump_DEBUG_MODULE_INFORMATION(PDEBUG_MODULE_INFORMATION iBuf)
{
TRACE( "MODULE_INFORMATION:%p\n", iBuf );
if (NULL == iBuf) return ;
TRACE( "Base:%ld\n", iBuf->Base );
TRACE( "Size:%ld\n", iBuf->Size );
TRACE( "Flags:%ld\n", iBuf->Flags );
TRACE( "Base:%d\n", iBuf->Base );
TRACE( "Size:%d\n", iBuf->Size );
TRACE( "Flags:%d\n", iBuf->Flags );
}
static void dump_DEBUG_HEAP_INFORMATION(PDEBUG_HEAP_INFORMATION iBuf)
{
TRACE( "HEAP_INFORMATION:%p\n", iBuf );
if (NULL == iBuf) return ;
TRACE( "Base:%ld\n", iBuf->Base );
TRACE( "Flags:%ld\n", iBuf->Flags );
TRACE( "Base:%d\n", iBuf->Base );
TRACE( "Flags:%d\n", iBuf->Flags );
}
static void dump_DEBUG_LOCK_INFORMATION(PDEBUG_LOCK_INFORMATION iBuf)
@ -61,13 +61,13 @@ static void dump_DEBUG_LOCK_INFORMATION(PDEBUG_LOCK_INFORMATION iBuf)
TRACE( "Address:%p\n", iBuf->Address );
TRACE( "Type:%d\n", iBuf->Type );
TRACE( "CreatorBackTraceIndex:%d\n", iBuf->CreatorBackTraceIndex );
TRACE( "OwnerThreadId:%ld\n", iBuf->OwnerThreadId );
TRACE( "ActiveCount:%ld\n", iBuf->ActiveCount );
TRACE( "ContentionCount:%ld\n", iBuf->ContentionCount );
TRACE( "EntryCount:%ld\n", iBuf->EntryCount );
TRACE( "RecursionCount:%ld\n", iBuf->RecursionCount );
TRACE( "NumberOfSharedWaiters:%ld\n", iBuf->NumberOfSharedWaiters );
TRACE( "NumberOfExclusiveWaiters:%ld\n", iBuf->NumberOfExclusiveWaiters );
TRACE( "OwnerThreadId:%d\n", iBuf->OwnerThreadId );
TRACE( "ActiveCount:%d\n", iBuf->ActiveCount );
TRACE( "ContentionCount:%d\n", iBuf->ContentionCount );
TRACE( "EntryCount:%d\n", iBuf->EntryCount );
TRACE( "RecursionCount:%d\n", iBuf->RecursionCount );
TRACE( "NumberOfSharedWaiters:%d\n", iBuf->NumberOfSharedWaiters );
TRACE( "NumberOfExclusiveWaiters:%d\n", iBuf->NumberOfExclusiveWaiters );
}
static void dump_DEBUG_BUFFER(PDEBUG_BUFFER iBuf)
@ -76,13 +76,13 @@ static void dump_DEBUG_BUFFER(PDEBUG_BUFFER iBuf)
TRACE( "SectionHandle:%p\n", iBuf->SectionHandle);
TRACE( "SectionBase:%p\n", iBuf->SectionBase);
TRACE( "RemoteSectionBase:%p\n", iBuf->RemoteSectionBase);
TRACE( "SectionBaseDelta:%ld\n", iBuf->SectionBaseDelta);
TRACE( "SectionBaseDelta:%d\n", iBuf->SectionBaseDelta);
TRACE( "EventPairHandle:%p\n", iBuf->EventPairHandle);
TRACE( "RemoteThreadHandle:%p\n", iBuf->RemoteThreadHandle);
TRACE( "InfoClassMask:%lx\n", iBuf->InfoClassMask);
TRACE( "SizeOfInfo:%ld\n", iBuf->SizeOfInfo);
TRACE( "AllocatedSize:%ld\n", iBuf->AllocatedSize);
TRACE( "SectionSize:%ld\n", iBuf->SectionSize);
TRACE( "InfoClassMask:%x\n", iBuf->InfoClassMask);
TRACE( "SizeOfInfo:%d\n", iBuf->SizeOfInfo);
TRACE( "AllocatedSize:%d\n", iBuf->AllocatedSize);
TRACE( "SectionSize:%d\n", iBuf->SectionSize);
TRACE( "BackTraceInfo:%p\n", iBuf->BackTraceInformation);
dump_DEBUG_MODULE_INFORMATION(iBuf->ModuleInformation);
dump_DEBUG_HEAP_INFORMATION(iBuf->HeapInformation);
@ -92,13 +92,13 @@ static void dump_DEBUG_BUFFER(PDEBUG_BUFFER iBuf)
PDEBUG_BUFFER WINAPI RtlCreateQueryDebugBuffer(IN ULONG iSize, IN BOOLEAN iEventPair)
{
PDEBUG_BUFFER oBuf = NULL;
FIXME("(%ld, %d): stub\n", iSize, iEventPair);
FIXME("(%d, %d): stub\n", iSize, iEventPair);
if (iSize < sizeof(DEBUG_BUFFER)) {
iSize = sizeof(DEBUG_BUFFER);
}
oBuf = (PDEBUG_BUFFER) RtlAllocateHeap(GetProcessHeap(), 0, iSize);
memset(oBuf, 0, iSize);
FIXME("(%ld, %d): returning %p\n", iSize, iEventPair, oBuf);
FIXME("(%d, %d): returning %p\n", iSize, iEventPair, oBuf);
return oBuf;
}
@ -118,7 +118,7 @@ NTSTATUS WINAPI RtlDestroyQueryDebugBuffer(IN PDEBUG_BUFFER iBuf)
NTSTATUS WINAPI RtlQueryProcessDebugInformation(IN ULONG iProcessId, IN ULONG iDebugInfoMask, IN OUT PDEBUG_BUFFER iBuf)
{
NTSTATUS nts = STATUS_SUCCESS;
FIXME("(%ld, %lx, %p): stub\n", iProcessId, iDebugInfoMask, iBuf);
FIXME("(%d, %x, %p): stub\n", iProcessId, iDebugInfoMask, iBuf);
iBuf->InfoClassMask = iDebugInfoMask;
if (iDebugInfoMask & PDI_MODULES) {

2
dlls/ntdll/debugtools.c
View file

@ -166,7 +166,7 @@ static int NTDLL_dbg_vlog( enum __wine_debug_class cls, struct __wine_debug_chan
if (info->out_pos == info->output || info->out_pos[-1] == '\n')
{
if (TRACE_ON(tid))
ret = wine_dbg_printf( "%04lx:", GetCurrentThreadId() );
ret = wine_dbg_printf( "%04x:", GetCurrentThreadId() );
if (cls < sizeof(classes)/sizeof(classes[0]))
ret += wine_dbg_printf( "%s:%s:%s ", classes[cls], channel->name, function );
}

10
dlls/ntdll/directory.c
View file

@ -1287,7 +1287,7 @@ NTSTATUS WINAPI NtQueryDirectoryFile( HANDLE handle, HANDLE event,
int cwd, fd;
static const WCHAR wszWildcards[] = { '*','?',0 };
TRACE("(%p %p %p %p %p %p 0x%08lx 0x%08x 0x%08x %s 0x%08x\n",
TRACE("(%p %p %p %p %p %p 0x%08x 0x%08x 0x%08x %s 0x%08x\n",
handle, event, apc_routine, apc_context, io, buffer,
length, info_class, single_entry, debugstr_us(mask),
restart_scan);
@ -1338,7 +1338,7 @@ NTSTATUS WINAPI NtQueryDirectoryFile( HANDLE handle, HANDLE event,
wine_server_release_fd( handle, fd );
if (cwd != -1) close( cwd );
TRACE( "=> %lx (%ld)\n", io->u.Status, io->Information );
TRACE( "=> %x (%ld)\n", io->u.Status, io->Information );
return io->u.Status;
}
@ -1966,7 +1966,7 @@ static void WINAPI read_changes_apc( void *user, PIO_STATUS_BLOCK iosb, ULONG st
NTSTATUS ret = STATUS_SUCCESS;
int len, action, i;
TRACE("%p %p %p %08lx\n", info, info->ApcContext, iosb, status);
TRACE("%p %p %p %08x\n", info, info->ApcContext, iosb, status);
/*
* FIXME: race me!
@ -2007,7 +2007,7 @@ static void WINAPI read_changes_apc( void *user, PIO_STATUS_BLOCK iosb, ULONG st
pfni->FileNameLength = len * sizeof (WCHAR);
pfni->FileName[len] = 0;
TRACE("action = %ld name = %s\n", pfni->Action,
TRACE("action = %d name = %s\n", pfni->Action,
debugstr_w(pfni->FileName) );
len = sizeof (*pfni) - sizeof (DWORD) + pfni->FileNameLength;
}
@ -2045,7 +2045,7 @@ NtNotifyChangeDirectoryFile( HANDLE FileHandle, HANDLE Event,
struct read_changes_info *info;
NTSTATUS status;
TRACE("%p %p %p %p %p %p %lu %lu %d\n",
TRACE("%p %p %p %p %p %p %u %u %d\n",
FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock,
Buffer, BufferSize, CompletionFilter, WatchTree );

4
dlls/ntdll/error.c
View file

@ -68,7 +68,7 @@ ULONG WINAPI RtlNtStatusToDosErrorNoTeb( NTSTATUS status )
if (status < table->end)
{
DWORD ret = table->table[status - table->start];
if (ret == ERROR_MR_MID_NOT_FOUND) FIXME( "no mapping for %08lx\n", status );
if (ret == ERROR_MR_MID_NOT_FOUND) FIXME( "no mapping for %08x\n", status );
return ret;
}
table++;
@ -77,7 +77,7 @@ ULONG WINAPI RtlNtStatusToDosErrorNoTeb( NTSTATUS status )
/* now some special cases */
if (HIWORD(status) == 0xc001) return LOWORD(status);
if (HIWORD(status) == 0x8007) return LOWORD(status);
FIXME( "no mapping for %08lx\n", status );
FIXME( "no mapping for %08x\n", status );
return ERROR_MR_MID_NOT_FOUND;
}

20
dlls/ntdll/exception.c
View file

@ -261,10 +261,10 @@ static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
}
/* Call handler */
TRACE( "calling handler at %p code=%lx flags=%lx\n",
TRACE( "calling handler at %p code=%x flags=%x\n",
frame->Handler, rec->ExceptionCode, rec->ExceptionFlags );
res = EXC_CallHandler( rec, frame, context, &dispatch, frame->Handler, EXC_RaiseHandler );
TRACE( "handler at %p returned %lx\n", frame->Handler, res );
TRACE( "handler at %p returned %x\n", frame->Handler, res );
if (frame == nested_frame)
{
@ -306,10 +306,10 @@ static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL f
{
DWORD c;
TRACE( "code=%lx flags=%lx addr=%p\n",
TRACE( "code=%x flags=%x addr=%p\n",
rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
for (c = 0; c < rec->NumberParameters; c++)
TRACE( " info[%ld]=%08lx\n", c, rec->ExceptionInformation[c] );
TRACE( " info[%d]=%08lx\n", c, rec->ExceptionInformation[c] );
if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
{
if (rec->ExceptionInformation[1] >> 16)
@ -324,10 +324,10 @@ static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL f
#ifdef __i386__
else
{
TRACE(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
TRACE(" eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
context->Eax, context->Ebx, context->Ecx,
context->Edx, context->Esi, context->Edi );
TRACE(" ebp=%08lx esp=%08lx cs=%04lx ds=%04lx es=%04lx fs=%04lx gs=%04lx flags=%08lx\n",
TRACE(" ebp=%08x esp=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
context->Ebp, context->Esp, context->SegCs, context->SegDs,
context->SegEs, context->SegFs, context->SegGs, context->EFlags );
}
@ -353,7 +353,7 @@ static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL f
else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
ERR("Process attempted to continue execution after noncontinuable exception.\n");
else
ERR("Unhandled exception code %lx flags %lx addr %p\n",
ERR("Unhandled exception code %x flags %x addr %p\n",
rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
NtTerminateProcess( NtCurrentProcess(), 1 );
}
@ -429,7 +429,7 @@ void WINAPI __regs_RtlUnwind( EXCEPTION_REGISTRATION_RECORD* pEndFrame, PVOID un
pRecord->ExceptionFlags |= EH_UNWINDING | (pEndFrame ? 0 : EH_EXIT_UNWIND);
TRACE( "code=%lx flags=%lx\n", pRecord->ExceptionCode, pRecord->ExceptionFlags );
TRACE( "code=%x flags=%x\n", pRecord->ExceptionCode, pRecord->ExceptionFlags );
/* get chain of exception frames */
frame = NtCurrentTeb()->Tib.ExceptionList;
@ -456,10 +456,10 @@ void WINAPI __regs_RtlUnwind( EXCEPTION_REGISTRATION_RECORD* pEndFrame, PVOID un
}
/* Call handler */
TRACE( "calling handler at %p code=%lx flags=%lx\n",
TRACE( "calling handler at %p code=%x flags=%x\n",
frame->Handler, pRecord->ExceptionCode, pRecord->ExceptionFlags );
res = EXC_CallHandler( pRecord, frame, context, &dispatch, frame->Handler, EXC_UnwindHandler );
TRACE( "handler at %p returned %lx\n", frame->Handler, res );
TRACE( "handler at %p returned %x\n", frame->Handler, res );
switch(res)
{

46
dlls/ntdll/file.c
View file

@ -135,8 +135,8 @@ NTSTATUS WINAPI NtCreateFile( PHANDLE handle, ACCESS_MASK access, POBJECT_ATTRIB
ANSI_STRING unix_name;
int created = FALSE;
TRACE("handle=%p access=%08lx name=%s objattr=%08lx root=%p sec=%p io=%p alloc_size=%p\n"
"attr=%08lx sharing=%08lx disp=%ld options=%08lx ea=%p.0x%08lx\n",
TRACE("handle=%p access=%08x name=%s objattr=%08x root=%p sec=%p io=%p alloc_size=%p\n"
"attr=%08x sharing=%08x disp=%d options=%08x ea=%p.0x%08x\n",
handle, access, debugstr_us(attr->ObjectName), attr->Attributes,
attr->RootDirectory, attr->SecurityDescriptor, io, alloc_size,
attributes, sharing, disposition, options, ea_buffer, ea_length );
@ -234,7 +234,7 @@ NTSTATUS WINAPI NtCreateFile( PHANDLE handle, ACCESS_MASK access, POBJECT_ATTRIB
SERVER_END_REQ;
RtlFreeAnsiString( &unix_name );
}
else WARN("%s not found (%lx)\n", debugstr_us(attr->ObjectName), io->u.Status );
else WARN("%s not found (%x)\n", debugstr_us(attr->ObjectName), io->u.Status );
if (io->u.Status == STATUS_SUCCESS)
{
@ -383,12 +383,12 @@ static void WINAPI FILE_AsyncReadService(void *user, PIO_STATUS_BLOCK iosb, ULON
int result;
int already = iosb->Information;
TRACE("%p %p 0x%lx\n", iosb, fileio->buffer, status);
TRACE("%p %p 0x%x\n", iosb, fileio->buffer, status);
switch (status)
{
case STATUS_ALERTED: /* got some new data */
if (iosb->u.Status != STATUS_PENDING) FIXME("unexpected status %08lx\n", iosb->u.Status);
if (iosb->u.Status != STATUS_PENDING) FIXME("unexpected status %08x\n", iosb->u.Status);
/* check to see if the data is ready (non-blocking) */
if ( fileio->avail_mode )
result = read(fileio->fd, &fileio->buffer[already],
@ -478,7 +478,7 @@ NTSTATUS WINAPI NtReadFile(HANDLE hFile, HANDLE hEvent,
{
int unix_handle, flags;
TRACE("(%p,%p,%p,%p,%p,%p,0x%08lx,%p,%p),partial stub!\n",
TRACE("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
hFile,hEvent,apc,apc_user,io_status,buffer,length,offset,key);
if (!io_status) return STATUS_ACCESS_VIOLATION;
@ -574,7 +574,7 @@ NTSTATUS WINAPI NtReadFile(HANDLE hFile, HANDLE hEvent,
if (ret != STATUS_USER_APC)
fileio->queue_apc_on_error = 1;
}
TRACE("= 0x%08lx\n", io_status->u.Status);
TRACE("= 0x%08x\n", io_status->u.Status);
return io_status->u.Status;
}
@ -612,7 +612,7 @@ NTSTATUS WINAPI NtReadFile(HANDLE hFile, HANDLE hEvent,
io_status->u.Status = STATUS_END_OF_FILE;
}
wine_server_release_fd( hFile, unix_handle );
TRACE("= 0x%08lx (%lu)\n", io_status->u.Status, io_status->Information);
TRACE("= 0x%08x (%lu)\n", io_status->u.Status, io_status->Information);
return io_status->u.Status;
}
@ -628,7 +628,7 @@ static void WINAPI FILE_AsyncWriteService(void *ovp, IO_STATUS_BLOCK *iosb, ULON
int result;
int already = iosb->Information;
TRACE("(%p %p 0x%lx)\n",iosb, fileio->buffer, status);
TRACE("(%p %p 0x%x)\n",iosb, fileio->buffer, status);
switch (status)
{
@ -700,7 +700,7 @@ NTSTATUS WINAPI NtWriteFile(HANDLE hFile, HANDLE hEvent,
{
int unix_handle, flags;
TRACE("(%p,%p,%p,%p,%p,%p,0x%08lx,%p,%p)!\n",
TRACE("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p)!\n",
hFile,hEvent,apc,apc_user,io_status,buffer,length,offset,key);
if (!io_status) return STATUS_ACCESS_VIOLATION;
@ -863,7 +863,7 @@ NTSTATUS WINAPI NtDeviceIoControlFile(HANDLE handle, HANDLE event,
{
ULONG device = (code >> 16);
TRACE("(%p,%p,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx)\n",
TRACE("(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
handle, event, apc, apc_context, io, code,
in_buffer, in_size, out_buffer, out_size);
@ -886,7 +886,7 @@ NTSTATUS WINAPI NtDeviceIoControlFile(HANDLE handle, HANDLE event,
in_buffer, in_size, out_buffer, out_size);
break;
default:
FIXME("Unsupported ioctl %lx (device=%lx access=%lx func=%lx method=%lx)\n",
FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
code, device, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
io->u.Status = STATUS_NOT_SUPPORTED;
break;
@ -899,7 +899,7 @@ NTSTATUS WINAPI NtDeviceIoControlFile(HANDLE handle, HANDLE event,
*/
static void CALLBACK pipe_completion_wait(HANDLE event, PIO_STATUS_BLOCK iosb, ULONG status)
{
TRACE("for %p/%p, status=%08lx\n", event, iosb, status);
TRACE("for %p/%p, status=%08x\n", event, iosb, status);
if (iosb)
iosb->u.Status = status;
@ -933,7 +933,7 @@ NTSTATUS WINAPI NtFsControlFile(HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc
PVOID apc_context, PIO_STATUS_BLOCK io, ULONG code,
PVOID in_buffer, ULONG in_size, PVOID out_buffer, ULONG out_size)
{
TRACE("(%p,%p,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx)\n",
TRACE("(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
handle, event, apc, apc_context, io, code,
in_buffer, in_size, out_buffer, out_size);
@ -1026,13 +1026,13 @@ NTSTATUS WINAPI NtFsControlFile(HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc
case FSCTL_LOCK_VOLUME:
case FSCTL_UNLOCK_VOLUME:
FIXME("stub! return success - Unsupported fsctl %lx (device=%lx access=%lx func=%lx method=%lx)\n",
FIXME("stub! return success - Unsupported fsctl %x (device=%x access=%x func=%x method=%x)\n",
code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
io->u.Status = STATUS_SUCCESS;
break;
default:
FIXME("Unsupported fsctl %lx (device=%lx access=%lx func=%lx method=%lx)\n",
FIXME("Unsupported fsctl %x (device=%x access=%x func=%x method=%x)\n",
code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
io->u.Status = STATUS_NOT_SUPPORTED;
break;
@ -1064,7 +1064,7 @@ NTSTATUS WINAPI NtSetVolumeInformationFile(
ULONG Length,
FS_INFORMATION_CLASS FsInformationClass)
{
FIXME("(%p,%p,%p,0x%08lx,0x%08x) stub\n",
FIXME("(%p,%p,%p,0x%08x,0x%08x) stub\n",
FileHandle,IoStatusBlock,FsInformation,Length,FsInformationClass);
return 0;
}
@ -1133,7 +1133,7 @@ NTSTATUS WINAPI NtQueryInformationFile( HANDLE hFile, PIO_STATUS_BLOCK io,
struct stat st;
int fd;
TRACE("(%p,%p,%p,0x%08lx,0x%08x)\n", hFile, io, ptr, len, class);
TRACE("(%p,%p,%p,0x%08x,0x%08x)\n", hFile, io, ptr, len, class);
io->Information = 0;
@ -1351,7 +1351,7 @@ NTSTATUS WINAPI NtSetInformationFile(HANDLE handle, PIO_STATUS_BLOCK io,
{
int fd;
TRACE("(%p,%p,%p,0x%08lx,0x%08x)\n", handle, io, ptr, len, class);
TRACE("(%p,%p,%p,0x%08x,0x%08x)\n", handle, io, ptr, len, class);
if ((io->u.Status = wine_server_handle_to_fd( handle, 0, &fd, NULL )))
return io->u.Status;
@ -1524,7 +1524,7 @@ NTSTATUS WINAPI NtQueryFullAttributesFile( const OBJECT_ATTRIBUTES *attr,
}
RtlFreeAnsiString( &unix_name );
}
else WARN("%s not found (%lx)\n", debugstr_us(attr->ObjectName), status );
else WARN("%s not found (%x)\n", debugstr_us(attr->ObjectName), status );
return status;
}
@ -1929,7 +1929,7 @@ NTSTATUS WINAPI NtUnlockFile( HANDLE hFile, PIO_STATUS_BLOCK io_status,
{
NTSTATUS status;
TRACE( "%p %lx%08lx %lx%08lx\n",
TRACE( "%p %x%08x %x%08x\n",
hFile, offset->u.HighPart, offset->u.LowPart, count->u.HighPart, count->u.LowPart );
if (io_status || key)
@ -1967,7 +1967,7 @@ NTSTATUS WINAPI NtCreateNamedPipeFile( PHANDLE handle, ULONG access,
NTSTATUS status;
static const WCHAR leadin[] = {'\\','?','?','\\','P','I','P','E','\\'};
TRACE("(%p %lx %s %p %lx %ld %lx %ld %ld %ld %ld %ld %ld %p)\n",
TRACE("(%p %x %s %p %x %d %x %d %d %d %d %d %d %p)\n",
handle, access, debugstr_w(attr->ObjectName->Buffer), iosb, sharing, dispo,
options, pipe_type, read_mode, completion_mode, max_inst, inbound_quota,
outbound_quota, timeout);
@ -2075,7 +2075,7 @@ NTSTATUS WINAPI NtCreateMailslotFile(PHANDLE pHandle, ULONG DesiredAccess,
'\\','?','?','\\','M','A','I','L','S','L','O','T','\\'};
NTSTATUS ret;
TRACE("%p %08lx %p %p %08lx %08lx %08lx %p\n",
TRACE("%p %08x %p %p %08x %08x %08x %p\n",
pHandle, DesiredAccess, attr, IoStatusBlock,
CreateOptions, MailslotQuota, MaxMessageSize, TimeOut);

4
dlls/ntdll/handletable.c
View file

@ -47,7 +47,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
*/
void WINAPI RtlInitializeHandleTable(ULONG MaxHandleCount, ULONG HandleSize, RTL_HANDLE_TABLE * HandleTable)
{
TRACE("(%lu, %lu, %p)\n", MaxHandleCount, HandleSize, HandleTable);
TRACE("(%u, %u, %p)\n", MaxHandleCount, HandleSize, HandleTable);
memset(HandleTable, 0, sizeof(*HandleTable));
HandleTable->MaxHandleCount = MaxHandleCount;
@ -282,7 +282,7 @@ BOOLEAN WINAPI RtlIsValidIndexHandle(const RTL_HANDLE_TABLE * HandleTable, ULONG
{
RTL_HANDLE * Handle;
TRACE("(%p, %lu, %p)\n", HandleTable, Index, ValidHandle);
TRACE("(%p, %u, %p)\n", HandleTable, Index, ValidHandle);
Handle = (RTL_HANDLE *)
((char *)HandleTable->FirstHandle + Index * HandleTable->HandleSize);

40
dlls/ntdll/heap.c
View file

@ -214,7 +214,7 @@ static void HEAP_Dump( HEAP *heap )
DPRINTF( "\nFree lists:\n Block Stat Size Id\n" );
for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
DPRINTF( "%p free %08lx prev=%p next=%p\n",
DPRINTF( "%p free %08x prev=%p next=%p\n",
&heap->freeList[i].arena, HEAP_freeListSizes[i],
LIST_ENTRY( heap->freeList[i].arena.entry.prev, ARENA_FREE, entry ),
LIST_ENTRY( heap->freeList[i].arena.entry.next, ARENA_FREE, entry ));
@ -223,7 +223,7 @@ static void HEAP_Dump( HEAP *heap )
while (subheap)
{
SIZE_T freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
DPRINTF( "\n\nSub-heap %p: size=%08lx committed=%08lx\n",
DPRINTF( "\n\nSub-heap %p: size=%08x committed=%08x\n",
subheap, subheap->size, subheap->commitSize );
DPRINTF( "\n Block Stat Size Id\n" );
@ -233,7 +233,7 @@ static void HEAP_Dump( HEAP *heap )
if (*(DWORD *)ptr & ARENA_FLAG_FREE)
{
ARENA_FREE *pArena = (ARENA_FREE *)ptr;
DPRINTF( "%p free %08lx prev=%p next=%p\n",
DPRINTF( "%p free %08x prev=%p next=%p\n",
pArena, pArena->size & ARENA_SIZE_MASK,
LIST_ENTRY( pArena->entry.prev, ARENA_FREE, entry ),
LIST_ENTRY( pArena->entry.next, ARENA_FREE, entry ) );
@ -244,7 +244,7 @@ static void HEAP_Dump( HEAP *heap )
else if (*(DWORD *)ptr & ARENA_FLAG_PREV_FREE)
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
DPRINTF( "%p Used %08lx back=%p\n",
DPRINTF( "%p Used %08x back=%p\n",
pArena, pArena->size & ARENA_SIZE_MASK, *((ARENA_FREE **)pArena - 1) );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_INUSE);
@ -253,13 +253,13 @@ static void HEAP_Dump( HEAP *heap )
else
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
DPRINTF( "%p used %08lx\n", pArena, pArena->size & ARENA_SIZE_MASK );
DPRINTF( "%p used %08x\n", pArena, pArena->size & ARENA_SIZE_MASK );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_INUSE);
usedSize += pArena->size & ARENA_SIZE_MASK;
}
}
DPRINTF( "\nTotal: Size=%08lx Committed=%08lx Free=%08lx Used=%08lx Arenas=%08lx (%ld%%)\n\n",
DPRINTF( "\nTotal: Size=%08x Committed=%08x Free=%08lx Used=%08lx Arenas=%08lx (%ld%%)\n\n",
subheap->size, subheap->commitSize, freeSize, usedSize,
arenaSize, (arenaSize * 100) / subheap->size );
subheap = subheap->next;
@ -272,7 +272,7 @@ static void HEAP_DumpEntry( LPPROCESS_HEAP_ENTRY entry )
WORD rem_flags;
TRACE( "Dumping entry %p\n", entry );
TRACE( "lpData\t\t: %p\n", entry->lpData );
TRACE( "cbData\t\t: %08lx\n", entry->cbData);
TRACE( "cbData\t\t: %08x\n", entry->cbData);
TRACE( "cbOverhead\t: %08x\n", entry->cbOverhead);
TRACE( "iRegionIndex\t: %08x\n", entry->iRegionIndex);
TRACE( "WFlags\t\t: ");
@ -301,8 +301,8 @@ static void HEAP_DumpEntry( LPPROCESS_HEAP_ENTRY entry )
}
if (entry->wFlags & PROCESS_HEAP_REGION)
{
TRACE( "Region.dwCommittedSize\t:%08lx\n",entry->u.Region.dwCommittedSize);
TRACE( "Region.dwUnCommittedSize\t:%08lx\n",entry->u.Region.dwUnCommittedSize);
TRACE( "Region.dwCommittedSize\t:%08x\n",entry->u.Region.dwCommittedSize);
TRACE( "Region.dwUnCommittedSize\t:%08x\n",entry->u.Region.dwUnCommittedSize);
TRACE( "Region.lpFirstBlock\t:%p\n",entry->u.Region.lpFirstBlock);
TRACE( "Region.lpLastBlock\t:%p\n",entry->u.Region.lpLastBlock);
}
@ -793,14 +793,14 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
if (!(pArena->size & ARENA_FLAG_FREE) ||
(pArena->size & ARENA_FLAG_PREV_FREE))
{
ERR("Heap %p: bad flags %08lx for free arena %p\n",
ERR("Heap %p: bad flags %08x for free arena %p\n",
subheap->heap, pArena->size & ~ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check arena size */
if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
ERR("Heap %p: bad size %08lx for free arena %p\n",
ERR("Heap %p: bad size %08x for free arena %p\n",
subheap->heap, pArena->size & ARENA_SIZE_MASK, pArena );
return FALSE;
}
@ -902,14 +902,14 @@ static BOOL HEAP_ValidateInUseArena( const SUBHEAP *subheap, const ARENA_INUSE *
/* Check size flags */
if (pArena->size & ARENA_FLAG_FREE)
{
ERR("Heap %p: bad flags %08lx for in-use arena %p\n",
ERR("Heap %p: bad flags %08x for in-use arena %p\n",
subheap->heap, pArena->size & ~ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check arena size */
if ((const char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
ERR("Heap %p: bad size %08lx for in-use arena %p\n",
ERR("Heap %p: bad size %08x for in-use arena %p\n",
subheap->heap, pArena->size & ARENA_SIZE_MASK, pArena );
return FALSE;
}
@ -1156,7 +1156,7 @@ PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, SIZE_T size )
if (!(pArena = HEAP_FindFreeBlock( heapPtr, rounded_size, &subheap )))
{
TRACE("(%p,%08lx,%08lx): returning NULL\n",
TRACE("(%p,%08x,%08lx): returning NULL\n",
heap, flags, size );
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus( STATUS_NO_MEMORY );
@ -1188,7 +1188,7 @@ PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, SIZE_T size )
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
TRACE("(%p,%08lx,%08lx): returning %p\n", heap, flags, size, pInUse + 1 );
TRACE("(%p,%08x,%08lx): returning %p\n", heap, flags, size, pInUse + 1 );
return (LPVOID)(pInUse + 1);
}
@ -1241,13 +1241,13 @@ BOOLEAN WINAPI RtlFreeHeap( HANDLE heap, ULONG flags, PVOID ptr )
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
TRACE("(%p,%08lx,%p): returning TRUE\n", heap, flags, ptr );
TRACE("(%p,%08x,%p): returning TRUE\n", heap, flags, ptr );
return TRUE;
error:
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
TRACE("(%p,%08lx,%p): returning FALSE\n", heap, flags, ptr );
TRACE("(%p,%08x,%p): returning FALSE\n", heap, flags, ptr );
return FALSE;
}
@ -1372,13 +1372,13 @@ PVOID WINAPI RtlReAllocateHeap( HANDLE heap, ULONG flags, PVOID ptr, SIZE_T size
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
TRACE("(%p,%08lx,%p,%08lx): returning %p\n", heap, flags, ptr, size, pArena + 1 );
TRACE("(%p,%08x,%p,%08lx): returning %p\n", heap, flags, ptr, size, pArena + 1 );
return (LPVOID)(pArena + 1);
error:
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
TRACE("(%p,%08lx,%p,%08lx): returning NULL\n", heap, flags, ptr, size );
TRACE("(%p,%08x,%p,%08lx): returning NULL\n", heap, flags, ptr, size );
return NULL;
}
@ -1489,7 +1489,7 @@ SIZE_T WINAPI RtlSizeHeap( HANDLE heap, ULONG flags, PVOID ptr )
}
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
TRACE("(%p,%08lx,%p): returning %08lx\n", heap, flags, ptr, ret );
TRACE("(%p,%08x,%p): returning %08lx\n", heap, flags, ptr, ret );
return ret;
}

32
dlls/ntdll/loader.c
View file

@ -215,7 +215,7 @@ static ULONG_PTR allocate_stub( const char *dll, const char *name )
if (!stubs)
{
ULONG size = MAX_SIZE;
SIZE_T size = MAX_SIZE;
if (NtAllocateVirtualMemory( NtCurrentProcess(), (void **)&stubs, 0, &size,
MEM_COMMIT, PAGE_EXECUTE_WRITECOPY ) != STATUS_SUCCESS)
return 0xdeadbeef;
@ -372,7 +372,7 @@ static FARPROC find_ordinal_export( HMODULE module, const IMAGE_EXPORT_DIRECTORY
if (ordinal >= exports->NumberOfFunctions)
{
TRACE(" ordinal %ld out of range!\n", ordinal + exports->Base );
TRACE(" ordinal %d out of range!\n", ordinal + exports->Base );
return NULL;
}
if (!functions[ordinal]) return NULL;
@ -486,7 +486,7 @@ static WINE_MODREF *import_dll( HMODULE module, const IMAGE_IMPORT_DESCRIPTOR *d
ERR("Library %s (which is needed by %s) not found\n",
name, debugstr_w(current_modref->ldr.FullDllName.Buffer));
else
ERR("Loading library %s (which is needed by %s) failed (error %lx).\n",
ERR("Loading library %s (which is needed by %s) failed (error %x).\n",
name, debugstr_w(current_modref->ldr.FullDllName.Buffer), status);
return NULL;
}
@ -755,7 +755,7 @@ static NTSTATUS alloc_thread_tls(void)
const IMAGE_TLS_DIRECTORY *dir = tls_dirs[i];
ULONG size = dir->EndAddressOfRawData - dir->StartAddressOfRawData;
TRACE( "thread %04lx idx %d: %ld/%ld bytes from %p to %p\n",
TRACE( "thread %04x idx %d: %d/%d bytes from %p to %p\n",
GetCurrentThreadId(), i, size, dir->SizeOfZeroFill,
(void *)dir->StartAddressOfRawData, data );
@ -785,11 +785,11 @@ static void call_tls_callbacks( HMODULE module, UINT reason )
for (callback = (const PIMAGE_TLS_CALLBACK *)dir->AddressOfCallBacks; *callback; callback++)
{
if (TRACE_ON(relay))
DPRINTF("%04lx:Call TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
DPRINTF("%04x:Call TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
GetCurrentThreadId(), *callback, module, reason_names[reason] );
(*callback)( module, reason, NULL );
if (TRACE_ON(relay))
DPRINTF("%04lx:Ret TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
DPRINTF("%04x:Ret TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
GetCurrentThreadId(), *callback, module, reason_names[reason] );
}
}
@ -816,7 +816,7 @@ static BOOL MODULE_InitDLL( WINE_MODREF *wm, UINT reason, LPVOID lpReserved )
size_t len = min( wm->ldr.BaseDllName.Length, sizeof(mod_name)-sizeof(WCHAR) );
memcpy( mod_name, wm->ldr.BaseDllName.Buffer, len );
mod_name[len / sizeof(WCHAR)] = 0;
DPRINTF("%04lx:Call PE DLL (proc=%p,module=%p %s,reason=%s,res=%p)\n",
DPRINTF("%04x:Call PE DLL (proc=%p,module=%p %s,reason=%s,res=%p)\n",
GetCurrentThreadId(), entry, module, debugstr_w(mod_name),
reason_names[reason], lpReserved );
}
@ -829,7 +829,7 @@ static BOOL MODULE_InitDLL( WINE_MODREF *wm, UINT reason, LPVOID lpReserved )
to the dll. We cannot assume that this module has not been
deleted. */
if (TRACE_ON(relay))
DPRINTF("%04lx:Ret PE DLL (proc=%p,module=%p %s,reason=%s,res=%p) retval=%x\n",
DPRINTF("%04x:Ret PE DLL (proc=%p,module=%p %s,reason=%s,res=%p) retval=%x\n",
GetCurrentThreadId(), entry, module, debugstr_w(mod_name),
reason_names[reason], lpReserved, retv );
else TRACE("(%p,%s,%p) - RETURN %d\n", module, reason_names[reason], lpReserved, retv );
@ -1090,7 +1090,7 @@ NTSTATUS WINAPI LdrFindEntryForAddress(const void* addr, PLDR_MODULE* pmod)
*/
NTSTATUS WINAPI LdrLockLoaderLock( ULONG flags, ULONG *result, ULONG *magic )
{
if (flags) FIXME( "flags %lx not supported\n", flags );
if (flags) FIXME( "flags %x not supported\n", flags );
if (result) *result = 1;
if (!magic) return STATUS_INVALID_PARAMETER_3;
@ -1167,7 +1167,7 @@ NTSTATUS WINAPI LdrGetDllHandle(ULONG x, ULONG y, const UNICODE_STRING *name, HM
}
done:
RtlLeaveCriticalSection( &loader_section );
TRACE("%lx %lx %s -> %p\n", x, y, debugstr_us(name), status ? NULL : *base);
TRACE("%x %x %s -> %p\n", x, y, debugstr_us(name), status ? NULL : *base);
return status;
}
@ -1274,6 +1274,7 @@ static void load_builtin_callback( void *module, const char *filename )
WINE_MODREF *wm;
WCHAR *fullname;
const WCHAR *load_path;
SIZE_T size;
if (!module)
{
@ -1287,7 +1288,8 @@ static void load_builtin_callback( void *module, const char *filename )
return;
}
addr = module;
NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &nt->OptionalHeader.SizeOfImage,
size = nt->OptionalHeader.SizeOfImage;
NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &size,
MEM_SYSTEM | MEM_IMAGE, PAGE_EXECUTE_WRITECOPY );
/* create the MODREF */
@ -1779,7 +1781,7 @@ static NTSTATUS load_dll( LPCWSTR load_path, LPCWSTR libname, DWORD flags, WINE_
return nts;
}
WARN("Failed to load module %s; status=%lx\n", debugstr_w(libname), nts);
WARN("Failed to load module %s; status=%x\n", debugstr_w(libname), nts);
if (handle) NtClose( handle );
if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
return nts;
@ -2154,7 +2156,7 @@ void WINAPI LdrInitializeThunk( ULONG unknown1, ULONG unknown2, ULONG unknown3,
return;
error:
ERR( "Main exe initialization for %s failed, status %lx\n",
ERR( "Main exe initialization for %s failed, status %x\n",
debugstr_w(peb->ProcessParameters->ImagePathName.Buffer), status );
exit(1);
}
@ -2362,14 +2364,14 @@ void __wine_process_init(void)
if ((status = load_builtin_dll( NULL, kernel32W, 0, 0, &wm )) != STATUS_SUCCESS)
{
MESSAGE( "wine: could not load kernel32.dll, status %lx\n", status );
MESSAGE( "wine: could not load kernel32.dll, status %x\n", status );
exit(1);
}
RtlInitAnsiString( &func_name, "__wine_kernel_init" );
if ((status = LdrGetProcedureAddress( wm->ldr.BaseAddress, &func_name,
0, (void **)&init_func )) != STATUS_SUCCESS)
{
MESSAGE( "wine: could not find __wine_kernel_init in kernel32.dll, status %lx\n", status );
MESSAGE( "wine: could not find __wine_kernel_init in kernel32.dll, status %x\n", status );
exit(1);
}
init_func();

2
dlls/ntdll/misc.c
View file

@ -36,7 +36,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
void dump_ObjectAttributes (const OBJECT_ATTRIBUTES *oa)
{
if (oa)
TRACE("%p:(name=%s, attr=0x%08lx, hRoot=%p, sd=%p)\n",
TRACE("%p:(name=%s, attr=0x%08x, hRoot=%p, sd=%p)\n",
oa, debugstr_us(oa->ObjectName),
oa->Attributes, oa->RootDirectory, oa->SecurityDescriptor);
}

38
dlls/ntdll/nt.c
View file

@ -56,7 +56,7 @@ NTSTATUS WINAPI NtDuplicateToken(
{
NTSTATUS status;
TRACE("(%p,0x%08lx,%p,0x%08x,0x%08x,%p)\n",
TRACE("(%p,0x%08x,%p,0x%08x,0x%08x,%p)\n",
ExistingToken, DesiredAccess, ObjectAttributes,
ImpersonationLevel, TokenType, NewToken);
dump_ObjectAttributes(ObjectAttributes);
@ -87,7 +87,7 @@ NTSTATUS WINAPI NtOpenProcessToken(
{
NTSTATUS ret;
TRACE("(%p,0x%08lx,%p)\n", ProcessHandle,DesiredAccess, TokenHandle);
TRACE("(%p,0x%08x,%p)\n", ProcessHandle,DesiredAccess, TokenHandle);
SERVER_START_REQ( open_token )
{
@ -115,7 +115,7 @@ NTSTATUS WINAPI NtOpenThreadToken(
{
NTSTATUS ret;
TRACE("(%p,0x%08lx,0x%08x,%p)\n",
TRACE("(%p,0x%08x,0x%08x,%p)\n",
ThreadHandle,DesiredAccess, OpenAsSelf, TokenHandle);
SERVER_START_REQ( open_token )
@ -149,7 +149,7 @@ NTSTATUS WINAPI NtAdjustPrivilegesToken(
{
NTSTATUS ret;
TRACE("(%p,0x%08x,%p,0x%08lx,%p,%p)\n",
TRACE("(%p,0x%08x,%p,0x%08x,%p,%p)\n",
TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength);
SERVER_START_REQ( adjust_token_privileges )
@ -197,7 +197,7 @@ NTSTATUS WINAPI NtQueryInformationToken(
ULONG len;
NTSTATUS status = STATUS_SUCCESS;
TRACE("(%p,%d,%p,%ld,%p)\n",
TRACE("(%p,%d,%p,%d,%p)\n",
token,tokeninfoclass,tokeninfo,tokeninfolength,retlen);
switch (tokeninfoclass)
@ -371,7 +371,7 @@ NTSTATUS WINAPI NtSetInformationToken(
PVOID TokenInformation,
ULONG TokenInformationLength)
{
FIXME("%p %d %p %lu\n", TokenHandle, TokenInformationClass,
FIXME("%p %d %p %u\n", TokenHandle, TokenInformationClass,
TokenInformation, TokenInformationLength);
return STATUS_NOT_IMPLEMENTED;
}
@ -388,7 +388,7 @@ NTSTATUS WINAPI NtAdjustGroupsToken(
PTOKEN_GROUPS PreviousState,
PULONG ReturnLength)
{
FIXME("%p %d %p %lu %p %p\n", TokenHandle, ResetToDefault,
FIXME("%p %d %p %u %p %p\n", TokenHandle, ResetToDefault,
NewState, BufferLength, PreviousState, ReturnLength);
return STATUS_NOT_IMPLEMENTED;
}
@ -435,7 +435,7 @@ NTSTATUS WINAPI NtQuerySection(
IN ULONG Length,
OUT PULONG ResultLength)
{
FIXME("(%p,%d,%p,0x%08lx,%p) stub!\n",
FIXME("(%p,%d,%p,0x%08x,%p) stub!\n",
SectionHandle,SectionInformationClass,SectionInformation,Length,ResultLength);
return 0;
}
@ -451,7 +451,7 @@ NTSTATUS WINAPI NtQuerySection(
NTSTATUS WINAPI NtCreatePort(PHANDLE PortHandle,POBJECT_ATTRIBUTES ObjectAttributes,
ULONG MaxConnectInfoLength,ULONG MaxDataLength,PULONG reserved)
{
FIXME("(%p,%p,%lu,%lu,%p),stub!\n",PortHandle,ObjectAttributes,
FIXME("(%p,%p,%u,%u,%p),stub!\n",PortHandle,ObjectAttributes,
MaxConnectInfoLength,MaxDataLength,reserved);
return STATUS_NOT_IMPLEMENTED;
}
@ -501,7 +501,7 @@ NTSTATUS WINAPI NtAcceptConnectPort(
PLPC_SECTION_WRITE WriteSection,
PLPC_SECTION_READ ReadSection)
{
FIXME("(%p,%lu,%p,%d,%p,%p),stub!\n",
FIXME("(%p,%u,%p,%d,%p,%p),stub!\n",
PortHandle,PortIdentifier,pLpcMessage,Accept,WriteSection,ReadSection);
return STATUS_NOT_IMPLEMENTED;
}
@ -545,8 +545,8 @@ NTSTATUS WINAPI NtRequestWaitReplyPort(
TRACE("\tVirtualRangesOffset = %u\n",pLpcMessageIn->VirtualRangesOffset);
TRACE("\tClientId.UniqueProcess = %p\n",pLpcMessageIn->ClientId.UniqueProcess);
TRACE("\tClientId.UniqueThread = %p\n",pLpcMessageIn->ClientId.UniqueThread);
TRACE("\tMessageId = %lu\n",pLpcMessageIn->MessageId);
TRACE("\tSectionSize = %lu\n",pLpcMessageIn->SectionSize);
TRACE("\tMessageId = %u\n",pLpcMessageIn->MessageId);
TRACE("\tSectionSize = %u\n",pLpcMessageIn->SectionSize);
TRACE("\tData = %s\n",
debugstr_an((const char*)pLpcMessageIn->Data,pLpcMessageIn->DataSize));
}
@ -579,7 +579,7 @@ NTSTATUS WINAPI NtSetIntervalProfile(
ULONG Interval,
KPROFILE_SOURCE Source)
{
FIXME("%lu,%d\n", Interval, Source);
FIXME("%u,%d\n", Interval, Source);
return STATUS_SUCCESS;
}
@ -611,7 +611,7 @@ NTSTATUS WINAPI NtQuerySystemInformation(
NTSTATUS ret = STATUS_SUCCESS;
ULONG len = 0;
TRACE("(0x%08x,%p,0x%08lx,%p)\n",
TRACE("(0x%08x,%p,0x%08x,%p)\n",
SystemInformationClass,SystemInformation,Length,ResultLength);
switch (SystemInformationClass)
@ -933,7 +933,7 @@ NTSTATUS WINAPI NtQuerySystemInformation(
}
break;
default:
FIXME("(0x%08x,%p,0x%08lx,%p) stub\n",
FIXME("(0x%08x,%p,0x%08x,%p) stub\n",
SystemInformationClass,SystemInformation,Length,ResultLength);
/* Several Information Classes are not implemented on Windows and return 2 different values
@ -954,7 +954,7 @@ NTSTATUS WINAPI NtQuerySystemInformation(
*/
NTSTATUS WINAPI NtSetSystemInformation(SYSTEM_INFORMATION_CLASS SystemInformationClass, PVOID SystemInformation, ULONG Length)
{
FIXME("(0x%08x,%p,0x%08lx) stub\n",SystemInformationClass,SystemInformation,Length);
FIXME("(0x%08x,%p,0x%08x) stub\n",SystemInformationClass,SystemInformation,Length);
return STATUS_SUCCESS;
}
@ -1000,7 +1000,7 @@ NTSTATUS WINAPI NtInitiatePowerAction(
IN ULONG Flags,
IN BOOLEAN Asynchronous)
{
FIXME("(%d,%d,0x%08lx,%d),stub\n",
FIXME("(%d,%d,0x%08x,%d),stub\n",
SystemAction,MinSystemState,Flags,Asynchronous);
return STATUS_NOT_IMPLEMENTED;
}
@ -1017,7 +1017,7 @@ NTSTATUS WINAPI NtPowerInformation(
IN PVOID lpOutputBuffer,
IN ULONG nOutputBufferSize)
{
TRACE("(%d,%p,%ld,%p,%ld)\n",
TRACE("(%d,%p,%d,%p,%d)\n",
InformationLevel,lpInputBuffer,nInputBufferSize,lpOutputBuffer,nOutputBufferSize);
switch(InformationLevel) {
case SystemPowerCapabilities: {
@ -1138,7 +1138,7 @@ NTSTATUS WINAPI NtAccessCheckAndAuditAlarm(PUNICODE_STRING SubsystemName, HANDLE
ACCESS_MASK DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOLEAN ObjectCreation,
PACCESS_MASK GrantedAccess, PBOOLEAN AccessStatus, PBOOLEAN GenerateOnClose)
{
FIXME("(%s, %p, %s, %p, 0x%08lx, %p, %d, %p, %p, %p), stub\n", debugstr_us(SubsystemName), HandleId,
FIXME("(%s, %p, %s, %p, 0x%08x, %p, %d, %p, %p, %p), stub\n", debugstr_us(SubsystemName), HandleId,
debugstr_us(ObjectTypeName), SecurityDescriptor, DesiredAccess, GenericMapping, ObjectCreation,
GrantedAccess, AccessStatus, GenerateOnClose);

18
dlls/ntdll/om.c
View file

@ -56,7 +56,7 @@ NTSTATUS WINAPI NtQueryObject(IN HANDLE handle,
{
NTSTATUS status;
TRACE("(%p,0x%08x,%p,0x%08lx,%p): stub\n",
TRACE("(%p,0x%08x,%p,0x%08x,%p): stub\n",
handle, info_class, ptr, len, used_len);
if (used_len) *used_len = 0;
@ -104,7 +104,7 @@ NTSTATUS WINAPI NtSetInformationObject(IN HANDLE handle,
{
NTSTATUS status;
TRACE("(%p,0x%08x,%p,0x%08lx): stub\n",
TRACE("(%p,0x%08x,%p,0x%08x): stub\n",
handle, info_class, ptr, len);
switch (info_class)
@ -161,7 +161,7 @@ NtQuerySecurityObject(
PISECURITY_DESCRIPTOR_RELATIVE psd = (PISECURITY_DESCRIPTOR_RELATIVE)Buffer;
UINT BufferIndex = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
FIXME("(%p,0x%08lx,%p,0x%08lx,%p) stub!\n",
FIXME("(%p,0x%08x,%p,0x%08x,%p) stub!\n",
Object, RequestedInformation, pSecurityDesriptor, Length, ResultLength);
RequestedInformation &= 0x0000000f;
@ -283,7 +283,7 @@ NtQuerySecurityObject(
pacl->AclSize = BufferIndex - pacl->AclSize;
}
*ResultLength = BufferIndex;
TRACE("len=%lu\n", *ResultLength);
TRACE("len=%u\n", *ResultLength);
if (Length < *ResultLength) return STATUS_BUFFER_TOO_SMALL;
memcpy(pSecurityDesriptor, Buffer, *ResultLength);
@ -367,7 +367,7 @@ NTSTATUS WINAPI NtOpenDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK Desir
POBJECT_ATTRIBUTES ObjectAttributes)
{
NTSTATUS ret;
TRACE("(%p,0x%08lx)\n", DirectoryHandle, DesiredAccess);
TRACE("(%p,0x%08x)\n", DirectoryHandle, DesiredAccess);
dump_ObjectAttributes(ObjectAttributes);
if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
@ -416,7 +416,7 @@ NTSTATUS WINAPI NtCreateDirectoryObject(PHANDLE DirectoryHandle, ACCESS_MASK Des
POBJECT_ATTRIBUTES ObjectAttributes)
{
NTSTATUS ret;
TRACE("(%p,0x%08lx)\n", DirectoryHandle, DesiredAccess);
TRACE("(%p,0x%08x)\n", DirectoryHandle, DesiredAccess);
dump_ObjectAttributes(ObjectAttributes);
if (!DirectoryHandle) return STATUS_ACCESS_VIOLATION;
@ -459,7 +459,7 @@ NTSTATUS WINAPI NtQueryDirectoryObject(IN HANDLE DirectoryHandle, OUT PDIRECTORY
IN ULONG BufferLength, IN BOOLEAN ReturnSingleEntry, IN BOOLEAN RestartScan,
IN OUT PULONG Context, OUT PULONG ReturnLength OPTIONAL)
{
FIXME("(%p,%p,0x%08lx,0x%08x,0x%08x,%p,%p), stub\n", DirectoryHandle, Buffer, BufferLength, ReturnSingleEntry,
FIXME("(%p,%p,0x%08x,0x%08x,0x%08x,%p,%p), stub\n", DirectoryHandle, Buffer, BufferLength, ReturnSingleEntry,
RestartScan, Context, ReturnLength);
return STATUS_NOT_IMPLEMENTED;
@ -488,7 +488,7 @@ NTSTATUS WINAPI NtOpenSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK
IN POBJECT_ATTRIBUTES ObjectAttributes)
{
NTSTATUS ret;
TRACE("(%p,0x%08lx,%p)\n",LinkHandle, DesiredAccess, ObjectAttributes);
TRACE("(%p,0x%08x,%p)\n",LinkHandle, DesiredAccess, ObjectAttributes);
dump_ObjectAttributes(ObjectAttributes);
if (!LinkHandle) return STATUS_ACCESS_VIOLATION;
@ -539,7 +539,7 @@ NTSTATUS WINAPI NtCreateSymbolicLinkObject(OUT PHANDLE SymbolicLinkHandle,IN ACC
IN PUNICODE_STRING TargetName)
{
NTSTATUS ret;
TRACE("(%p,0x%08lx,%p, -> %s)\n", SymbolicLinkHandle, DesiredAccess, ObjectAttributes,
TRACE("(%p,0x%08x,%p, -> %s)\n", SymbolicLinkHandle, DesiredAccess, ObjectAttributes,
debugstr_us(TargetName));
dump_ObjectAttributes(ObjectAttributes);

4
dlls/ntdll/path.c
View file

@ -828,7 +828,7 @@ DWORD WINAPI RtlGetFullPathName_U(const WCHAR* name, ULONG size, WCHAR* buffer,
DWORD dosdev;
DWORD reqsize;
TRACE("(%s %lu %p %p)\n", debugstr_w(name), size, buffer, file_part);
TRACE("(%s %u %p %p)\n", debugstr_w(name), size, buffer, file_part);
if (!name || !*name) return 0;
@ -965,7 +965,7 @@ NTSTATUS WINAPI RtlGetCurrentDirectory_U(ULONG buflen, LPWSTR buf)
UNICODE_STRING* us;
ULONG len;
TRACE("(%lu %p)\n", buflen, buf);
TRACE("(%u %p)\n", buflen, buf);
RtlAcquirePebLock();

6
dlls/ntdll/process.c
View file

@ -92,7 +92,7 @@ NTSTATUS WINAPI NtQueryInformationProcess(
NTSTATUS ret = STATUS_SUCCESS;
ULONG len = 0;
TRACE("(%p,0x%08x,%p,0x%08lx,%p)\n",
TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
ProcessHandle,ProcessInformationClass,
ProcessInformation,ProcessInformationLength,
ReturnLength);
@ -292,7 +292,7 @@ NTSTATUS WINAPI NtQueryInformationProcess(
else ret = STATUS_INFO_LENGTH_MISMATCH;
break;
default:
FIXME("(%p,info_class=%d,%p,0x%08lx,%p) Unknown information class\n",
FIXME("(%p,info_class=%d,%p,0x%08x,%p) Unknown information class\n",
ProcessHandle,ProcessInformationClass,
ProcessInformation,ProcessInformationLength,
ReturnLength);
@ -349,7 +349,7 @@ NTSTATUS WINAPI NtSetInformationProcess(
}
break;
default:
FIXME("(%p,0x%08x,%p,0x%08lx) stub\n",
FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
ProcessHandle,ProcessInformationClass,ProcessInformation,
ProcessInformationLength);
ret = STATUS_NOT_IMPLEMENTED;

26
dlls/ntdll/reg.c
View file

@ -59,7 +59,7 @@ NTSTATUS WINAPI NtCreateKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_AT
if (attr->Length > sizeof(OBJECT_ATTRIBUTES)) return STATUS_INVALID_PARAMETER;
if (attr->ObjectName->Length > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
TRACE( "(%p,%s,%s,%lx,%lx,%p)\n", attr->RootDirectory, debugstr_us(attr->ObjectName),
TRACE( "(%p,%s,%s,%x,%x,%p)\n", attr->RootDirectory, debugstr_us(attr->ObjectName),
debugstr_us(class), options, access, retkey );
SERVER_START_REQ( create_key )
@ -117,7 +117,7 @@ NTSTATUS WINAPI NtOpenKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTR
NTSTATUS ret;
DWORD len = attr->ObjectName->Length;
TRACE( "(%p,%s,%lx,%p)\n", attr->RootDirectory,
TRACE( "(%p,%s,%x,%p)\n", attr->RootDirectory,
debugstr_us(attr->ObjectName), access, retkey );
if (len > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
@ -417,7 +417,7 @@ NTSTATUS WINAPI NtEnumerateValueKey( HANDLE handle, ULONG index,
void *ptr;
size_t fixed_size;
TRACE( "(%p,%lu,%d,%p,%ld)\n", handle, index, info_class, info, length );
TRACE( "(%p,%u,%d,%p,%d)\n", handle, index, info_class, info, length );
/* compute the length we want to retrieve */
switch(info_class)
@ -465,7 +465,7 @@ NTSTATUS WINAPI NtQueryValueKey( HANDLE handle, const UNICODE_STRING *name,
UCHAR *data_ptr;
unsigned int fixed_size = 0;
TRACE( "(%p,%s,%d,%p,%ld)\n", handle, debugstr_us(name), info_class, info, length );
TRACE( "(%p,%s,%d,%p,%d)\n", handle, debugstr_us(name), info_class, info, length );
if (name->Length > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
@ -610,7 +610,7 @@ NTSTATUS WINAPI NtNotifyChangeKey(
{
NTSTATUS ret;
TRACE("(%p,%p,%p,%p,%p,0x%08lx, 0x%08x,%p,0x%08lx,0x%08x)\n",
TRACE("(%p,%p,%p,%p,%p,0x%08x, 0x%08x,%p,0x%08x,0x%08x)\n",
KeyHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, CompletionFilter,
Asynchronous, ChangeBuffer, Length, WatchSubtree);
@ -659,7 +659,7 @@ NTSTATUS WINAPI NtQueryMultipleValueKey(
ULONG Length,
PULONG ReturnLength)
{
FIXME("(%p,%p,0x%08lx,%p,0x%08lx,%p) stub!\n",
FIXME("(%p,%p,0x%08x,%p,0x%08x,%p) stub!\n",
KeyHandle, ListOfValuesToQuery, NumberOfItems, MultipleValueInformation,
Length,ReturnLength);
return STATUS_SUCCESS;
@ -688,7 +688,7 @@ NTSTATUS WINAPI NtRestoreKey(
HANDLE FileHandle,
ULONG RestoreFlags)
{
FIXME("(%p,%p,0x%08lx) stub\n",
FIXME("(%p,%p,0x%08x) stub\n",
KeyHandle, FileHandle, RestoreFlags);
return STATUS_SUCCESS;
}
@ -722,7 +722,7 @@ NTSTATUS WINAPI NtSetInformationKey(
IN PVOID KeyInformation,
IN ULONG KeyInformationLength)
{
FIXME("(%p,0x%08x,%p,0x%08lx) stub\n",
FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
KeyHandle, KeyInformationClass, KeyInformation, KeyInformationLength);
return STATUS_SUCCESS;
}
@ -741,7 +741,7 @@ NTSTATUS WINAPI NtSetValueKey( HANDLE hkey, const UNICODE_STRING *name, ULONG Ti
{
NTSTATUS ret;
TRACE( "(%p,%s,%ld,%p,%ld)\n", hkey, debugstr_us(name), type, data, count );
TRACE( "(%p,%s,%d,%p,%d)\n", hkey, debugstr_us(name), type, data, count );
if (name->Length > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
@ -853,7 +853,7 @@ NTSTATUS WINAPI RtlOpenCurrentUser(
UNICODE_STRING ObjectName;
NTSTATUS ret;
TRACE("(0x%08lx, %p)\n",DesiredAccess, KeyHandle);
TRACE("(0x%08x, %p)\n",DesiredAccess, KeyHandle);
if ((ret = RtlFormatCurrentUserKeyPath(&ObjectName))) return ret;
InitializeObjectAttributes(&ObjectAttributes,&ObjectName,OBJ_CASE_INSENSITIVE,0, NULL);
@ -1119,7 +1119,7 @@ NTSTATUS WINAPI RtlQueryRegistryValues(IN ULONG RelativeTo, IN PCWSTR Path,
NTSTATUS status=STATUS_SUCCESS, ret = STATUS_SUCCESS;
INT i;
TRACE("(%ld, %s, %p, %p, %p)\n", RelativeTo, debugstr_w(Path), QueryTable, Context, Environment);
TRACE("(%d, %s, %p, %p, %p)\n", RelativeTo, debugstr_w(Path), QueryTable, Context, Environment);
if(Path == NULL)
return STATUS_INVALID_PARAMETER;
@ -1289,7 +1289,7 @@ NTSTATUS WINAPI RtlCheckRegistryKey(IN ULONG RelativeTo, IN PWSTR Path)
HANDLE handle;
NTSTATUS status;
TRACE("(%ld, %s)\n", RelativeTo, debugstr_w(Path));
TRACE("(%d, %s)\n", RelativeTo, debugstr_w(Path));
if((!RelativeTo) && Path == NULL)
return STATUS_OBJECT_PATH_SYNTAX_BAD;
@ -1321,7 +1321,7 @@ NTSTATUS WINAPI RtlDeleteRegistryValue(IN ULONG RelativeTo, IN PCWSTR Path, IN P
HANDLE handle;
UNICODE_STRING Value;
TRACE("(%ld, %s, %s)\n", RelativeTo, debugstr_w(Path), debugstr_w(ValueName));
TRACE("(%d, %s, %s)\n", RelativeTo, debugstr_w(Path), debugstr_w(ValueName));
RtlInitUnicodeString(&Value, ValueName);
if(RelativeTo == RTL_REGISTRY_HANDLE)

48
dlls/ntdll/relay.c
View file

@ -381,18 +381,18 @@ static LONGLONG WINAPI relay_call_from_32( struct relay_descr *descr, unsigned i
else
{
if (entry_point->name)
DPRINTF( "%04lx:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
else
DPRINTF( "%04lx:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
RELAY_PrintArgs( stack + 1, nb_args, descr->arg_types[ordinal] );
DPRINTF( ") ret=%08x\n", stack[0] );
ret = call_entry_point( entry_point->orig_func, nb_args, stack + 1 );
if (entry_point->name)
DPRINTF( "%04lx:Ret %s.%s()", GetCurrentThreadId(), data->dllname, entry_point->name );
DPRINTF( "%04x:Ret %s.%s()", GetCurrentThreadId(), data->dllname, entry_point->name );
else
DPRINTF( "%04lx:Ret %s.%u()", GetCurrentThreadId(), data->dllname, data->base + ordinal );
DPRINTF( "%04x:Ret %s.%u()", GetCurrentThreadId(), data->dllname, data->base + ordinal );
if (flags & 1) /* 64-bit return value */
DPRINTF( " retval=%08x%08x ret=%08x\n",
@ -429,14 +429,14 @@ void WINAPI __regs_relay_call_from_32_regs( struct relay_descr *descr, unsigned
if (TRACE_ON(relay))
{
if (entry_point->name)
DPRINTF( "%04lx:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
else
DPRINTF( "%04lx:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
RELAY_PrintArgs( args, nb_args, descr->arg_types[ordinal] );
DPRINTF( ") ret=%08x\n", ret_addr );
DPRINTF( "%04lx: eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx "
"ebp=%08lx esp=%08lx ds=%04lx es=%04lx fs=%04lx gs=%04lx flags=%08lx\n",
DPRINTF( "%04x: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
"ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
@ -456,15 +456,15 @@ void WINAPI __regs_relay_call_from_32_regs( struct relay_descr *descr, unsigned
if (TRACE_ON(relay))
{
if (entry_point->name)
DPRINTF( "%04lx:Ret %s.%s() retval=%08lx ret=%08lx\n",
DPRINTF( "%04x:Ret %s.%s() retval=%08x ret=%08x\n",
GetCurrentThreadId(), data->dllname, entry_point->name,
context->Eax, context->Eip );
else
DPRINTF( "%04lx:Ret %s.%u() retval=%08lx ret=%08lx\n",
DPRINTF( "%04x:Ret %s.%u() retval=%08x ret=%08x\n",
GetCurrentThreadId(), data->dllname, data->base + ordinal,
context->Eax, context->Eip );
DPRINTF( "%04lx: eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx "
"ebp=%08lx esp=%08lx ds=%04lx es=%04lx fs=%04lx gs=%04lx flags=%08lx\n",
DPRINTF( "%04x: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
"ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
@ -644,13 +644,15 @@ void SNOOP_SetupDLL(HMODULE hmod)
char *p, *name;
void *addr;
SIZE_T size;
ULONG size32;
IMAGE_EXPORT_DIRECTORY *exports;
if (!init_done) init_debug_lists();
exports = RtlImageDirectoryEntryToData( hmod, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size );
exports = RtlImageDirectoryEntryToData( hmod, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size32 );
if (!exports) return;
name = (char *)hmod + exports->Name;
size = size32;
TRACE_(snoop)("hmod=%p, name=%s\n", hmod, name);
@ -763,7 +765,7 @@ static void SNOOP_PrintArg(DWORD x)
{
int i,nostring;
DPRINTF("%08lx",x);
DPRINTF("%08x",x);
if (!HIWORD(x) || TRACE_ON(seh)) return; /* trivial reject to avoid faults */
__TRY
{
@ -818,7 +820,7 @@ void WINAPI __regs_SNOOP_Entry( CONTEXT86 *context )
dll=dll->next;
}
if (!dll) {
FIXME("entrypoint 0x%08lx not found\n",entry);
FIXME("entrypoint 0x%08x not found\n",entry);
return; /* oops */
}
/* guess cdecl ... */
@ -870,8 +872,8 @@ void WINAPI __regs_SNOOP_Entry( CONTEXT86 *context )
context->Eip = (DWORD)fun->origfun;
if (fun->name) DPRINTF("%04lx:CALL %s.%s(",GetCurrentThreadId(),dll->name,fun->name);
else DPRINTF("%04lx:CALL %s.%ld(",GetCurrentThreadId(),dll->name,dll->ordbase+ordinal);
if (fun->name) DPRINTF("%04x:CALL %s.%s(",GetCurrentThreadId(),dll->name,fun->name);
else DPRINTF("%04x:CALL %s.%d(",GetCurrentThreadId(),dll->name,dll->ordbase+ordinal);
if (fun->nrofargs>0) {
max = fun->nrofargs; if (max>16) max=16;
for (i=0;i<max;i++)
@ -887,7 +889,7 @@ void WINAPI __regs_SNOOP_Entry( CONTEXT86 *context )
0,16*sizeof(DWORD));
memcpy(ret->args,(LPBYTE)(context->Esp + 4),sizeof(DWORD)*16);
}
DPRINTF(") ret=%08lx\n",(DWORD)ret->origreturn);
DPRINTF(") ret=%08x\n",(DWORD)ret->origreturn);
}
@ -908,9 +910,9 @@ void WINAPI __regs_SNOOP_Return( CONTEXT86 *context )
int i,max;
if (fun->name)
DPRINTF("%04lx:RET %s.%s(", GetCurrentThreadId(), ret->dll->name, fun->name);
DPRINTF("%04x:RET %s.%s(", GetCurrentThreadId(), ret->dll->name, fun->name);
else
DPRINTF("%04lx:RET %s.%ld(", GetCurrentThreadId(),
DPRINTF("%04x:RET %s.%d(", GetCurrentThreadId(),
ret->dll->name,ret->dll->ordbase+ret->ordinal);
max = fun->nrofargs;
@ -921,7 +923,7 @@ void WINAPI __regs_SNOOP_Return( CONTEXT86 *context )
SNOOP_PrintArg(ret->args[i]);
if (i<max-1) DPRINTF(",");
}
DPRINTF(") retval=%08lx ret=%08lx\n",
DPRINTF(") retval=%08x ret=%08x\n",
context->Eax,(DWORD)ret->origreturn );
RtlFreeHeap(GetProcessHeap(),0,ret->args);
ret->args = NULL;
@ -929,11 +931,11 @@ void WINAPI __regs_SNOOP_Return( CONTEXT86 *context )
else
{
if (fun->name)
DPRINTF("%04lx:RET %s.%s() retval=%08lx ret=%08lx\n",
DPRINTF("%04x:RET %s.%s() retval=%08x ret=%08x\n",
GetCurrentThreadId(),
ret->dll->name, fun->name, context->Eax, (DWORD)ret->origreturn);
else
DPRINTF("%04lx:RET %s.%ld() retval=%08lx ret=%08lx\n",
DPRINTF("%04x:RET %s.%d() retval=%08x ret=%08x\n",
GetCurrentThreadId(),
ret->dll->name,ret->dll->ordbase+ret->ordinal,
context->Eax, (DWORD)ret->origreturn);

6
dlls/ntdll/resource.c
View file

@ -266,7 +266,7 @@ NTSTATUS WINAPI LdrFindResourceDirectory_U( HMODULE hmod, const LDR_RESOURCE_INF
__TRY
{
if (info) TRACE( "module %p type %s name %s lang %04lx level %ld\n",
if (info) TRACE( "module %p type %s name %s lang %04x level %d\n",
hmod, debugstr_w((LPCWSTR)info->Type),
level > 1 ? debugstr_w((LPCWSTR)info->Name) : "",
level > 2 ? info->Language : 0, level );
@ -294,7 +294,7 @@ NTSTATUS WINAPI LdrFindResource_U( HMODULE hmod, const LDR_RESOURCE_INFO *info,
__TRY
{
if (info) TRACE( "module %p type %s name %s lang %04lx level %ld\n",
if (info) TRACE( "module %p type %s name %s lang %04x level %d\n",
hmod, debugstr_w((LPCWSTR)info->Type),
level > 1 ? debugstr_w((LPCWSTR)info->Name) : "",
level > 2 ? info->Language : 0, level );
@ -443,7 +443,7 @@ NTSTATUS WINAPI RtlFormatMessage( LPWSTR Message, UCHAR MaxWidth,
BOOLEAN ArgumentIsArray, va_list * Arguments,
LPWSTR Buffer, ULONG BufferSize )
{
FIXME("(%s, %u, %s, %s, %s, %p, %p, %ld)\n", debugstr_w(Message),
FIXME("(%s, %u, %s, %s, %s, %p, %p, %d)\n", debugstr_w(Message),
MaxWidth, IgnoreInserts ? "TRUE" : "FALSE", Ansi ? "TRUE" : "FALSE",
ArgumentIsArray ? "TRUE" : "FALSE", Arguments, Buffer, BufferSize);
return STATUS_SUCCESS;

12
dlls/ntdll/rtl.c
View file

@ -344,11 +344,11 @@ NTSTATUS WINAPI vDbgPrintExWithPrefix( LPCSTR prefix, ULONG id, ULONG level, LPC
switch (level & DPFLTR_MASK)
{
case DPFLTR_ERROR_LEVEL: ERR("%s%lx: %s", prefix, id, buf); break;
case DPFLTR_WARNING_LEVEL: WARN("%s%lx: %s", prefix, id, buf); break;
case DPFLTR_ERROR_LEVEL: ERR("%s%x: %s", prefix, id, buf); break;
case DPFLTR_WARNING_LEVEL: WARN("%s%x: %s", prefix, id, buf); break;
case DPFLTR_TRACE_LEVEL:
case DPFLTR_INFO_LEVEL:
default: TRACE("%s%lx: %s", prefix, id, buf); break;
default: TRACE("%s%x: %s", prefix, id, buf); break;
}
return STATUS_SUCCESS;
}
@ -545,7 +545,7 @@ SIZE_T WINAPI RtlCompareMemoryUlong(const ULONG *Source1, SIZE_T Length, ULONG d
*/
void WINAPI RtlAssert(LPVOID x1,LPVOID x2,DWORD x3, DWORD x4)
{
FIXME("(%p,%p,0x%08lx,0x%08lx),stub\n",x1,x2,x3,x4);
FIXME("(%p,%p,0x%08x,0x%08x),stub\n",x1,x2,x3,x4);
}
/*************************************************************************
@ -563,7 +563,7 @@ void WINAPI RtlAssert(LPVOID x1,LPVOID x2,DWORD x3, DWORD x4)
*/
VOID WINAPI RtlFillMemoryUlong(ULONG* lpDest, ULONG ulCount, ULONG ulValue)
{
TRACE("(%p,%ld,%ld)\n", lpDest, ulCount, ulValue);
TRACE("(%p,%d,%d)\n", lpDest, ulCount, ulValue);
ulCount /= sizeof(ULONG);
while(ulCount--)
@ -587,7 +587,7 @@ DWORD WINAPI RtlComputeCrc32(DWORD dwInitial, PBYTE pData, INT iLen)
{
DWORD crc = ~dwInitial;
TRACE("(%ld,%p,%d)\n", dwInitial, pData, iLen);
TRACE("(%d,%p,%d)\n", dwInitial, pData, iLen);
while (iLen > 0)
{

32
dlls/ntdll/rtlbitmap.c
View file

@ -74,7 +74,7 @@ static const signed char NTDLL_mostSignificant[16] = {
*/
VOID WINAPI RtlInitializeBitMap(PRTL_BITMAP lpBits, PULONG lpBuff, ULONG ulSize)
{
TRACE("(%p,%p,%ld)\n", lpBits,lpBuff,ulSize);
TRACE("(%p,%p,%d)\n", lpBits,lpBuff,ulSize);
lpBits->SizeOfBitMap = ulSize;
lpBits->Buffer = lpBuff;
}
@ -130,7 +130,7 @@ VOID WINAPI RtlSetBits(PRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
{
LPBYTE lpOut;
TRACE("(%p,%ld,%ld)\n", lpBits, ulStart, ulCount);
TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
if (!lpBits || !ulCount ||
ulStart >= lpBits->SizeOfBitMap ||
@ -190,7 +190,7 @@ VOID WINAPI RtlClearBits(PRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
{
LPBYTE lpOut;
TRACE("(%p,%ld,%ld)\n", lpBits, ulStart, ulCount);
TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
if (!lpBits || !ulCount ||
ulStart >= lpBits->SizeOfBitMap ||
@ -253,7 +253,7 @@ BOOLEAN WINAPI RtlAreBitsSet(PCRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
LPBYTE lpOut;
ULONG ulRemainder;
TRACE("(%p,%ld,%ld)\n", lpBits, ulStart, ulCount);
TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
if (!lpBits || !ulCount ||
ulStart >= lpBits->SizeOfBitMap ||
@ -326,7 +326,7 @@ BOOLEAN WINAPI RtlAreBitsClear(PCRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount
LPBYTE lpOut;
ULONG ulRemainder;
TRACE("(%p,%ld,%ld)\n", lpBits, ulStart, ulCount);
TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
if (!lpBits || !ulCount ||
ulStart >= lpBits->SizeOfBitMap ||
@ -394,7 +394,7 @@ ULONG WINAPI RtlFindSetBits(PCRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
{
ULONG ulPos, ulEnd;
TRACE("(%p,%ld,%ld)\n", lpBits, ulCount, ulHint);
TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
if (!lpBits || !ulCount || ulCount > lpBits->SizeOfBitMap)
return ~0U;
@ -441,7 +441,7 @@ ULONG WINAPI RtlFindClearBits(PCRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
{
ULONG ulPos, ulEnd;
TRACE("(%p,%ld,%ld)\n", lpBits, ulCount, ulHint);
TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
if (!lpBits || !ulCount || ulCount > lpBits->SizeOfBitMap)
return ~0U;
@ -488,7 +488,7 @@ ULONG WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP lpBits, ULONG ulCount, ULONG ulH
{
ULONG ulPos;
TRACE("(%p,%ld,%ld)\n", lpBits, ulCount, ulHint);
TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
ulPos = RtlFindSetBits(lpBits, ulCount, ulHint);
if (ulPos != ~0U)
@ -513,7 +513,7 @@ ULONG WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP lpBits, ULONG ulCount, ULONG ulH
{
ULONG ulPos;
TRACE("(%p,%ld,%ld)\n", lpBits, ulCount, ulHint);
TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
ulPos = RtlFindClearBits(lpBits, ulCount, ulHint);
if (ulPos != ~0U)
@ -866,7 +866,7 @@ ULONG WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG
{
ULONG ulSize = 0;
TRACE("(%p,%ld,%p)\n", lpBits, ulStart, lpPos);
TRACE("(%p,%d,%p)\n", lpBits, ulStart, lpPos);
if (lpBits && ulStart < lpBits->SizeOfBitMap && lpPos)
*lpPos = NTDLL_FindSetRun(lpBits, ulStart, &ulSize);
@ -893,7 +893,7 @@ ULONG WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP lpBits, ULONG ulStart, PULO
{
ULONG ulSize = 0;
TRACE("(%p,%ld,%p)\n", lpBits, ulStart, lpPos);
TRACE("(%p,%d,%p)\n", lpBits, ulStart, lpPos);
if (lpBits && ulStart < lpBits->SizeOfBitMap && lpPos)
*lpPos = NTDLL_FindClearRun(lpBits, ulStart, &ulSize);
@ -918,7 +918,7 @@ ULONG WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP lpBits, ULONG ulStart, PULO
*/
ULONG WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
{
FIXME("(%p,%ld,%p)-stub!\n", lpBits, ulStart, lpPos);
FIXME("(%p,%d,%p)-stub!\n", lpBits, ulStart, lpPos);
return 0;
}
@ -939,7 +939,7 @@ ULONG WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP lpBits, ULONG ulStart, PULON
*/
ULONG WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
{
FIXME("(%p,%ld,%p)-stub!\n", lpBits, ulStart, lpPos);
FIXME("(%p,%d,%p)-stub!\n", lpBits, ulStart, lpPos);
return 0;
}
@ -955,7 +955,7 @@ static ULONG WINAPI NTDLL_FindRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries
BOOL bNeedSort = ulCount > 1 ? TRUE : FALSE;
ULONG ulPos = 0, ulRuns = 0;
TRACE("(%p,%p,%ld,%d)\n", lpBits, lpSeries, ulCount, bLongest);
TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
if (!ulCount)
return ~0U;
@ -1017,7 +1017,7 @@ static ULONG WINAPI NTDLL_FindRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries
ULONG WINAPI RtlFindSetRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
ULONG ulCount, BOOLEAN bLongest)
{
TRACE("(%p,%p,%ld,%d)\n", lpBits, lpSeries, ulCount, bLongest);
TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
return NTDLL_FindRuns(lpBits, lpSeries, ulCount, bLongest, NTDLL_FindSetRun);
}
@ -1039,7 +1039,7 @@ ULONG WINAPI RtlFindSetRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
ULONG WINAPI RtlFindClearRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
ULONG ulCount, BOOLEAN bLongest)
{
TRACE("(%p,%p,%ld,%d)\n", lpBits, lpSeries, ulCount, bLongest);
TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
return NTDLL_FindRuns(lpBits, lpSeries, ulCount, bLongest, NTDLL_FindClearRun);
}

30
dlls/ntdll/sec.c
View file

@ -131,7 +131,7 @@ NTSTATUS WINAPI RtlAllocateAndInitializeSid (
{
SID *tmp_sid;
TRACE("(%p, 0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,%p)\n",
TRACE("(%p, 0x%04x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,%p)\n",
pIdentifierAuthority,nSubAuthorityCount,
nSubAuthority0, nSubAuthority1, nSubAuthority2, nSubAuthority3,
nSubAuthority4, nSubAuthority5, nSubAuthority6, nSubAuthority7, pSid);
@ -824,7 +824,7 @@ NTSTATUS WINAPI RtlMakeSelfRelativeSD(
SECURITY_DESCRIPTOR* pAbs = pAbsoluteSecurityDescriptor;
SECURITY_DESCRIPTOR* pRel = pSelfRelativeSecurityDescriptor;
TRACE(" %p %p %p(%ld)\n", pAbs, pRel, lpdwBufferLength,
TRACE(" %p %p %p(%d)\n", pAbs, pRel, lpdwBufferLength,
lpdwBufferLength ? *lpdwBufferLength: -1);
if (!lpdwBufferLength || !pAbs)
@ -1047,7 +1047,7 @@ NTSTATUS WINAPI RtlAbsoluteToSelfRelativeSD(
*/
NTSTATUS WINAPI RtlCreateAcl(PACL acl,DWORD size,DWORD rev)
{
TRACE("%p 0x%08lx 0x%08lx\n", acl, size, rev);
TRACE("%p 0x%08x 0x%08x\n", acl, size, rev);
if (rev!=ACL_REVISION)
return STATUS_INVALID_PARAMETER;
@ -1148,7 +1148,7 @@ NTSTATUS WINAPI RtlDeleteAce(PACL pAcl, DWORD dwAceIndex)
pAcl->AceCount--;
}
TRACE("pAcl=%p dwAceIndex=%ld status=0x%08lx\n", pAcl, dwAceIndex, status);
TRACE("pAcl=%p dwAceIndex=%d status=0x%08x\n", pAcl, dwAceIndex, status);
return status;
}
@ -1175,7 +1175,7 @@ NTSTATUS WINAPI RtlAddAccessAllowedAceEx(
IN DWORD AccessMask,
IN PSID pSid)
{
TRACE("(%p,0x%08lx,0x%08lx,%p)\n", pAcl, dwAceRevision, AccessMask, pSid);
TRACE("(%p,0x%08x,0x%08x,%p)\n", pAcl, dwAceRevision, AccessMask, pSid);
return add_access_ace(pAcl, dwAceRevision, AceFlags,
AccessMask, pSid, ACCESS_ALLOWED_ACE_TYPE);
@ -1203,7 +1203,7 @@ NTSTATUS WINAPI RtlAddAccessDeniedAceEx(
IN DWORD AccessMask,
IN PSID pSid)
{
TRACE("(%p,0x%08lx,0x%08lx,%p)\n", pAcl, dwAceRevision, AccessMask, pSid);
TRACE("(%p,0x%08x,0x%08x,%p)\n", pAcl, dwAceRevision, AccessMask, pSid);
return add_access_ace(pAcl, dwAceRevision, AceFlags,
AccessMask, pSid, ACCESS_DENIED_ACE_TYPE);
@ -1222,7 +1222,7 @@ NTSTATUS WINAPI RtlAddAuditAccessAce(
{
DWORD dwAceFlags = 0;
TRACE("(%p,%ld,%ld,%p,%u,%u)\n",pAcl,dwAceRevision,dwAccessMask,
TRACE("(%p,%d,%d,%p,%u,%u)\n",pAcl,dwAceRevision,dwAccessMask,
pSid,bAuditSuccess,bAuditFailure);
if (bAuditSuccess)
@ -1281,7 +1281,7 @@ NTSTATUS WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce )
{
PACE_HEADER ace;
TRACE("(%p,%ld,%p)\n",pAcl,dwAceIndex,pAce);
TRACE("(%p,%d,%p)\n",pAcl,dwAceIndex,pAce);
if ((dwAceIndex < 0) || (dwAceIndex > pAcl->AceCount))
return STATUS_INVALID_PARAMETER;
@ -1330,7 +1330,7 @@ RtlAdjustPrivilege(ULONG Privilege,
HANDLE TokenHandle;
NTSTATUS Status;
TRACE("(%ld, %s, %s, %p)\n", Privilege, Enable ? "TRUE" : "FALSE",
TRACE("(%d, %s, %s, %p)\n", Privilege, Enable ? "TRUE" : "FALSE",
CurrentThread ? "TRUE" : "FALSE", Enabled);
if (CurrentThread)
@ -1349,7 +1349,7 @@ RtlAdjustPrivilege(ULONG Privilege,
if (!NT_SUCCESS(Status))
{
WARN("Retrieving token handle failed (Status %lx)\n", Status);
WARN("Retrieving token handle failed (Status %x)\n", Status);
return Status;
}
@ -1374,7 +1374,7 @@ RtlAdjustPrivilege(ULONG Privilege,
}
if (!NT_SUCCESS(Status))
{
WARN("NtAdjustPrivilegesToken() failed (Status %lx)\n", Status);
WARN("NtAdjustPrivilegesToken() failed (Status %x)\n", Status);
return Status;
}
@ -1479,7 +1479,7 @@ NtAccessCheck(
{
NTSTATUS status;
TRACE("(%p, %p, %08lx, %p, %p, %p, %p, %p), stub\n",
TRACE("(%p, %p, %08x, %p, %p, %p, %p, %p), stub\n",
SecurityDescriptor, ClientToken, DesiredAccess, GenericMapping,
PrivilegeSet, ReturnLength, GrantedAccess, AccessStatus);
@ -1544,7 +1544,7 @@ NtSetSecurityObject(
IN SECURITY_INFORMATION SecurityInformation,
IN PSECURITY_DESCRIPTOR SecurityDescriptor)
{
FIXME("%p 0x%08lx %p\n", Handle, SecurityInformation, SecurityDescriptor);
FIXME("%p 0x%08x %p\n", Handle, SecurityInformation, SecurityDescriptor);
return STATUS_SUCCESS;
}
@ -1602,7 +1602,7 @@ NTSTATUS WINAPI RtlQueryInformationAcl(
{
NTSTATUS status = STATUS_SUCCESS;
TRACE("pAcl=%p pAclInfo=%p len=%ld, class=%d\n",
TRACE("pAcl=%p pAclInfo=%p len=%d, class=%d\n",
pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass);
switch (dwAclInformationClass)
@ -1643,7 +1643,7 @@ NTSTATUS WINAPI RtlQueryInformationAcl(
if (pAcl->AclSize < paclsize->AclBytesInUse)
{
WARN("Acl has %ld bytes free\n", paclsize->AclBytesFree);
WARN("Acl has %d bytes free\n", paclsize->AclBytesFree);
paclsize->AclBytesFree = 0;
paclsize->AclBytesInUse = pAcl->AclSize;
}

20
dlls/ntdll/serial.c
View file

@ -129,7 +129,7 @@ static const char* iocode2str(DWORD ioc)
X(IOCTL_SERIAL_WAIT_ON_MASK);
X(IOCTL_SERIAL_XOFF_COUNTER);
#undef X
default: { static char tmp[32]; sprintf(tmp, "IOCTL_SERIAL_%ld\n", ioc); return tmp; }
default: { static char tmp[32]; sprintf(tmp, "IOCTL_SERIAL_%d\n", ioc); return tmp; }
}
}
@ -483,7 +483,7 @@ static NTSTATUS set_baud_rate(int fd, const SERIAL_BAUD_RATE* sbr)
nuts.flags &= ~ASYNC_SPD_MASK;
nuts.flags |= ASYNC_SPD_CUST;
WARN("You (or a program acting at your behest) have specified\n"
"a non-standard baud rate %ld. Wine will set the rate to %d,\n"
"a non-standard baud rate %d. Wine will set the rate to %d,\n"
"which is as close as we can get by our present understanding of your\n"
"hardware. I hope you know what you are doing. Any disruption Wine\n"
"has caused to your linux system can be undone with setserial \n"
@ -494,7 +494,7 @@ static NTSTATUS set_baud_rate(int fd, const SERIAL_BAUD_RATE* sbr)
}
break;
#endif /* Don't have linux/serial.h or lack TIOCSSERIAL */
ERR("baudrate %ld\n", sbr->BaudRate);
ERR("baudrate %d\n", sbr->BaudRate);
return STATUS_NOT_SUPPORTED;
}
#elif !defined(__EMX__)
@ -540,7 +540,7 @@ static NTSTATUS set_baud_rate(int fd, const SERIAL_BAUD_RATE* sbr)
case 460800: port.c_cflag |= B460800;break;
#endif
default:
ERR("baudrate %ld\n", sbr->BaudRate);
ERR("baudrate %d\n", sbr->BaudRate);
return STATUS_NOT_SUPPORTED;
}
port.c_ispeed = port.c_ospeed;
@ -735,7 +735,7 @@ static NTSTATUS set_line_control(int fd, const SERIAL_LINE_CONTROL* slc)
static NTSTATUS set_queue_size(int fd, const SERIAL_QUEUE_SIZE* sqs)
{
FIXME("insize %ld outsize %ld unimplemented stub\n", sqs->InSize, sqs->OutSize);
FIXME("insize %d outsize %d unimplemented stub\n", sqs->InSize, sqs->OutSize);
return STATUS_SUCCESS;
}
@ -924,7 +924,7 @@ static DWORD WINAPI check_events(int fd, DWORD mask,
{
DWORD ret = 0, queue;
TRACE("mask 0x%08lx\n", mask);
TRACE("mask 0x%08x\n", mask);
TRACE("old->rx 0x%08x vs. new->rx 0x%08x\n", old->rx, new->rx);
TRACE("old->tx 0x%08x vs. new->tx 0x%08x\n", old->tx, new->tx);
TRACE("old->frame 0x%08x vs. new->frame 0x%08x\n", old->frame, new->frame);
@ -964,7 +964,7 @@ static DWORD WINAPI check_events(int fd, DWORD mask,
if (!queue)
#endif
ret |= EV_TXEMPTY;
TRACE("OUTQUEUE %ld, Transmitter %sempty\n",
TRACE("OUTQUEUE %d, Transmitter %sempty\n",
queue, (ret & EV_TXEMPTY) ? "" : "not ");
}
return ret & mask;
@ -992,7 +992,7 @@ static DWORD CALLBACK wait_for_event(LPVOID arg)
DWORD new_mstat, new_evtmask;
LARGE_INTEGER time;
TRACE("device=%p fd=0x%08x mask=0x%08lx buffer=%p event=%p irq_info=%p\n",
TRACE("device=%p fd=0x%08x mask=0x%08x buffer=%p event=%p irq_info=%p\n",
commio->hDevice, fd, commio->evtmask, commio->events, commio->hEvent, &commio->irq_info);
time.QuadPart = (ULONGLONG)10000;
@ -1128,7 +1128,7 @@ static inline NTSTATUS io_control(HANDLE hDevice,
NTSTATUS status = STATUS_SUCCESS;
int fd = -1;
TRACE("%p %s %p %ld %p %ld %p\n",
TRACE("%p %s %p %d %p %d %p\n",
hDevice, iocode2str(dwIoControlCode), lpInBuffer, nInBufferSize,
lpOutBuffer, nOutBufferSize, piosb);
@ -1336,7 +1336,7 @@ static inline NTSTATUS io_control(HANDLE hDevice,
status = STATUS_INVALID_PARAMETER;
break;
default:
FIXME("Unsupported IOCTL %lx (type=%lx access=%lx func=%lx meth=%lx)\n",
FIXME("Unsupported IOCTL %x (type=%x access=%x func=%x meth=%x)\n",
dwIoControlCode, dwIoControlCode >> 16, (dwIoControlCode >> 14) & 3,
(dwIoControlCode >> 2) & 0xFFF, dwIoControlCode & 3);
sz = 0;

4
dlls/ntdll/server.c
View file

@ -196,7 +196,7 @@ void server_protocol_error( const char *err, ... )
va_list args;
va_start( args, err );
fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
fprintf( stderr, "wine client error:%x: ", GetCurrentThreadId() );
vfprintf( stderr, err, args );
va_end( args );
server_abort_thread(1);
@ -208,7 +208,7 @@ void server_protocol_error( const char *err, ... )
*/
void server_protocol_perror( const char *err )
{
fprintf( stderr, "wine client error:%lx: ", GetCurrentThreadId() );
fprintf( stderr, "wine client error:%x: ", GetCurrentThreadId() );
perror( err );
server_abort_thread(1);
}

10
dlls/ntdll/signal_i386.c
View file

@ -739,7 +739,7 @@ void set_cpu_context( const CONTEXT *context )
if (flags & CONTEXT_FULL)
{
if ((flags & CONTEXT_FULL) != (CONTEXT_FULL & ~CONTEXT_i386))
FIXME( "setting partial context (%lx) not supported\n", flags );
FIXME( "setting partial context (%x) not supported\n", flags );
else
__wine_call_from_32_restore_regs( context );
}
@ -837,7 +837,7 @@ static BOOL check_atl_thunk( EXCEPTION_RECORD *rec, CONTEXT *context )
{
*((DWORD *)context->Esp + 1) = thunk->this;
context->Eip = (DWORD_PTR)(&thunk->func + 1) + thunk->func;
TRACE( "emulating ATL thunk at %p, func=%08lx arg=%08lx\n",
TRACE( "emulating ATL thunk at %p, func=%08x arg=%08x\n",
thunk, context->Eip, *((DWORD *)context->Esp + 1) );
ret = TRUE;
}
@ -880,7 +880,7 @@ static EXCEPTION_RECORD *setup_exception( SIGCONTEXT *sigcontext, raise_func fun
if ((char *)stack >= (char *)get_signal_stack() &&
(char *)stack < (char *)get_signal_stack() + signal_stack_size)
{
ERR( "nested exception on signal stack in thread %04lx eip %08x esp %08x stack %p-%p\n",
ERR( "nested exception on signal stack in thread %04x eip %08x esp %08x stack %p-%p\n",
GetCurrentThreadId(), (unsigned int) EIP_sig(sigcontext),
(unsigned int) ESP_sig(sigcontext), NtCurrentTeb()->Tib.StackLimit,
NtCurrentTeb()->Tib.StackBase );
@ -894,13 +894,13 @@ static EXCEPTION_RECORD *setup_exception( SIGCONTEXT *sigcontext, raise_func fun
UINT diff = (char *)NtCurrentTeb()->Tib.StackLimit - (char *)stack;
if (diff < 4096)
{
ERR( "stack overflow %u bytes in thread %04lx eip %08x esp %08x stack %p-%p\n",
ERR( "stack overflow %u bytes in thread %04x eip %08x esp %08x stack %p-%p\n",
diff, GetCurrentThreadId(), (unsigned int) EIP_sig(sigcontext),
(unsigned int) ESP_sig(sigcontext), NtCurrentTeb()->Tib.StackLimit,
NtCurrentTeb()->Tib.StackBase );
server_abort_thread(1);
}
else WARN( "exception outside of stack limits in thread %04lx eip %08x esp %08x stack %p-%p\n",
else WARN( "exception outside of stack limits in thread %04x eip %08x esp %08x stack %p-%p\n",
GetCurrentThreadId(), (unsigned int) EIP_sig(sigcontext),
(unsigned int) ESP_sig(sigcontext), NtCurrentTeb()->Tib.StackLimit,
NtCurrentTeb()->Tib.StackBase );

16
dlls/ntdll/sync.c
View file

@ -131,7 +131,7 @@ NTSTATUS WINAPI NtQuerySemaphore(
ULONG Length,
PULONG ReturnLength)
{
FIXME("(%p,%d,%p,0x%08lx,%p) stub!\n",
FIXME("(%p,%d,%p,0x%08x,%p) stub!\n",
SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
return STATUS_SUCCESS;
}
@ -280,7 +280,7 @@ NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
NTSTATUS ret;
if (PulseCount)
FIXME("(%p,%ld)\n", handle, *PulseCount);
FIXME("(%p,%d)\n", handle, *PulseCount);
SERVER_START_REQ( event_op )
{
@ -392,7 +392,7 @@ NTSTATUS WINAPI NtQueryMutant(IN HANDLE handle,
IN ULONG MutantInformationLength,
OUT PULONG ResultLength OPTIONAL )
{
FIXME("(%p %u %p %lu %p): stub!\n",
FIXME("(%p %u %p %u %p): stub!\n",
handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
return STATUS_NOT_IMPLEMENTED;
}
@ -473,7 +473,7 @@ NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
{
NTSTATUS status = STATUS_SUCCESS;
TRACE("(%p,%p,%p,%p,%08x,0x%08lx,%p) stub\n",
TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
handle, when, callback, callback_arg, resume, period, state);
SERVER_START_REQ( set_timer )
@ -549,7 +549,7 @@ NTSTATUS WINAPI NtQueryTimer(
NTSTATUS status;
LARGE_INTEGER now;
TRACE("(%p,%d,%p,0x%08lx,%p)\n", TimerHandle, TimerInformationClass,
TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle, TimerInformationClass,
TimerInformation, Length, ReturnLength);
switch (TimerInformationClass)
@ -606,7 +606,7 @@ NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
IN BOOLEAN set_resolution,
OUT ULONG* current_resolution )
{
FIXME("(%lu,%u,%p), stub!\n",
FIXME("(%u,%u,%p), stub!\n",
resolution, set_resolution, current_resolution);
return STATUS_NOT_IMPLEMENTED;
@ -849,7 +849,7 @@ NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeou
NTSTATUS WINAPI NtCreateIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes, ULONG NumberOfConcurrentThreads )
{
FIXME("(%p, %lx, %p, %ld)\n", CompletionPort, DesiredAccess,
FIXME("(%p, %x, %p, %d)\n", CompletionPort, DesiredAccess,
ObjectAttributes, NumberOfConcurrentThreads);
return STATUS_NOT_IMPLEMENTED;
}
@ -858,7 +858,7 @@ NTSTATUS WINAPI NtSetIoCompletion( HANDLE CompletionPort, ULONG_PTR CompletionKe
PIO_STATUS_BLOCK iosb, ULONG NumberOfBytesTransferred,
ULONG NumberOfBytesToTransfer )
{
FIXME("(%p, %lx, %p, %ld, %ld)\n", CompletionPort, CompletionKey,
FIXME("(%p, %lx, %p, %d, %d)\n", CompletionPort, CompletionKey,
iosb, NumberOfBytesTransferred, NumberOfBytesToTransfer);
return STATUS_NOT_IMPLEMENTED;
}

34
dlls/ntdll/tape.c
View file

@ -76,7 +76,7 @@ static const char *io2str( DWORD io )
X(IOCTL_TAPE_SET_POSITION);
X(IOCTL_TAPE_WRITE_MARKS);
#undef X
default: { static char tmp[32]; sprintf(tmp, "IOCTL_TAPE_%ld\n", io); return tmp; }
default: { static char tmp[32]; sprintf(tmp, "IOCTL_TAPE_%d\n", io); return tmp; }
}
}
@ -97,7 +97,7 @@ static NTSTATUS TAPE_CreatePartition( int fd, TAPE_CREATE_PARTITION *data )
#ifdef HAVE_SYS_MTIO_H
struct mtop cmd;
TRACE( "fd: %d method: 0x%08lx count: 0x%08lx size: 0x%08lx\n",
TRACE( "fd: %d method: 0x%08x count: 0x%08x size: 0x%08x\n",
fd, data->Method, data->Count, data->Size );
if (data->Count > 1)
@ -120,7 +120,7 @@ static NTSTATUS TAPE_CreatePartition( int fd, TAPE_CREATE_PARTITION *data )
break;
#endif
default:
ERR( "Unhandled method: 0x%08lx\n", data->Method );
ERR( "Unhandled method: 0x%08x\n", data->Method );
return STATUS_INVALID_PARAMETER;
}
@ -139,7 +139,7 @@ static NTSTATUS TAPE_Erase( int fd, TAPE_ERASE *data )
#ifdef HAVE_SYS_MTIO_H
struct mtop cmd;
TRACE( "fd: %d type: 0x%08lx immediate: 0x%02x\n",
TRACE( "fd: %d type: 0x%08x immediate: 0x%02x\n",
fd, data->Type, data->Immediate );
switch (data->Type)
@ -153,7 +153,7 @@ static NTSTATUS TAPE_Erase( int fd, TAPE_ERASE *data )
cmd.mt_count = 0;
break;
default:
ERR( "Unhandled type: 0x%08lx\n", data->Type );
ERR( "Unhandled type: 0x%08x\n", data->Type );
return STATUS_INVALID_PARAMETER;
}
@ -251,7 +251,7 @@ static NTSTATUS TAPE_GetPosition( int fd, ULONG type, TAPE_GET_POSITION *data )
#endif
NTSTATUS status;
TRACE( "fd: %d type: 0x%08lx\n", fd, type );
TRACE( "fd: %d type: 0x%08x\n", fd, type );
memset( data, 0, sizeof(TAPE_GET_POSITION) );
@ -281,7 +281,7 @@ static NTSTATUS TAPE_GetPosition( int fd, ULONG type, TAPE_GET_POSITION *data )
WARN( "Positioning type not supported\n" );
break;
default:
ERR( "Unhandled type: 0x%08lx\n", type );
ERR( "Unhandled type: 0x%08x\n", type );
return STATUS_INVALID_PARAMETER;
}
@ -300,7 +300,7 @@ static NTSTATUS TAPE_Prepare( int fd, TAPE_PREPARE *data )
#ifdef HAVE_SYS_MTIO_H
struct mtop cmd;
TRACE( "fd: %d type: 0x%08lx immediate: 0x%02x\n",
TRACE( "fd: %d type: 0x%08x immediate: 0x%02x\n",
fd, data->Operation, data->Immediate );
switch (data->Operation)
@ -334,7 +334,7 @@ static NTSTATUS TAPE_Prepare( int fd, TAPE_PREPARE *data )
/* Native ignores this if the drive doesn't support it */
return STATUS_SUCCESS;
default:
ERR( "Unhandled operation: 0x%08lx\n", data->Operation );
ERR( "Unhandled operation: 0x%08x\n", data->Operation );
return STATUS_INVALID_PARAMETER;
}
@ -355,7 +355,7 @@ static NTSTATUS TAPE_SetDriveParams( int fd, TAPE_SET_DRIVE_PARAMETERS *data )
TRACE( "fd: %d ECC: 0x%02x, compression: 0x%02x padding: 0x%02x\n",
fd, data->ECC, data->Compression, data->DataPadding );
TRACE( "setmarks: 0x%02x zonesize: 0x%08lx\n",
TRACE( "setmarks: 0x%02x zonesize: 0x%08x\n",
data->ReportSetmarks, data->EOTWarningZoneSize );
if (data->ECC || data->DataPadding || data->ReportSetmarks ||
@ -379,7 +379,7 @@ static NTSTATUS TAPE_SetMediaParams( int fd, TAPE_SET_MEDIA_PARAMETERS *data )
#ifdef HAVE_SYS_MTIO_H
struct mtop cmd;
TRACE( "fd: %d blocksize: 0x%08lx\n", fd, data->BlockSize );
TRACE( "fd: %d blocksize: 0x%08x\n", fd, data->BlockSize );
cmd.mt_op = MTSETBLK;
cmd.mt_count = data->BlockSize;
@ -399,7 +399,7 @@ static NTSTATUS TAPE_SetPosition( int fd, TAPE_SET_POSITION *data )
#ifdef HAVE_SYS_MTIO_H
struct mtop cmd;
TRACE( "fd: %d method: 0x%08lx partition: 0x%08lx offset: 0x%08lx immediate: 0x%02x\n",
TRACE( "fd: %d method: 0x%08x partition: 0x%08x offset: 0x%08x immediate: 0x%02x\n",
fd, data->Method, data->Partition, data->Offset.u.LowPart, data->Immediate );
if (data->Offset.u.HighPart > 0)
@ -451,7 +451,7 @@ static NTSTATUS TAPE_SetPosition( int fd, TAPE_SET_POSITION *data )
WARN( "Positioning method not supported\n" );
return STATUS_INVALID_PARAMETER;
default:
ERR( "Unhandled method: 0x%08lx\n", data->Method );
ERR( "Unhandled method: 0x%08x\n", data->Method );
return STATUS_INVALID_PARAMETER;
}
@ -470,7 +470,7 @@ static NTSTATUS TAPE_WriteMarks( int fd, TAPE_WRITE_MARKS *data )
#ifdef HAVE_SYS_MTIO_H
struct mtop cmd;
TRACE( "fd: %d type: 0x%08lx count: 0x%08lx immediate: 0x%02x\n",
TRACE( "fd: %d type: 0x%08x count: 0x%08x immediate: 0x%02x\n",
fd, data->Type, data->Count, data->Immediate );
switch (data->Type)
@ -488,7 +488,7 @@ static NTSTATUS TAPE_WriteMarks( int fd, TAPE_WRITE_MARKS *data )
cmd.mt_count = data->Count;
break;
default:
ERR( "Unhandled type: 0x%08lx\n", data->Type );
ERR( "Unhandled type: 0x%08x\n", data->Type );
return STATUS_INVALID_PARAMETER;
}
@ -514,7 +514,7 @@ NTSTATUS TAPE_DeviceIoControl( HANDLE device, HANDLE event,
NTSTATUS status = STATUS_INVALID_PARAMETER;
int fd;
TRACE( "%p %s %p %ld %p %ld %p\n", device, io2str(io_control),
TRACE( "%p %s %p %d %p %d %p\n", device, io2str(io_control),
in_buffer, in_size, out_buffer, out_size, io_status );
io_status->Information = 0;
@ -563,7 +563,7 @@ NTSTATUS TAPE_DeviceIoControl( HANDLE device, HANDLE event,
case IOCTL_TAPE_FIND_NEW_DEVICES:
break;
default:
FIXME( "Unsupported IOCTL %lx (type=%lx access=%lx func=%lx meth=%lx)\n",
FIXME( "Unsupported IOCTL %x (type=%x access=%x func=%x meth=%x)\n",
io_control, io_control >> 16, (io_control >> 14) & 3,
(io_control >> 2) & 0xfff, io_control & 3 );
break;

2
dlls/ntdll/threadpool.c
View file

@ -182,7 +182,7 @@ NTSTATUS WINAPI RtlQueueWorkItem(PRTL_WORK_ITEM_ROUTINE Function, PVOID Context,
work_item->context = Context;
if (Flags != WT_EXECUTEDEFAULT)
FIXME("Flags 0x%lx not supported\n", Flags);
FIXME("Flags 0x%x not supported\n", Flags);
status = add_work_item_to_queue(work_item);

4
dlls/ntdll/version.c
View file

@ -497,7 +497,7 @@ done:
NtCurrentTeb()->Peb->OSBuildNumber = current_version->dwBuildNumber;
NtCurrentTeb()->Peb->OSPlatformId = current_version->dwPlatformId;
TRACE( "got %ld.%ld plaform %ld build %lx name %s service pack %d.%d product %d\n",
TRACE( "got %d.%d plaform %d build %x name %s service pack %d.%d product %d\n",
current_version->dwMajorVersion, current_version->dwMinorVersion,
current_version->dwPlatformId, current_version->dwBuildNumber,
debugstr_w(current_version->szCSDVersion),
@ -595,7 +595,7 @@ NTSTATUS WINAPI RtlVerifyVersionInfo( const RTL_OSVERSIONINFOEXW *info,
RTL_OSVERSIONINFOEXW ver;
NTSTATUS status;
TRACE("(%p,0x%lx,0x%s)\n", info, dwTypeMask, wine_dbgstr_longlong(dwlConditionMask));
TRACE("(%p,0x%x,0x%s)\n", info, dwTypeMask, wine_dbgstr_longlong(dwlConditionMask));
ver.dwOSVersionInfoSize = sizeof(ver);
if ((status = RtlGetVersion( &ver )) != STATUS_SUCCESS) return status;

28
dlls/ntdll/virtual.c
View file

@ -866,7 +866,7 @@ static int do_relocations( char *base, const IMAGE_DATA_DIRECTORY *dir,
/* sanity checks */
if ((char *)rel + rel->SizeOfBlock > base + dir->VirtualAddress + dir->Size)
{
ERR_(module)("invalid relocation %p,%lx,%ld at %p,%lx,%lx\n",
ERR_(module)("invalid relocation %p,%x,%d at %p,%x,%x\n",
rel, rel->VirtualAddress, rel->SizeOfBlock,
base, dir->VirtualAddress, dir->Size );
return 0;
@ -879,7 +879,7 @@ static int do_relocations( char *base, const IMAGE_DATA_DIRECTORY *dir,
continue;
}
TRACE_(module)("%d relocations for page %lx\n", count, rel->VirtualAddress);
TRACE_(module)("%d relocations for page %x\n", count, rel->VirtualAddress);
/* patching in reverse order */
for (i = 0 ; i < count; i++)
@ -1048,7 +1048,7 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, SIZE_T total_siz
end = sec->VirtualAddress + ROUND_SIZE( sec->VirtualAddress, map_size );
if (sec->VirtualAddress > total_size || end > total_size || end < sec->VirtualAddress)
{
ERR_(module)( "Section %.8s too large (%lx+%lx/%lx)\n",
ERR_(module)( "Section %.8s too large (%x+%lx/%lx)\n",
sec->Name, sec->VirtualAddress, map_size, total_size );
goto error;
}
@ -1056,7 +1056,7 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, SIZE_T total_siz
if ((sec->Characteristics & IMAGE_SCN_MEM_SHARED) &&
(sec->Characteristics & IMAGE_SCN_MEM_WRITE))
{
TRACE_(module)( "mapping shared section %.8s at %p off %lx (%x) size %lx (%lx) flags %lx\n",
TRACE_(module)( "mapping shared section %.8s at %p off %x (%x) size %lx (%lx) flags %x\n",
sec->Name, ptr + sec->VirtualAddress,
sec->PointerToRawData, (int)pos, file_size, map_size,
sec->Characteristics );
@ -1085,7 +1085,7 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, SIZE_T total_siz
continue;
}
TRACE_(module)( "mapping section %.8s at %p off %lx size %lx virt %lx flags %lx\n",
TRACE_(module)( "mapping section %.8s at %p off %x size %x virt %x flags %x\n",
sec->Name, ptr + sec->VirtualAddress,
sec->PointerToRawData, sec->SizeOfRawData,
sec->Misc.VirtualSize, sec->Characteristics );
@ -1126,7 +1126,7 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, SIZE_T total_siz
relocs = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
if (nt->FileHeader.Characteristics & IMAGE_FILE_RELOCS_STRIPPED)
{
WARN( "Need to relocate module from addr %lx, but there are no relocation records\n",
WARN( "Need to relocate module from addr %x, but there are no relocation records\n",
nt->OptionalHeader.ImageBase );
status = STATUS_CONFLICTING_ADDRESSES;
goto error;
@ -1311,7 +1311,7 @@ NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, ULONG zero_
NTSTATUS status = STATUS_SUCCESS;
struct file_view *view;
TRACE("%p %p %08lx %lx %08lx\n", process, *ret, size, type, protect );
TRACE("%p %p %08lx %x %08x\n", process, *ret, size, type, protect );
if (!size) return STATUS_INVALID_PARAMETER;
@ -1352,7 +1352,7 @@ NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, ULONG zero_
if (!(type & (MEM_COMMIT | MEM_RESERVE)) ||
(type & ~(MEM_COMMIT | MEM_RESERVE | MEM_TOP_DOWN | MEM_WRITE_WATCH | MEM_RESET)))
{
WARN("called with wrong alloc type flags (%08lx) !\n", type);
WARN("called with wrong alloc type flags (%08x) !\n", type);
return STATUS_INVALID_PARAMETER;
}
if (type & MEM_WRITE_WATCH)
@ -1417,7 +1417,7 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *si
LPVOID addr = *addr_ptr;
SIZE_T size = *size_ptr;
TRACE("%p %p %08lx %lx\n", process, addr, size, type );
TRACE("%p %p %08lx %x\n", process, addr, size, type );
if (!is_current_process( process ))
{
@ -1470,7 +1470,7 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *si
}
else
{
WARN("called with wrong free type flags (%08lx) !\n", type);
WARN("called with wrong free type flags (%08x) !\n", type);
status = STATUS_INVALID_PARAMETER;
}
@ -1495,7 +1495,7 @@ NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T
SIZE_T size = *size_ptr;
LPVOID addr = *addr_ptr;
TRACE("%p %p %08lx %08lx\n", process, addr, size, new_prot );
TRACE("%p %p %08lx %08x\n", process, addr, size, new_prot );
if (!is_current_process( process ))
{
@ -1782,7 +1782,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
offset.QuadPart = offset_ptr ? offset_ptr->QuadPart : 0;
TRACE("handle=%p process=%p addr=%p off=%lx%08lx size=%lx access=%lx\n",
TRACE("handle=%p process=%p addr=%p off=%x%08x size=%lx access=%x\n",
handle, process, *addr_ptr, offset.u.HighPart, offset.u.LowPart, size, protect );
if (!is_current_process( process ))
@ -1897,7 +1897,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
/* Map the file */
TRACE("handle=%p size=%lx offset=%lx%08lx\n",
TRACE("handle=%p size=%lx offset=%x%08x\n",
handle, size, offset.u.HighPart, offset.u.LowPart );
res = map_file_into_view( view, unix_handle, 0, size, offset.QuadPart, prot, removable );
@ -1913,7 +1913,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
}
else
{
ERR( "map_file_into_view %p %lx %lx%08lx failed\n",
ERR( "map_file_into_view %p %lx %x%08x failed\n",
view->base, size, offset.u.HighPart, offset.u.LowPart );
delete_view( view );
}