marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Converted to the new debug interface, using script written by Patrik 

Stridvall.
oldstable
Alexandre Julliard 1999-05-23 10:25:25 +00:00
parent 158f00ed8d
commit 156570906f
42 changed files with 572 additions and 575 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
dlls/ntdll/file.c
View File

@ -1,6 +1,6 @@
#include <stdlib.h>
#include <string.h>
#include "debug.h"
#include "debugtools.h"
#include "ntddk.h"
@ -25,7 +25,7 @@ NTSTATUS WINAPI NtOpenFile(
ULONG ShareAccess,
ULONG OpenOptions)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s),%p,0x%08lx,0x%08lx) stub\n",
FIXME("(%p,0x%08lx,%p(%s),%p,0x%08lx,0x%08lx) stub\n",
FileHandle, DesiredAccess, ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL,
IoStatusBlock, ShareAccess, OpenOptions);
@ -64,7 +64,7 @@ NTSTATUS WINAPI NtCreateFile(
PVOID EaBuffer,
ULONG EaLength)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s),%p,%p,0x%08lx,0x%08lx,0x%08lx,0x%08lx,%p,0x%08lx) stub\n",
FIXME("(%p,0x%08lx,%p(%s),%p,%p,0x%08lx,0x%08lx,0x%08lx,0x%08lx,%p,0x%08lx) stub\n",
FileHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL,
IoStatusBlock,AllocateSize,FileAttributes,
@ -98,7 +98,7 @@ NTSTATUS WINAPI NtReadFile (
PLARGE_INTEGER ByteOffset,
PULONG Key)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,%p,%p,%p,0x%08lx,%p,%p),stub!\n",
FIXME("(0x%08x,0x%08x,%p,%p,%p,%p,0x%08lx,%p,%p),stub!\n",
FileHandle,EventHandle,ApcRoutine,ApcContext,IoStatusBlock,Buffer,Length,ByteOffset,Key);
return 0;
}
@ -118,7 +118,7 @@ NTSTATUS WINAPI NtDeviceIoControlFile(
OUT PVOID OutputBuffer,
IN ULONG OutputBufferSize)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx): empty stub\n",
FIXME("(0x%08x,0x%08x,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx): empty stub\n",
DeviceHandle, Event, UserApcRoutine, UserApcContext,
IoStatusBlock, IoControlCode, InputBuffer, InputBufferSize, OutputBuffer, OutputBufferSize);
return 0;
@ -139,7 +139,7 @@ NTSTATUS WINAPI NtFsControlFile(
OUT PVOID OutputBuffer,
IN ULONG OutputBufferSize)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx): stub\n",
FIXME("(0x%08x,0x%08x,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx): stub\n",
DeviceHandle,Event,ApcRoutine,ApcContext,IoStatusBlock,IoControlCode,
InputBuffer,InputBufferSize,OutputBuffer,OutputBufferSize);
return 0;
@ -154,7 +154,7 @@ NTSTATUS WINAPI NtSetVolumeInformationFile(
PVOID VolumeInformation,
ULONG Length)
{
FIXME(ntdll,"(0x%08x,%p,%p,0x%08lx) stub\n",
FIXME("(0x%08x,%p,%p,0x%08lx) stub\n",
FileHandle,VolumeInformationClass,VolumeInformation,Length);
return 0;
}
@ -169,7 +169,7 @@ NTSTATUS WINAPI NtQueryInformationFile(
ULONG Length,
FILE_INFORMATION_CLASS FileInformationClass)
{
FIXME(ntdll,"(0x%08x,%p,%p,0x%08lx,0x%08x),stub!\n",
FIXME("(0x%08x,%p,%p,0x%08lx,0x%08x),stub!\n",
FileHandle,IoStatusBlock,FileInformation,Length,FileInformationClass);
return 0;
}
@ -184,7 +184,7 @@ NTSTATUS WINAPI NtSetInformationFile(
ULONG Length,
FILE_INFORMATION_CLASS FileInformationClass)
{
FIXME(ntdll,"(0x%08x,%p,%p,0x%08lx,0x%08x)\n",
FIXME("(0x%08x,%p,%p,0x%08lx,0x%08x)\n",
FileHandle,IoStatusBlock,FileInformation,Length,FileInformationClass);
return 0;
}
@ -206,7 +206,7 @@ NTSTATUS WINAPI NtQueryDirectoryFile(
IN PUNICODE_STRING FileName OPTIONAL,
IN BOOLEAN RestartScan)
{
FIXME (ntdll,"(0x%08x 0x%08x %p %p %p %p 0x%08lx 0x%08x 0x%08x %p 0x%08x\n",
FIXME("(0x%08x 0x%08x %p %p %p %p 0x%08lx 0x%08x 0x%08x %p 0x%08x\n",
FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, FileInformation,
Length, FileInformationClass, ReturnSingleEntry,
debugstr_w(FileName->Buffer),RestartScan);

66
dlls/ntdll/nt.c
View File

@ -11,7 +11,7 @@
#include <string.h>
#include <time.h>
#include "debugstr.h"
#include "debug.h"
#include "debugtools.h"
#include "ntddk.h"
@ -33,7 +33,7 @@ NTSTATUS WINAPI NtCreateTimer(
IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
IN TIMER_TYPE TimerType)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s),0x%08x) stub\n",
FIXME("(%p,0x%08lx,%p(%s),0x%08x) stub\n",
TimerHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL,
TimerType);
@ -51,7 +51,7 @@ NTSTATUS WINAPI NtSetTimer(
IN ULONG Period OPTIONAL,
OUT PBOOLEAN PreviousState OPTIONAL)
{
FIXME(ntdll,"(0x%08x,%p,%p,%p,%08x,0x%08lx,%p) stub\n",
FIXME("(0x%08x,%p,%p,%p,%08x,0x%08lx,%p) stub\n",
TimerHandle,DueTime,TimerApcRoutine,TimerContext,WakeTimer,Period,PreviousState);
return 0;
}
@ -61,7 +61,7 @@ NTSTATUS WINAPI NtSetTimer(
*/
NTSTATUS WINAPI NtQueryTimerResolution(DWORD x1,DWORD x2,DWORD x3)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx), stub!\n",x1,x2,x3);
FIXME("(0x%08lx,0x%08lx,0x%08lx), stub!\n",x1,x2,x3);
return 1;
}
@ -79,7 +79,7 @@ NTSTATUS WINAPI NtTerminateProcess(
HANDLE ProcessHandle,
LONG ExitStatus)
{
TRACE(ntdll, "0x%08x 0x%08lx\n", ProcessHandle, ExitStatus );
TRACE("0x%08x 0x%08lx\n", ProcessHandle, ExitStatus );
/* win32 (0x7fffffff) to nt (-1) */
if ( NtCurrentProcess() == ProcessHandle )
@ -99,7 +99,7 @@ NTSTATUS WINAPI NtQueryInformationProcess(
IN ULONG ProcessInformationLength,
OUT PULONG ReturnLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx,%p),stub!\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx,%p),stub!\n",
ProcessHandle,ProcessInformationClass,ProcessInformation,ProcessInformationLength,ReturnLength);
return 0;
}
@ -113,7 +113,7 @@ NTSTATUS WINAPI NtSetInformationProcess(
IN PVOID ProcessInformation,
IN ULONG ProcessInformationLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx) stub\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx) stub\n",
ProcessHandle,ProcessInformationClass,ProcessInformation,ProcessInformationLength);
return 0;
}
@ -129,7 +129,7 @@ NTSTATUS WINAPI NtResumeThread(
IN HANDLE ThreadHandle,
IN PULONG SuspendCount)
{
FIXME(ntdll,"(0x%08x,%p),stub!\n",
FIXME("(0x%08x,%p),stub!\n",
ThreadHandle,SuspendCount);
return 0;
}
@ -158,7 +158,7 @@ NTSTATUS WINAPI NtQueryInformationThread(
IN ULONG ThreadInformationLength,
OUT PULONG ReturnLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx,%p),stub!\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx,%p),stub!\n",
ThreadHandle, ThreadInformationClass, ThreadInformation,
ThreadInformationLength, ReturnLength);
return 0;
@ -173,7 +173,7 @@ NTSTATUS WINAPI NtSetInformationThread(
PVOID ThreadInformation,
ULONG ThreadInformationLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx),stub!\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx),stub!\n",
ThreadHandle, ThreadInformationClass, ThreadInformation, ThreadInformationLength);
return 0;
}
@ -193,7 +193,7 @@ NTSTATUS WINAPI NtDuplicateToken(
IN TOKEN_TYPE TokenType,
OUT PHANDLE NewToken)
{
FIXME(ntdll,"(0x%08x,0x%08lx,%p,0x%08x,0x%08x,%p),stub!\n",
FIXME("(0x%08x,0x%08lx,%p,0x%08x,0x%08x,%p),stub!\n",
ExistingToken, DesiredAccess, ObjectAttributes, ImpersonationLevel,
TokenType, NewToken);
return 0;
@ -207,7 +207,7 @@ NTSTATUS WINAPI NtOpenProcessToken(
DWORD DesiredAccess,
HANDLE *TokenHandle)
{
FIXME(ntdll,"(0x%08x,0x%08lx,%p): stub\n",
FIXME("(0x%08x,0x%08lx,%p): stub\n",
ProcessHandle,DesiredAccess, TokenHandle);
*TokenHandle = 0xcafe;
return 0;
@ -222,7 +222,7 @@ NTSTATUS WINAPI NtOpenThreadToken(
BOOLEAN OpenAsSelf,
HANDLE *TokenHandle)
{
FIXME(ntdll,"(0x%08x,0x%08lx,0x%08x,%p): stub\n",
FIXME("(0x%08x,0x%08lx,0x%08x,%p): stub\n",
ThreadHandle,DesiredAccess, OpenAsSelf, TokenHandle);
*TokenHandle = 0xcafe;
return 0;
@ -241,7 +241,7 @@ NTSTATUS WINAPI NtAdjustPrivilegesToken(
OUT PTOKEN_PRIVILEGES PreviousState,
OUT PDWORD ReturnLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx,%p,%p),stub!\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx,%p,%p),stub!\n",
TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength);
return 0;
}
@ -257,7 +257,7 @@ NTSTATUS WINAPI NtQueryInformationToken(
DWORD tokeninfolength,
LPDWORD retlen )
{
FIXME(ntdll,"(%08x,%ld,%p,%ld,%p): stub\n",
FIXME("(%08x,%ld,%p,%ld,%p): stub\n",
token,tokeninfoclass,tokeninfo,tokeninfolength,retlen);
switch (tokeninfoclass)
@ -295,7 +295,7 @@ NTSTATUS WINAPI NtCreateSection(
IN ULONG AllocationAttributes,
IN HANDLE FileHandle OPTIONAL)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s),%p,0x%08lx,0x%08lx,0x%08x) stub\n",
FIXME("(%p,0x%08lx,%p(%s),%p,0x%08lx,0x%08lx,0x%08x) stub\n",
SectionHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL,
MaximumSize,SectionPageProtection,AllocationAttributes,FileHandle);
@ -310,7 +310,7 @@ NTSTATUS WINAPI NtOpenSection(
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s)),stub!\n",
FIXME("(%p,0x%08lx,%p(%s)),stub!\n",
SectionHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL);
return 0;
@ -326,7 +326,7 @@ NTSTATUS WINAPI NtQuerySection(
IN ULONG Length,
OUT PULONG ResultLength)
{
FIXME(ntdll,"(0x%08x,%p,%p,0x%08lx,%p) stub!\n",
FIXME("(0x%08x,%p,%p,0x%08lx,%p) stub!\n",
SectionHandle,SectionInformationClass,SectionInformation,Length,ResultLength);
return 0;
}
@ -362,7 +362,7 @@ NTSTATUS WINAPI NtMapViewOfSection(
ULONG AllocationType,
ULONG Protect)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx,0x%08lx,%p,%p,0x%08x,0x%08lx,0x%08lx) stub\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx,0x%08lx,%p,%p,0x%08x,0x%08lx,0x%08lx) stub\n",
SectionHandle,ProcessHandle,BaseAddress,ZeroBits,CommitSize,SectionOffset,
ViewSize,InheritDisposition,AllocationType,Protect);
return 0;
@ -377,7 +377,7 @@ NTSTATUS WINAPI NtMapViewOfSection(
*/
NTSTATUS WINAPI NtCreatePort(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5);
return 0;
}
@ -386,7 +386,7 @@ NTSTATUS WINAPI NtCreatePort(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5)
*/
NTSTATUS WINAPI NtConnectPort(DWORD x1,PUNICODE_STRING uni,DWORD x3,DWORD x4,DWORD x5,DWORD x6,DWORD x7,DWORD x8)
{
FIXME(ntdll,"(0x%08lx,%s,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",
FIXME("(0x%08lx,%s,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",
x1,debugstr_w(uni->Buffer),x3,x4,x5,x6,x7,x8);
return 0;
}
@ -396,7 +396,7 @@ NTSTATUS WINAPI NtConnectPort(DWORD x1,PUNICODE_STRING uni,DWORD x3,DWORD x4,DWO
*/
NTSTATUS WINAPI NtListenPort(DWORD x1,DWORD x2)
{
FIXME(ntdll,"(0x%08lx,0x%08lx),stub!\n",x1,x2);
FIXME("(0x%08lx,0x%08lx),stub!\n",x1,x2);
return 0;
}
@ -405,7 +405,7 @@ NTSTATUS WINAPI NtListenPort(DWORD x1,DWORD x2)
*/
NTSTATUS WINAPI NtAcceptConnectPort(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5,x6);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5,x6);
return 0;
}
@ -414,7 +414,7 @@ NTSTATUS WINAPI NtAcceptConnectPort(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5
*/
NTSTATUS WINAPI NtCompleteConnectPort(DWORD x1)
{
FIXME(ntdll,"(0x%08lx),stub!\n",x1);
FIXME("(0x%08lx),stub!\n",x1);
return 0;
}
@ -423,7 +423,7 @@ NTSTATUS WINAPI NtCompleteConnectPort(DWORD x1)
*/
NTSTATUS WINAPI NtRegisterThreadTerminatePort(DWORD x1)
{
FIXME(ntdll,"(0x%08lx),stub!\n",x1);
FIXME("(0x%08lx),stub!\n",x1);
return 0;
}
@ -432,7 +432,7 @@ NTSTATUS WINAPI NtRegisterThreadTerminatePort(DWORD x1)
*/
NTSTATUS WINAPI NtRequestWaitReplyPort(DWORD x1,DWORD x2,DWORD x3)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3);
FIXME("(0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3);
return 0;
}
@ -441,7 +441,7 @@ NTSTATUS WINAPI NtRequestWaitReplyPort(DWORD x1,DWORD x2,DWORD x3)
*/
NTSTATUS WINAPI NtReplyWaitReceivePort(DWORD x1,DWORD x2,DWORD x3,DWORD x4)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
return 0;
}
@ -453,7 +453,7 @@ NTSTATUS WINAPI NtReplyWaitReceivePort(DWORD x1,DWORD x2,DWORD x3,DWORD x4)
* NtSetIntervalProfile [NTDLL]
*/
NTSTATUS WINAPI NtSetIntervalProfile(DWORD x1,DWORD x2) {
FIXME(ntdll,"(0x%08lx,0x%08lx),stub!\n",x1,x2);
FIXME("(0x%08lx,0x%08lx),stub!\n",x1,x2);
return 0;
}
@ -464,7 +464,7 @@ NTSTATUS WINAPI NtQueryPerformanceCounter(
IN PLARGE_INTEGER Counter,
IN PLARGE_INTEGER Frequency)
{
FIXME(ntdll,"(%p, 0%p) stub\n",
FIXME("(%p, 0%p) stub\n",
Counter, Frequency);
return 0;
}
@ -474,7 +474,7 @@ NTSTATUS WINAPI NtQueryPerformanceCounter(
*/
NTSTATUS WINAPI NtCreateMailslotFile(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6,DWORD x7,DWORD x8)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5,x6,x7,x8);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5,x6,x7,x8);
return 0;
}
@ -501,7 +501,7 @@ NTSTATUS WINAPI NtQuerySystemInformation(
IN ULONG Length,
OUT PULONG ResultLength)
{
FIXME(ntdll,"(0x%08x,%p,0x%08lx,%p) stub\n",
FIXME("(0x%08x,%p,0x%08lx,%p) stub\n",
SystemInformationClass,SystemInformation,Length,ResultLength);
ZeroMemory (SystemInformation, Length);
return 0;
@ -517,7 +517,7 @@ NTSTATUS WINAPI NtCreatePagingFile(
IN ULONG MaxiumSize,
OUT PULONG ActualSize)
{
FIXME(ntdll,"(%p(%s),0x%08lx,0x%08lx,%p),stub!\n",
FIXME("(%p(%s),0x%08lx,0x%08lx,%p),stub!\n",
PageFileName->Buffer, debugstr_w(PageFileName->Buffer),MiniumSize,MaxiumSize,ActualSize);
return 0;
}
@ -530,7 +530,7 @@ NTSTATUS WINAPI NtCreatePagingFile(
NTSTATUS WINAPI NtDisplayString (
PUNICODE_STRING string)
{
TRACE(ntdll,"%p(%s)\n",string->Buffer, debugstr_w(string->Buffer));
TRACE("%p(%s)\n",string->Buffer, debugstr_w(string->Buffer));
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), string->Buffer, string->Length, 0, 0);
return 0;
}

24
dlls/ntdll/om.c
View File

@ -4,7 +4,7 @@
#include <stdlib.h>
#include <string.h>
#include "debug.h"
#include "debugtools.h"
#include "ntddk.h"
@ -27,7 +27,7 @@ NTSTATUS WINAPI NtQueryObject(
IN ULONG Length,
OUT PULONG ResultLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx,%p): stub\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx,%p): stub\n",
ObjectHandle, ObjectInformationClass, ObjectInformation, Length, ResultLength);
return 0;
}
@ -37,7 +37,7 @@ NTSTATUS WINAPI NtQueryObject(
*/
NTSTATUS WINAPI NtQuerySecurityObject(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx) stub!\n",x1,x2,x3,x4,x5);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx) stub!\n",x1,x2,x3,x4,x5);
return 0;
}
/******************************************************************************
@ -52,7 +52,7 @@ NTSTATUS WINAPI NtDuplicateObject(
IN BOOLEAN InheritHandle,
ULONG Options)
{
FIXME(ntdll,"(0x%08x,%p,0x%08x,%p,0x%08lx,0x%08x,0x%08lx) stub!\n",
FIXME("(0x%08x,%p,0x%08x,%p,0x%08lx,0x%08x,0x%08lx) stub!\n",
SourceProcessHandle,SourceHandle,TargetProcessHandle,TargetHandle,
DesiredAccess,InheritHandle,Options);
*TargetHandle = 0;
@ -68,7 +68,7 @@ NTSTATUS WINAPI NtDuplicateObject(
NTSTATUS WINAPI NtClose(
HANDLE Handle)
{
FIXME(ntdll,"(0x%08x),stub!\n",Handle);
FIXME("(0x%08x),stub!\n",Handle);
return 1;
}
@ -80,7 +80,7 @@ NTSTATUS WINAPI NtWaitForSingleObject(
IN BOOLEAN Alertable,
IN PLARGE_INTEGER Time)
{
FIXME(ntdll,"(%p,0x%08x,%p),stub!\n",Object,Alertable,Time);
FIXME("(%p,0x%08x,%p),stub!\n",Object,Alertable,Time);
return 0;
}
@ -102,7 +102,7 @@ NTSTATUS WINAPI NtOpenDirectoryObject(
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s)): stub\n",
FIXME("(%p,0x%08lx,%p(%s)): stub\n",
DirectoryHandle, DesiredAccess, ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL);
return 0;
@ -116,7 +116,7 @@ NTSTATUS WINAPI NtCreateDirectoryObject(
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s)),stub!\n",
FIXME("(%p,0x%08lx,%p(%s)),stub!\n",
DirectoryHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL);
return 0;
@ -144,7 +144,7 @@ NTSTATUS WINAPI NtQueryDirectoryObject(
IN OUT PULONG ObjectIndex,
OUT PULONG DataWritten OPTIONAL)
{
FIXME(ntdll,"(0x%08x,%p,0x%08lx,0x%08x,0x%08x,%p,%p) stub\n",
FIXME("(0x%08x,%p,0x%08lx,0x%08x,0x%08x,%p,%p) stub\n",
DirObjHandle, DirObjInformation, BufferLength, GetNextIndex,
IgnoreInputIndex, ObjectIndex, DataWritten);
return 0xc0000000; /* We don't have any. Whatever. (Yet.) */
@ -162,7 +162,7 @@ NTSTATUS WINAPI NtOpenSymbolicLinkObject(
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s)) stub\n",
FIXME("(%p,0x%08lx,%p(%s)) stub\n",
LinkHandle, DesiredAccess, ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL);
return 0;
@ -177,7 +177,7 @@ NTSTATUS WINAPI NtCreateSymbolicLinkObject(
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PUNICODE_STRING Name)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s), %p) stub\n",
FIXME("(%p,0x%08lx,%p(%s), %p) stub\n",
SymbolicLinkHandle, DesiredAccess, ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL,
debugstr_w(Name->Buffer));
@ -192,7 +192,7 @@ NTSTATUS WINAPI NtQuerySymbolicLinkObject(
IN OUT PUNICODE_STRING LinkTarget,
OUT PULONG ReturnedLength OPTIONAL)
{
FIXME(ntdll,"(0x%08x,%p,%p) stub\n",
FIXME("(0x%08x,%p,%p) stub\n",
LinkHandle, debugstr_w(LinkTarget->Buffer), ReturnedLength);
return 0;

38
dlls/ntdll/reg.c
View File

@ -2,7 +2,7 @@
* registry functions
*/
#include "debug.h"
#include "debugtools.h"
#include "winreg.h"
#include "ntddk.h"
@ -23,7 +23,7 @@ NTSTATUS WINAPI NtCreateKey(
ULONG CreateOptions,
PULONG Disposition)
{
FIXME(ntdll,"(%p,0x%08lx,%p (%s),0x%08lx, %p(%s),0x%08lx,%p),stub!\n",
FIXME("(%p,0x%08lx,%p (%s),0x%08lx, %p(%s),0x%08lx,%p),stub!\n",
KeyHandle, DesiredAccess, ObjectAttributes,debugstr_w(ObjectAttributes->ObjectName->Buffer),
TitleIndex, Class, debugstr_w(Class->Buffer), CreateOptions, Disposition);
return 0;
@ -35,7 +35,7 @@ NTSTATUS WINAPI NtCreateKey(
*/
NTSTATUS NtDeleteKey(HANDLE KeyHandle)
{
FIXME(ntdll,"(0x%08x) stub!\n",
FIXME("(0x%08x) stub!\n",
KeyHandle);
return 1;
}
@ -48,7 +48,7 @@ NTSTATUS WINAPI NtDeleteValueKey(
IN HANDLE KeyHandle,
IN PUNICODE_STRING ValueName)
{
FIXME(ntdll,"(0x%08x,%p(%s)) stub!\n",
FIXME("(0x%08x,%p(%s)) stub!\n",
KeyHandle, ValueName,debugstr_w(ValueName->Buffer));
return 1;
@ -65,7 +65,7 @@ NTSTATUS WINAPI NtEnumerateKey(
ULONG Length,
PULONG ResultLength)
{
FIXME(ntdll,"(0x%08x,0x%08lx,0x%08x,%p,0x%08lx,%p) stub\n",
FIXME("(0x%08x,0x%08lx,0x%08x,%p,0x%08lx,%p) stub\n",
KeyHandle, Index, KeyInformationClass, KeyInformation, Length, ResultLength);
return 1;
}
@ -82,7 +82,7 @@ NTSTATUS WINAPI NtEnumerateValueKey(
ULONG Length,
PULONG ResultLength)
{
FIXME(ntdll,"(0x%08x,0x%08lx,0x%08x,%p,0x%08lx,%p) stub!\n",
FIXME("(0x%08x,0x%08lx,0x%08x,%p,0x%08lx,%p) stub!\n",
KeyHandle, Index, KeyInformationClass, KeyInformation, Length, ResultLength);
return 1;
}
@ -93,7 +93,7 @@ NTSTATUS WINAPI NtEnumerateValueKey(
*/
NTSTATUS NtFlushKey(HANDLE KeyHandle)
{
FIXME(ntdll,"(0x%08x) stub!\n",
FIXME("(0x%08x) stub!\n",
KeyHandle);
return 1;
}
@ -106,7 +106,7 @@ NTSTATUS WINAPI NtLoadKey(
PHANDLE KeyHandle,
POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(%p,%p (%s)),stub!\n",
FIXME("(%p,%p (%s)),stub!\n",
KeyHandle, ObjectAttributes,debugstr_w(ObjectAttributes->ObjectName->Buffer));
return 0;
@ -128,7 +128,7 @@ NTSTATUS WINAPI NtNotifyChangeKey(
IN ULONG Length,
IN BOOLEAN WatchSubtree)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,%p,%p,0x%08lx, 0x%08x,%p,0x%08lx,0x%08x) stub!\n",
FIXME("(0x%08x,0x%08x,%p,%p,%p,0x%08lx, 0x%08x,%p,0x%08lx,0x%08x) stub!\n",
KeyHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, CompletionFilter,
Asynchroneous, ChangeBuffer, Length, WatchSubtree);
return 0;
@ -147,7 +147,7 @@ NTSTATUS WINAPI NtOpenKey(
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(%p,0x%08lx,%p (%s)),stub!\n",
FIXME("(%p,0x%08lx,%p (%s)),stub!\n",
KeyHandle, DesiredAccess, ObjectAttributes,debugstr_w(ObjectAttributes->ObjectName->Buffer));
return 0;
}
@ -163,7 +163,7 @@ NTSTATUS WINAPI NtQueryKey(
ULONG Length,
PULONG ResultLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx,%p) stub\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx,%p) stub\n",
KeyHandle, KeyInformationClass, KeyInformation, Length, ResultLength);
return 0;
}
@ -181,7 +181,7 @@ NTSTATUS WINAPI NtQueryMultipleValueKey(
ULONG Length,
PULONG ReturnLength)
{
FIXME(ntdll,"(0x%08x,%p,0x%08lx,%p,0x%08lx,%p) stub!\n",
FIXME("(0x%08x,%p,0x%08lx,%p,0x%08lx,%p) stub!\n",
KeyHandle, ListOfValuesToQuery, NumberOfItems, MultipleValueInformation,
Length,ReturnLength);
return 0;
@ -199,7 +199,7 @@ NTSTATUS WINAPI NtQueryValueKey(
ULONG Length,
PULONG ResultLength)
{
FIXME(ntdll,"(0x%08x,%p,0x%08x,%p,0x%08lx,%p) stub\n",
FIXME("(0x%08x,%p,0x%08x,%p,0x%08lx,%p) stub\n",
KeyHandle, ValueName, KeyValueInformationClass, KeyValueInformation, Length, ResultLength);
return 0;
}
@ -213,7 +213,7 @@ NTSTATUS WINAPI NtReplaceKey(
IN HANDLE Key,
IN POBJECT_ATTRIBUTES ReplacedObjectAttributes)
{
FIXME(ntdll,"(%p(%s),0x%08x,%p (%s)),stub!\n",
FIXME("(%p(%s),0x%08x,%p (%s)),stub!\n",
ObjectAttributes,debugstr_w(ObjectAttributes->ObjectName->Buffer),Key,
ReplacedObjectAttributes,debugstr_w(ReplacedObjectAttributes->ObjectName->Buffer));
return 0;
@ -228,7 +228,7 @@ NTSTATUS WINAPI NtRestoreKey(
HANDLE FileHandle,
ULONG RestoreFlags)
{
FIXME(ntdll,"(0x%08x,0x%08x,0x%08lx) stub\n",
FIXME("(0x%08x,0x%08x,0x%08lx) stub\n",
KeyHandle, FileHandle, RestoreFlags);
return 0;
@ -241,7 +241,7 @@ NTSTATUS WINAPI NtSaveKey(
IN HANDLE KeyHandle,
IN HANDLE FileHandle)
{
FIXME(ntdll,"(0x%08x,0x%08x) stub\n",
FIXME("(0x%08x,0x%08x) stub\n",
KeyHandle, FileHandle);
return 0;
}
@ -255,7 +255,7 @@ NTSTATUS WINAPI NtSetInformationKey(
IN PVOID KeyInformation,
IN ULONG KeyInformationLength)
{
FIXME(ntdll,"(0x%08x,0x%08x,%p,0x%08lx) stub\n",
FIXME("(0x%08x,0x%08x,%p,0x%08lx) stub\n",
KeyHandle, KeyInformationClass, KeyInformation, KeyInformationLength);
return 0;
}
@ -271,7 +271,7 @@ NTSTATUS WINAPI NtSetValueKey(
PVOID Data,
ULONG DataSize)
{
FIXME(ntdll,"(0x%08x,%p(%s), 0x%08lx, 0x%08lx, %p, 0x%08lx) stub!\n",
FIXME("(0x%08x,%p(%s), 0x%08lx, 0x%08lx, %p, 0x%08lx) stub!\n",
KeyHandle, ValueName,debugstr_w(ValueName->Buffer), TitleIndex, Type, Data, DataSize);
return 1;
@ -284,7 +284,7 @@ NTSTATUS WINAPI NtSetValueKey(
NTSTATUS WINAPI NtUnloadKey(
IN HANDLE KeyHandle)
{
FIXME(ntdll,"(0x%08x) stub\n",
FIXME("(0x%08x) stub\n",
KeyHandle);
return 0;
}

52
dlls/ntdll/rtl.c
View File

@ -10,7 +10,7 @@
#include <stdlib.h>
#include <string.h>
#include "heap.h"
#include "debug.h"
#include "debugtools.h"
#include "winuser.h"
#include "winerror.h"
#include "stackframe.h"
@ -56,7 +56,7 @@ void WINAPI RtlDeleteResource(LPRTL_RWLOCK rwl)
{
EnterCriticalSection( &rwl->rtlCS );
if( rwl->iNumberActive || rwl->uExclusiveWaiters || rwl->uSharedWaiters )
MSG("Deleting active MRSW lock (%p), expect failure\n", rwl );
MESSAGE("Deleting active MRSW lock (%p), expect failure\n", rwl );
rwl->hOwningThreadId = 0;
rwl->uExclusiveWaiters = rwl->uSharedWaiters = 0;
rwl->iNumberActive = 0;
@ -203,10 +203,10 @@ void WINAPI RtlDumpResource(LPRTL_RWLOCK rwl)
{
if( rwl )
{
MSG("RtlDumpResource(%p):\n\tactive count = %i\n\twaiting readers = %i\n\twaiting writers = %i\n",
MESSAGE("RtlDumpResource(%p):\n\tactive count = %i\n\twaiting readers = %i\n\twaiting writers = %i\n",
rwl, rwl->iNumberActive, rwl->uSharedWaiters, rwl->uExclusiveWaiters );
if( rwl->iNumberActive )
MSG("\towner thread = %08x\n", rwl->hOwningThreadId );
MESSAGE("\towner thread = %08x\n", rwl->hOwningThreadId );
}
}
@ -225,7 +225,7 @@ HANDLE WINAPI RtlCreateHeap(
PVOID Unknown,
PRTL_HEAP_DEFINITION Definition)
{
FIXME (ntdll,"(0x%08lx, %p, 0x%08lx, 0x%08lx, %p, %p) semi-stub\n",
FIXME("(0x%08lx, %p, 0x%08lx, 0x%08lx, %p, %p) semi-stub\n",
Flags, BaseAddress, SizeToReserve, SizeToCommit, Unknown, Definition);
return HeapCreate ( Flags, SizeToCommit, SizeToReserve);
@ -239,7 +239,7 @@ PVOID WINAPI RtlAllocateHeap(
ULONG Flags,
ULONG Size)
{
FIXME(ntdll,"(0x%08x, 0x%08lx, 0x%08lx) semi stub\n",
FIXME("(0x%08x, 0x%08lx, 0x%08lx) semi stub\n",
Heap, Flags, Size);
return HeapAlloc(Heap, Flags, Size);
}
@ -252,7 +252,7 @@ BOOLEAN WINAPI RtlFreeHeap(
ULONG Flags,
PVOID Address)
{
FIXME(ntdll,"(0x%08x, 0x%08lx, %p) semi stub\n",
FIXME("(0x%08x, 0x%08lx, %p) semi stub\n",
Heap, Flags, Address);
return HeapFree(Heap, Flags, Address);
}
@ -265,7 +265,7 @@ BOOLEAN WINAPI RtlFreeHeap(
BOOLEAN WINAPI RtlDestroyHeap(
HANDLE Heap)
{
FIXME(ntdll,"(0x%08x) semi stub\n", Heap);
FIXME("(0x%08x) semi stub\n", Heap);
return HeapDestroy(Heap);
}
@ -280,7 +280,7 @@ void __cdecl DbgPrint(LPCSTR fmt,LPVOID args) {
char buf[512];
wvsprintfA(buf,fmt,&args);
MSG("DbgPrint says: %s",buf);
MESSAGE("DbgPrint says: %s",buf);
/* hmm, raise exception? */
}
@ -288,7 +288,7 @@ void __cdecl DbgPrint(LPCSTR fmt,LPVOID args) {
* RtlAcquirePebLock [NTDLL]
*/
VOID WINAPI RtlAcquirePebLock(void) {
FIXME(ntdll,"()\n");
FIXME("()\n");
/* enter critical section ? */
}
@ -296,7 +296,7 @@ VOID WINAPI RtlAcquirePebLock(void) {
* RtlReleasePebLock [NTDLL]
*/
VOID WINAPI RtlReleasePebLock(void) {
FIXME(ntdll,"()\n");
FIXME("()\n");
/* leave critical section ? */
}
@ -304,14 +304,14 @@ VOID WINAPI RtlReleasePebLock(void) {
* RtlIntegerToChar [NTDLL]
*/
DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4) {
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
return 0;
}
/******************************************************************************
* RtlSetEnvironmentVariable [NTDLL]
*/
DWORD WINAPI RtlSetEnvironmentVariable(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val) {
FIXME(ntdll,"(0x%08lx,%s,%s),stub!\n",x1,debugstr_w(key->Buffer),debugstr_w(val->Buffer));
FIXME("(0x%08lx,%s,%s),stub!\n",x1,debugstr_w(key->Buffer),debugstr_w(val->Buffer));
return 0;
}
@ -319,7 +319,7 @@ DWORD WINAPI RtlSetEnvironmentVariable(DWORD x1,PUNICODE_STRING key,PUNICODE_STR
* RtlNewSecurityObject [NTDLL]
*/
DWORD WINAPI RtlNewSecurityObject(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6) {
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5,x6);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4,x5,x6);
return 0;
}
@ -327,7 +327,7 @@ DWORD WINAPI RtlNewSecurityObject(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,D
* RtlDeleteSecurityObject [NTDLL]
*/
DWORD WINAPI RtlDeleteSecurityObject(DWORD x1) {
FIXME(ntdll,"(0x%08lx),stub!\n",x1);
FIXME("(0x%08lx),stub!\n",x1);
return 0;
}
@ -336,7 +336,7 @@ DWORD WINAPI RtlDeleteSecurityObject(DWORD x1) {
*/
LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x)
{
FIXME(ntdll,"(%p), stub\n",x);
FIXME("(%p), stub\n",x);
return x;
}
@ -345,7 +345,7 @@ LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x)
*/
DWORD WINAPI RtlNtStatusToDosError(DWORD error)
{
FIXME(ntdll, "(%lx): map STATUS_ to ERROR_\n",error);
FIXME("(%lx): map STATUS_ to ERROR_\n",error);
switch (error)
{ case STATUS_SUCCESS: return ERROR_SUCCESS;
case STATUS_INVALID_PARAMETER: return ERROR_BAD_ARGUMENTS;
@ -355,7 +355,7 @@ DWORD WINAPI RtlNtStatusToDosError(DWORD error)
/* case STATUS_UNKNOWN_REVISION:
case STATUS_BUFFER_OVERFLOW:*/
}
FIXME(ntdll, "unknown status (%lx)\n",error);
FIXME("unknown status (%lx)\n",error);
return ERROR_SUCCESS;
}
@ -364,7 +364,7 @@ DWORD WINAPI RtlNtStatusToDosError(DWORD error)
*/
BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type)
{
FIXME(ntdll, "(%p): stub\n", type);
FIXME("(%p): stub\n", type);
*type=3; /* dunno. 1 for client, 3 for server? */
return 1;
}
@ -398,7 +398,7 @@ INT WINAPI RtlExtendedLargeIntegerDivide(
*rest = x1 % divisor;
return x1/divisor;
#else
FIXME(ntdll,"((%d<<32)+%d,%d,%p), implement this using normal integer arithmetic!\n",dividend.HighPart,dividend.LowPart,divisor,rest);
FIXME("((%d<<32)+%d,%d,%p), implement this using normal integer arithmetic!\n",dividend.HighPart,dividend.LowPart,divisor,rest);
return 0;
#endif
}
@ -415,7 +415,7 @@ long long WINAPI RtlExtendedIntegerMultiply(
#if SIZEOF_LONG_LONG==8
return (*(long long*)&factor1) * factor2;
#else
FIXME(ntdll,"((%d<<32)+%d,%ld), implement this using normal integer arithmetic!\n",factor1.HighPart,factor1.LowPart,factor2);
FIXME("((%d<<32)+%d,%ld), implement this using normal integer arithmetic!\n",factor1.HighPart,factor1.LowPart,factor2);
return 0;
#endif
}
@ -425,7 +425,7 @@ long long WINAPI RtlExtendedIntegerMultiply(
*/
DWORD WINAPI RtlFormatCurrentUserKeyPath(DWORD x)
{
FIXME(ntdll,"(0x%08lx): stub\n",x);
FIXME("(0x%08lx): stub\n",x);
return 1;
}
@ -454,7 +454,7 @@ BOOLEAN WINAPI RtlDosPathNameToNtPathName_U(
{
LPSTR fromA = HEAP_strdupWtoA(GetProcessHeap(),0,from);
FIXME(ntdll,"(%s,%p,%08lx,%08lx)\n",fromA,us,x2,x3);
FIXME("(%s,%p,%08lx,%08lx)\n",fromA,us,x2,x3);
if (us)
RtlInitUnicodeString(us,HEAP_strdupW(GetProcessHeap(),0,from));
return TRUE;
@ -464,7 +464,7 @@ BOOLEAN WINAPI RtlDosPathNameToNtPathName_U(
* RtlCreateEnvironment [NTDLL]
*/
DWORD WINAPI RtlCreateEnvironment(DWORD x1,DWORD x2) {
FIXME(ntdll,"(0x%08lx,0x%08lx),stub!\n",x1,x2);
FIXME("(0x%08lx,0x%08lx),stub!\n",x1,x2);
return 0;
}
@ -473,7 +473,7 @@ DWORD WINAPI RtlCreateEnvironment(DWORD x1,DWORD x2) {
* RtlDestroyEnvironment [NTDLL]
*/
DWORD WINAPI RtlDestroyEnvironment(DWORD x) {
FIXME(ntdll,"(0x%08lx),stub!\n",x);
FIXME("(0x%08lx),stub!\n",x);
return 0;
}
@ -481,6 +481,6 @@ DWORD WINAPI RtlDestroyEnvironment(DWORD x) {
* RtlQueryEnvironmentVariable_U [NTDLL]
*/
DWORD WINAPI RtlQueryEnvironmentVariable_U(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val) {
FIXME(ntdll,"(0x%08lx,%s,%p),stub!\n",x1,debugstr_w(key->Buffer),val);
FIXME("(0x%08lx,%s,%p),stub!\n",x1,debugstr_w(key->Buffer),val);
return 0;
}

8
dlls/ntdll/rtlstr.c
View File

@ -15,7 +15,7 @@
#include "wine/winestring.h"
#include "heap.h"
#include "winnls.h"
#include "debug.h"
#include "debugtools.h"
#include "ntddk.h"
@ -138,7 +138,7 @@ VOID WINAPI RtlInitString(PSTRING target,LPCSTR source)
*/
VOID WINAPI RtlInitUnicodeString(PUNICODE_STRING target,LPCWSTR source)
{
TRACE(ntdll,"%p %p(%s)\n", target, source, debugstr_w(source));
TRACE("%p %p(%s)\n", target, source, debugstr_w(source));
target->Length = target->MaximumLength = 0;
target->Buffer = (LPWSTR)source;
@ -220,7 +220,7 @@ WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING oem,PUNICODE_STRING uni,BOOLEAN
* RtlEqualUnicodeString [NTDLL]
*/
DWORD WINAPI RtlEqualUnicodeString(PUNICODE_STRING s1,PUNICODE_STRING s2,DWORD x) {
FIXME(ntdll,"(%s,%s,%ld),stub!\n",debugstr_w(s1->Buffer),debugstr_w(s2->Buffer),x);
FIXME("(%s,%s,%ld),stub!\n",debugstr_w(s1->Buffer),debugstr_w(s2->Buffer),x);
return 0;
if (s1->Length != s2->Length)
return 1;
@ -318,7 +318,7 @@ out:
NTSTATUS WINAPI RtlCompareUnicodeString(
PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
{
FIXME(ntdll,"(%s,%s,0x%08x),stub!\n",debugstr_w(String1->Buffer),debugstr_w(String1->Buffer),CaseInSensitive);
FIXME("(%s,%s,0x%08x),stub!\n",debugstr_w(String1->Buffer),debugstr_w(String1->Buffer),CaseInSensitive);
return 0;
}

20
dlls/ntdll/sec.c
View File

@ -17,7 +17,7 @@
#include "heap.h"
#include "winnls.h"
#include "debugstr.h"
#include "debug.h"
#include "debugtools.h"
#include "winuser.h"
#include "winerror.h"
#include "stackframe.h"
@ -38,7 +38,7 @@ DEFAULT_DEBUG_CHANNEL(ntdll)
BOOLEAN WINAPI RtlAllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
DWORD nSubAuthorityCount,DWORD x3,DWORD x4,DWORD x5,DWORD x6,DWORD x7,DWORD x8,DWORD x9,DWORD x10, PSID pSid)
{
FIXME(ntdll,"(%p,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,%p),stub!\n",
FIXME("(%p,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx,%p),stub!\n",
pIdentifierAuthority,nSubAuthorityCount,x3,x4,x5,x6,x7,x8,x9,x10,pSid);
return 0;
}
@ -48,7 +48,7 @@ BOOLEAN WINAPI RtlAllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY pIdentifie
*/
DWORD WINAPI RtlEqualSid(DWORD x1,DWORD x2)
{
FIXME(ntdll,"(0x%08lx,0x%08lx),stub!\n", x1,x2);
FIXME("(0x%08lx,0x%08lx),stub!\n", x1,x2);
return TRUE;
}
@ -57,7 +57,7 @@ DWORD WINAPI RtlEqualSid(DWORD x1,DWORD x2)
*/
DWORD WINAPI RtlFreeSid(DWORD x1)
{
FIXME(ntdll,"(0x%08lx),stub!\n", x1);
FIXME("(0x%08lx),stub!\n", x1);
return TRUE;
}
@ -74,7 +74,7 @@ DWORD WINAPI RtlLengthRequiredSid(DWORD nrofsubauths)
*/
DWORD WINAPI RtlLengthSid(PSID sid)
{
TRACE(ntdll,"sid=%p\n",sid);
TRACE("sid=%p\n",sid);
if (!sid)
return FALSE;
return sizeof(DWORD)*sid->SubAuthorityCount+sizeof(SID);
@ -197,7 +197,7 @@ NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
OUT PACL *pDacl,
OUT PBOOLEAN lpbDaclDefaulted)
{
TRACE(ntdll,"(%p,%p,%p,%p)\n",
TRACE("(%p,%p,%p,%p)\n",
pSecurityDescriptor, lpbDaclPresent, *pDacl, lpbDaclDefaulted);
if (pSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION)
@ -258,7 +258,7 @@ NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
OUT PACL *pSacl,
OUT PBOOLEAN lpbSaclDefaulted)
{
TRACE(ntdll,"(%p,%p,%p,%p)\n",
TRACE("(%p,%p,%p,%p)\n",
pSecurityDescriptor, lpbSaclPresent, *pSacl, lpbSaclDefaulted);
if (pSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION)
@ -473,7 +473,7 @@ NTSTATUS WINAPI RtlAddAce(
*/
DWORD WINAPI RtlAddAccessAllowedAce(DWORD x1,DWORD x2,DWORD x3,DWORD x4)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
return 0;
}
@ -482,7 +482,7 @@ DWORD WINAPI RtlAddAccessAllowedAce(DWORD x1,DWORD x2,DWORD x3,DWORD x4)
*/
DWORD WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce )
{
FIXME(ntdll,"(%p,%ld,%p),stub!\n",pAcl,dwAceIndex,pAce);
FIXME("(%p,%ld,%p),stub!\n",pAcl,dwAceIndex,pAce);
return 0;
}
@ -495,7 +495,7 @@ DWORD WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce )
*/
DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4)
{
FIXME(ntdll,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
return 0;
}

16
dlls/ntdll/sync.c
View File

@ -6,7 +6,7 @@
#include <string.h>
#include <time.h>
#include "debugstr.h"
#include "debug.h"
#include "debugtools.h"
#include "ntddk.h"
@ -26,7 +26,7 @@ NTSTATUS WINAPI NtCreateSemaphore(
IN ULONG InitialCount,
IN ULONG MaximumCount)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s),0x%08lx,0x%08lx) stub!\n",
FIXME("(%p,0x%08lx,%p(%s),0x%08lx,0x%08lx) stub!\n",
SemaphoreHandle, DesiredAccess, ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL,
InitialCount, MaximumCount);
@ -41,7 +41,7 @@ NTSTATUS WINAPI NtOpenSemaphore(
IN ACCESS_MASK DesiredAcces,
IN POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(0x%08x,0x%08lx,%p(%s)) stub!\n",
FIXME("(0x%08x,0x%08lx,%p(%s)) stub!\n",
SemaphoreHandle, DesiredAcces, ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL);
return 0;
@ -57,7 +57,7 @@ NTSTATUS WINAPI NtQuerySemaphore(
ULONG Length,
PULONG ReturnLength)
{
FIXME(ntdll,"(0x%08x,%p,%p,0x%08lx,%p) stub!\n",
FIXME("(0x%08x,%p,%p,0x%08lx,%p) stub!\n",
SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
return 0;
}
@ -69,7 +69,7 @@ NTSTATUS WINAPI NtReleaseSemaphore(
IN ULONG ReleaseCount,
IN PULONG PreviousCount)
{
FIXME(ntdll,"(0x%08x,0x%08lx,%p,) stub!\n",
FIXME("(0x%08x,0x%08lx,%p,) stub!\n",
SemaphoreHandle, ReleaseCount, PreviousCount);
return 0;
}
@ -88,7 +88,7 @@ NTSTATUS WINAPI NtCreateEvent(
IN BOOLEAN ManualReset,
IN BOOLEAN InitialState)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s),%08x,%08x): empty stub\n",
FIXME("(%p,0x%08lx,%p(%s),%08x,%08x): empty stub\n",
EventHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL,
ManualReset,InitialState);
@ -103,7 +103,7 @@ NTSTATUS WINAPI NtOpenEvent(
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes)
{
FIXME(ntdll,"(%p,0x%08lx,%p(%s)),stub!\n",
FIXME("(%p,0x%08lx,%p(%s)),stub!\n",
EventHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes ? debugstr_w(ObjectAttributes->ObjectName->Buffer) : NULL);
return 0;
@ -116,7 +116,7 @@ NTSTATUS WINAPI NtSetEvent(
IN HANDLE EventHandle,
PULONG NumberOfThreadsReleased)
{
FIXME(ntdll,"(0x%08x,%p)\n",
FIXME("(0x%08x,%p)\n",
EventHandle, NumberOfThreadsReleased);
return 0;
}

6
dlls/ntdll/time.c
View File

@ -10,7 +10,7 @@
#include <string.h>
#include "ntddk.h"
#include "debug.h"
#include "debugtools.h"
#include "file.h"
DEFAULT_DEBUG_CHANNEL(ntdll)
@ -174,7 +174,7 @@ VOID WINAPI RtlSystemTimeToLocalTime(
IN PLARGE_INTEGER SystemTime,
OUT PLARGE_INTEGER LocalTime)
{
FIXME(ntdll,"(%p, %p),stub!\n",SystemTime,LocalTime);
FIXME("(%p, %p),stub!\n",SystemTime,LocalTime);
memcpy (LocalTime, SystemTime, sizeof (PLARGE_INTEGER));
}
@ -209,5 +209,5 @@ VOID WINAPI RtlTimeToElapsedTimeFields(
PLARGE_INTEGER liTime,
PTIME_FIELDS TimeFields)
{
FIXME(ntdll,"(%p,%p): stub\n",liTime,TimeFields);
FIXME("(%p,%p): stub\n",liTime,TimeFields);
}

22
memory/atom.c
View File

@ -21,7 +21,7 @@
#include "ldt.h"
#include "stackframe.h"
#include "user.h"
#include "debug.h"
#include "debugtools.h"
#ifdef CONFIG_IPC
#include "dde_atom.h"
@ -164,7 +164,7 @@ static WORD ATOM_Hash(
) {
WORD i, hash = 0;
TRACE(atom,"%x, %s, %x\n", entries, str, len);
TRACE("%x, %s, %x\n", entries, str, len);
for (i = 0; i < len; i++) hash ^= toupper(str[i]) + i;
return hash % entries;
@ -181,7 +181,7 @@ static BOOL ATOM_IsIntAtom(LPCSTR atomstr,WORD *atomid) {
return FALSE;
*atomid=strtol(atomstr+1,&xend,10);
if (*xend) {
FIXME(atom,"found atom named '%s'\n",atomstr);
FIXME("found atom named '%s'\n",atomstr);
return FALSE;
}
return TRUE;
@ -211,7 +211,7 @@ static ATOM ATOM_AddAtom(
int len, ae_len;
WORD iatom;
TRACE(atom,"0x%x, %s\n", selector, str);
TRACE("0x%x, %s\n", selector, str);
if (ATOM_IsIntAtom(str,&iatom))
return iatom;
@ -226,7 +226,7 @@ static ATOM ATOM_AddAtom(
(!lstrncmpiA( entryPtr->str, str, len )))
{
entryPtr->refCount++;
TRACE(atom,"-- existing 0x%x\n", entry);
TRACE("-- existing 0x%x\n", entry);
return HANDLETOATOM( entry );
}
entry = entryPtr->next;
@ -243,7 +243,7 @@ static ATOM ATOM_AddAtom(
entryPtr->length = len;
strncpy( entryPtr->str, str, ae_len - sizeof(ATOMENTRY) + 1); /* always use strncpy ('\0's padding) */
table->entries[hash] = entry;
TRACE(atom,"-- new 0x%x\n", entry);
TRACE("-- new 0x%x\n", entry);
return HANDLETOATOM( entry );
}
@ -263,7 +263,7 @@ static ATOM ATOM_DeleteAtom(
HANDLE16 entry, *prevEntry;
WORD hash;
TRACE(atom,"0x%x, 0x%x\n", selector, atom);
TRACE("0x%x, 0x%x\n", selector, atom);
if (atom < MIN_STR_ATOM) return 0; /* Integer atom */
@ -306,7 +306,7 @@ static ATOM ATOM_FindAtom(
HANDLE16 entry;
int len;
TRACE(atom,"%x, %s\n", selector, str);
TRACE("%x, %s\n", selector, str);
if (ATOM_IsIntAtom(str,&iatom))
return iatom;
if ((len = strlen( str )) > 255) len = 255;
@ -318,12 +318,12 @@ static ATOM ATOM_FindAtom(
ATOMENTRY * entryPtr = ATOM_MakePtr( selector, entry );
if ((entryPtr->length == len) &&
(!lstrncmpiA( entryPtr->str, str, len )))
{ TRACE(atom,"-- found %x\n", entry);
{ TRACE("-- found %x\n", entry);
return HANDLETOATOM( entry );
}
entry = entryPtr->next;
}
TRACE(atom,"-- not found\n");
TRACE("-- not found\n");
return 0;
}
@ -347,7 +347,7 @@ static UINT ATOM_GetAtomName(
UINT len;
char text[8];
TRACE(atom,"%x, %x\n", selector, atom);
TRACE("%x, %x\n", selector, atom);
if (!count) return 0;
if (atom < MIN_STR_ATOM)

90
memory/global.c
View File

@ -19,7 +19,7 @@
#include "dde_mem.h"
#include "stackframe.h"
#include "module.h"
#include "debug.h"
#include "debugtools.h"
#include "winerror.h"
DEFAULT_DEBUG_CHANNEL(global)
@ -84,11 +84,11 @@ void debug_handles(void)
for (i = globalArenaSize-1 ; i>=0 ; i--) {
if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
printed=1;
DUMP("0x%08x, ",pGlobalArena[i].handle);
DPRINTF("0x%08x, ",pGlobalArena[i].handle);
}
}
if (printed)
DUMP("\n");
DPRINTF("\n");
}
@ -213,7 +213,7 @@ HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner,
HGLOBAL16 handle;
SHMDATA shmdata;
TRACE(global, "%ld flags=%04x\n", size, flags );
TRACE("%ld flags=%04x\n", size, flags );
/* If size is 0, create a discarded block */
@ -331,20 +331,20 @@ HGLOBAL16 WINAPI GlobalReAlloc16(
GLOBALARENA *pArena, *pNewArena;
WORD sel = GlobalHandleToSel16( handle );
TRACE(global, "%04x %ld flags=%04x\n",
TRACE("%04x %ld flags=%04x\n",
handle, size, flags );
if (!handle) return 0;
#ifdef CONFIG_IPC
if (flags & GMEM_DDESHARE || is_dde_handle(handle))
{
FIXME(global, "shared memory reallocating unimplemented\n");
FIXME("shared memory reallocating unimplemented\n");
return 0;
}
#endif /* CONFIG_IPC */
if (!VALID_HANDLE(handle)) {
WARN(global, "Invalid handle 0x%04x!\n", handle);
WARN("Invalid handle 0x%04x!\n", handle);
return 0;
}
pArena = GET_ARENA_PTR( handle );
@ -387,7 +387,7 @@ HGLOBAL16 WINAPI GlobalReAlloc16(
ptr = (void *)pArena->base;
oldsize = pArena->size;
TRACE(global,"oldsize %08lx\n",oldsize);
TRACE("oldsize %08lx\n",oldsize);
if (ptr && (size == oldsize)) return handle; /* Nothing to do */
if (((char *)ptr >= DOSMEM_MemoryBase(0)) &&
@ -449,12 +449,12 @@ HGLOBAL16 WINAPI GlobalFree16(
void *ptr;
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
return 0;
}
ptr = (void *)GET_ARENA_PTR(handle)->base;
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (!GLOBAL_FreeBlock( handle )) return handle; /* failed */
#ifdef CONFIG_IPC
if (is_dde_handle(handle)) return DDE_GlobalFree(handle);
@ -471,7 +471,7 @@ HGLOBAL16 WINAPI GlobalFree16(
*/
SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
{
TRACE(global, "(%04x) -> %08lx\n",
TRACE("(%04x) -> %08lx\n",
handle, MAKELONG( 0, GlobalHandleToSel16(handle)) );
if (handle)
{
@ -483,7 +483,7 @@ SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
#endif /* CONFIG_IPC */
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
return (SEGPTR)0;
}
if (!GET_ARENA_PTR(handle)->base) return (SEGPTR)0;
@ -532,10 +532,10 @@ BOOL16 WINAPI GlobalUnlock16(
) {
GLOBALARENA *pArena = GET_ARENA_PTR(handle);
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
return 0;
}
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (pArena->lockCount) pArena->lockCount--;
return pArena->lockCount;
}
@ -558,7 +558,7 @@ void WINAPI GlobalChangeLockCount16( CONTEXT *context )
else if ( delta == -1 )
GlobalUnlock16( handle );
else
ERR( global, "(%04X, %d): strange delta value\n", handle, delta );
ERR("(%04X, %d): strange delta value\n", handle, delta );
}
/***********************************************************************
@ -570,7 +570,7 @@ void WINAPI GlobalChangeLockCount16( CONTEXT *context )
DWORD WINAPI GlobalSize16(
HGLOBAL16 handle /* [in] Handle of global memory object */
) {
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (!handle) return 0;
if (!VALID_HANDLE(handle))
return 0;
@ -590,9 +590,9 @@ DWORD WINAPI GlobalSize16(
DWORD WINAPI GlobalHandle16(
WORD sel /* [in] Address of global memory block */
) {
TRACE(global, "%04x\n", sel );
TRACE("%04x\n", sel );
if (!VALID_HANDLE(sel)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
WARN("Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
return 0;
}
return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
@ -627,9 +627,9 @@ UINT16 WINAPI GlobalFlags16(
) {
GLOBALARENA *pArena;
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
return 0;
}
pArena = GET_ARENA_PTR(handle);
@ -644,10 +644,10 @@ UINT16 WINAPI GlobalFlags16(
*/
HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to LockSegment16!\n",handle);
WARN("Invalid handle 0x%04x passed to LockSegment16!\n",handle);
return 0;
}
GET_ARENA_PTR(handle)->lockCount++;
@ -660,10 +660,10 @@ HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
*/
void WINAPI UnlockSegment16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
WARN("Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
return;
}
GET_ARENA_PTR(handle)->lockCount--;
@ -720,7 +720,7 @@ BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
*/
LONG WINAPI SetSwapAreaSize16( WORD size )
{
FIXME(global, "(%d) - stub!\n", size );
FIXME("(%d) - stub!\n", size );
return MAKELONG( size, 0xffff );
}
@ -730,7 +730,7 @@ LONG WINAPI SetSwapAreaSize16( WORD size )
*/
HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
return handle;
}
@ -741,7 +741,7 @@ HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
*/
HGLOBAL16 WINAPI GlobalLRUNewest16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
return handle;
}
@ -808,9 +808,9 @@ WORD WINAPI GlobalDOSFree16(
*/
WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalPageLock!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalPageLock!\n",handle);
return 0;
}
return ++(GET_ARENA_PTR(handle)->pageLockCount);
@ -822,9 +822,9 @@ WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
*/
WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
return 0;
}
return --(GET_ARENA_PTR(handle)->pageLockCount);
@ -836,9 +836,9 @@ WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
*/
WORD WINAPI GlobalFix16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
return 0;
}
GET_ARENA_PTR(handle)->lockCount++;
@ -852,9 +852,9 @@ WORD WINAPI GlobalFix16( HGLOBAL16 handle )
*/
void WINAPI GlobalUnfix16( HGLOBAL16 handle )
{
TRACE(global, "%04x\n", handle );
TRACE("%04x\n", handle );
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
return;
}
GET_ARENA_PTR(handle)->lockCount--;
@ -867,7 +867,7 @@ void WINAPI GlobalUnfix16( HGLOBAL16 handle )
void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
{
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
WARN("Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
return;
}
GET_ARENA_PTR(handle)->hOwner = hOwner;
@ -880,7 +880,7 @@ void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
{
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
WARN("Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
return 0;
}
return GET_ARENA_PTR(handle)->hOwner;
@ -897,12 +897,12 @@ WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
if (is_dde_handle(handle)) return DDE_GlobalHandleToSel(handle);
#endif
if (!VALID_HANDLE(handle)) {
WARN(global,"Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
return 0;
}
if (!(handle & 7))
{
WARN(global, "Program attempted invalid selector conversion\n" );
WARN("Program attempted invalid selector conversion\n" );
return handle - 1;
}
return handle | 7;
@ -1141,7 +1141,7 @@ LPVOID WINAPI GlobalLock(
}
else
{
WARN(global, "invalid handle\n");
WARN("invalid handle\n");
palloc=(LPVOID) NULL;
}
/* HeapUnlock(GetProcessHeap()); */;
@ -1176,7 +1176,7 @@ BOOL WINAPI GlobalUnlock(
}
else
{
WARN(global, "invalid handle\n");
WARN("invalid handle\n");
locked=FALSE;
}
/* HeapUnlock(GetProcessHeap()); */
@ -1244,7 +1244,7 @@ HGLOBAL WINAPI GlobalReAlloc(
*/
if (hmem == 0)
{
ERR(global, "GlobalReAlloc32 with null handle!\n");
ERR("GlobalReAlloc32 with null handle!\n");
SetLastError( ERROR_NOACCESS );
return 0;
}
@ -1280,7 +1280,7 @@ HGLOBAL WINAPI GlobalReAlloc(
/* reallocate a moveable block */
pintern=HANDLE_TO_INTERN(hmem);
if(pintern->LockCount>1) {
ERR(global,"handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
SetLastError(ERROR_INVALID_HANDLE);
} else if(size!=0)
{
@ -1382,7 +1382,7 @@ DWORD WINAPI GlobalSize(
}
else
{
WARN(global, "invalid handle\n");
WARN("invalid handle\n");
retval=0;
}
/* HeapUnlock(GetProcessHeap()); */
@ -1462,7 +1462,7 @@ UINT WINAPI GlobalFlags(
}
else
{
WARN(global,"Invalid handle: %04x", hmem);
WARN("Invalid handle: %04x", hmem);
retval=0;
}
/* HeapUnlock(GetProcessHeap()); */

112
memory/heap.c
View File

@ -17,7 +17,7 @@
#include "winnt.h"
#include "heap.h"
#include "toolhelp.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(heap)
@ -118,19 +118,19 @@ void HEAP_Dump( HEAP *heap )
SUBHEAP *subheap;
char *ptr;
DUMP( "Heap: %08lx\n", (DWORD)heap );
DUMP( "Next: %08lx Sub-heaps: %08lx",
DPRINTF( "Heap: %08lx\n", (DWORD)heap );
DPRINTF( "Next: %08lx Sub-heaps: %08lx",
(DWORD)heap->next, (DWORD)&heap->subheap );
subheap = &heap->subheap;
while (subheap->next)
{
DUMP( " -> %08lx", (DWORD)subheap->next );
DPRINTF( " -> %08lx", (DWORD)subheap->next );
subheap = subheap->next;
}
DUMP( "\nFree lists:\n Block Stat Size Id\n" );
DPRINTF( "\nFree lists:\n Block Stat Size Id\n" );
for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
DUMP( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
DPRINTF( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
(DWORD)&heap->freeList[i].arena, heap->freeList[i].arena.size,
heap->freeList[i].arena.threadId,
(DWORD)heap->freeList[i].arena.prev,
@ -140,17 +140,17 @@ void HEAP_Dump( HEAP *heap )
while (subheap)
{
DWORD freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
DUMP( "\n\nSub-heap %08lx: size=%08lx committed=%08lx\n",
DPRINTF( "\n\nSub-heap %08lx: size=%08lx committed=%08lx\n",
(DWORD)subheap, subheap->size, subheap->commitSize );
DUMP( "\n Block Stat Size Id\n" );
DPRINTF( "\n Block Stat Size Id\n" );
ptr = (char*)subheap + subheap->headerSize;
while (ptr < (char *)subheap + subheap->size)
{
if (*(DWORD *)ptr & ARENA_FLAG_FREE)
{
ARENA_FREE *pArena = (ARENA_FREE *)ptr;
DUMP( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
DPRINTF( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
(DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
pArena->threadId, (DWORD)pArena->prev,
(DWORD)pArena->next);
@ -161,7 +161,7 @@ void HEAP_Dump( HEAP *heap )
else if (*(DWORD *)ptr & ARENA_FLAG_PREV_FREE)
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
DUMP( "%08lx Used %08lx %04x back=%08lx EIP=%p\n",
DPRINTF( "%08lx Used %08lx %04x back=%08lx EIP=%p\n",
(DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
pArena->threadId, *((DWORD *)pArena - 1),
pArena->callerEIP );
@ -172,7 +172,7 @@ void HEAP_Dump( HEAP *heap )
else
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
DUMP( "%08lx used %08lx %04x EIP=%p\n",
DPRINTF( "%08lx used %08lx %04x EIP=%p\n",
(DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
pArena->threadId, pArena->callerEIP );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
@ -180,7 +180,7 @@ void HEAP_Dump( HEAP *heap )
usedSize += pArena->size & ARENA_SIZE_MASK;
}
}
DUMP( "\nTotal: Size=%08lx Committed=%08lx Free=%08lx Used=%08lx Arenas=%08lx (%ld%%)\n\n",
DPRINTF( "\nTotal: Size=%08lx Committed=%08lx Free=%08lx Used=%08lx Arenas=%08lx (%ld%%)\n\n",
subheap->size, subheap->commitSize, freeSize, usedSize,
arenaSize, (arenaSize * 100) / subheap->size );
subheap = subheap->next;
@ -200,7 +200,7 @@ static HEAP *HEAP_GetPtr(
HEAP *heapPtr = (HEAP *)heap;
if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
{
ERR(heap, "Invalid heap %08x!\n", heap );
ERR("Invalid heap %08x!\n", heap );
SetLastError( ERROR_INVALID_HANDLE );
return NULL;
}
@ -270,7 +270,7 @@ static BOOL HEAP_Commit( SUBHEAP *subheap, void *ptr )
size - subheap->commitSize, MEM_COMMIT,
PAGE_EXECUTE_READWRITE))
{
WARN(heap, "Could not commit %08lx bytes at %08lx for heap %08lx\n",
WARN("Could not commit %08lx bytes at %08lx for heap %08lx\n",
size - subheap->commitSize,
(DWORD)((char *)subheap + subheap->commitSize),
(DWORD)subheap->heap );
@ -294,7 +294,7 @@ static BOOL HEAP_Decommit( SUBHEAP *subheap, void *ptr )
if (!VirtualFree( (char *)subheap + size,
subheap->commitSize - size, MEM_DECOMMIT ))
{
WARN(heap, "Could not decommit %08lx bytes at %08lx for heap %08lx\n",
WARN("Could not decommit %08lx bytes at %08lx for heap %08lx\n",
subheap->commitSize - size,
(DWORD)((char *)subheap + size),
(DWORD)subheap->heap );
@ -454,7 +454,7 @@ static BOOL HEAP_InitSubHeap( HEAP *heap, LPVOID address, DWORD flags,
if (!VirtualAlloc(address, commitSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
{
WARN(heap, "Could not commit %08lx bytes for sub-heap %08lx\n",
WARN("Could not commit %08lx bytes for sub-heap %08lx\n",
commitSize, (DWORD)address );
return FALSE;
}
@ -469,7 +469,7 @@ static BOOL HEAP_InitSubHeap( HEAP *heap, LPVOID address, DWORD flags,
(flags & HEAP_WINE_CODESEG) != 0, FALSE );
if (!selector)
{
ERR(heap, "Could not allocate selector\n" );
ERR("Could not allocate selector\n" );
return FALSE;
}
}
@ -559,7 +559,7 @@ static SUBHEAP *HEAP_CreateSubHeap( HEAP *heap, DWORD flags,
if (!(address = VirtualAlloc( NULL, totalSize,
MEM_RESERVE, PAGE_EXECUTE_READWRITE )))
{
WARN(heap, "Could not VirtualAlloc %08lx bytes\n",
WARN("Could not VirtualAlloc %08lx bytes\n",
totalSize );
return NULL;
}
@ -613,7 +613,7 @@ static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, DWORD size,
if (!(heap->flags & HEAP_GROWABLE))
{
WARN(heap, "Not enough space in heap %08lx for %08lx bytes\n",
WARN("Not enough space in heap %08lx for %08lx bytes\n",
(DWORD)heap, size );
return NULL;
}
@ -622,7 +622,7 @@ static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, DWORD size,
MAX( HEAP_DEF_SIZE, size ) )))
return NULL;
TRACE(heap, "created new sub-heap %08lx of %08lx bytes for heap %08lx\n",
TRACE("created new sub-heap %08lx of %08lx bytes for heap %08lx\n",
(DWORD)subheap, size, (DWORD)heap );
*ppSubHeap = subheap;
@ -658,7 +658,7 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
/* Check magic number */
if (pArena->magic != ARENA_FREE_MAGIC)
{
ERR(heap, "Heap %08lx: invalid free arena magic for %08lx\n",
ERR("Heap %08lx: invalid free arena magic for %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena );
return FALSE;
}
@ -666,20 +666,20 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
if (!(pArena->size & ARENA_FLAG_FREE) ||
(pArena->size & ARENA_FLAG_PREV_FREE))
{
ERR(heap, "Heap %08lx: bad flags %lx for free arena %08lx\n",
ERR("Heap %08lx: bad flags %lx for free arena %08lx\n",
(DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
}
/* Check arena size */
if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
ERR(heap, "Heap %08lx: bad size %08lx for free arena %08lx\n",
ERR("Heap %08lx: bad size %08lx for free arena %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
return FALSE;
}
/* Check that next pointer is valid */
if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->next ))
{
ERR(heap, "Heap %08lx: bad next ptr %08lx for arena %08lx\n",
ERR("Heap %08lx: bad next ptr %08lx for arena %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
return FALSE;
}
@ -687,14 +687,14 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
if (!(pArena->next->size & ARENA_FLAG_FREE) ||
(pArena->next->magic != ARENA_FREE_MAGIC))
{
ERR(heap, "Heap %08lx: next arena %08lx invalid for %08lx\n",
ERR("Heap %08lx: next arena %08lx invalid for %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
return FALSE;
}
/* Check that prev pointer is valid */
if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->prev ))
{
ERR(heap, "Heap %08lx: bad prev ptr %08lx for arena %08lx\n",
ERR("Heap %08lx: bad prev ptr %08lx for arena %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
return FALSE;
}
@ -702,7 +702,7 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
if (!(pArena->prev->size & ARENA_FLAG_FREE) ||
(pArena->prev->magic != ARENA_FREE_MAGIC))
{
ERR(heap, "Heap %08lx: prev arena %08lx invalid for %08lx\n",
ERR("Heap %08lx: prev arena %08lx invalid for %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
return FALSE;
}
@ -712,7 +712,7 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
if (!(*(DWORD *)((char *)(pArena + 1) +
(pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
{
ERR(heap, "Heap %08lx: free arena %08lx next block has no PREV_FREE flag\n",
ERR("Heap %08lx: free arena %08lx next block has no PREV_FREE flag\n",
(DWORD)subheap->heap, (DWORD)pArena );
return FALSE;
}
@ -720,7 +720,7 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
if (*((ARENA_FREE **)((char *)(pArena + 1) +
(pArena->size & ARENA_SIZE_MASK)) - 1) != pArena)
{
ERR(heap, "Heap %08lx: arena %08lx has wrong back ptr %08lx\n",
ERR("Heap %08lx: arena %08lx has wrong back ptr %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena,
*((DWORD *)((char *)(pArena+1)+ (pArena->size & ARENA_SIZE_MASK)) - 1));
return FALSE;
@ -740,20 +740,20 @@ static BOOL HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena )
/* Check magic number */
if (pArena->magic != ARENA_INUSE_MAGIC)
{
ERR(heap, "Heap %08lx: invalid in-use arena magic for %08lx\n",
ERR("Heap %08lx: invalid in-use arena magic for %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena );
return FALSE;
}
/* Check size flags */
if (pArena->size & ARENA_FLAG_FREE)
{
ERR(heap, "Heap %08lx: bad flags %lx for in-use arena %08lx\n",
ERR("Heap %08lx: bad flags %lx for in-use arena %08lx\n",
(DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
}
/* Check arena size */
if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
ERR(heap, "Heap %08lx: bad size %08lx for in-use arena %08lx\n",
ERR("Heap %08lx: bad size %08lx for in-use arena %08lx\n",
(DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
return FALSE;
}
@ -761,7 +761,7 @@ static BOOL HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena )
if (((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd) &&
(*(DWORD *)((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
{
ERR(heap, "Heap %08lx: in-use arena %08lx next block has PREV_FREE flag\n",
ERR("Heap %08lx: in-use arena %08lx next block has PREV_FREE flag\n",
(DWORD)subheap->heap, (DWORD)pArena );
return FALSE;
}
@ -772,7 +772,7 @@ static BOOL HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena )
/* Check prev pointer */
if (!HEAP_IsValidArenaPtr( subheap->heap, pPrev ))
{
ERR(heap, "Heap %08lx: bad back ptr %08lx for arena %08lx\n",
ERR("Heap %08lx: bad back ptr %08lx for arena %08lx\n",
(DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
return FALSE;
}
@ -780,14 +780,14 @@ static BOOL HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena )
if (!(pPrev->size & ARENA_FLAG_FREE) ||
(pPrev->magic != ARENA_FREE_MAGIC))
{
ERR(heap, "Heap %08lx: prev arena %08lx invalid for in-use %08lx\n",
ERR("Heap %08lx: prev arena %08lx invalid for in-use %08lx\n",
(DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
return FALSE;
}
/* Check that prev arena is really the previous block */
if ((char *)(pPrev + 1) + (pPrev->size & ARENA_SIZE_MASK) != (char *)pArena)
{
ERR(heap, "Heap %08lx: prev arena %08lx is not prev for in-use %08lx\n",
ERR("Heap %08lx: prev arena %08lx is not prev for in-use %08lx\n",
(DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
return FALSE;
}
@ -847,7 +847,7 @@ SEGPTR HEAP_GetSegptr( HANDLE heap, DWORD flags, LPCVOID ptr )
flags |= heapPtr->flags;
if (!(flags & HEAP_WINE_SEGPTR))
{
ERR(heap, "Heap %08x is not a SEGPTR heap\n",
ERR("Heap %08x is not a SEGPTR heap\n",
heap );
return 0;
}
@ -857,7 +857,7 @@ SEGPTR HEAP_GetSegptr( HANDLE heap, DWORD flags, LPCVOID ptr )
if (!(subheap = HEAP_FindSubHeap( heapPtr, ptr )))
{
ERR(heap, "%p is not inside heap %08x\n",
ERR("%p is not inside heap %08x\n",
ptr, heap );
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
return 0;
@ -912,7 +912,7 @@ BOOL WINAPI HeapDestroy(
HEAP *heapPtr = HEAP_GetPtr( heap );
SUBHEAP *subheap;
TRACE(heap, "%08x\n", heap );
TRACE("%08x\n", heap );
if (!heapPtr) return FALSE;
DeleteCriticalSection( &heapPtr->critSection );
@ -957,7 +957,7 @@ LPVOID WINAPI HeapAlloc(
if (!(pArena = HEAP_FindFreeBlock( heapPtr, size, &subheap )))
{
TRACE(heap, "(%08x,%08lx,%08lx): returning NULL\n",
TRACE("(%08x,%08lx,%08lx): returning NULL\n",
heap, flags, size );
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
SetLastError( ERROR_COMMITMENT_LIMIT );
@ -987,7 +987,7 @@ LPVOID WINAPI HeapAlloc(
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
TRACE(heap, "(%08x,%08lx,%08lx): returning %08lx\n",
TRACE("(%08x,%08lx,%08lx): returning %08lx\n",
heap, flags, size, (DWORD)(pInUse + 1) );
return (LPVOID)(pInUse + 1);
}
@ -1016,14 +1016,14 @@ BOOL WINAPI HeapFree(
if (!(flags & HEAP_NO_SERIALIZE)) HeapLock( heap );
if (!ptr)
{
WARN(heap, "(%08x,%08lx,%08lx): asked to free NULL\n",
WARN("(%08x,%08lx,%08lx): asked to free NULL\n",
heap, flags, (DWORD)ptr );
}
if (!ptr || !HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
{
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
SetLastError( ERROR_INVALID_PARAMETER );
TRACE(heap, "(%08x,%08lx,%08lx): returning FALSE\n",
TRACE("(%08x,%08lx,%08lx): returning FALSE\n",
heap, flags, (DWORD)ptr );
return FALSE;
}
@ -1037,7 +1037,7 @@ BOOL WINAPI HeapFree(
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
/* SetLastError( 0 ); */
TRACE(heap, "(%08x,%08lx,%08lx): returning TRUE\n",
TRACE("(%08x,%08lx,%08lx): returning TRUE\n",
heap, flags, (DWORD)ptr );
return TRUE;
}
@ -1076,7 +1076,7 @@ LPVOID WINAPI HeapReAlloc(
{
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
SetLastError( ERROR_INVALID_PARAMETER );
TRACE(heap, "(%08x,%08lx,%08lx,%08lx): returning NULL\n",
TRACE("(%08x,%08lx,%08lx,%08lx): returning NULL\n",
heap, flags, (DWORD)ptr, size );
return NULL;
}
@ -1160,7 +1160,7 @@ LPVOID WINAPI HeapReAlloc(
pArena->callerEIP = GET_EIP();
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
TRACE(heap, "(%08x,%08lx,%08lx,%08lx): returning %08lx\n",
TRACE("(%08x,%08lx,%08lx,%08lx): returning %08lx\n",
heap, flags, (DWORD)ptr, size, (DWORD)(pArena + 1) );
return (LPVOID)(pArena + 1);
}
@ -1242,7 +1242,7 @@ DWORD WINAPI HeapSize(
}
if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
TRACE(heap, "(%08x,%08lx,%08lx): returning %08lx\n",
TRACE("(%08x,%08lx,%08lx): returning %08lx\n",
heap, flags, (DWORD)ptr, ret );
return ret;
}
@ -1270,7 +1270,7 @@ BOOL WINAPI HeapValidate(
if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
{
ERR(heap, "Invalid heap %08x!\n", heap );
ERR("Invalid heap %08x!\n", heap );
return FALSE;
}
@ -1286,7 +1286,7 @@ BOOL WINAPI HeapValidate(
((char *)block < (char *)subheap + subheap->headerSize
+ sizeof(ARENA_INUSE)))
{
ERR(heap, "Heap %08lx: block %08lx is not inside heap\n",
ERR("Heap %08lx: block %08lx is not inside heap\n",
(DWORD)heap, (DWORD)block );
ret = FALSE;
} else
@ -1340,7 +1340,7 @@ BOOL WINAPI HeapWalk(
HANDLE heap, /* [in] Handle to heap to enumerate */
LPPROCESS_HEAP_ENTRY *entry /* [out] Pointer to structure of enumeration info */
) {
FIXME(heap, "(%08x): stub.\n", heap );
FIXME("(%08x): stub.\n", heap );
return FALSE;
}
@ -1355,7 +1355,7 @@ LPVOID HEAP_xalloc( HANDLE heap, DWORD flags, DWORD size )
LPVOID p = HeapAlloc( heap, flags, size );
if (!p)
{
MSG("Virtual memory exhausted.\n" );
MESSAGE("Virtual memory exhausted.\n" );
exit(1);
}
SET_EIP(p);
@ -1373,7 +1373,7 @@ LPVOID HEAP_xrealloc( HANDLE heap, DWORD flags, LPVOID lpMem, DWORD size )
LPVOID p = HeapReAlloc( heap, flags, lpMem, size );
if (!p)
{
MSG("Virtual memory exhausted.\n" );
MESSAGE("Virtual memory exhausted.\n" );
exit(1);
}
SET_EIP(p);
@ -1701,7 +1701,7 @@ DWORD WINAPI Local32Alloc16( HANDLE heap, DWORD size, INT16 type, DWORD flags )
break;
if (page == HTABLE_NPAGES)
{
WARN( heap, "Out of handles!\n" );
WARN("Out of handles!\n" );
HeapFree( header->heap, 0, ptr );
return 0;
}
@ -1712,7 +1712,7 @@ DWORD WINAPI Local32Alloc16( HANDLE heap, DWORD size, INT16 type, DWORD flags )
if ( !VirtualAlloc( (LPBYTE)header + (page << 12),
0x1000, MEM_COMMIT, PAGE_READWRITE ) )
{
WARN( heap, "Cannot grow handle table!\n" );
WARN("Cannot grow handle table!\n" );
HeapFree( header->heap, 0, ptr );
return 0;
}
@ -1968,7 +1968,7 @@ BOOL16 WINAPI Local32Info16( LOCAL32INFO *pLocal32Info, HGLOBAL16 handle )
*/
BOOL16 WINAPI Local32First16( LOCAL32ENTRY *pLocal32Entry, HGLOBAL16 handle )
{
FIXME( heap, "(%p, %04X): stub!\n", pLocal32Entry, handle );
FIXME("(%p, %04X): stub!\n", pLocal32Entry, handle );
return FALSE;
}
@ -1977,7 +1977,7 @@ BOOL16 WINAPI Local32First16( LOCAL32ENTRY *pLocal32Entry, HGLOBAL16 handle )
*/
BOOL16 WINAPI Local32Next16( LOCAL32ENTRY *pLocal32Entry )
{
FIXME( heap, "(%p): stub!\n", pLocal32Entry );
FIXME("(%p): stub!\n", pLocal32Entry );
return FALSE;
}

10
memory/ldt.c
View File

@ -9,7 +9,7 @@
#include <string.h>
#include <errno.h>
#include "ldt.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ldt)
@ -148,7 +148,7 @@ int LDT_SetEntry( int entry, const ldt_entry *content )
{
int ret = 0;
TRACE(ldt, "entry=%04x base=%08lx limit=%05lx %s %d-bit "
TRACE("entry=%04x base=%08lx limit=%05lx %s %d-bit "
"flags=%c%c%c\n", entry, content->base, content->limit,
content->limit_in_pages ? "pages" : "bytes",
content->seg_32bit ? 32 : 16,
@ -183,7 +183,7 @@ int LDT_SetEntry( int entry, const ldt_entry *content )
{
if (ldt_info.base_addr >= 0xc0000000)
{
WARN(ldt, "Invalid base addr %08lx\n",
WARN("Invalid base addr %08lx\n",
ldt_info.base_addr );
return -1;
}
@ -213,7 +213,7 @@ int LDT_SetEntry( int entry, const ldt_entry *content )
if (ret < 0)
{
perror("i386_set_ldt");
MSG("Did you reconfigure the kernel with \"options USER_LDT\"?\n");
MESSAGE("Did you reconfigure the kernel with \"options USER_LDT\"?\n");
exit(1);
}
}
@ -287,7 +287,7 @@ void LDT_Print( int start, int length )
flags[1] = (ldt_flags_copy[i] & LDT_FLAGS_READONLY) ? '-' : 'w';
flags[2] = '-';
}
MSG("%04x: sel=%04x base=%08lx limit=%08lx %d-bit %c%c%c\n",
MESSAGE("%04x: sel=%04x base=%08lx limit=%08lx %d-bit %c%c%c\n",
i, ENTRY_TO_SELECTOR(i), ldt_copy[i].base, ldt_copy[i].limit,
ldt_flags_copy[i] & LDT_FLAGS_32BIT ? 32 : 16,
flags[0], flags[1], flags[2] );

12
memory/selector.c
View File

@ -11,7 +11,7 @@
#include "selectors.h"
#include "stackframe.h"
#include "process.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(selector)
@ -59,7 +59,7 @@ WORD WINAPI AllocSelector16( WORD sel )
count = sel ? ((GET_SEL_LIMIT(sel) >> 16) + 1) : 1;
newsel = AllocSelectorArray16( count );
TRACE(selector, "(%04x): returning %04x\n",
TRACE("(%04x): returning %04x\n",
sel, newsel );
if (!newsel) return 0;
if (!sel) return newsel; /* nothing to copy */
@ -166,7 +166,7 @@ void SELECTOR_FreeBlock( WORD sel, WORD count )
WORD i, nextsel;
ldt_entry entry;
TRACE(selector, "(%04x,%d)\n", sel, count );
TRACE("(%04x,%d)\n", sel, count );
sel &= ~(__AHINCR - 1); /* clear bottom bits of selector */
nextsel = sel + (count << __AHSHIFT);
@ -178,7 +178,7 @@ void SELECTOR_FreeBlock( WORD sel, WORD count )
GET_FS(fs);
if ((fs >= sel) && (fs < nextsel))
{
WARN(selector, "Freeing %%fs selector (%04x), not good.\n", fs );
WARN("Freeing %%fs selector (%04x), not good.\n", fs );
SET_FS( 0 );
}
GET_GS(gs);
@ -262,7 +262,7 @@ WORD WINAPI AllocCStoDSAlias16( WORD sel )
ldt_entry entry;
newsel = AllocSelectorArray16( 1 );
TRACE(selector, "(%04x): returning %04x\n",
TRACE("(%04x): returning %04x\n",
sel, newsel );
if (!newsel) return 0;
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
@ -281,7 +281,7 @@ WORD WINAPI AllocDStoCSAlias16( WORD sel )
ldt_entry entry;
newsel = AllocSelectorArray16( 1 );
TRACE(selector, "(%04x): returning %04x\n",
TRACE("(%04x): returning %04x\n",
sel, newsel );
if (!newsel) return 0;
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );

72
memory/string.c
View File

@ -12,7 +12,7 @@
#include "wine/keyboard16.h"
#include "winerror.h"
#include "ldt.h"
#include "debug.h"
#include "debugtools.h"
#include "winnls.h"
DEFAULT_DEBUG_CHANNEL(string)
@ -87,7 +87,7 @@ SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
*/
LPSTR WINAPI lstrcatA( LPSTR dst, LPCSTR src )
{
TRACE(string,"Append %s to %s\n",
TRACE("Append %s to %s\n",
debugstr_a (src), debugstr_a (dst));
/* Windows does not check for NULL pointers here, so we don't either */
strcat( dst, src );
@ -101,7 +101,7 @@ LPSTR WINAPI lstrcatA( LPSTR dst, LPCSTR src )
LPWSTR WINAPI lstrcatW( LPWSTR dst, LPCWSTR src )
{
register LPWSTR p = dst;
TRACE(string,"Append L%s to L%s\n",
TRACE("Append L%s to L%s\n",
debugstr_w (src), debugstr_w (dst));
/* Windows does not check for NULL pointers here, so we don't either */
while (*p) p++;
@ -126,7 +126,7 @@ SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
LPSTR WINAPI lstrcatnA( LPSTR dst, LPCSTR src, INT n )
{
register LPSTR p = dst;
TRACE(string,"strcatn add %d chars from %s to %s\n",
TRACE("strcatn add %d chars from %s to %s\n",
n, debugstr_an (src, n), debugstr_a (dst));
while (*p) p++;
if ((n -= (INT)(p - dst)) <= 0) return dst;
@ -141,7 +141,7 @@ LPSTR WINAPI lstrcatnA( LPSTR dst, LPCSTR src, INT n )
LPWSTR WINAPI lstrcatnW( LPWSTR dst, LPCWSTR src, INT n )
{
register LPWSTR p = dst;
TRACE(string,"strcatn add %d chars from L%s to L%s\n",
TRACE("strcatn add %d chars from L%s to L%s\n",
n, debugstr_wn (src, n), debugstr_w (dst));
while (*p) p++;
if ((n -= (INT)(p - dst)) <= 0) return dst;
@ -175,7 +175,7 @@ INT WINAPI lstrcmpA( LPCSTR str1, LPCSTR str2 )
*/
INT WINAPI lstrcmpW( LPCWSTR str1, LPCWSTR str2 )
{
TRACE(string,"L%s and L%s\n",
TRACE("L%s and L%s\n",
debugstr_w (str1), debugstr_w (str2));
if (!str1 || !str2) {
SetLastError(ERROR_INVALID_PARAMETER);
@ -199,7 +199,7 @@ INT16 WINAPI lstrcmpi16( LPCSTR str1, LPCSTR str2 )
* lstrcmpi32A (KERNEL32.605)
*/
INT WINAPI lstrcmpiA( LPCSTR str1, LPCSTR str2 )
{ TRACE(string,"strcmpi %s and %s\n",
{ TRACE("strcmpi %s and %s\n",
debugstr_a (str1), debugstr_a (str2));
return CompareStringA(LOCALE_SYSTEM_DEFAULT,NORM_IGNORECASE,str1,-1,str2,-1)-2;
}
@ -214,7 +214,7 @@ INT WINAPI lstrcmpiW( LPCWSTR str1, LPCWSTR str2 )
#if 0
/* Too much! (From registry loading.) */
TRACE(string,"strcmpi L%s and L%s\n",
TRACE("strcmpi L%s and L%s\n",
debugstr_w (str1), debugstr_w (str2));
#endif
if (!str1 || !str2) {
@ -250,7 +250,7 @@ SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
*/
LPSTR WINAPI lstrcpyA( LPSTR dst, LPCSTR src )
{
TRACE(string,"strcpy %s\n", debugstr_a (src));
TRACE("strcpy %s\n", debugstr_a (src));
/* In real windows the whole function is protected by an exception handler
* that returns ERROR_INVALID_PARAMETER on faulty parameters
* We currently just check for NULL.
@ -271,7 +271,7 @@ LPSTR WINAPI lstrcpyA( LPSTR dst, LPCSTR src )
LPWSTR WINAPI lstrcpyW( LPWSTR dst, LPCWSTR src )
{
register LPWSTR p = dst;
TRACE(string,"strcpy L%s\n", debugstr_w (src));
TRACE("strcpy L%s\n", debugstr_w (src));
/* In real windows the whole function is protected by an exception handler
* that returns ERROR_INVALID_PARAMETER on faulty parameters
* We currently just check for NULL.
@ -303,7 +303,7 @@ SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
LPSTR WINAPI lstrcpynA( LPSTR dst, LPCSTR src, INT n )
{
LPSTR p = dst;
TRACE(string,"strcpyn %s for %d chars\n",
TRACE("strcpyn %s for %d chars\n",
debugstr_an (src,n), n);
/* In real windows the whole function is protected by an exception handler
* that returns ERROR_INVALID_PARAMETER on faulty parameters
@ -327,7 +327,7 @@ LPSTR WINAPI lstrcpynA( LPSTR dst, LPCSTR src, INT n )
LPWSTR WINAPI lstrcpynW( LPWSTR dst, LPCWSTR src, INT n )
{
LPWSTR p = dst;
TRACE(string,"strcpyn L%s for %d chars\n",
TRACE("strcpyn L%s for %d chars\n",
debugstr_wn (src,n), n);
/* In real windows the whole function is protected by an exception handler
* that returns ERROR_INVALID_PARAMETER on faulty parameters
@ -361,7 +361,7 @@ INT WINAPI lstrlenA( LPCSTR str )
* in lstrlen() ... we check only for NULL pointer reference.
* - Marcus Meissner
*/
TRACE(string,"strlen %s\n", debugstr_a (str));
TRACE("strlen %s\n", debugstr_a (str));
if (!str) return 0;
return (INT)strlen(str);
}
@ -373,7 +373,7 @@ INT WINAPI lstrlenA( LPCSTR str )
INT WINAPI lstrlenW( LPCWSTR str )
{
INT len = 0;
TRACE(string,"strlen L%s\n", debugstr_w (str));
TRACE("strlen L%s\n", debugstr_w (str));
if (!str) return 0;
while (*str++) len++;
return len;
@ -385,7 +385,7 @@ INT WINAPI lstrlenW( LPCWSTR str )
*/
INT WINAPI lstrncmpA( LPCSTR str1, LPCSTR str2, INT n )
{
TRACE(string,"strncmp %s and %s for %d chars\n",
TRACE("strncmp %s and %s for %d chars\n",
debugstr_an (str1, n), debugstr_an (str2, n), n);
return (INT)strncmp( str1, str2, n );
}
@ -396,7 +396,7 @@ INT WINAPI lstrncmpA( LPCSTR str1, LPCSTR str2, INT n )
*/
INT WINAPI lstrncmpW( LPCWSTR str1, LPCWSTR str2, INT n )
{
TRACE(string,"strncmp L%s and L%s for %d chars\n",
TRACE("strncmp L%s and L%s for %d chars\n",
debugstr_wn (str1, n), debugstr_wn (str2, n), n);
if (!n) return 0;
while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
@ -411,7 +411,7 @@ INT WINAPI lstrncmpiA( LPCSTR str1, LPCSTR str2, INT n )
{
INT res;
TRACE(string,"strncmpi %s and %s for %d chars\n",
TRACE("strncmpi %s and %s for %d chars\n",
debugstr_an (str1, n), debugstr_an (str2, n), n);
if (!n) return 0;
while ((--n > 0) && *str1)
@ -428,7 +428,7 @@ INT WINAPI lstrncmpiW( LPCWSTR str1, LPCWSTR str2, INT n )
{
INT res;
TRACE(string,"strncmpi L%s and L%s for %d chars\n",
TRACE("strncmpi L%s and L%s for %d chars\n",
debugstr_wn (str1, n), debugstr_wn (str2, n), n);
if (!n) return 0;
while ((--n > 0) && *str1)
@ -448,7 +448,7 @@ LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
{
register LPWSTR p = dst;
TRACE(string,"%s\n",src);
TRACE("%s\n",src);
while ((*p++ = (WCHAR)(unsigned char)*src++));
return dst;
@ -462,7 +462,7 @@ LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
{
register LPSTR p = dst;
TRACE(string,"L%s\n",debugstr_w(src));
TRACE("L%s\n",debugstr_w(src));
while ((*p++ = (CHAR)*src++));
return dst;
@ -478,7 +478,7 @@ LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT n )
{
LPWSTR p = dst;
TRACE(string,"%s %i\n",src, n);
TRACE("%s %i\n",src, n);
while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
if (n >= 0) *p = 0;
@ -495,7 +495,7 @@ LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT n )
{
LPSTR p = dst;
TRACE(string,"L%s %i\n",debugstr_w(src), n);
TRACE("L%s %i\n",debugstr_w(src), n);
while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
if (n >= 0) *p = 0;
@ -508,7 +508,7 @@ LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT n )
INT16 WINAPI UnicodeToAnsi16( LPCWSTR src, LPSTR dst, INT16 codepage )
{
if ( codepage != -1 )
FIXME( string, "codepage %d not supported\n", codepage );
FIXME("codepage %d not supported\n", codepage );
lstrcpyWtoA( dst, src );
@ -597,9 +597,9 @@ BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
{
LPSTR oldd = d;
if (!s || !d) return TRUE;
TRACE(string,"CharToOem %s\n", debugstr_a (s));
TRACE("CharToOem %s\n", debugstr_a (s));
while ((*d++ = ANSI_TO_OEM(*s++)));
TRACE(string," to %s\n", debugstr_a (oldd));
TRACE(" to %s\n", debugstr_a (oldd));
return TRUE;
}
@ -631,9 +631,9 @@ BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
{
LPSTR oldd = d;
if (!s || !d) return TRUE;
TRACE(string,"CharToOem L%s\n", debugstr_w (s));
TRACE("CharToOem L%s\n", debugstr_w (s));
while ((*d++ = ANSI_TO_OEM(*s++)));
TRACE(string," to %s\n", debugstr_a (oldd));
TRACE(" to %s\n", debugstr_a (oldd));
return TRUE;
}
@ -644,9 +644,9 @@ BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
{
LPSTR oldd = d;
TRACE(string,"OemToChar %s\n", debugstr_a (s));
TRACE("OemToChar %s\n", debugstr_a (s));
while ((*d++ = OEM_TO_ANSI(*s++)));
TRACE(string," to %s\n", debugstr_a (oldd));
TRACE(" to %s\n", debugstr_a (oldd));
return TRUE;
}
@ -656,7 +656,7 @@ BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
*/
BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
{
TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
TRACE("OemToCharBuff %s\n", debugstr_an (s, len));
while (len--) *d++ = OEM_TO_ANSI(*s++);
return TRUE;
}
@ -667,7 +667,7 @@ BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
*/
BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
{
TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
TRACE("OemToCharBuff %s\n", debugstr_an (s, len));
while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
return TRUE;
}
@ -695,7 +695,7 @@ INT WINAPI WideCharToLocal(
LPWSTR pWide,
INT dwChars)
{ *pLocal = 0;
TRACE(string,"(%p, %s, %i)\n", pLocal, debugstr_w(pWide),dwChars);
TRACE("(%p, %s, %i)\n", pLocal, debugstr_w(pWide),dwChars);
WideCharToMultiByte(CP_ACP,0,pWide,-1,pLocal,dwChars,NULL,NULL);
return strlen(pLocal);
}
@ -711,7 +711,7 @@ INT WINAPI LocalToWideChar(
LPSTR pLocal,
INT dwChars)
{ *pWide = 0;
TRACE(string,"(%p, %s, %i)\n",pWide, pLocal, dwChars);
TRACE("(%p, %s, %i)\n",pWide, pLocal, dwChars);
MultiByteToWideChar(CP_ACP,0,pLocal,-1,pWide,dwChars);
return lstrlenW(pWide);
}
@ -730,7 +730,7 @@ LPSTR WINAPI lstrrchr( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
{
LPCSTR lpGotIt = NULL;
TRACE(string,"(%s, %s)\n", lpStart, lpEnd);
TRACE("(%s, %s)\n", lpStart, lpEnd);
if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
@ -754,7 +754,7 @@ LPWSTR WINAPI lstrrchrw( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch )
{
LPCWSTR lpGotIt = NULL;
TRACE(string,"(%p, %p, %c)\n", lpStart, lpEnd, wMatch);
TRACE("(%p, %p, %c)\n", lpStart, lpEnd, wMatch);
if (!lpEnd) lpEnd = lpStart + lstrlenW(lpStart);
for(; lpStart < lpEnd; lpStart = CharNextW(lpStart))
@ -775,7 +775,7 @@ LPWSTR WINAPI strstrw( LPCWSTR lpFirst, LPCWSTR lpSrch) {
UINT uSrchLen = (UINT)lstrlenW(lpSrch);
WORD wMatchBeg = *(WORD*)lpSrch;
TRACE(string,"(%p, %p)\n", lpFirst, lpSrch);
TRACE("(%p, %p)\n", lpFirst, lpSrch);
for(;
((lpFirst=CRTDLL_wcschr(lpFirst, wMatchBeg))!=0) &&

36
memory/virtual.c
View File

@ -21,7 +21,7 @@
#include "xmalloc.h"
#include "global.h"
#include "server.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(virtual)
@ -118,18 +118,18 @@ static void VIRTUAL_DumpView( FILE_VIEW *view )
UINT addr = view->base;
BYTE prot = view->prot[0];
DUMP( "View: %08x - %08x%s",
DPRINTF( "View: %08x - %08x%s",
view->base, view->base + view->size - 1,
(view->flags & VFLAG_SYSTEM) ? " (system)" : "" );
if (view->mapping)
DUMP( " %d @ %08x\n", view->mapping, view->offset );
DPRINTF( " %d @ %08x\n", view->mapping, view->offset );
else
DUMP( " (anonymous)\n");
DPRINTF( " (anonymous)\n");
for (count = i = 1; i < view->size >> page_shift; i++, count++)
{
if (view->prot[i] == prot) continue;
DUMP( " %08x - %08x %s\n",
DPRINTF( " %08x - %08x %s\n",
addr, addr + (count << page_shift) - 1,
VIRTUAL_GetProtStr(prot) );
addr += (count << page_shift);
@ -137,7 +137,7 @@ static void VIRTUAL_DumpView( FILE_VIEW *view )
count = 0;
}
if (count)
DUMP( " %08x - %08x %s\n",
DPRINTF( " %08x - %08x %s\n",
addr, addr + (count << page_shift) - 1,
VIRTUAL_GetProtStr(prot) );
}
@ -149,7 +149,7 @@ static void VIRTUAL_DumpView( FILE_VIEW *view )
void VIRTUAL_Dump(void)
{
FILE_VIEW *view = VIRTUAL_FirstView;
DUMP( "\nDump of all virtual memory views:\n\n" );
DPRINTF( "\nDump of all virtual memory views:\n\n" );
while (view)
{
VIRTUAL_DumpView( view );
@ -365,7 +365,7 @@ static BOOL VIRTUAL_SetProt(
UINT size, /* [in] Size in bytes */
BYTE vprot /* [in] Protections to use */
) {
TRACE(virtual, "%08x-%08x %s\n",
TRACE("%08x-%08x %s\n",
base, base + size - 1, VIRTUAL_GetProtStr( vprot ) );
if (mprotect( (void *)base, size, VIRTUAL_GetUnixProt(vprot) ))
@ -533,7 +533,7 @@ LPVOID WINAPI VirtualAlloc(
UINT base, ptr, view_size;
BYTE vprot;
TRACE(virtual, "%08x %08lx %lx %08lx\n",
TRACE("%08x %08lx %lx %08lx\n",
(UINT)addr, size, type, protect );
/* Round parameters to a page boundary */
@ -566,7 +566,7 @@ LPVOID WINAPI VirtualAlloc(
/* FIXME: MEM_TOP_DOWN allocates the largest possible address.
* Is there _ANY_ way to do it with UNIX mmap()?
*/
WARN(virtual,"MEM_TOP_DOWN ignored\n");
WARN("MEM_TOP_DOWN ignored\n");
type &= ~MEM_TOP_DOWN;
}
/* Compute the protection flags */
@ -655,7 +655,7 @@ BOOL WINAPI VirtualFree(
FILE_VIEW *view;
UINT base;
TRACE(virtual, "%08x %08lx %lx\n",
TRACE("%08x %08lx %lx\n",
(UINT)addr, size, type );
/* Fix the parameters */
@ -752,7 +752,7 @@ BOOL WINAPI VirtualProtect(
UINT base, i;
BYTE vprot, *p;
TRACE(virtual, "%08x %08lx %08lx\n",
TRACE("%08x %08lx %08lx\n",
(UINT)addr, size, new_prot );
/* Fix the parameters */
@ -803,7 +803,7 @@ BOOL WINAPI VirtualProtectEx(
{
if (PROCESS_IsCurrent( handle ))
return VirtualProtect( addr, size, new_prot, old_prot );
ERR(virtual,"Unsupported on other process\n");
ERR("Unsupported on other process\n");
return FALSE;
}
@ -892,7 +892,7 @@ DWORD WINAPI VirtualQueryEx(
{
if (PROCESS_IsCurrent( handle ))
return VirtualQuery( addr, info, len );
ERR(virtual,"Unsupported on other process\n");
ERR("Unsupported on other process\n");
return 0;
}
@ -1057,7 +1057,7 @@ HANDLE WINAPI CreateFileMappingA(
/* Check parameters */
TRACE(virtual,"(%x,%p,%08lx,%08lx%08lx,%s)\n",
TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
hFile, sa, protect, size_high, size_low, debugstr_a(name) );
vprot = VIRTUAL_GetProt( protect );
@ -1202,7 +1202,7 @@ LPVOID WINAPI MapViewOfFileEx(
goto error;
if (info.size_high || offset_high)
ERR(virtual, "Offsets larger than 4Gb not supported\n");
ERR("Offsets larger than 4Gb not supported\n");
if ((offset_low >= info.size_low) ||
(count > info.size_low - offset_low))
@ -1237,7 +1237,7 @@ LPVOID WINAPI MapViewOfFileEx(
/* Map the file */
TRACE(virtual, "handle=%x size=%x offset=%lx\n",
TRACE("handle=%x size=%x offset=%lx\n",
handle, size, offset_low );
ptr = (UINT)FILE_dommap( unix_handle,
@ -1289,7 +1289,7 @@ BOOL WINAPI FlushViewOfFile(
FILE_VIEW *view;
UINT addr = ROUND_ADDR( base );
TRACE(virtual, "FlushViewOfFile at %p for %ld bytes\n",
TRACE("FlushViewOfFile at %p for %ld bytes\n",
base, cbFlush );
if (!(view = VIRTUAL_FindView( addr )))

24
objects/brush.c
View File

@ -8,7 +8,7 @@
#include "winbase.h"
#include "brush.h"
#include "bitmap.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(gdi)
@ -26,7 +26,7 @@ HBRUSH16 WINAPI CreateBrushIndirect16( const LOGBRUSH16 * brush )
brushPtr->logbrush.lbColor = brush->lbColor;
brushPtr->logbrush.lbHatch = brush->lbHatch;
GDI_HEAP_UNLOCK( hbrush );
TRACE(gdi, "%04x\n", hbrush);
TRACE("%04x\n", hbrush);
return hbrush;
}
@ -44,7 +44,7 @@ HBRUSH WINAPI CreateBrushIndirect( const LOGBRUSH * brush )
brushPtr->logbrush.lbColor = brush->lbColor;
brushPtr->logbrush.lbHatch = brush->lbHatch;
GDI_HEAP_UNLOCK( hbrush );
TRACE(gdi, "%08x\n", hbrush);
TRACE("%08x\n", hbrush);
return hbrush;
}
@ -56,7 +56,7 @@ HBRUSH16 WINAPI CreateHatchBrush16( INT16 style, COLORREF color )
{
LOGBRUSH logbrush;
TRACE(gdi, "%d %06lx\n", style, color );
TRACE("%d %06lx\n", style, color );
logbrush.lbStyle = BS_HATCHED;
logbrush.lbColor = color;
@ -74,7 +74,7 @@ HBRUSH WINAPI CreateHatchBrush( INT style, COLORREF color )
{
LOGBRUSH logbrush;
TRACE(gdi, "%d %06lx\n", style, color );
TRACE("%d %06lx\n", style, color );
logbrush.lbStyle = BS_HATCHED;
logbrush.lbColor = color;
@ -100,7 +100,7 @@ HBRUSH16 WINAPI CreatePatternBrush16( HBITMAP16 hbitmap )
HBRUSH WINAPI CreatePatternBrush( HBITMAP hbitmap )
{
LOGBRUSH logbrush = { BS_PATTERN, 0, 0 };
TRACE(gdi, "%04x\n", hbitmap );
TRACE("%04x\n", hbitmap );
logbrush.lbHatch = (INT)BITMAP_CopyBitmap( hbitmap );
if(!logbrush.lbHatch)
@ -119,7 +119,7 @@ HBRUSH16 WINAPI CreateDIBPatternBrush16( HGLOBAL16 hbitmap, UINT16 coloruse )
BITMAPINFO *info, *newInfo;
INT size;
TRACE(gdi, "%04x\n", hbitmap );
TRACE("%04x\n", hbitmap );
logbrush.lbStyle = BS_DIBPATTERN;
logbrush.lbColor = coloruse;
@ -173,7 +173,7 @@ HBRUSH WINAPI CreateDIBPatternBrush(
BITMAPINFO *info, *newInfo;
INT size;
TRACE(gdi, "%04x\n", hbitmap );
TRACE("%04x\n", hbitmap );
logbrush.lbStyle = BS_DIBPATTERN;
logbrush.lbColor = coloruse;
@ -226,7 +226,7 @@ HBRUSH WINAPI CreateDIBPatternBrushPt(
BITMAPINFO *newInfo;
INT size;
TRACE(gdi, "%p %ldx%ld %dbpp\n", info, info->bmiHeader.biWidth,
TRACE("%p %ldx%ld %dbpp\n", info, info->bmiHeader.biWidth,
info->bmiHeader.biHeight, info->bmiHeader.biBitCount);
logbrush.lbStyle = BS_DIBPATTERN;
@ -262,7 +262,7 @@ HBRUSH16 WINAPI CreateSolidBrush16( COLORREF color )
{
LOGBRUSH logbrush;
TRACE(gdi, "%06lx\n", color );
TRACE("%06lx\n", color );
logbrush.lbStyle = BS_SOLID;
logbrush.lbColor = color;
@ -279,7 +279,7 @@ HBRUSH WINAPI CreateSolidBrush( COLORREF color )
{
LOGBRUSH logbrush;
TRACE(gdi, "%06lx\n", color );
TRACE("%06lx\n", color );
logbrush.lbStyle = BS_SOLID;
logbrush.lbColor = color;
@ -388,7 +388,7 @@ INT BRUSH_GetObject( BRUSHOBJ * brush, INT count, LPSTR buffer )
*/
BOOL16 WINAPI SetSolidBrush16(HBRUSH16 hBrush, COLORREF newColor )
{
FIXME(gdi, "(hBrush %04x, newColor %04x): stub!\n", hBrush, (int)newColor);
FIXME("(hBrush %04x, newColor %04x): stub!\n", hBrush, (int)newColor);
return(FALSE);
}

4
objects/color.c
View File

@ -6,7 +6,7 @@
*/
#include "color.h"
#include "debug.h"
#include "debugtools.h"
#include "palette.h"
#include "windef.h"
@ -165,7 +165,7 @@ COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF
{
if( (i = color & 0x0000ffff) >= size )
{
WARN(palette, "RGB(%lx) : idx %d is out of bounds, assuming NULL\n", color, i);
WARN("RGB(%lx) : idx %d is out of bounds, assuming NULL\n", color, i);
color = *(COLORREF*)palPalEntry;
}
else color = *(COLORREF*)(palPalEntry + i);

42
objects/dc.c
View File

@ -15,7 +15,7 @@
#include "dc.h"
#include "gdi.h"
#include "heap.h"
#include "debug.h"
#include "debugtools.h"
#include "font.h"
#include "winerror.h"
#include "wine/winuser16.h"
@ -226,7 +226,7 @@ HDC16 WINAPI GetDCState16( HDC16 hdc )
}
newdc = (DC *) GDI_HEAP_LOCK( handle );
TRACE(dc, "(%04x): returning %04x\n", hdc, handle );
TRACE("(%04x): returning %04x\n", hdc, handle );
newdc->w.flags = dc->w.flags | DC_SAVED;
newdc->w.devCaps = dc->w.devCaps;
@ -317,7 +317,7 @@ void WINAPI SetDCState16( HDC16 hdc, HDC16 hdcs )
GDI_HEAP_UNLOCK( hdcs );
return;
}
TRACE(dc, "%04x %04x\n", hdc, hdcs );
TRACE("%04x %04x\n", hdc, hdcs );
dc->w.flags = dcs->w.flags & ~DC_SAVED;
dc->w.devCaps = dcs->w.devCaps;
@ -436,7 +436,7 @@ INT WINAPI SaveDC( HDC hdc )
dcs->header.hNext = dc->header.hNext;
dc->header.hNext = hdcs;
TRACE(dc, "(%04x): returning %d\n", hdc, dc->saveLevel+1 );
TRACE("(%04x): returning %d\n", hdc, dc->saveLevel+1 );
ret = ++dc->saveLevel;
GDI_HEAP_UNLOCK( hdcs );
GDI_HEAP_UNLOCK( hdc );
@ -461,7 +461,7 @@ BOOL WINAPI RestoreDC( HDC hdc, INT level )
DC * dc, * dcs;
BOOL success;
TRACE(dc, "%04x %d\n", hdc, level );
TRACE("%04x %d\n", hdc, level );
dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(dc->funcs->pRestoreDC)
@ -518,13 +518,13 @@ HDC16 WINAPI CreateDC16( LPCSTR driver, LPCSTR device, LPCSTR output,
if (!(dc = DC_AllocDC( funcs ))) return 0;
dc->w.flags = 0;
TRACE(dc, "(driver=%s, device=%s, output=%s): returning %04x\n",
TRACE("(driver=%s, device=%s, output=%s): returning %04x\n",
debugstr_a(driver), debugstr_a(device), debugstr_a(output), dc->hSelf );
if (dc->funcs->pCreateDC &&
!dc->funcs->pCreateDC( dc, driver, device, output, initData ))
{
WARN(dc, "creation aborted by device\n" );
WARN("creation aborted by device\n" );
GDI_HEAP_FREE( dc->hSelf );
return 0;
}
@ -620,7 +620,7 @@ HDC WINAPI CreateCompatibleDC( HDC hdc )
if (!(dc = DC_AllocDC( funcs ))) return 0;
TRACE(dc, "(%04x): returning %04x\n",
TRACE("(%04x): returning %04x\n",
hdc, dc->hSelf );
/* Create default bitmap */
@ -637,7 +637,7 @@ HDC WINAPI CreateCompatibleDC( HDC hdc )
if (dc->funcs->pCreateDC &&
!dc->funcs->pCreateDC( dc, NULL, NULL, NULL, NULL ))
{
WARN(dc, "creation aborted by device\n");
WARN("creation aborted by device\n");
DeleteObject( hbitmap );
GDI_HEAP_FREE( dc->hSelf );
return 0;
@ -666,7 +666,7 @@ BOOL WINAPI DeleteDC( HDC hdc )
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
TRACE(dc, "%04x\n", hdc );
TRACE("%04x\n", hdc );
/* Call hook procedure to check whether is it OK to delete this DC */
if ( dc->hookProc && !(dc->w.flags & (DC_SAVED | DC_MEMORY))
@ -710,7 +710,7 @@ BOOL WINAPI DeleteDC( HDC hdc )
*/
HDC16 WINAPI ResetDC16( HDC16 hdc, const DEVMODEA *devmode )
{
FIXME(dc, "stub\n" );
FIXME("stub\n" );
return hdc;
}
@ -720,7 +720,7 @@ HDC16 WINAPI ResetDC16( HDC16 hdc, const DEVMODEA *devmode )
*/
HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
{
FIXME(dc, "stub\n" );
FIXME("stub\n" );
return hdc;
}
@ -730,7 +730,7 @@ HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
*/
HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
{
FIXME(dc, "stub\n" );
FIXME("stub\n" );
return hdc;
}
@ -784,7 +784,7 @@ INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
return 0;
}
TRACE(dc, "(%04x,%d): returning %d\n",
TRACE("(%04x,%d): returning %d\n",
hdc, cap, *(WORD *)(((char *)dc->w.devCaps) + cap) );
ret = *(WORD *)(((char *)dc->w.devCaps) + cap);
GDI_HEAP_UNLOCK( hdc );
@ -1194,7 +1194,7 @@ BOOL16 WINAPI SetDCHook( HDC16 hdc, FARPROC16 hookProc, DWORD dwHookData )
{
DC *dc = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC );
TRACE(dc, "hookProc %08x, default is %08x\n",
TRACE("hookProc %08x, default is %08x\n",
(UINT)hookProc, (UINT)DCHook16 );
if (!dc) return FALSE;
@ -1232,7 +1232,7 @@ WORD WINAPI SetHookFlags16(HDC16 hDC, WORD flags)
/* "Undocumented Windows" info is slightly confusing.
*/
TRACE(dc,"hDC %04x, flags %04x\n",hDC,flags);
TRACE("hDC %04x, flags %04x\n",hDC,flags);
if( flags & DCHF_INVALIDATEVISRGN )
dc->w.flags |= DC_DIRTY;
@ -1279,7 +1279,7 @@ UINT16 WINAPI GetBoundsRect16(HDC16 hdc, LPRECT16 rect, UINT16 flags)
*/
UINT WINAPI GetBoundsRect(HDC hdc, LPRECT rect, UINT flags)
{
FIXME(dc, "(): stub\n");
FIXME("(): stub\n");
return DCB_RESET; /* bounding rectangle always empty */
}
@ -1289,7 +1289,7 @@ UINT WINAPI GetBoundsRect(HDC hdc, LPRECT rect, UINT flags)
UINT16 WINAPI SetBoundsRect16(HDC16 hdc, const RECT16* rect, UINT16 flags)
{
if ( (flags & DCB_ACCUMULATE) || (flags & DCB_ENABLE) )
FIXME( dc, "(%04x, %p, %04x): stub\n", hdc, rect, flags );
FIXME("(%04x, %p, %04x): stub\n", hdc, rect, flags );
return DCB_RESET | DCB_DISABLE; /* bounding rectangle always empty and disabled*/
}
@ -1299,7 +1299,7 @@ UINT16 WINAPI SetBoundsRect16(HDC16 hdc, const RECT16* rect, UINT16 flags)
*/
UINT WINAPI SetBoundsRect(HDC hdc, const RECT* rect, UINT flags)
{
FIXME(dc, "(): stub\n");
FIXME("(): stub\n");
return DCB_DISABLE; /* bounding rectangle always empty */
}
@ -1312,7 +1312,7 @@ UINT WINAPI SetBoundsRect(HDC hdc, const RECT* rect, UINT flags)
*/
void WINAPI Death16(HDC16 hDC)
{
MSG("Death(%04x) called. Application enters text mode...\n", hDC);
MESSAGE("Death(%04x) called. Application enters text mode...\n", hDC);
}
/***********************************************************************
@ -1323,5 +1323,5 @@ void WINAPI Death16(HDC16 hDC)
void WINAPI Resurrection16(HDC16 hDC,
WORD w1, WORD w2, WORD w3, WORD w4, WORD w5, WORD w6)
{
MSG("Resurrection(%04x, %04x, %04x, %04x, %04x, %04x, %04x) called. Application left text mode.\n", hDC, w1, w2, w3, w4, w5, w6);
MESSAGE("Resurrection(%04x, %04x, %04x, %04x, %04x, %04x, %04x) called. Application left text mode.\n", hDC, w1, w2, w3, w4, w5, w6);
}

18
objects/dib.c
View File

@ -9,7 +9,7 @@
#include "bitmap.h"
#include "callback.h"
#include "dc.h"
#include "debug.h"
#include "debugtools.h"
#include "monitor.h"
#include "palette.h"
@ -35,7 +35,7 @@ int DIB_GetDIBWidthBytes( int width, int depth )
case 24: words = (width * 3 + 3)/4; break;
default:
WARN(bitmap, "(%d): Unsupported depth\n", depth );
WARN("(%d): Unsupported depth\n", depth );
/* fall through */
case 32:
words = width;
@ -107,7 +107,7 @@ int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
*compr = 0;
return 0;
}
WARN(bitmap, "(%ld): wrong size for header\n", header->biSize );
WARN("(%ld): wrong size for header\n", header->biSize );
return -1;
}
@ -253,7 +253,7 @@ INT WINAPI SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx,
ySrc, startscan, lines, bits,
info, coloruse );
else {
FIXME(bitmap, "unimplemented on hdc %08x\n", hdc);
FIXME("unimplemented on hdc %08x\n", hdc);
ret = 0;
}
@ -565,7 +565,7 @@ INT WINAPI GetDIBits(
}
}
TRACE(bitmap, "biSizeImage = %ld, biWidth = %ld, biHeight = %ld\n",
TRACE("biSizeImage = %ld, biWidth = %ld, biHeight = %ld\n",
info->bmiHeader.biSizeImage, info->bmiHeader.biWidth,
info->bmiHeader.biHeight);
@ -640,7 +640,7 @@ HBITMAP WINAPI CreateDIBitmap( HDC hdc, const BITMAPINFOHEADER *header,
}
else
{
WARN(bitmap, "(%ld): wrong size for data\n",
WARN("(%ld): wrong size for data\n",
data->bmiHeader.biSize );
return 0;
}
@ -736,7 +736,7 @@ void DIB_FixColorsToLoadflags(BITMAPINFO * bmi, UINT loadflags, BYTE pix)
if (bmi->bmiHeader.biSize == sizeof(BITMAPINFOHEADER)) incr = 4;
else if (bmi->bmiHeader.biSize == sizeof(BITMAPCOREHEADER)) incr = 3;
else {
WARN(bitmap, "Wrong bitmap header size!\n");
WARN("Wrong bitmap header size!\n");
return;
}
colors = bmi->bmiHeader.biClrUsed;
@ -752,11 +752,11 @@ void DIB_FixColorsToLoadflags(BITMAPINFO * bmi, UINT loadflags, BYTE pix)
case 4: pix = pix >> 4; break;
case 8: break;
default:
WARN(bitmap, "(%d): Unsupported depth\n", bmi->bmiHeader.biBitCount);
WARN("(%d): Unsupported depth\n", bmi->bmiHeader.biBitCount);
return;
}
if (pix >= colors) {
WARN(bitmap, "pixel has color index greater than biClrUsed!\n");
WARN("pixel has color index greater than biClrUsed!\n");
return;
}
if (loadflags & LR_LOADMAP3DCOLORS) c_W = c_F;

30
objects/enhmetafile.c
View File

@ -11,7 +11,7 @@
#include "wine/winestring.h"
#include "winerror.h"
#include "enhmetafile.h"
#include "debug.h"
#include "debugtools.h"
#include "heap.h"
DEFAULT_DEBUG_CHANNEL(enhmetafile)
@ -59,7 +59,7 @@ static ENHMETAHEADER *EMF_GetEnhMetaHeader( HENHMETAFILE hmf )
{
ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_GetObjPtr( hmf,
ENHMETAFILE_MAGIC );
TRACE(enhmetafile, "hmf %04x -> enhmetaObj %p\n", hmf, metaObj);
TRACE("hmf %04x -> enhmetaObj %p\n", hmf, metaObj);
return metaObj->emh;
}
@ -86,7 +86,7 @@ static HENHMETAFILE EMF_GetEnhMetaFile( HFILE hFile )
emh = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
if (emh->iType != EMR_HEADER || emh->dSignature != ENHMETA_SIGNATURE) {
WARN(enhmetafile, "Invalid emf header type 0x%08lx sig 0x%08lx.\n",
WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
emh->iType, emh->dSignature);
UnmapViewOfFile( emh );
CloseHandle( hMapping );
@ -110,7 +110,7 @@ HENHMETAFILE WINAPI GetEnhMetaFileA(
hFile = CreateFileA(lpszMetaFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE) {
WARN(enhmetafile,"could not open %s\n", lpszMetaFile);
WARN("could not open %s\n", lpszMetaFile);
return 0;
}
hmf = EMF_GetEnhMetaFile( hFile );
@ -130,7 +130,7 @@ HENHMETAFILE WINAPI GetEnhMetaFileW(
hFile = CreateFileW(lpszMetaFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE) {
WARN(enhmetafile,"could not open %s\n", debugstr_w(lpszMetaFile));
WARN("could not open %s\n", debugstr_w(lpszMetaFile));
return 0;
}
hmf = EMF_GetEnhMetaFile( hFile );
@ -268,14 +268,14 @@ BOOL WINAPI PlayEnhMetaFileRecord(
)
{
int type;
TRACE(enhmetafile,
TRACE(
"hdc = %08x, handletable = %p, record = %p, numHandles = %d\n",
hdc, handletable, mr, handles);
if (!mr) return FALSE;
type = mr->iType;
TRACE(enhmetafile, " type=%d\n", type);
TRACE(" type=%d\n", type);
switch(type)
{
case EMR_HEADER:
@ -402,7 +402,7 @@ BOOL WINAPI PlayEnhMetaFileRecord(
DWORD obj = mr->dParm[0];
DWORD style = mr->dParm[1], brush = mr->dParm[2];
LOGBRUSH *b = (LOGBRUSH *) &mr->dParm[3];
FIXME(enhmetafile, "Some ExtCreatePen args not handled\n");
FIXME("Some ExtCreatePen args not handled\n");
(handletable->objectHandle)[obj] =
ExtCreatePen(style, brush, b, 0, NULL);
break;
@ -451,7 +451,7 @@ BOOL WINAPI PlayEnhMetaFileRecord(
{
/* 0-3 : a bounding rectangle? */
INT count = mr->dParm[4];
FIXME(enhmetafile, "Some Polygon16 args not handled\n");
FIXME("Some Polygon16 args not handled\n");
Polygon16(hdc, (POINT16 *)&mr->dParm[5], count);
break;
}
@ -459,7 +459,7 @@ BOOL WINAPI PlayEnhMetaFileRecord(
{
/* 0-3 : a bounding rectangle? */
INT count = mr->dParm[4];
FIXME(enhmetafile, "Some Polyline16 args not handled\n");
FIXME("Some Polyline16 args not handled\n");
Polyline16(hdc, (POINT16 *)&mr->dParm[5], count);
break;
}
@ -506,14 +506,14 @@ BOOL WINAPI PlayEnhMetaFileRecord(
/* 10-16: ??? */
LPWSTR str = (LPWSTR)& mr->dParm[17];
/* trailing info: dx array? */
FIXME(enhmetafile, "Many ExtTextOut args not handled\n");
FIXME("Many ExtTextOut args not handled\n");
ExtTextOutW(hdc, x, y, flags, /* lpRect */ NULL,
str, count, /* lpDx */ NULL);
break;
}
default:
FIXME(enhmetafile, "type %d is unimplemented\n", type);
FIXME("type %d is unimplemented\n", type);
/* SetLastError(E_NOTIMPL); */
break;
}
@ -598,10 +598,10 @@ BOOL WINAPI PlayEnhMetaFile(
xform.eM22 = yscale;
xform.eDx = lpRect->left;
xform.eDy = lpRect->top;
FIXME(enhmetafile, "play into rect doesn't work\n");
FIXME("play into rect doesn't work\n");
savedMode = SetGraphicsMode(hdc, GM_ADVANCED);
if (!SetWorldTransform(hdc, &xform)) {
WARN(enhmetafile, "World transform failed!\n");
WARN("World transform failed!\n");
}
}
@ -682,7 +682,7 @@ HENHMETAFILE WINAPI SetWinMetaFileBits(UINT cbBuffer,
CONST METAFILEPICT *lpmfp
)
{
FIXME(enhmetafile,"Stub\n");
FIXME("Stub\n");
return 0;
}

62
objects/gdiobj.c
View File

@ -21,7 +21,7 @@
#include "palette.h"
#include "pen.h"
#include "region.h"
#include "debug.h"
#include "debugtools.h"
#include "gdi.h"
DEFAULT_DEBUG_CHANNEL(gdi)
@ -368,7 +368,7 @@ BOOL WINAPI DeleteObject( HGDIOBJ obj )
return TRUE;
if (!(header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj ))) return FALSE;
TRACE(gdi, "%04x\n", obj );
TRACE("%04x\n", obj );
/* Delete object */
@ -382,10 +382,10 @@ BOOL WINAPI DeleteObject( HGDIOBJ obj )
case REGION_MAGIC: return REGION_DeleteObject( obj, (RGNOBJ*)header );
case DC_MAGIC: return DeleteDC(obj);
case 0 :
WARN(gdi, "Already deleted\n");
WARN("Already deleted\n");
break;
default:
WARN(gdi, "Unknown magic number (%d)\n",header->wMagic);
WARN("Unknown magic number (%d)\n",header->wMagic);
}
return FALSE;
}
@ -406,7 +406,7 @@ HGDIOBJ WINAPI GetStockObject( INT obj )
{
if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
if (!StockObjects[obj]) return 0;
TRACE(gdi, "returning %d\n",
TRACE("returning %d\n",
FIRST_STOCK_HANDLE + obj );
return (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
}
@ -419,7 +419,7 @@ INT16 WINAPI GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
{
GDIOBJHDR * ptr = NULL;
INT16 result = 0;
TRACE(gdi, "%04x %d %p\n", handle, count, buffer );
TRACE("%04x %d %p\n", handle, count, buffer );
if (!count) return 0;
if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
@ -458,7 +458,7 @@ INT WINAPI GetObjectA( HANDLE handle, INT count, LPVOID buffer )
{
GDIOBJHDR * ptr = NULL;
INT result = 0;
TRACE(gdi, "%08x %d %p\n", handle, count, buffer );
TRACE("%08x %d %p\n", handle, count, buffer );
if (!count) return 0;
if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
@ -485,7 +485,7 @@ INT WINAPI GetObjectA( HANDLE handle, INT count, LPVOID buffer )
result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
break;
default:
FIXME(gdi, "Magic %04x not implemented\n",
FIXME("Magic %04x not implemented\n",
ptr->wMagic );
break;
}
@ -499,7 +499,7 @@ INT WINAPI GetObjectW( HANDLE handle, INT count, LPVOID buffer )
{
GDIOBJHDR * ptr = NULL;
INT result = 0;
TRACE(gdi, "%08x %d %p\n", handle, count, buffer );
TRACE("%08x %d %p\n", handle, count, buffer );
if (!count) return 0;
if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
@ -526,7 +526,7 @@ INT WINAPI GetObjectW( HANDLE handle, INT count, LPVOID buffer )
result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
break;
default:
FIXME(gdi, "Magic %04x not implemented\n",
FIXME("Magic %04x not implemented\n",
ptr->wMagic );
break;
}
@ -541,7 +541,7 @@ DWORD WINAPI GetObjectType( HANDLE handle )
{
GDIOBJHDR * ptr = NULL;
INT result = 0;
TRACE(gdi, "%08x\n", handle );
TRACE("%08x\n", handle );
if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
@ -588,7 +588,7 @@ DWORD WINAPI GetObjectType( HANDLE handle )
result = OBJ_ENHMETADC;
break;
default:
FIXME(gdi, "Magic %04x not implemented\n",
FIXME("Magic %04x not implemented\n",
ptr->wMagic );
break;
}
@ -613,7 +613,7 @@ HANDLE WINAPI GetCurrentObject(HDC hdc,UINT type)
case OBJ_BITMAP: return dc->w.hBitmap;
default:
/* the SDK only mentions those above */
WARN(gdi,"(%08x,%d): unknown type.\n",hdc,type);
WARN("(%08x,%d): unknown type.\n",hdc,type);
return 0;
}
}
@ -635,7 +635,7 @@ HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ handle )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pSelectObject) return 0;
TRACE(gdi, "hdc=%04x %04x\n", hdc, handle );
TRACE("hdc=%04x %04x\n", hdc, handle );
return dc->funcs->pSelectObject( dc, handle );
}
@ -660,7 +660,7 @@ BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj );
if (!header) return FALSE;
TRACE(gdi, "%04x\n", obj );
TRACE("%04x\n", obj );
/* Unrealize object */
@ -701,7 +701,7 @@ INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
LOGPEN16 *pen;
LOGBRUSH16 *brush = NULL;
TRACE(gdi, "%04x %d %08lx %08lx\n",
TRACE("%04x %d %08lx %08lx\n",
hdc, nObjType, (DWORD)lpEnumFunc, lParam );
switch(nObjType)
{
@ -715,7 +715,7 @@ INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
pen->lopnWidth.y = 0;
pen->lopnColor = solid_colors[i];
retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
TRACE(gdi, "solid pen %08lx, ret=%d\n",
TRACE("solid pen %08lx, ret=%d\n",
solid_colors[i], retval);
if (!retval) break;
}
@ -731,7 +731,7 @@ INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
brush->lbColor = solid_colors[i];
brush->lbHatch = 0;
retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
TRACE(gdi, "solid brush %08lx, ret=%d\n",
TRACE("solid brush %08lx, ret=%d\n",
solid_colors[i], retval);
if (!retval) break;
}
@ -743,7 +743,7 @@ INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
brush->lbColor = RGB(0,0,0);
brush->lbHatch = i;
retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
TRACE(gdi, "hatched brush %d, ret=%d\n",
TRACE("hatched brush %d, ret=%d\n",
i, retval);
if (!retval) break;
}
@ -751,7 +751,7 @@ INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
break;
default:
WARN(gdi, "(%d): Invalid type\n", nObjType );
WARN("(%d): Invalid type\n", nObjType );
break;
}
return retval;
@ -780,7 +780,7 @@ INT WINAPI EnumObjects( HDC hdc, INT nObjType,
LOGPEN pen;
LOGBRUSH brush;
TRACE(gdi, "%04x %d %08lx %08lx\n",
TRACE("%04x %d %08lx %08lx\n",
hdc, nObjType, (DWORD)lpEnumFunc, lParam );
switch(nObjType)
{
@ -793,7 +793,7 @@ INT WINAPI EnumObjects( HDC hdc, INT nObjType,
pen.lopnWidth.y = 0;
pen.lopnColor = solid_colors[i];
retval = lpEnumFunc( &pen, lParam );
TRACE(gdi, "solid pen %08lx, ret=%d\n",
TRACE("solid pen %08lx, ret=%d\n",
solid_colors[i], retval);
if (!retval) break;
}
@ -807,7 +807,7 @@ INT WINAPI EnumObjects( HDC hdc, INT nObjType,
brush.lbColor = solid_colors[i];
brush.lbHatch = 0;
retval = lpEnumFunc( &brush, lParam );
TRACE(gdi, "solid brush %08lx, ret=%d\n",
TRACE("solid brush %08lx, ret=%d\n",
solid_colors[i], retval);
if (!retval) break;
}
@ -819,7 +819,7 @@ INT WINAPI EnumObjects( HDC hdc, INT nObjType,
brush.lbColor = RGB(0,0,0);
brush.lbHatch = i;
retval = lpEnumFunc( &brush, lParam );
TRACE(gdi, "hatched brush %d, ret=%d\n",
TRACE("hatched brush %d, ret=%d\n",
i, retval);
if (!retval) break;
}
@ -827,7 +827,7 @@ INT WINAPI EnumObjects( HDC hdc, INT nObjType,
default:
/* FIXME: implement Win32 types */
WARN( gdi, "(%d): Invalid type\n", nObjType );
WARN("(%d): Invalid type\n", nObjType );
break;
}
return retval;
@ -964,7 +964,7 @@ DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
case 0x0103: /* LocalHeap */
return GDI_HeapSel;
default:
WARN(gdi, "(wReqType=%04x): Unknown\n", wReqType);
WARN("(wReqType=%04x): Unknown\n", wReqType);
return (DWORD)-1;
}
}
@ -1030,7 +1030,7 @@ INT WINAPI MulDiv(
*/
BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
{
FIXME(gdi, "GetColorAdjustment, stub\n");
FIXME("GetColorAdjustment, stub\n");
return 0;
}
@ -1041,7 +1041,7 @@ BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
*/
BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
{
FIXME(gdi, "GetMiterLimit, stub\n");
FIXME("GetMiterLimit, stub\n");
return 0;
}
@ -1052,7 +1052,7 @@ BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
*/
BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
{
FIXME(gdi, "SetMiterLimit, stub\n");
FIXME("SetMiterLimit, stub\n");
return 0;
}
@ -1063,7 +1063,7 @@ BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
*/
BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
{
FIXME(gdi, "GdiComment, stub\n");
FIXME("GdiComment, stub\n");
return 0;
}
/*******************************************************************
@ -1073,7 +1073,7 @@ BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
*/
BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
{
FIXME(gdi, "SetColorAdjustment, stub\n");
FIXME("SetColorAdjustment, stub\n");
return 0;
}

68
objects/metafile.c
View File

@ -38,7 +38,7 @@
#include "bitmap.h"
#include "heap.h"
#include "toolhelp.h"
#include "debug.h"
#include "debugtools.h"
#include "global.h"
DEFAULT_DEBUG_CHANNEL(metafile)
@ -201,7 +201,7 @@ static METAHEADER *MF_ReadMetaFile(HFILE hfile)
}
if (mh->mtType != METAFILE_MEMORY) {
WARN(metafile, "Disk metafile had mtType = %04x\n", mh->mtType);
WARN("Disk metafile had mtType = %04x\n", mh->mtType);
mh->mtType = METAFILE_MEMORY;
}
return mh;
@ -215,7 +215,7 @@ HMETAFILE16 WINAPI GetMetaFile16( LPCSTR lpFilename )
METAHEADER *mh;
HFILE hFile;
TRACE(metafile,"%s\n", lpFilename);
TRACE("%s\n", lpFilename);
if(!lpFilename)
return 0;
@ -240,7 +240,7 @@ HMETAFILE WINAPI GetMetaFileA( LPCSTR lpFilename )
METAHEADER *mh;
HFILE hFile;
TRACE(metafile,"%s\n", lpFilename);
TRACE("%s\n", lpFilename);
if(!lpFilename)
return 0;
@ -265,7 +265,7 @@ HMETAFILE WINAPI GetMetaFileW( LPCWSTR lpFilename )
METAHEADER *mh;
HFILE hFile;
TRACE(metafile,"%s\n", debugstr_w(lpFilename));
TRACE("%s\n", debugstr_w(lpFilename));
if(!lpFilename)
return 0;
@ -293,14 +293,14 @@ static METAHEADER *MF_LoadDiskBasedMetaFile(METAHEADER *mh)
METAHEADER *mh2;
if(mh->mtType != METAFILE_DISK) {
ERR(metafile, "Not a disk based metafile\n");
ERR("Not a disk based metafile\n");
return NULL;
}
mhd = (METAHEADERDISK *)((char *)mh + sizeof(METAHEADER));
if((hfile = CreateFileA(mhd->filename, GENERIC_READ, 0, NULL,
OPEN_EXISTING, 0, -1)) == HFILE_ERROR) {
WARN(metafile, "Can't open file of disk based metafile\n");
WARN("Can't open file of disk based metafile\n");
return NULL;
}
mh2 = MF_ReadMetaFile(hfile);
@ -337,7 +337,7 @@ HMETAFILE16 WINAPI CopyMetaFile16( HMETAFILE16 hSrcMetaFile, LPCSTR lpFilename)
METAHEADER *mh2 = NULL;
HFILE hFile;
TRACE(metafile,"(%08x,%s)\n", hSrcMetaFile, lpFilename);
TRACE("(%08x,%s)\n", hSrcMetaFile, lpFilename);
if(!mh) return 0;
@ -387,7 +387,7 @@ HMETAFILE WINAPI CopyMetaFileA(
METAHEADER *mh2 = NULL;
HFILE hFile;
TRACE(metafile,"(%08x,%s)\n", hSrcMetaFile, lpFilename);
TRACE("(%08x,%s)\n", hSrcMetaFile, lpFilename);
if(!mh) return 0;
@ -452,7 +452,7 @@ BOOL16 WINAPI IsValidMetaFile16(HMETAFILE16 hmf)
res=TRUE;
MF_ReleaseMetaHeader16(hmf);
}
TRACE(metafile,"IsValidMetaFile %x => %d\n",hmf,res);
TRACE("IsValidMetaFile %x => %d\n",hmf,res);
return res;
}
@ -498,10 +498,10 @@ static BOOL MF_PlayMetaFile( HDC hdc, METAHEADER *mh)
while (offset < mh->mtSize * 2)
{
mr = (METARECORD *)((char *)mh + offset);
TRACE(metafile,"offset=%04x,size=%08lx\n",
TRACE("offset=%04x,size=%08lx\n",
offset, mr->rdSize);
if (!mr->rdSize) {
TRACE(metafile,
TRACE(
"Entry got size 0 at offset %d, total mf length is %ld\n",
offset,mh->mtSize*2);
break; /* would loop endlessly otherwise */
@ -578,7 +578,7 @@ BOOL16 WINAPI EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
DC *dc;
BOOL16 result = TRUE, loaded = FALSE;
TRACE(metafile,"(%04x, %04x, %08lx, %08lx)\n",
TRACE("(%04x, %04x, %08lx, %08lx)\n",
hdc, hmf, (DWORD)lpEnumFunc, lpData);
@ -670,7 +670,7 @@ BOOL WINAPI EnumMetaFile(
HBRUSH hBrush;
HFONT hFont;
TRACE(metafile,"(%08x,%08x,%p,%p)\n",
TRACE("(%08x,%08x,%p,%p)\n",
hdc, hmf, lpEnumFunc, (void*)lpData);
if (!mh) return 0;
if(mh->mtType == METAFILE_DISK) { /* Create a memoery-based copy */
@ -696,7 +696,7 @@ BOOL WINAPI EnumMetaFile(
while (offset < (mh->mtSize * 2))
{
mr = (METARECORD *)((char *)mh + offset);
TRACE(metafile, "Calling EnumFunc with record type %x\n",
TRACE("Calling EnumFunc with record type %x\n",
mr->rdFunction);
if (!lpEnumFunc( hdc, ht, mr, mh->mtNoObjects, (LONG)lpData ))
{
@ -753,7 +753,7 @@ void WINAPI PlayMetaFileRecord16(
char *ptr;
BITMAPINFOHEADER *infohdr;
TRACE(metafile,"(%04x %08lx %08lx %04x) function %04x\n",
TRACE("(%04x %08lx %08lx %04x) function %04x\n",
hdc,(LONG)ht, (LONG)mr, nHandles, mr->rdFunction);
switch (mr->rdFunction)
@ -965,7 +965,7 @@ void WINAPI PlayMetaFileRecord16(
break;
default:
ERR(metafile, "META_CREATEPATTERNBRUSH: Unknown pattern type %d\n",
ERR("META_CREATEPATTERNBRUSH: Unknown pattern type %d\n",
mr->rdParm[0]);
break;
}
@ -1009,7 +1009,7 @@ void WINAPI PlayMetaFileRecord16(
break;
case META_ESCAPE:
FIXME(metafile, "META_ESCAPE unimplemented.\n");
FIXME("META_ESCAPE unimplemented.\n");
break;
case META_EXTTEXTOUT:
@ -1109,7 +1109,7 @@ void WINAPI PlayMetaFileRecord16(
/* *(mr->rdParm) may be BS_PATTERN or BS_DIBPATTERN:
but there's no difference */
TRACE(metafile,"%d\n",*(mr->rdParm));
TRACE("%d\n",*(mr->rdParm));
s1 = mr->rdSize * 2 - sizeof(METARECORD) - 2;
hndl = GlobalAlloc16(GMEM_MOVEABLE, s1);
ptr = GlobalLock16(hndl);
@ -1172,7 +1172,7 @@ void WINAPI PlayMetaFileRecord16(
}
#define META_UNIMP(x) case x: \
FIXME(metafile, "PlayMetaFileRecord:record type "#x" not implemented.\n"); \
FIXME("PlayMetaFileRecord:record type "#x" not implemented.\n"); \
break;
META_UNIMP(META_DRAWTEXT)
META_UNIMP(META_ANIMATEPALETTE)
@ -1190,7 +1190,7 @@ break;
#undef META_UNIMP
default:
WARN(metafile, "PlayMetaFileRecord: Unknown record type %x\n",
WARN("PlayMetaFileRecord: Unknown record type %x\n",
mr->rdFunction);
}
}
@ -1204,7 +1204,7 @@ BOOL WINAPI PlayMetaFileRecord( HDC hdc, HANDLETABLE *handletable,
HANDLETABLE16 * ht = (void *)GlobalAlloc(GPTR,
handles*sizeof(HANDLETABLE16));
int i = 0;
TRACE(metafile, "(%08x,%p,%p,%d)\n", hdc, handletable, metarecord,
TRACE("(%08x,%p,%p,%d)\n", hdc, handletable, metarecord,
handles);
for (i=0; i<handles; i++)
ht->objectHandle[i] = handletable->objectHandle[i];
@ -1226,7 +1226,7 @@ HGLOBAL16 WINAPI GetMetaFileBits16(
HMETAFILE16 hmf /* metafile handle */
)
{
TRACE(metafile,"hMem out: %04x\n", hmf);
TRACE("hMem out: %04x\n", hmf);
return hmf;
}
@ -1243,7 +1243,7 @@ HMETAFILE16 WINAPI SetMetaFileBits16(
/* handle to a memory region holding a metafile */
)
{
TRACE(metafile,"hmf out: %04x\n", hMem);
TRACE("hmf out: %04x\n", hMem);
return hMem;
}
@ -1298,14 +1298,14 @@ UINT WINAPI GetMetaFileBitsEx(
METAHEADER *mh = MF_GetMetaHeader(hmf);
UINT mfSize;
TRACE(metafile, "(%08x,%d,%p)\n", hmf, nSize, buf);
TRACE("(%08x,%d,%p)\n", hmf, nSize, buf);
if (!mh) return 0; /* FIXME: error code */
if(mh->mtType == METAFILE_DISK)
FIXME(metafile, "Disk-based metafile?\n");
FIXME("Disk-based metafile?\n");
mfSize = mh->mtSize * 2;
if (!buf) {
MF_ReleaseMetaHeader(hmf);
TRACE(metafile,"returning size %d\n", mfSize);
TRACE("returning size %d\n", mfSize);
return mfSize;
}
if(mfSize > nSize) mfSize = nSize;
@ -1321,7 +1321,7 @@ UINT WINAPI GetWinMetaFileBits(HENHMETAFILE hemf,
UINT cbBuffer, LPBYTE lpbBuffer,
INT fnMapMode, HDC hdcRef)
{
FIXME(metafile, "(%d,%d,%p,%d,%d): stub\n",
FIXME("(%d,%d,%p,%d,%d): stub\n",
hemf, cbBuffer, lpbBuffer, fnMapMode, hdcRef);
return 0;
}
@ -1368,20 +1368,20 @@ static BOOL MF_Play_MetaCreateRegion( METARECORD *mr, HRGN hrgn )
for(band = 0, start = &(mr->rdParm[11]); band < mr->rdParm[5];
band++, start = end + 1) {
if(*start / 2 != (*start + 1) / 2) {
WARN(metafile, "Delimiter not even.\n");
WARN("Delimiter not even.\n");
DeleteObject( hrgn2 );
return FALSE;
}
end = start + *start + 3;
if(end > (WORD *)mr + mr->rdSize) {
WARN(metafile, "End points outside record.\n");
WARN("End points outside record.\n");
DeleteObject( hrgn2 );
return FALSE;
}
if(*start != *end) {
WARN(metafile, "Mismatched delimiters.\n");
WARN("Mismatched delimiters.\n");
DeleteObject( hrgn2 );
return FALSE;
}
@ -1427,8 +1427,8 @@ static BOOL MF_Play_MetaExtTextOut(HDC16 hdc, METARECORD *mr)
if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2)
dxx = (LPINT16)(sot+(((s1+1)>>1)*2));
else {
TRACE(metafile,"%s len: %ld\n", sot, mr->rdSize);
WARN(metafile,
TRACE("%s len: %ld\n", sot, mr->rdSize);
WARN(
"Please report: ExtTextOut len=%ld slen=%d rdSize=%ld opt=%04x\n",
len, s1, mr->rdSize, mr->rdParm[3]);
dxx = NULL; /* should't happen -- but if, we continue with NULL */
@ -1441,6 +1441,6 @@ static BOOL MF_Play_MetaExtTextOut(HDC16 hdc, METARECORD *mr)
sot, /* string */
s1, dxx); /* length, dx array */
if (dxx)
TRACE(metafile,"%s len: %ld dx0: %d\n", sot, mr->rdSize, dxx[0]);
TRACE("%s len: %ld dx0: %d\n", sot, mr->rdSize, dxx[0]);
return TRUE;
}

42
objects/palette.c
View File

@ -17,7 +17,7 @@
#include "color.h"
#include "palette.h"
#include "xmalloc.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(palette)
@ -110,7 +110,7 @@ HPALETTE WINAPI CreatePalette(
int size;
if (!palette) return 0;
TRACE(palette,"entries=%i\n", palette->palNumEntries);
TRACE("entries=%i\n", palette->palNumEntries);
size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
@ -124,7 +124,7 @@ HPALETTE WINAPI CreatePalette(
palettePtr->mapping = NULL;
GDI_HEAP_UNLOCK( hpalette );
TRACE(palette," returning %04x\n", hpalette);
TRACE(" returning %04x\n", hpalette);
return hpalette;
}
@ -215,7 +215,7 @@ UINT WINAPI GetPaletteEntries(
PALETTEOBJ * palPtr;
INT numEntries;
TRACE(palette,"hpal = %04x, count=%i\n", hpalette, count );
TRACE("hpal = %04x, count=%i\n", hpalette, count );
palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
if (!palPtr) return 0;
@ -267,7 +267,7 @@ UINT WINAPI SetPaletteEntries(
PALETTEOBJ * palPtr;
INT numEntries;
TRACE(palette,"hpal=%04x,start=%i,count=%i\n",hpalette,start,count );
TRACE("hpal=%04x,start=%i,count=%i\n",hpalette,start,count );
palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
if (!palPtr) return 0;
@ -315,7 +315,7 @@ BOOL WINAPI ResizePalette(
int prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
int* mapping = NULL;
TRACE(palette,"hpal = %04x, prev = %i, new = %i\n",
TRACE("hpal = %04x, prev = %i, new = %i\n",
hPal, palPtr ? palPtr->logpalette.palNumEntries : -1,
cEntries );
if( !palPtr ) return FALSE;
@ -375,7 +375,7 @@ BOOL WINAPI AnimatePalette(
UINT NumEntries, /* [in] Count of entries in palette */
const PALETTEENTRY* PaletteColors) /* [in] Pointer to first replacement */
{
TRACE(palette, "%04x (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
TRACE("%04x (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
if( hPal != STOCK_DEFAULT_PALETTE )
{
@ -419,7 +419,7 @@ UINT WINAPI SetSystemPaletteUse(
UINT use) /* [in] Palette-usage flag */
{
UINT old = SystemPaletteUse;
FIXME(palette,"(%04x,%04x): stub\n", hdc, use );
FIXME("(%04x,%04x): stub\n", hdc, use );
SystemPaletteUse = use;
return old;
}
@ -473,7 +473,7 @@ UINT WINAPI GetSystemPaletteEntries(
UINT i;
DC *dc;
TRACE(palette, "hdc=%04x,start=%i,count=%i\n", hdc,start,count);
TRACE("hdc=%04x,start=%i,count=%i\n", hdc,start,count);
if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
if (!entries) return dc->w.devCaps->sizePalette;
@ -488,7 +488,7 @@ UINT WINAPI GetSystemPaletteEntries(
{
*(COLORREF*)(entries + i) = COLOR_GetSystemPaletteEntry( start + i );
TRACE(palette,"\tidx(%02x) -> RGB(%08lx)\n",
TRACE("\tidx(%02x) -> RGB(%08lx)\n",
start + i, *(COLORREF*)(entries + i) );
}
GDI_HEAP_UNLOCK( hdc );
@ -527,7 +527,7 @@ UINT WINAPI GetNearestPaletteIndex(
palObj->logpalette.palNumEntries,
NULL, color, FALSE );
TRACE(palette,"(%04x,%06lx): returning %d\n", hpalette, color, index );
TRACE("(%04x,%06lx): returning %d\n", hpalette, color, index );
GDI_HEAP_UNLOCK( hpalette );
return index;
}
@ -572,7 +572,7 @@ COLORREF WINAPI GetNearestColor(
GDI_HEAP_UNLOCK( dc->w.hPalette );
}
TRACE(palette,"(%06lx): returning %06lx\n", color, nearest );
TRACE("(%06lx): returning %06lx\n", color, nearest );
GDI_HEAP_UNLOCK( hdc );
return nearest;
}
@ -623,7 +623,7 @@ HPALETTE16 WINAPI GDISelectPalette16( HDC16 hdc, HPALETTE16 hpal, WORD wBkg)
HPALETTE16 prev;
DC *dc;
TRACE(palette, "%04x %04x\n", hdc, hpal );
TRACE("%04x %04x\n", hdc, hpal );
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
@ -653,7 +653,7 @@ UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
if (!dc) return 0;
}
TRACE(palette, "%04x...\n", hdc );
TRACE("%04x...\n", hdc );
if( dc && dc->w.hPalette != hLastRealizedPalette )
{
@ -663,7 +663,7 @@ UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
palPtr = (PALETTEOBJ *) GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC );
if (!palPtr) {
FIXME(palette,"invalid selected palette %04x\n",dc->w.hPalette);
FIXME("invalid selected palette %04x\n",dc->w.hPalette);
return 0;
}
@ -674,11 +674,11 @@ UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
GDI_HEAP_UNLOCK( dc->w.hPalette );
hLastRealizedPalette = dc->w.hPalette;
}
else TRACE(palette, " skipping (hLastRealizedPalette = %04x)\n",
else TRACE(" skipping (hLastRealizedPalette = %04x)\n",
hLastRealizedPalette);
GDI_HEAP_UNLOCK( hdc );
TRACE(palette, " realized %i colors.\n", realized );
TRACE(" realized %i colors.\n", realized );
return (UINT16)realized;
}
@ -691,7 +691,7 @@ UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
DC *dc;
PALETTEOBJ* palPtr;
TRACE(palette,"%04x\n", hdc );
TRACE("%04x\n", hdc );
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
@ -757,10 +757,10 @@ HPALETTE WINAPI SelectPalette(
WORD wBkgPalette = 1;
PALETTEOBJ* lpt = (PALETTEOBJ*) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
TRACE(palette,"dc=%04x,pal=%04x,force=%i\n", hDC, hPal, bForceBackground);
TRACE("dc=%04x,pal=%04x,force=%i\n", hDC, hPal, bForceBackground);
if( !lpt ) return 0;
TRACE(palette," entries = %d\n", lpt->logpalette.palNumEntries);
TRACE(" entries = %d\n", lpt->logpalette.palNumEntries);
GDI_HEAP_UNLOCK( hPal );
if( hPal != STOCK_DEFAULT_PALETTE )
@ -865,6 +865,6 @@ BOOL WINAPI UpdateColors(
*/
VOID WINAPI SetMagicColors16(HDC16 hDC, COLORREF color, UINT16 index)
{
FIXME(palette,"(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
FIXME("(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
}

10
objects/pen.c
View File

@ -6,7 +6,7 @@
#include <string.h>
#include "pen.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(gdi)
@ -19,7 +19,7 @@ HPEN16 WINAPI CreatePen16( INT16 style, INT16 width, COLORREF color )
{
LOGPEN logpen;
TRACE(gdi, "%d %d %06lx\n", style, width, color );
TRACE("%d %d %06lx\n", style, width, color );
logpen.lopnStyle = style;
logpen.lopnWidth.x = width;
@ -37,7 +37,7 @@ HPEN WINAPI CreatePen( INT style, INT width, COLORREF color )
{
LOGPEN logpen;
TRACE(gdi, "%d %d %06lx\n", style, width, color );
TRACE("%d %d %06lx\n", style, width, color );
logpen.lopnStyle = style;
logpen.lopnWidth.x = width;
@ -100,10 +100,10 @@ HPEN WINAPI ExtCreatePen( DWORD style, DWORD width,
LOGPEN logpen;
if ((style & PS_STYLE_MASK) == PS_USERSTYLE)
FIXME(gdi, "PS_USERSTYLE not handled\n");
FIXME("PS_USERSTYLE not handled\n");
if ((style & PS_TYPE_MASK) == PS_GEOMETRIC)
if (brush->lbHatch)
FIXME(gdi, "Hatches not implemented\n");
FIXME("Hatches not implemented\n");
logpen.lopnStyle = style & ~PS_TYPE_MASK;
logpen.lopnWidth.x = (style & PS_GEOMETRIC) ? width : 1;

60
objects/region.c
View File

@ -85,7 +85,7 @@ SOFTWARE.
#include <string.h>
#include "region.h"
#include "winuser.h"
#include "debug.h"
#include "debugtools.h"
#include "heap.h"
#include "dc.h"
@ -112,11 +112,11 @@ static void REGION_DumpRegion(WINEREGION *pReg)
{
RECT *pRect, *pRectEnd = pReg->rects + pReg->numRects;
TRACE(region, "Region %p: %d,%d - %d,%d %d rects\n", pReg,
TRACE("Region %p: %d,%d - %d,%d %d rects\n", pReg,
pReg->extents.left, pReg->extents.top,
pReg->extents.right, pReg->extents.bottom, pReg->numRects);
for(pRect = pReg->rects; pRect < pRectEnd; pRect++)
TRACE(region, "\t%d,%d - %d,%d\n", pRect->left, pRect->top,
TRACE("\t%d,%d - %d,%d\n", pRect->left, pRect->top,
pRect->right, pRect->bottom);
return;
}
@ -180,7 +180,7 @@ static void REGION_DestroyWineRegion( WINEREGION* pReg )
*/
BOOL REGION_DeleteObject( HRGN hrgn, RGNOBJ * obj )
{
TRACE(region, " %04x\n", hrgn );
TRACE(" %04x\n", hrgn );
REGION_DestroyWineRegion( obj->rgn );
return GDI_FreeObject( hrgn );
@ -207,7 +207,7 @@ INT WINAPI OffsetRgn( HRGN hrgn, INT x, INT y )
int nbox = obj->rgn->numRects;
RECT *pbox = obj->rgn->rects;
TRACE(region, " %04x %d,%d\n", hrgn, x, y );
TRACE(" %04x %d,%d\n", hrgn, x, y );
if(nbox) {
while(nbox--) {
pbox->left += x;
@ -249,7 +249,7 @@ INT WINAPI GetRgnBox( HRGN hrgn, LPRECT rect )
if (obj)
{
INT ret;
TRACE(region, " %04x\n", hrgn );
TRACE(" %04x\n", hrgn );
rect->left = obj->rgn->extents.left;
rect->top = obj->rgn->extents.top;
rect->right = obj->rgn->extents.right;
@ -273,7 +273,7 @@ HRGN16 WINAPI CreateRectRgn16(INT16 left, INT16 top, INT16 right, INT16 bottom)
if (!(hrgn = (HRGN16)REGION_CreateRegion(RGN_DEFAULT_RECTS)))
return 0;
TRACE(region, "\n");
TRACE("\n");
SetRectRgn16(hrgn, left, top, right, bottom);
return hrgn;
}
@ -290,7 +290,7 @@ HRGN WINAPI CreateRectRgn(INT left, INT top, INT right, INT bottom)
if (!(hrgn = REGION_CreateRegion(RGN_DEFAULT_RECTS)))
return 0;
TRACE(region, "\n");
TRACE("\n");
SetRectRgn(hrgn, left, top, right, bottom);
return hrgn;
}
@ -338,7 +338,7 @@ BOOL WINAPI SetRectRgn( HRGN hrgn, INT left, INT top,
{
RGNOBJ * obj;
TRACE(region, " %04x %d,%d-%d,%d\n",
TRACE(" %04x %d,%d-%d,%d\n",
hrgn, left, top, right, bottom );
if (!(obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return FALSE;
@ -412,7 +412,7 @@ HRGN WINAPI CreateRoundRectRgn( INT left, INT top,
d = (ellipse_height < 128) ? ((3 * ellipse_height) >> 2) : 64;
if (!(hrgn = REGION_CreateRegion(d))) return 0;
obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
TRACE(region,"(%d,%d-%d,%d %dx%d): ret=%04x\n",
TRACE("(%d,%d-%d,%d %dx%d): ret=%04x\n",
left, top, right, bottom, ellipse_width, ellipse_height, hrgn );
/* Check parameters */
@ -543,7 +543,7 @@ DWORD WINAPI GetRegionData(HRGN hrgn, DWORD count, LPRGNDATA rgndata)
DWORD size;
RGNOBJ *obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
TRACE(region, " %04x count = %ld, rgndata = %p\n",
TRACE(" %04x count = %ld, rgndata = %p\n",
hrgn, count, rgndata);
if(!obj) return 0;
@ -587,17 +587,17 @@ HRGN WINAPI ExtCreateRegion( const XFORM* lpXform, DWORD dwCount, const RGNDATA*
{
HRGN hrgn;
TRACE(region, " %p %ld %p = ", lpXform, dwCount, rgndata );
TRACE(" %p %ld %p = ", lpXform, dwCount, rgndata );
if( lpXform )
WARN(region, "(Xform not implemented - ignored) ");
WARN("(Xform not implemented - ignored) ");
if( rgndata->rdh.iType != RDH_RECTANGLES )
{
/* FIXME: We can use CreatePolyPolygonRgn() here
* for trapezoidal data */
WARN(region, "(Unsupported region data) ");
WARN("(Unsupported region data) ");
goto fail;
}
@ -611,11 +611,11 @@ HRGN WINAPI ExtCreateRegion( const XFORM* lpXform, DWORD dwCount, const RGNDATA*
REGION_UnionRectWithRegion( pCurRect, obj->rgn );
GDI_HEAP_UNLOCK( hrgn );
TRACE(region,"%04x\n", hrgn );
TRACE("%04x\n", hrgn );
return hrgn;
}
fail:
WARN(region, "Failed\n");
WARN("Failed\n");
return 0;
}
@ -832,7 +832,7 @@ BOOL REGION_LPTODP( HDC hdc, HRGN hDest, HRGN hSrc )
DC * dc = DC_GetDCPtr( hdc );
RECT tmpRect;
TRACE(region, " hdc=%04x dest=%04x src=%04x\n",
TRACE(" hdc=%04x dest=%04x src=%04x\n",
hdc, hDest, hSrc) ;
if (dc->w.MapMode == MM_TEXT) /* Requires only a translation */
@ -887,7 +887,7 @@ INT WINAPI CombineRgn(HRGN hDest, HRGN hSrc1, HRGN hSrc2, INT mode)
RGNOBJ *destObj = (RGNOBJ *) GDI_GetObjPtr( hDest, REGION_MAGIC);
INT result = ERROR;
TRACE(region, " %04x,%04x -> %04x mode=%x\n",
TRACE(" %04x,%04x -> %04x mode=%x\n",
hSrc1, hSrc2, hDest, mode );
if (destObj)
{
@ -895,7 +895,7 @@ INT WINAPI CombineRgn(HRGN hDest, HRGN hSrc1, HRGN hSrc2, INT mode)
if (src1Obj)
{
TRACE(region, "dump:\n");
TRACE("dump:\n");
if(TRACE_ON(region))
REGION_DumpRegion(src1Obj->rgn);
if (mode == RGN_COPY)
@ -909,7 +909,7 @@ INT WINAPI CombineRgn(HRGN hDest, HRGN hSrc1, HRGN hSrc2, INT mode)
if (src2Obj)
{
TRACE(region, "dump:\n");
TRACE("dump:\n");
if(TRACE_ON(region))
REGION_DumpRegion(src2Obj->rgn);
switch (mode)
@ -933,7 +933,7 @@ INT WINAPI CombineRgn(HRGN hDest, HRGN hSrc1, HRGN hSrc2, INT mode)
}
GDI_HEAP_UNLOCK( hSrc1 );
}
TRACE(region, "dump:\n");
TRACE("dump:\n");
if(TRACE_ON(region))
REGION_DumpRegion(destObj->rgn);
@ -1988,7 +1988,7 @@ static void REGION_InsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE,
tmpSLLBlock = HeapAlloc( SystemHeap, 0, sizeof(ScanLineListBlock));
if(!tmpSLLBlock)
{
WARN(region, "Can't alloc SLLB\n");
WARN("Can't alloc SLLB\n");
return;
}
(*SLLBlock)->next = tmpSLLBlock;
@ -2436,7 +2436,7 @@ HRGN WINAPI CreatePolyPolygonRgn(const POINT *Pts, const INT *Count,
if (iPts == NUMPTSTOBUFFER) {
tmpPtBlock = HeapAlloc( SystemHeap, 0, sizeof(POINTBLOCK));
if(!tmpPtBlock) {
WARN(region, "Can't alloc tPB\n");
WARN("Can't alloc tPB\n");
return 0;
}
curPtBlock->next = tmpPtBlock;
@ -2487,7 +2487,7 @@ HRGN WINAPI CreatePolyPolygonRgn(const POINT *Pts, const INT *Count,
tmpPtBlock = HeapAlloc( SystemHeap, 0,
sizeof(POINTBLOCK) );
if(!tmpPtBlock) {
WARN(region, "Can't alloc tPB\n");
WARN("Can't alloc tPB\n");
return 0;
}
curPtBlock->next = tmpPtBlock;
@ -2577,7 +2577,7 @@ HRGN WINAPI CreatePolygonRgn( const POINT *points, INT count,
*/
HRGN WINAPI GetRandomRgn(DWORD dwArg1, DWORD dwArg2, DWORD dwArg3)
{
FIXME (region, "(0x%08lx 0x%08lx 0x%08lx): empty stub!\n",
FIXME("(0x%08lx 0x%08lx 0x%08lx): empty stub!\n",
dwArg1, dwArg2, dwArg3);
return 0;
@ -2637,7 +2637,7 @@ empty:
return FALSE;
}
TRACE(region,"cropped to empty!\n");
TRACE("cropped to empty!\n");
EMPTY_REGION(rgnDst);
}
else /* region box and clipping rect appear to intersect */
@ -2669,7 +2669,7 @@ empty:
if( TRACE_ON(region) )
{
REGION_DumpRegion( rgnSrc );
TRACE(region,"\tclipa = %i, clipb = %i\n", clipa, clipb );
TRACE("\tclipa = %i, clipb = %i\n", clipa, clipb );
}
for( i = clipa, j = 0; i < clipb ; i++ )
@ -2719,7 +2719,7 @@ empty:
if( TRACE_ON(region) )
{
TRACE(region,"result:\n");
TRACE("result:\n");
REGION_DumpRegion( rgnDst );
}
}
@ -2793,10 +2793,10 @@ HRGN REGION_CropRgn( HRGN hDst, HRGN hSrc, const RECT *lpRect, const POINT *lpPt
if( !lpPt ) lpPt = &pt;
if( lpRect )
TRACE(region, "src %p -> dst %p (%i,%i)-(%i,%i) by (%li,%li)\n", objSrc->rgn, rgnDst,
TRACE("src %p -> dst %p (%i,%i)-(%i,%i) by (%li,%li)\n", objSrc->rgn, rgnDst,
lpRect->left, lpRect->top, lpRect->right, lpRect->bottom, lpPt->x, lpPt->y );
else
TRACE(region, "src %p -> dst %p by (%li,%li)\n", objSrc->rgn, rgnDst, lpPt->x, lpPt->y );
TRACE("src %p -> dst %p by (%li,%li)\n", objSrc->rgn, rgnDst, lpPt->x, lpPt->y );
if( REGION_CropAndOffsetRegion( lpPt, lpRect, objSrc->rgn, rgnDst ) == FALSE )
{

20
objects/text.c
View File

@ -11,7 +11,7 @@
#include "dc.h"
#include "gdi.h"
#include "heap.h"
#include "debug.h"
#include "debugtools.h"
#include "cache.h"
#include "debugstr.h"
@ -202,7 +202,7 @@ INT16 WINAPI DrawText16( HDC16 hdc, LPCSTR str, INT16 i_count,
int width = rect->right - rect->left;
int max_width = 0;
TRACE(text,"%s, %d , [(%d,%d),(%d,%d)]\n",
TRACE("%s, %d , [(%d,%d),(%d,%d)]\n",
debugstr_an (str, count), count,
rect->left, rect->top, rect->right, rect->bottom);
@ -325,9 +325,9 @@ INT WINAPI DrawTextW( HDC hdc, LPCWSTR str, INT count,
INT WINAPI DrawTextExA( HDC hdc, LPCSTR str, INT count,
LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp )
{
TRACE(text,"(%d,'%s',%d,%p,0x%08x,%p)\n",hdc,str,count,rect,flags,dtp);
TRACE("(%d,'%s',%d,%p,0x%08x,%p)\n",hdc,str,count,rect,flags,dtp);
if(dtp) {
FIXME(text,"Ignores params:%d,%d,%d,%d,%d\n",dtp->cbSize,
FIXME("Ignores params:%d,%d,%d,%d,%d\n",dtp->cbSize,
dtp->iTabLength,dtp->iLeftMargin,dtp->iRightMargin,
dtp->uiLengthDrawn);
}
@ -340,8 +340,8 @@ INT WINAPI DrawTextExA( HDC hdc, LPCSTR str, INT count,
INT WINAPI DrawTextExW( HDC hdc, LPCWSTR str, INT count,
LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp )
{
TRACE(text,"(%d,%p,%d,%p,0x%08x,%p)\n",hdc,str,count,rect,flags,dtp);
FIXME(text,"ignores extended functionality\n");
TRACE("(%d,%p,%d,%p,0x%08x,%p)\n",hdc,str,count,rect,flags,dtp);
FIXME("ignores extended functionality\n");
return DrawTextW(hdc,str,count,rect,flags);
}
@ -641,7 +641,7 @@ LONG WINAPI TabbedTextOut16( HDC16 hdc, INT16 x, INT16 y, LPCSTR lpstr,
INT16 count, INT16 cTabStops,
const INT16 *lpTabPos, INT16 nTabOrg )
{
TRACE(text, "%04x %d,%d '%.*s' %d\n",
TRACE("%04x %d,%d '%.*s' %d\n",
hdc, x, y, count, lpstr, count );
return TEXT_TabbedTextOut( hdc, x, y, lpstr, count, cTabStops,
lpTabPos, NULL, nTabOrg, TRUE );
@ -655,7 +655,7 @@ LONG WINAPI TabbedTextOutA( HDC hdc, INT x, INT y, LPCSTR lpstr,
INT count, INT cTabStops,
const INT *lpTabPos, INT nTabOrg )
{
TRACE(text, "%04x %d,%d '%.*s' %d\n",
TRACE("%04x %d,%d '%.*s' %d\n",
hdc, x, y, count, lpstr, count );
return TEXT_TabbedTextOut( hdc, x, y, lpstr, count, cTabStops,
NULL, lpTabPos, nTabOrg, TRUE );
@ -685,7 +685,7 @@ LONG WINAPI TabbedTextOutW( HDC hdc, INT x, INT y, LPCWSTR str,
DWORD WINAPI GetTabbedTextExtent16( HDC16 hdc, LPCSTR lpstr, INT16 count,
INT16 cTabStops, const INT16 *lpTabPos )
{
TRACE(text, "%04x '%.*s' %d\n",
TRACE("%04x '%.*s' %d\n",
hdc, count, lpstr, count );
return TEXT_TabbedTextOut( hdc, 0, 0, lpstr, count, cTabStops,
lpTabPos, NULL, 0, FALSE );
@ -698,7 +698,7 @@ DWORD WINAPI GetTabbedTextExtent16( HDC16 hdc, LPCSTR lpstr, INT16 count,
DWORD WINAPI GetTabbedTextExtentA( HDC hdc, LPCSTR lpstr, INT count,
INT cTabStops, const INT *lpTabPos )
{
TRACE(text, "%04x '%.*s' %d\n",
TRACE("%04x '%.*s' %d\n",
hdc, count, lpstr, count );
return TEXT_TabbedTextOut( hdc, 0, 0, lpstr, count, cTabStops,
NULL, lpTabPos, 0, FALSE );

8
scheduler/handle.c
View File

@ -9,7 +9,7 @@
#include "winbase.h"
#include "server.h"
#include "winerror.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win32)
@ -105,7 +105,7 @@ HANDLE WINAPI ConvertToGlobalHandle(HANDLE hSrc)
* SetHandleContext (KERNEL32)
*/
BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context) {
FIXME(win32,"(%d,%ld), stub. The external WSOCK32 will not work with WINE, do not use it.\n",hnd,context);
FIXME("(%d,%ld), stub. The external WSOCK32 will not work with WINE, do not use it.\n",hnd,context);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
@ -114,7 +114,7 @@ BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context) {
* GetHandleContext (KERNEL32)
*/
DWORD WINAPI GetHandleContext(HANDLE hnd) {
FIXME(win32,"(%d), stub. The external WSOCK32 will not work with WINE, do not use it.\n",hnd);
FIXME("(%d), stub. The external WSOCK32 will not work with WINE, do not use it.\n",hnd);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
@ -123,7 +123,7 @@ DWORD WINAPI GetHandleContext(HANDLE hnd) {
* CreateSocketHandle (KERNEL32)
*/
HANDLE WINAPI CreateSocketHandle(void) {
FIXME(win32,"(), stub. The external WSOCK32 will not work with WINE, do not use it.\n");
FIXME("(), stub. The external WSOCK32 will not work with WINE, do not use it.\n");
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return INVALID_HANDLE_VALUE;
}

6
scheduler/services.c
View File

@ -8,7 +8,7 @@
#include <unistd.h>
#include "services.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(timer)
@ -159,13 +159,13 @@ static DWORD CALLBACK SERVICE_Loop( SERVICETABLE *service )
/* Wait until some condition satisfied */
TRACE( timer, "Waiting for %d objects with timeout %ld\n",
TRACE("Waiting for %d objects with timeout %ld\n",
count, timeout );
retval = WaitForMultipleObjectsEx( count, handles,
FALSE, timeout, TRUE );
TRACE( timer, "Wait returned: %ld\n", retval );
TRACE("Wait returned: %ld\n", retval );
}
return 0L;

1
scheduler/synchro.c
View File

@ -16,7 +16,6 @@
#include "message.h"
#include "x11drv.h"
#include "server.h"
#include "debug.h"
/***********************************************************************

4
scheduler/sysdeps.c
View File

@ -28,7 +28,7 @@ static int *ph_errno = &h_errno;
#include "thread.h"
#include "server.h"
#include "winbase.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(thread)
@ -166,7 +166,7 @@ int SYSDEPS_SpawnThread( THDB *thread )
#endif /* NO_REENTRANT_LIBC */
FIXME(thread, "CreateThread: stub\n" );
FIXME("CreateThread: stub\n" );
return 0;
}

24
scheduler/syslevel.c
View File

@ -10,7 +10,7 @@
#include "syslevel.h"
#include "heap.h"
#include "stackframe.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win32)
@ -62,7 +62,7 @@ VOID WINAPI _CreateSysLevel(SYSLEVEL *lock, INT level)
MakeCriticalSectionGlobal( &lock->crst );
lock->level = level;
TRACE( win32, "(%p, %d): handle is %d\n",
TRACE("(%p, %d): handle is %d\n",
lock, level, lock->crst.LockSemaphore );
}
@ -74,14 +74,14 @@ VOID WINAPI _EnterSysLevel(SYSLEVEL *lock)
THDB *thdb = THREAD_Current();
int i;
TRACE( win32, "(%p, level %d): thread %p (fs %04x, pid %d) count before %ld\n",
TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count before %ld\n",
lock, lock->level, thdb->server_tid, thdb->teb_sel, getpid(),
thdb->sys_count[lock->level] );
for ( i = 3; i > lock->level; i-- )
if ( thdb->sys_count[i] > 0 )
{
ERR( win32, "(%p, level %d): Holding %p, level %d. Expect deadlock!\n",
ERR("(%p, level %d): Holding %p, level %d. Expect deadlock!\n",
lock, lock->level, thdb->sys_mutex[i], i );
}
@ -90,7 +90,7 @@ VOID WINAPI _EnterSysLevel(SYSLEVEL *lock)
thdb->sys_count[lock->level]++;
thdb->sys_mutex[lock->level] = lock;
TRACE( win32, "(%p, level %d): thread %p (fs %04x, pid %d) count after %ld\n",
TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count after %ld\n",
lock, lock->level, thdb->server_tid, thdb->teb_sel, getpid(),
thdb->sys_count[lock->level] );
@ -105,13 +105,13 @@ VOID WINAPI _LeaveSysLevel(SYSLEVEL *lock)
{
THDB *thdb = THREAD_Current();
TRACE( win32, "(%p, level %d): thread %p (fs %04x, pid %d) count before %ld\n",
TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count before %ld\n",
lock, lock->level, thdb->server_tid, thdb->teb_sel, getpid(),
thdb->sys_count[lock->level] );
if ( thdb->sys_count[lock->level] <= 0 || thdb->sys_mutex[lock->level] != lock )
{
ERR( win32, "(%p, level %d): Invalid state: count %ld mutex %p.\n",
ERR("(%p, level %d): Invalid state: count %ld mutex %p.\n",
lock, lock->level, thdb->sys_count[lock->level],
thdb->sys_mutex[lock->level] );
}
@ -123,7 +123,7 @@ VOID WINAPI _LeaveSysLevel(SYSLEVEL *lock)
LeaveCriticalSection( &lock->crst );
TRACE( win32, "(%p, level %d): thread %p (fs %04x, pid %d) count after %ld\n",
TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count after %ld\n",
lock, lock->level, thdb->server_tid, thdb->teb_sel, getpid(),
thdb->sys_count[lock->level] );
}
@ -152,7 +152,7 @@ DWORD WINAPI _ConfirmSysLevel(SYSLEVEL *lock)
*/
VOID WINAPI _CheckNotSysLevel(SYSLEVEL *lock)
{
FIXME(win32, "(%p)\n", lock);
FIXME("(%p)\n", lock);
}
@ -210,7 +210,7 @@ VOID SYSLEVEL_ReleaseWin16Lock(VOID)
ReleaseThunkLock(&count);
if (count > 0xffff)
ERR(win32, "Win16Mutex recursion count too large!\n");
ERR("Win16Mutex recursion count too large!\n");
CURRENT_STACK16->mutex_count = (WORD)count;
}
@ -223,7 +223,7 @@ VOID SYSLEVEL_RestoreWin16Lock(VOID)
DWORD count = CURRENT_STACK16->mutex_count;
if (!count)
ERR(win32, "Win16Mutex recursion count is zero!\n");
ERR("Win16Mutex recursion count is zero!\n");
RestoreThunkLock(count);
}
@ -239,7 +239,7 @@ VOID SYSLEVEL_CheckNotLevel( INT level )
for ( i = 3; i >= level; i-- )
if ( thdb->sys_count[i] > 0 )
{
ERR( win32, "(%d): Holding lock of level %d!\n",
ERR("(%d): Holding lock of level %d!\n",
level, i );
kill( getpid(), SIGHUP );

26
scheduler/thread.c
View File

@ -22,7 +22,7 @@
#include "server.h"
#include "services.h"
#include "stackframe.h"
#include "debug.h"
#include "debugtools.h"
#include "queue.h"
#include "hook.h"
@ -109,7 +109,7 @@ static BOOL THREAD_InitTHDB( THDB *thdb, DWORD stack_size, BOOL alloc_stack16,
if (stack_size<1024*1024)
stack_size = 1024 * 1024;
if (stack_size >= 16*1024*1024)
WARN(thread,"Thread stack size is %ld MB.\n",stack_size/1024/1024);
WARN("Thread stack size is %ld MB.\n",stack_size/1024/1024);
thdb->stack_base = VirtualAlloc(NULL,
stack_size + (alloc_stack16 ? 0x10000 : 0),
MEM_COMMIT, PAGE_EXECUTE_READWRITE );
@ -158,7 +158,7 @@ void CALLBACK THREAD_FreeTHDB( ULONG_PTR arg )
THDB *thdb = (THDB *)arg;
THDB **pptr = &THREAD_First;
TRACE( thread, "(%p) called\n", thdb );
TRACE("(%p) called\n", thdb );
SERVICE_Delete( thdb->cleanup );
PROCESS_CallUserSignalProc( USIG_THREAD_EXIT, 0, 0 );
@ -198,7 +198,7 @@ THDB *THREAD_CreateInitialThread( PDB *pdb, int server_fd )
if (!(initial_thdb.teb_sel = SELECTOR_AllocBlock( &initial_thdb.teb, 0x1000,
SEGMENT_DATA, TRUE, FALSE )))
{
MSG("Could not allocate fs register for initial thread\n" );
MESSAGE("Could not allocate fs register for initial thread\n" );
return NULL;
}
SET_CUR_THREAD( &initial_thdb );
@ -372,7 +372,7 @@ DWORD WINAPI GetLastError(void)
{
THDB *thread = THREAD_Current();
DWORD ret = thread->last_error;
TRACE(thread,"0x%lx\n",ret);
TRACE("0x%lx\n",ret);
return ret;
}
@ -389,7 +389,7 @@ void WINAPI SetLastError(
THDB *thread = THREAD_Current();
/* This one must work before we have a thread (FIXME) */
TRACE(thread,"%p error=0x%lx\n",thread,error);
TRACE("%p error=0x%lx\n",thread,error);
if (thread)
thread->last_error = error;
@ -406,7 +406,7 @@ void WINAPI SetLastErrorEx(
DWORD error, /* [in] Per-thread error code */
DWORD type) /* [in] Error type */
{
TRACE(thread, "(0x%08lx, 0x%08lx)\n", error,type);
TRACE("(0x%08lx, 0x%08lx)\n", error,type);
switch(type) {
case 0:
break;
@ -415,7 +415,7 @@ void WINAPI SetLastErrorEx(
case SLE_WARNING:
/* Fall through for now */
default:
FIXME(thread, "(error=%08lx, type=%08lx): Unhandled type\n", error,type);
FIXME("(error=%08lx, type=%08lx): Unhandled type\n", error,type);
break;
}
SetLastError( error );
@ -546,7 +546,7 @@ BOOL WINAPI SetThreadContext(
HANDLE handle, /* [in] Handle to thread with context */
CONTEXT *context) /* [out] Address of context structure */
{
FIXME( thread, "not implemented\n" );
FIXME("not implemented\n" );
return TRUE;
}
@ -563,7 +563,7 @@ BOOL WINAPI GetThreadContext(
{
WORD cs, ds;
FIXME( thread, "returning dummy info\n" );
FIXME("returning dummy info\n" );
/* make up some plausible values for segment registers */
GET_CS(cs);
@ -746,7 +746,7 @@ BOOL WINAPI GetThreadTimes(
LPFILETIME kerneltime, /* [out] Time thread spent in kernel mode */
LPFILETIME usertime) /* [out] Time thread spent in user mode */
{
FIXME(thread,"(0x%08x): stub\n",thread);
FIXME("(0x%08x): stub\n",thread);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
@ -841,7 +841,7 @@ CLEANUP:
*/
VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
{
FIXME(thread, "(0x%08lx,%d): stub\n", threadId, boost);
FIXME("(0x%08lx,%d): stub\n", threadId, boost);
}
/**********************************************************************
@ -849,7 +849,7 @@ VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
*/
VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
{
FIXME(thread, "(0x%08lx,%d): stub\n", threadId, boost);
FIXME("(0x%08lx,%d): stub\n", threadId, boost);
}
/**********************************************************************

10
win32/code_page.c
View File

@ -8,7 +8,7 @@
#include "winerror.h"
#include "winnls.h"
#include "heap.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win32)
@ -188,10 +188,10 @@ INT WINAPI WideCharToMultiByte(UINT page, DWORD flags, LPCWSTR src,
}
if (page!=GetACP() && page!=CP_OEMCP && page!=CP_ACP)
FIXME(win32,"Conversion in CP %d not supported\n",page);
FIXME("Conversion in CP %d not supported\n",page);
#if 0
if (flags)
FIXME(win32,"flags %lx not supported\n",flags);
FIXME("flags %lx not supported\n",flags);
#endif
if(used)
*used=0;
@ -280,7 +280,7 @@ BOOL WINAPI IsDBCSLeadByte( BYTE testchar )
*/
BOOL WINAPI EnumSystemCodePagesA(CODEPAGE_ENUMPROCA lpfnCodePageEnum,DWORD flags)
{
TRACE(win32,"(%p,%08lx)\n",lpfnCodePageEnum,flags);
TRACE("(%p,%08lx)\n",lpfnCodePageEnum,flags);
lpfnCodePageEnum("437");
return TRUE;
}
@ -292,7 +292,7 @@ BOOL WINAPI EnumSystemCodePagesW( CODEPAGE_ENUMPROCW lpfnCodePageEnum,
DWORD flags)
{
WCHAR *cp;
TRACE(win32,"(%p,%08lx)\n",lpfnCodePageEnum,flags );
TRACE("(%p,%08lx)\n",lpfnCodePageEnum,flags );
cp = HEAP_strdupAtoW( GetProcessHeap(), 0, "437" );
lpfnCodePageEnum(cp);

52
win32/console.c
View File

@ -43,7 +43,7 @@
#include "winerror.h"
#include "wincon.h"
#include "heap.h"
#include "debug.h"
#include "debugtools.h"
#include "server/request.h"
#include "server.h"
@ -188,7 +188,7 @@ CONSOLE_string_to_IR( HANDLE hConsoleInput,unsigned char *buf,int len) {
case 24:/*F12 */scancode = 0x00da;break;
/* FIXME: Shift-Fx */
default:
FIXME(console,"parse ESC[%d~\n",subid);
FIXME("parse ESC[%d~\n",subid);
break;
}
break;
@ -282,7 +282,7 @@ BOOL WINAPI SetConsoleCtrlHandler( HANDLER_ROUTINE *func, BOOL add )
{
unsigned int alloc_loop = sizeof(handlers)/sizeof(HANDLER_ROUTINE *);
unsigned int done = 0;
FIXME(console, "(%p,%i) - no error checking or testing yet\n", func, add);
FIXME("(%p,%i) - no error checking or testing yet\n", func, add);
if (!func)
{
console_ignore_ctrl_c = add;
@ -297,7 +297,7 @@ BOOL WINAPI SetConsoleCtrlHandler( HANDLER_ROUTINE *func, BOOL add )
done++;
}
if (!done)
FIXME(console, "Out of space on CtrlHandler table\n");
FIXME("Out of space on CtrlHandler table\n");
return(done);
}
else
@ -309,7 +309,7 @@ BOOL WINAPI SetConsoleCtrlHandler( HANDLER_ROUTINE *func, BOOL add )
done++;
}
if (!done)
WARN(console, "Attempt to remove non-installed CtrlHandler %p\n",
WARN("Attempt to remove non-installed CtrlHandler %p\n",
func);
return (done);
}
@ -336,17 +336,17 @@ BOOL WINAPI GenerateConsoleCtrlEvent( DWORD dwCtrlEvent,
{
if (dwCtrlEvent != CTRL_C_EVENT && dwCtrlEvent != CTRL_BREAK_EVENT)
{
ERR( console, "invalid event %d for PGID %ld\n",
ERR("invalid event %d for PGID %ld\n",
(unsigned short)dwCtrlEvent, dwProcessGroupID );
return FALSE;
}
if (dwProcessGroupID == GetCurrentProcessId() )
{
FIXME( console, "Attempt to send event %d to self - stub\n",
FIXME("Attempt to send event %d to self - stub\n",
(unsigned short)dwCtrlEvent );
return FALSE;
}
FIXME( console,"event %d to external PGID %ld - not implemented yet\n",
FIXME("event %d to external PGID %ld - not implemented yet\n",
(unsigned short)dwCtrlEvent, dwProcessGroupID );
return FALSE;
}
@ -373,7 +373,7 @@ HANDLE WINAPI CreateConsoleScreenBuffer( DWORD dwDesiredAccess,
DWORD dwShareMode, LPSECURITY_ATTRIBUTES sa,
DWORD dwFlags, LPVOID lpScreenBufferData )
{
FIXME(console, "(%ld,%ld,%p,%ld,%p): stub\n",dwDesiredAccess,
FIXME("(%ld,%ld,%p,%ld,%p): stub\n",dwDesiredAccess,
dwShareMode, sa, dwFlags, lpScreenBufferData);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return INVALID_HANDLE_VALUE;
@ -411,7 +411,7 @@ BOOL WINAPI GetConsoleScreenBufferInfo( HANDLE hConsoleOutput,
BOOL WINAPI SetConsoleActiveScreenBuffer(
HANDLE hConsoleOutput) /* [in] Handle to console screen buffer */
{
FIXME(console, "(%x): stub\n", hConsoleOutput);
FIXME("(%x): stub\n", hConsoleOutput);
return FALSE;
}
@ -483,7 +483,7 @@ static BOOL CONSOLE_make_complex(HANDLE handle)
if (!CONSOLE_GetInfo( handle, &info )) return FALSE;
if (info.pid) return TRUE; /* already complex */
MSG("Console: Making console complex (creating an xterm)...\n");
MESSAGE("Console: Making console complex (creating an xterm)...\n");
if (tcgetattr(0, &term) < 0) {
/* ignore failure, or we can't run from a script */
@ -500,7 +500,7 @@ static BOOL CONSOLE_make_complex(HANDLE handle)
* xterm: unable to open font "vga", trying "fixed"....
*/
execlp("xterm", "xterm", buf, "-fn","vga",NULL);
ERR(console, "error creating AllocConsole xterm\n");
ERR("error creating AllocConsole xterm\n");
exit(1);
}
@ -518,7 +518,7 @@ static BOOL CONSOLE_make_complex(HANDLE handle)
usleep(100);
}
if (i > 10000) {
ERR(console, "can't read xterm WID\n");
ERR("can't read xterm WID\n");
kill(xpid, SIGKILL);
return FALSE;
}
@ -550,7 +550,7 @@ BOOL WINAPI AllocConsole(VOID)
HANDLE hIn, hOut, hErr;
DWORD ret;
TRACE(console,"()\n");
TRACE("()\n");
CLIENT_SendRequest( REQ_ALLOC_CONSOLE, -1, 1, &req, sizeof(req) );
ret = CLIENT_WaitReply( NULL, NULL, 0 );
if (ret != ERROR_SUCCESS) {
@ -559,7 +559,7 @@ BOOL WINAPI AllocConsole(VOID)
* and our handles are wrong? puzzling -MM 990330
*/
if (ret!=ERROR_ACCESS_DENIED) {
ERR(console," failed to allocate console: %ld\n",ret);
ERR(" failed to allocate console: %ld\n",ret);
return FALSE;
}
}
@ -572,7 +572,7 @@ BOOL WINAPI AllocConsole(VOID)
if (ret != ERROR_SUCCESS)
{
/* FIXME: free console */
ERR(console," open console error %ld\n",ret);
ERR(" open console error %ld\n",ret);
return FALSE;
}
hIn = reply.handle;
@ -757,7 +757,7 @@ BOOL WINAPI WriteConsoleOutputA( HANDLE hConsoleOutput,
buffer = HeapAlloc(GetProcessHeap(),0,100);;
curbufsize = 100;
TRACE(console,"wr: top = %d, bottom=%d, left=%d,right=%d\n",
TRACE("wr: top = %d, bottom=%d, left=%d,right=%d\n",
lpWriteRegion->Top,
lpWriteRegion->Bottom,
lpWriteRegion->Left,
@ -825,7 +825,7 @@ BOOL WINAPI ReadConsoleA( HANDLE hConsoleInput,
struct read_console_input_request req;
INPUT_RECORD ir;
TRACE(console,"(%d,%p,%ld,%p,%p)\n",
TRACE("(%d,%p,%ld,%p,%p)\n",
hConsoleInput,lpBuffer,nNumberOfCharsToRead,
lpNumberOfCharsRead,lpReserved
);
@ -1092,7 +1092,7 @@ BOOL WINAPI SetConsoleCursorPosition( HANDLE hcon, COORD pos )
if (pos.y)
CONSOLE_make_complex(hcon);
TRACE(console, "%d (%dx%d)\n", hcon, pos.x , pos.y );
TRACE("%d (%dx%d)\n", hcon, pos.x , pos.y );
/* x are columns, y rows */
if (pos.y)
/* full screen cursor absolute positioning */
@ -1120,7 +1120,7 @@ BOOL WINAPI GetNumberOfConsoleInputEvents(HANDLE hcon,LPDWORD nrofevents)
*/
BOOL WINAPI GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons)
{
FIXME(console,"(%p): stub\n", nrofbuttons);
FIXME("(%p): stub\n", nrofbuttons);
*nrofbuttons = 2;
return TRUE;
}
@ -1191,7 +1191,7 @@ BOOL WINAPI SetConsoleWindowInfo(
BOOL bAbsolute, /* [in] Coordinate type flag */
LPSMALL_RECT window) /* [in] Address of new window rectangle */
{
FIXME(console, "(%x,%d,%p): stub\n", hcon, bAbsolute, window);
FIXME("(%x,%d,%p): stub\n", hcon, bAbsolute, window);
return TRUE;
}
@ -1215,7 +1215,7 @@ BOOL WINAPI SetConsoleTextAttribute(HANDLE hConsoleOutput,WORD wAttr)
DWORD xlen;
char buffer[20];
TRACE(console,"(%d,%d)\n",hConsoleOutput,wAttr);
TRACE("(%d,%d)\n",hConsoleOutput,wAttr);
sprintf(buffer,"%c[0;%s3%d;4%dm",
27,
(wAttr & FOREGROUND_INTENSITY)?"1;":"",
@ -1241,7 +1241,7 @@ BOOL WINAPI SetConsoleTextAttribute(HANDLE hConsoleOutput,WORD wAttr)
BOOL WINAPI SetConsoleScreenBufferSize( HANDLE hConsoleOutput,
COORD dwSize )
{
FIXME(console, "(%d,%dx%d): stub\n",hConsoleOutput,dwSize.x,dwSize.y);
FIXME("(%d,%dx%d): stub\n",hConsoleOutput,dwSize.x,dwSize.y);
return TRUE;
}
@ -1330,7 +1330,7 @@ BOOL WINAPI FillConsoleOutputAttribute( HANDLE hConsoleOutput,
WORD wAttribute, DWORD nLength, COORD dwCoord,
LPDWORD lpNumAttrsWritten)
{
FIXME(console, "(%d,%d,%ld,%dx%d,%p): stub\n", hConsoleOutput,
FIXME("(%d,%d,%ld,%dx%d,%p): stub\n", hConsoleOutput,
wAttribute,nLength,dwCoord.x,dwCoord.y,lpNumAttrsWritten);
*lpNumAttrsWritten = nLength;
return TRUE;
@ -1345,7 +1345,7 @@ BOOL WINAPI FillConsoleOutputAttribute( HANDLE hConsoleOutput,
BOOL WINAPI ReadConsoleOutputCharacterA(HANDLE hConsoleOutput,
LPSTR lpstr, DWORD dword, COORD coord, LPDWORD lpdword)
{
FIXME(console, "(%d,%p,%ld,%dx%d,%p): stub\n", hConsoleOutput,lpstr,
FIXME("(%d,%p,%ld,%dx%d,%p): stub\n", hConsoleOutput,lpstr,
dword,coord.x,coord.y,lpdword);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
@ -1362,7 +1362,7 @@ BOOL WINAPI ScrollConsoleScreenBuffer( HANDLE hConsoleOutput,
LPSMALL_RECT lpScrollRect, LPSMALL_RECT lpClipRect,
COORD dwDestOrigin, LPCHAR_INFO lpFill)
{
FIXME(console, "(%d,%p,%p,%dx%d,%p): stub\n", hConsoleOutput,lpScrollRect,
FIXME("(%d,%p,%p,%dx%d,%p): stub\n", hConsoleOutput,lpScrollRect,
lpClipRect,dwDestOrigin.x,dwDestOrigin.y,lpFill);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;

2
win32/error.c
View File

@ -5,8 +5,8 @@
*/
#include <errno.h>
#include "windef.h"
#include "winerror.h"
#include "debug.h"
/* The errno_xlat_table contains the errno-to-Win32 error
* mapping. Since this is a single table, it can't easily

16
win32/file.c
View File

@ -20,7 +20,7 @@
#include "device.h"
#include "process.h"
#include "heap.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(file)
@ -42,7 +42,7 @@ BOOL WINAPI ReadFileEx(HFILE hFile, LPVOID lpBuffer, DWORD numtoread,
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
FIXME(file, "file %d to buf %p num %ld %p func %p stub\n",
FIXME("file %d to buf %p num %ld %p func %p stub\n",
hFile, lpBuffer, numtoread, lpOverlapped, lpCompletionRoutine);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
@ -68,11 +68,11 @@ BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD attributes)
if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name ))
return FALSE;
TRACE(file,"(%s,%lx)\n",lpFileName,attributes);
TRACE("(%s,%lx)\n",lpFileName,attributes);
if (attributes & FILE_ATTRIBUTE_NORMAL) {
attributes &= ~FILE_ATTRIBUTE_NORMAL;
if (attributes)
FIXME(file,"(%s):%lx illegal combination with FILE_ATTRIBUTE_NORMAL.\n",
FIXME("(%s):%lx illegal combination with FILE_ATTRIBUTE_NORMAL.\n",
lpFileName,attributes);
}
if(stat(full_name.long_name,&buf)==-1)
@ -93,17 +93,17 @@ BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD attributes)
if (attributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (!S_ISDIR(buf.st_mode))
FIXME(file,"SetFileAttributes expected the file '%s' to be a directory",
FIXME("SetFileAttributes expected the file '%s' to be a directory",
lpFileName);
attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
}
attributes &= ~(FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
if (attributes)
FIXME(file,"(%s):%lx attribute(s) not implemented.\n",
FIXME("(%s):%lx attribute(s) not implemented.\n",
lpFileName,attributes);
if (-1==chmod(full_name.long_name,buf.st_mode))
{
MSG("Wine ERROR: Couldn't set file attributes for existing file \"%s\". Check permissions !\n", full_name.long_name);
MESSAGE("Wine ERROR: Couldn't set file attributes for existing file \"%s\". Check permissions !\n", full_name.long_name);
SetLastError(ErrnoToLastError(errno));
return FALSE;
}
@ -150,7 +150,7 @@ VOID WINAPI SetFileApisToANSI(void)
*/
BOOL WINAPI AreFileApisANSI(void)
{
FIXME(file,"(void): stub\n");
FIXME("(void): stub\n");
return TRUE;
}

4
win32/init.c
View File

@ -12,7 +12,7 @@
#include "wine/winestring.h"
#include "heap.h"
#include "task.h"
#include "debug.h"
#include "debugtools.h"
#include "process.h"
DEFAULT_DEBUG_CHANNEL(win32)
@ -28,7 +28,7 @@ VOID WINAPI GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo)
startup = ((LPSTARTUPINFOA )PROCESS_Current()->env_db->startup_info);
memcpy ( lpStartupInfo, startup, sizeof (STARTUPINFOA) );
TRACE ( win32, "size: %ld\n"
TRACE("size: %ld\n"
"\tlpReserverd: %s, lpDesktop: %s, lpTitle: %s\n"
"\tdwX: %ld, dwY: %ld, dwXSize: %ld, dwYSize: %ld\n"
"\tdwFlags: %lx, wShowWindow: %x\n", lpStartupInfo->cb,

4
win32/process.c
View File

@ -16,7 +16,7 @@
#include "file.h"
#include "task.h"
#include "toolhelp.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win32)
@ -25,7 +25,7 @@ DEFAULT_DEBUG_CHANNEL(win32)
* ContinueDebugEvent [KERNEL32.146]
*/
BOOL WINAPI ContinueDebugEvent(DWORD pid,DWORD tid,DWORD contstatus) {
FIXME(win32,"(0x%lx,%ld,%ld): stub\n",pid,tid,contstatus);
FIXME("(0x%lx,%ld,%ld): stub\n",pid,tid,contstatus);
return TRUE;
}

1
win32/struct32.c
View File

@ -6,7 +6,6 @@
#include "struct32.h"
#include "winerror.h"
#include "debug.h"
void STRUCT32_MSG16to32(const MSG16 *msg16,MSG *msg32)
{

1
win32/thread.c
View File

@ -9,7 +9,6 @@
#include <string.h>
#include "windef.h"
#include "winerror.h"
#include "debug.h"
/*

4
win32/time.c
View File

@ -10,7 +10,7 @@
#include <unistd.h>
#include "file.h"
#include "winerror.h"
#include "debug.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win32)
@ -148,7 +148,7 @@ BOOL WINAPI SystemTimeToTzSpecificLocalTime(
LPSYSTEMTIME lpUniversalTime,
LPSYSTEMTIME lpLocalTime) {
FIXME(win32, ":stub\n");
FIXME(":stub\n");
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}