1464 lines
46 KiB
C++
1464 lines
46 KiB
C++
/*
|
|
* DEBUG.CPP
|
|
*
|
|
* Purpose:
|
|
* RICHEDIT debugging support--commented out in ship builds
|
|
*
|
|
* History: <nl>
|
|
* 7/29/98 KeithCu Wrote it stealing much from Rich Arneson's code
|
|
*
|
|
* Copyright (c) 1995-1998, Microsoft Corporation. All rights reserved.
|
|
*/
|
|
|
|
#include "_common.h"
|
|
|
|
//Module is empty if this is a retail build.
|
|
#if defined(DEBUG) || defined(_RELEASE_ASSERTS_)
|
|
|
|
DWORD dwDebugOptions = 0; //Debug option flags
|
|
PFNASSERTHOOK pfnAssert = NULL; //Assert hook function
|
|
PFNTRACEHOOK pfnTrace = NULL; //Trace hook function
|
|
|
|
// Static variables
|
|
static HINSTANCE ghMod; //Dll module handle
|
|
static DWORD TlsIndex; //Debug output indent level
|
|
static HANDLE hLogFile = NULL; //Log file handle
|
|
static BOOL fIgnoreAsserts = FALSE; //Ignore all asserts if true
|
|
static CRITICAL_SECTION csLog; //Critical section for log file i/o
|
|
static CRITICAL_SECTION csAssert; //Critical section for asserts
|
|
static HANDLE hEventAssert1 = NULL; //Event for assert syncing
|
|
static HANDLE hEventAssert2 = NULL; //Event for assert syncing
|
|
static HWND hwndAssert = NULL; //Assert dialog window handle
|
|
static HANDLE hAssertThrd = NULL; //Assert thread handle
|
|
static char szAssert[MAXDEBUGSTRLEN]; //Assert message buffer
|
|
static int idAssert = -1; //Assert button pressed by user
|
|
DWORD WINAPI AssertThread(LPVOID lParam); //Assert thread entry point
|
|
static BOOL fDllDetach = FALSE; //True if we are in dll detach
|
|
|
|
//Strings for subsystem element of message
|
|
static char* TrcSubsys [] =
|
|
{
|
|
"",
|
|
"Display",
|
|
"Wrapper",
|
|
"Edit",
|
|
"TextServices",
|
|
"TOM",
|
|
"OLE Object Support",
|
|
"Store",
|
|
"Selection",
|
|
"WinHost",
|
|
"DataXfer",
|
|
"MultiUndo",
|
|
"Range",
|
|
"Util",
|
|
"Notification Mgr.",
|
|
"RTF Reader",
|
|
"RTF Writer",
|
|
"Printing",
|
|
"Far East",
|
|
"Font"
|
|
};
|
|
|
|
//Strings for severity element of message
|
|
static char* TrcSeverity [] =
|
|
{
|
|
"",
|
|
"WARNING",
|
|
"ERROR",
|
|
"ASSERT",
|
|
"INFO",
|
|
"MEMORY"
|
|
};
|
|
|
|
//Strings for scope element of message
|
|
static char* TrcScope [] =
|
|
{
|
|
"",
|
|
"External",
|
|
"Internal"
|
|
};
|
|
|
|
//Structure for lookup tables
|
|
typedef struct
|
|
{
|
|
DWORD dwKey;
|
|
char * sz;
|
|
} TabElem;
|
|
|
|
//Lookup table for CTrace param strings
|
|
static TabElem TrcParamTab [] =
|
|
{
|
|
//Richedit Messages
|
|
{(DWORD)EM_GETLIMITTEXT, "EM_GETLIMITTEXT"},
|
|
{(DWORD)EM_POSFROMCHAR, "EM_POSFROMCHAR"},
|
|
{(DWORD)EM_CHARFROMPOS, "EM_CHARFROMPOS"},
|
|
{(DWORD)EM_SCROLLCARET, "EM_SCROLLCARET"},
|
|
{(DWORD)EM_CANPASTE, "EM_CANPASTE"},
|
|
{(DWORD)EM_DISPLAYBAND, "EM_DISPLAYBAND"},
|
|
{(DWORD)EM_EXGETSEL, "EM_EXGETSEL"},
|
|
{(DWORD)EM_EXLIMITTEXT, "EM_EXLIMITTEXT"},
|
|
{(DWORD)EM_EXLINEFROMCHAR, "EM_EXLINEFROMCHAR"},
|
|
{(DWORD)EM_EXSETSEL, "EM_EXSETSEL"},
|
|
{(DWORD)EM_FINDTEXT, "EM_FINDTEXT"},
|
|
{(DWORD)EM_FORMATRANGE, "EM_FORMATRANGE"},
|
|
{(DWORD)EM_GETCHARFORMAT, "EM_GETCHARFORMAT"},
|
|
{(DWORD)EM_GETEVENTMASK, "EM_GETEVENTMASK"},
|
|
{(DWORD)EM_GETOLEINTERFACE, "EM_GETOLEINTERFACE"},
|
|
{(DWORD)EM_GETPARAFORMAT, "EM_GETPARAFORMAT"},
|
|
{(DWORD)EM_GETSELTEXT, "EM_GETSELTEXT"},
|
|
{(DWORD)EM_HIDESELECTION, "EM_HIDESELECTION"},
|
|
{(DWORD)EM_PASTESPECIAL, "EM_PASTESPECIAL"},
|
|
{(DWORD)EM_REQUESTRESIZE, "EM_REQUESTRESIZE"},
|
|
{(DWORD)EM_SELECTIONTYPE, "EM_SELECTIONTYPE"},
|
|
{(DWORD)EM_SETBKGNDCOLOR, "EM_SETBKGNDCOLOR"},
|
|
{(DWORD)EM_SETCHARFORMAT, "EM_SETCHARFORMAT"},
|
|
{(DWORD)EM_SETEVENTMASK, "EM_SETEVENTMASK"},
|
|
{(DWORD)EM_SETOLECALLBACK, "EM_SETOLECALLBACK"},
|
|
{(DWORD)EM_SETPARAFORMAT, "EM_SETPARAFORMAT"},
|
|
{(DWORD)EM_SETTARGETDEVICE, "EM_SETTARGETDEVICE"},
|
|
{(DWORD)EM_STREAMIN, "EM_STREAMIN"},
|
|
{(DWORD)EM_STREAMOUT, "EM_STREAMOUT"},
|
|
{(DWORD)EM_GETTEXTRANGE, "EM_GETTEXTRANGE"},
|
|
{(DWORD)EM_FINDWORDBREAK, "EM_FINDWORDBREAK"},
|
|
{(DWORD)EM_SETOPTIONS, "EM_SETOPTIONS"},
|
|
{(DWORD)EM_GETOPTIONS, "EM_GETOPTIONS"},
|
|
{(DWORD)EM_FINDTEXTEX, "EM_FINDTEXTEX"},
|
|
{(DWORD)EM_GETWORDBREAKPROCEX, "EM_GETWORDBREAKPROCEX"},
|
|
{(DWORD)EM_SETWORDBREAKPROCEX, "EM_SETWORDBREAKPROCEX"},
|
|
{(DWORD)EM_SETUNDOLIMIT, "EM_SETUNDOLIMIT"},
|
|
{(DWORD)EM_REDO, "EM_REDO"},
|
|
{(DWORD)EM_CANREDO, "EM_CANREDO"},
|
|
{(DWORD)EM_SETPUNCTUATION, "EM_SETPUNCTUATION"},
|
|
{(DWORD)EM_GETPUNCTUATION, "EM_GETPUNCTUATION"},
|
|
{(DWORD)EM_SETWORDWRAPMODE, "EM_SETWORDWRAPMODE"},
|
|
{(DWORD)EM_GETWORDWRAPMODE, "EM_GETWORDWRAPMODE"},
|
|
{(DWORD)EM_SETIMECOLOR, "EM_SETIMECOLOR"},
|
|
{(DWORD)EM_GETIMECOLOR, "EM_GETIMECOLOR"},
|
|
{(DWORD)EM_SETIMEOPTIONS, "EM_SETIMEOPTIONS"},
|
|
{(DWORD)EM_GETIMEOPTIONS, "EM_GETIMEOPTIONS"},
|
|
{(DWORD)EN_MSGFILTER, "EN_MSGFILTER"},
|
|
{(DWORD)EN_REQUESTRESIZE, "EN_REQUESTRESIZE"},
|
|
{(DWORD)EN_SELCHANGE, "EN_SELCHANGE"},
|
|
{(DWORD)EN_DROPFILES, "EN_DROPFILES"},
|
|
{(DWORD)EN_PROTECTED, "EN_PROTECTED"},
|
|
{(DWORD)EN_CORRECTTEXT, "EN_CORRECTTEXT"},
|
|
{(DWORD)EN_STOPNOUNDO, "EN_STOPNOUNDO"},
|
|
{(DWORD)EN_IMECHANGE, "EN_IMECHANGE"},
|
|
{(DWORD)EN_SAVECLIPBOARD, "EN_SAVECLIPBOARD"},
|
|
{(DWORD)EN_OLEOPFAILED, "EN_OLEOPFAILED"},
|
|
|
|
//Window Messages
|
|
|
|
{(DWORD)WM_NULL, "WM_NULL"},
|
|
{(DWORD)WM_CREATE, "WM_CREATE"},
|
|
{(DWORD)WM_DESTROY, "WM_DESTROY"},
|
|
{(DWORD)WM_MOVE, "WM_MOVE"},
|
|
{(DWORD)WM_SIZE, "WM_SIZE"},
|
|
{(DWORD)WM_ACTIVATE, "WM_ACTIVATE"},
|
|
{(DWORD)WM_SETFOCUS, "WM_SETFOCUS"},
|
|
{(DWORD)WM_KILLFOCUS, "WM_KILLFOCUS"},
|
|
{(DWORD)WM_ENABLE, "WM_ENABLE"},
|
|
{(DWORD)WM_SETREDRAW, "WM_SETREDRAW"},
|
|
{(DWORD)WM_SETTEXT, "WM_SETTEXT"},
|
|
{(DWORD)WM_GETTEXT, "WM_GETTEXT"},
|
|
{(DWORD)WM_GETTEXTLENGTH, "WM_GETTEXTLENGTH"},
|
|
{(DWORD)WM_PAINT, "WM_PAINT"},
|
|
{(DWORD)WM_CLOSE, "WM_CLOSE"},
|
|
{(DWORD)WM_QUERYENDSESSION, "WM_QUERYENDSESSION"},
|
|
{(DWORD)WM_QUIT, "WM_QUIT"},
|
|
{(DWORD)WM_QUERYOPEN, "WM_QUERYOPEN"},
|
|
{(DWORD)WM_ERASEBKGND, "WM_ERASEBKGND"},
|
|
{(DWORD)WM_SYSCOLORCHANGE, "WM_SYSCOLORCHANGE"},
|
|
{(DWORD)WM_ENDSESSION, "WM_ENDSESSION"},
|
|
{(DWORD)WM_SHOWWINDOW, "WM_SHOWWINDOW"},
|
|
{(DWORD)WM_WININICHANGE, "WM_WININICHANGE"},
|
|
{(DWORD)WM_SETTINGCHANGE, "WM_SETTINGCHANGE"},
|
|
{(DWORD)WM_DEVMODECHANGE, "WM_DEVMODECHANGE"},
|
|
{(DWORD)WM_ACTIVATEAPP, "WM_ACTIVATEAPP"},
|
|
{(DWORD)WM_FONTCHANGE, "WM_FONTCHANGE"},
|
|
{(DWORD)WM_TIMECHANGE, "WM_TIMECHANGE"},
|
|
{(DWORD)WM_CANCELMODE, "WM_CANCELMODE"},
|
|
{(DWORD)WM_SETCURSOR, "WM_SETCURSOR"},
|
|
{(DWORD)WM_MOUSEACTIVATE, "WM_MOUSEACTIVATE"},
|
|
{(DWORD)WM_CHILDACTIVATE, "WM_CHILDACTIVATE"},
|
|
{(DWORD)WM_QUEUESYNC, "WM_QUEUESYNC"},
|
|
{(DWORD)WM_GETMINMAXINFO, "WM_GETMINMAXINFO"},
|
|
{(DWORD)WM_PAINTICON, "WM_PAINTICON"},
|
|
{(DWORD)WM_ICONERASEBKGND, "WM_ICONERASEBKGND"},
|
|
{(DWORD)WM_NEXTDLGCTL, "WM_NEXTDLGCTL"},
|
|
{(DWORD)WM_SPOOLERSTATUS, "WM_SPOOLERSTATUS"},
|
|
{(DWORD)WM_DRAWITEM, "WM_DRAWITEM"},
|
|
{(DWORD)WM_MEASUREITEM, "WM_MEASUREITEM"},
|
|
{(DWORD)WM_DELETEITEM, "WM_DELETEITEM"},
|
|
{(DWORD)WM_VKEYTOITEM, "WM_VKEYTOITEM"},
|
|
{(DWORD)WM_CHARTOITEM, "WM_CHARTOITEM"},
|
|
{(DWORD)WM_SETFONT, "WM_SETFONT"},
|
|
{(DWORD)WM_GETFONT, "WM_GETFONT"},
|
|
{(DWORD)WM_SETHOTKEY, "WM_SETHOTKEY"},
|
|
{(DWORD)WM_GETHOTKEY, "WM_GETHOTKEY"},
|
|
{(DWORD)WM_QUERYDRAGICON, "WM_QUERYDRAGICON"},
|
|
{(DWORD)WM_COMPAREITEM, "WM_COMPAREITEM"},
|
|
{(DWORD)WM_COMPACTING, "WM_COMPACTING"},
|
|
{(DWORD)WM_COMMNOTIFY, "WM_COMMNOTIFY"},
|
|
{(DWORD)WM_WINDOWPOSCHANGING, "WM_WINDOWPOSCHANGING"},
|
|
{(DWORD)WM_WINDOWPOSCHANGED, "WM_WINDOWPOSCHANGED"},
|
|
{(DWORD)WM_POWER, "WM_POWER"},
|
|
{(DWORD)WM_COPYDATA, "WM_COPYDATA"},
|
|
{(DWORD)WM_CANCELJOURNAL, "WM_CANCELJOURNAL"},
|
|
{(DWORD)WM_NOTIFY, "WM_NOTIFY"},
|
|
{(DWORD)WM_INPUTLANGCHANGEREQUEST, "WM_INPUTLANGCHANGEREQUEST"},
|
|
{(DWORD)WM_INPUTLANGCHANGE, "WM_INPUTLANGCHANGE"},
|
|
{(DWORD)WM_TCARD, "WM_TCARD"},
|
|
{(DWORD)WM_HELP, "WM_HELP"},
|
|
{(DWORD)WM_USERCHANGED, "WM_USERCHANGED"},
|
|
{(DWORD)WM_NOTIFYFORMAT, "WM_NOTIFYFORMAT"},
|
|
{(DWORD)WM_CONTEXTMENU, "WM_CONTEXTMENU"},
|
|
{(DWORD)WM_STYLECHANGING, "WM_STYLECHANGING"},
|
|
{(DWORD)WM_STYLECHANGED, "WM_STYLECHANGED"},
|
|
{(DWORD)WM_DISPLAYCHANGE, "WM_DISPLAYCHANGE"},
|
|
{(DWORD)WM_GETICON, "WM_GETICON"},
|
|
{(DWORD)WM_SETICON, "WM_SETICON"},
|
|
{(DWORD)WM_NCCREATE, "WM_NCCREATE"},
|
|
{(DWORD)WM_NCDESTROY, "WM_NCDESTROY"},
|
|
{(DWORD)WM_NCCALCSIZE, "WM_NCCALCSIZE"},
|
|
{(DWORD)WM_NCHITTEST, "WM_NCHITTEST"},
|
|
{(DWORD)WM_NCPAINT, "WM_NCPAINT"},
|
|
{(DWORD)WM_NCACTIVATE, "WM_NCACTIVATE"},
|
|
{(DWORD)WM_GETDLGCODE, "WM_GETDLGCODE"},
|
|
{(DWORD)WM_NCMOUSEMOVE, "WM_NCMOUSEMOVE"},
|
|
{(DWORD)WM_NCLBUTTONDOWN, "WM_NCLBUTTONDOWN"},
|
|
{(DWORD)WM_NCLBUTTONUP, "WM_NCLBUTTONUP"},
|
|
{(DWORD)WM_NCLBUTTONDBLCLK, "WM_NCLBUTTONDBLCLK"},
|
|
{(DWORD)WM_NCRBUTTONDOWN, "WM_NCRBUTTONDOWN"},
|
|
{(DWORD)WM_NCRBUTTONUP, "WM_NCRBUTTONUP"},
|
|
{(DWORD)WM_NCRBUTTONDBLCLK, "WM_NCRBUTTONDBLCLK"},
|
|
{(DWORD)WM_NCMBUTTONDOWN, "WM_NCMBUTTONDOWN"},
|
|
{(DWORD)WM_NCMBUTTONUP, "WM_NCMBUTTONUP"},
|
|
{(DWORD)WM_NCMBUTTONDBLCLK, "WM_NCMBUTTONDBLCLK"},
|
|
{(DWORD)WM_KEYFIRST, "WM_KEYFIRST"},
|
|
{(DWORD)WM_KEYDOWN, "WM_KEYDOWN"},
|
|
{(DWORD)WM_KEYUP, "WM_KEYUP"},
|
|
{(DWORD)WM_CHAR, "WM_CHAR"},
|
|
{(DWORD)WM_DEADCHAR, "WM_DEADCHAR"},
|
|
{(DWORD)WM_SYSKEYDOWN, "WM_SYSKEYDOWN"},
|
|
{(DWORD)WM_SYSKEYUP, "WM_SYSKEYUP"},
|
|
{(DWORD)WM_SYSCHAR, "WM_SYSCHAR"},
|
|
{(DWORD)WM_SYSDEADCHAR, "WM_SYSDEADCHAR"},
|
|
{(DWORD)WM_KEYLAST, "WM_KEYLAST"},
|
|
{(DWORD)WM_IME_STARTCOMPOSITION, "WM_IME_STARTCOMPOSITION"},
|
|
{(DWORD)WM_IME_ENDCOMPOSITION, "WM_IME_ENDCOMPOSITION"},
|
|
{(DWORD)WM_IME_COMPOSITION, "WM_IME_COMPOSITION"},
|
|
{(DWORD)WM_IME_KEYLAST, "WM_IME_KEYLAST"},
|
|
{(DWORD)WM_INITDIALOG, "WM_INITDIALOG"},
|
|
{(DWORD)WM_COMMAND, "WM_COMMAND"},
|
|
{(DWORD)WM_SYSCOMMAND, "WM_SYSCOMMAND"},
|
|
{(DWORD)WM_TIMER, "WM_TIMER"},
|
|
{(DWORD)WM_HSCROLL, "WM_HSCROLL"},
|
|
{(DWORD)WM_VSCROLL, "WM_VSCROLL"},
|
|
{(DWORD)WM_INITMENU, "WM_INITMENU"},
|
|
{(DWORD)WM_INITMENUPOPUP, "WM_INITMENUPOPUP"},
|
|
{(DWORD)WM_MENUSELECT, "WM_MENUSELECT"},
|
|
{(DWORD)WM_MENUCHAR, "WM_MENUCHAR"},
|
|
{(DWORD)WM_ENTERIDLE, "WM_ENTERIDLE"},
|
|
{(DWORD)WM_CTLCOLORMSGBOX, "WM_CTLCOLORMSGBOX"},
|
|
{(DWORD)WM_CTLCOLOREDIT, "WM_CTLCOLOREDIT"},
|
|
{(DWORD)WM_CTLCOLORLISTBOX, "WM_CTLCOLORLISTBOX"},
|
|
{(DWORD)WM_CTLCOLORBTN, "WM_CTLCOLORBTN"},
|
|
{(DWORD)WM_CTLCOLORDLG, "WM_CTLCOLORDLG"},
|
|
{(DWORD)WM_CTLCOLORSCROLLBAR, "WM_CTLCOLORSCROLLBAR"},
|
|
{(DWORD)WM_CTLCOLORSTATIC, "WM_CTLCOLORSTATIC"},
|
|
{(DWORD)WM_MOUSEFIRST, "WM_MOUSEFIRST"},
|
|
{(DWORD)WM_MOUSEMOVE, "WM_MOUSEMOVE"},
|
|
{(DWORD)WM_LBUTTONDOWN, "WM_LBUTTONDOWN"},
|
|
{(DWORD)WM_LBUTTONUP, "WM_LBUTTONUP"},
|
|
{(DWORD)WM_LBUTTONDBLCLK, "WM_LBUTTONDBLCLK"},
|
|
{(DWORD)WM_RBUTTONDOWN, "WM_RBUTTONDOWN"},
|
|
{(DWORD)WM_RBUTTONUP, "WM_RBUTTONUP"},
|
|
{(DWORD)WM_RBUTTONDBLCLK, "WM_RBUTTONDBLCLK"},
|
|
{(DWORD)WM_MBUTTONDOWN, "WM_MBUTTONDOWN"},
|
|
{(DWORD)WM_MBUTTONUP, "WM_MBUTTONUP"},
|
|
{(DWORD)WM_MBUTTONDBLCLK, "WM_MBUTTONDBLCLK"},
|
|
{(DWORD)WM_MOUSELAST, "WM_MOUSELAST"},
|
|
{(DWORD)WM_PARENTNOTIFY, "WM_PARENTNOTIFY"},
|
|
{(DWORD)WM_ENTERMENULOOP, "WM_ENTERMENULOOP"},
|
|
{(DWORD)WM_EXITMENULOOP, "WM_EXITMENULOOP"},
|
|
{(DWORD)WM_NEXTMENU, "WM_NEXTMENU"},
|
|
{(DWORD)WM_SIZING, "WM_SIZING"},
|
|
{(DWORD)WM_CAPTURECHANGED, "WM_CAPTURECHANGED"},
|
|
{(DWORD)WM_MOVING, "WM_MOVING"},
|
|
{(DWORD)WM_POWERBROADCAST, "WM_POWERBROADCAST"},
|
|
{(DWORD)WM_DEVICECHANGE, "WM_DEVICECHANGE"},
|
|
{(DWORD)WM_IME_SETCONTEXT, "WM_IME_SETCONTEXT"},
|
|
{(DWORD)WM_IME_NOTIFY, "WM_IME_NOTIFY"},
|
|
{(DWORD)WM_IME_CONTROL, "WM_IME_CONTROL"},
|
|
{(DWORD)WM_IME_COMPOSITIONFULL, "WM_IME_COMPOSITIONFULL"},
|
|
{(DWORD)WM_IME_SELECT, "WM_IME_SELECT"},
|
|
{(DWORD)WM_IME_CHAR, "WM_IME_CHAR"},
|
|
{(DWORD)WM_IME_KEYDOWN, "WM_IME_KEYDOWN"},
|
|
{(DWORD)WM_IME_KEYUP, "WM_IME_KEYUP"},
|
|
{(DWORD)WM_MDICREATE, "WM_MDICREATE"},
|
|
{(DWORD)WM_MDIDESTROY, "WM_MDIDESTROY"},
|
|
{(DWORD)WM_MDIACTIVATE, "WM_MDIACTIVATE"},
|
|
{(DWORD)WM_MDIRESTORE, "WM_MDIRESTORE"},
|
|
{(DWORD)WM_MDINEXT, "WM_MDINEXT"},
|
|
{(DWORD)WM_MDIMAXIMIZE, "WM_MDIMAXIMIZE"},
|
|
{(DWORD)WM_MDITILE, "WM_MDITILE"},
|
|
{(DWORD)WM_MDICASCADE, "WM_MDICASCADE"},
|
|
{(DWORD)WM_MDIICONARRANGE, "WM_MDIICONARRANGE"},
|
|
{(DWORD)WM_MDIGETACTIVE, "WM_MDIGETACTIVE"},
|
|
{(DWORD)WM_MDISETMENU, "WM_MDISETMENU"},
|
|
{(DWORD)WM_ENTERSIZEMOVE, "WM_ENTERSIZEMOVE"},
|
|
{(DWORD)WM_EXITSIZEMOVE, "WM_EXITSIZEMOVE"},
|
|
{(DWORD)WM_DROPFILES, "WM_DROPFILES"},
|
|
{(DWORD)WM_MDIREFRESHMENU, "WM_MDIREFRESHMENU"},
|
|
{(DWORD)WM_CUT, "WM_CUT"},
|
|
{(DWORD)WM_COPY, "WM_COPY"},
|
|
{(DWORD)WM_PASTE, "WM_PASTE"},
|
|
{(DWORD)WM_CLEAR, "WM_CLEAR"},
|
|
{(DWORD)WM_UNDO, "WM_UNDO"},
|
|
{(DWORD)WM_RENDERFORMAT, "WM_RENDERFORMAT"},
|
|
{(DWORD)WM_RENDERALLFORMATS, "WM_RENDERALLFORMATS"},
|
|
{(DWORD)WM_DESTROYCLIPBOARD, "WM_DESTROYCLIPBOARD"},
|
|
{(DWORD)WM_DRAWCLIPBOARD, "WM_DRAWCLIPBOARD"},
|
|
{(DWORD)WM_PAINTCLIPBOARD, "WM_PAINTCLIPBOARD"},
|
|
{(DWORD)WM_VSCROLLCLIPBOARD, "WM_VSCROLLCLIPBOARD"},
|
|
{(DWORD)WM_SIZECLIPBOARD, "WM_SIZECLIPBOARD"},
|
|
{(DWORD)WM_ASKCBFORMATNAME, "WM_ASKCBFORMATNAME"},
|
|
{(DWORD)WM_CHANGECBCHAIN, "WM_CHANGECBCHAIN"},
|
|
{(DWORD)WM_HSCROLLCLIPBOARD, "WM_HSCROLLCLIPBOARD"},
|
|
{(DWORD)WM_QUERYNEWPALETTE, "WM_QUERYNEWPALETTE"},
|
|
{(DWORD)WM_PALETTEISCHANGING, "WM_PALETTEISCHANGING"},
|
|
{(DWORD)WM_PALETTECHANGED, "WM_PALETTECHANGED"},
|
|
{(DWORD)WM_HOTKEY, "WM_HOTKEY"},
|
|
{(DWORD)WM_PRINT, "WM_PRINT"},
|
|
{(DWORD)WM_PRINTCLIENT, "WM_PRINTCLIENT"},
|
|
{(DWORD)WM_HANDHELDFIRST, "WM_HANDHELDFIRST"},
|
|
{(DWORD)WM_HANDHELDLAST, "WM_HANDHELDLAST"},
|
|
{(DWORD)WM_AFXFIRST, "WM_AFXFIRST"},
|
|
{(DWORD)WM_AFXLAST, "WM_AFXLAST"},
|
|
{(DWORD)WM_PENWINFIRST, "WM_PENWINFIRST"},
|
|
{(DWORD)WM_PENWINLAST, "WM_PENWINLAST"},
|
|
{(DWORD)WM_APP, "WM_APP"}
|
|
};
|
|
|
|
// release + asserts build has no memory checking
|
|
#ifndef _RELEASE_ASSERTS_
|
|
|
|
void DlgDisplayVrgmst(HWND hListMemory)
|
|
{
|
|
char szTemp[300];
|
|
int cbTotal = 0;
|
|
for(int imst = 0; vrgmst[imst].szFile != 0; imst++)
|
|
{
|
|
cbTotal += vrgmst[imst].cbAlloc;
|
|
wsprintfA(szTemp, "%6.d %s", vrgmst[imst].cbAlloc, vrgmst[imst].szFile);
|
|
SendMessage(hListMemory, LB_ADDSTRING, 0, (LPARAM) szTemp);
|
|
}
|
|
|
|
wsprintfA(szTemp, "%6.d %s", cbTotal, "--- Total ---");
|
|
SendMessage(hListMemory, LB_ADDSTRING, 0, (LPARAM) szTemp);
|
|
}
|
|
|
|
HFONT hf = 0;
|
|
|
|
INT_PTR CALLBACK FDlgRicheditDebugCentral(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HWND hListMemory;
|
|
switch (message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
hListMemory = GetDlgItem(hdlg, IDC_MEMORY_STATISTICS);
|
|
LOGFONTA lf;
|
|
ZeroMemory(&lf, sizeof(lf));
|
|
lf.lfHeight = 14;
|
|
memcpy(lf.lfFaceName, "Courier New", 12);
|
|
hf = CreateFontIndirectA(&lf);
|
|
SendMessage(hListMemory, WM_SETFONT, (WPARAM)hf, FALSE);
|
|
UpdateMst();
|
|
DlgDisplayVrgmst(hListMemory);
|
|
return FALSE;
|
|
|
|
case WM_COMMAND:
|
|
switch (wParam)
|
|
{
|
|
case IDOK:
|
|
EndDialog(hdlg, IDOK);
|
|
return TRUE;
|
|
case IDCANCEL:
|
|
EndDialog(hdlg, IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void RicheditDebugCentral(void)
|
|
{
|
|
DialogBoxA(hinstRE, MAKEINTRESOURCEA(IDD_DEBUG), NULL, FDlgRicheditDebugCentral);
|
|
DeleteObject(hf);
|
|
}
|
|
|
|
#endif //!_RELEASE_ASSERTS_
|
|
|
|
|
|
/*
|
|
* DebugMain
|
|
*
|
|
* @mfunc
|
|
* Dll entry point. See Win32 SDK documentation for details.
|
|
* hDLL - handle of DLL
|
|
* dwReason - indicates why DLL called
|
|
* lpReserved - reserved
|
|
*
|
|
* @rdesc
|
|
* TRUE (always)
|
|
*
|
|
*/
|
|
BOOL WINAPI DebugMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved)
|
|
{
|
|
switch (dwReason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
{
|
|
//
|
|
// DLL is attaching to the address space of the current process.
|
|
//
|
|
ghMod = hDLL;
|
|
TlsIndex = TlsAlloc();
|
|
TlsSetValue(TlsIndex, (LPVOID)-1);
|
|
InitializeCriticalSection(&csLog);
|
|
InitializeCriticalSection(&csAssert);
|
|
|
|
//Create a separate thread to handle asserts.
|
|
//We use events to halt the the asserting thread
|
|
//during an assert, and to halt the assert thread the rest of
|
|
//the time. Note that these are autoreset events.
|
|
hEventAssert1= CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
hEventAssert2= CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
|
|
INITDEBUGSERVICES(OPTUSEDEFAULTS, NULL, NULL);
|
|
|
|
break;
|
|
}
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
{
|
|
|
|
//
|
|
// A new thread is being created in the current process.
|
|
//
|
|
TlsSetValue(TlsIndex, (LPVOID)-1);
|
|
break;
|
|
}
|
|
|
|
case DLL_THREAD_DETACH:
|
|
{
|
|
//
|
|
// A thread is exiting cleanly.
|
|
//
|
|
break;
|
|
}
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
{
|
|
//
|
|
// The calling process is detaching the DLL from its address space.
|
|
//
|
|
fDllDetach = TRUE;
|
|
|
|
//Clean up after ourselves.
|
|
TlsFree(TlsIndex);
|
|
SETLOGGING(FALSE);
|
|
|
|
//Clean up the assert thread stuff.
|
|
if (NULL != hAssertThrd)
|
|
TerminateThread(hAssertThrd, 0);
|
|
if (NULL != hEventAssert1)
|
|
CloseHandle(hEventAssert1);
|
|
if (NULL != hEventAssert2)
|
|
CloseHandle(hEventAssert2);
|
|
|
|
DeleteCriticalSection(&csLog);
|
|
DeleteCriticalSection(&csAssert);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//This is not in release asserts build
|
|
#ifndef _RELEASE_ASSERTS_
|
|
|
|
/*
|
|
* SetLogging
|
|
*
|
|
* @mfunc
|
|
* This function starts and stops logging of output from
|
|
* the debug services. If logging is being started, it
|
|
* creates a new file for logging (path and name specified
|
|
* in win.ini). fStartLog is TRUE and logging is already
|
|
* on, or fStartLog is FALSE and logging is off, this
|
|
* nothing happens.
|
|
*
|
|
* fStartLog - TRUE to start logging, FALSE to stop logging.
|
|
*
|
|
*/
|
|
void WINAPI SetLogging(BOOL fStartLog)
|
|
{
|
|
//Don't start logging if it's already on.
|
|
if (fStartLog && !fLogging)
|
|
{
|
|
char szLogFile[MAX_PATH];
|
|
|
|
//Set option flag telling everyone we're on
|
|
dwDebugOptions |= OPTLOGGINGON;
|
|
|
|
//Get file name
|
|
GetProfileStringA("RICHEDIT DEBUG", "LOGFILE", "", szLogFile, MAX_PATH);
|
|
|
|
//Create new file
|
|
hLogFile = CreateFileA(szLogFile, GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
//If we didn't succed creating the file, reset flags and tell user.
|
|
if (INVALID_HANDLE_VALUE == hLogFile)
|
|
{
|
|
dwDebugOptions &= ~OPTLOGGINGON;
|
|
MessageBoxA(NULL, "Unable to open log file.", "Richedit Debug", MB_OK);
|
|
}
|
|
}
|
|
//Don't stop logging if it's not on.
|
|
else if (!fStartLog && fLogging)
|
|
{
|
|
//Set option flag telling everyone we're off, and close file.
|
|
dwDebugOptions &= ~OPTLOGGINGON;
|
|
CloseHandle(hLogFile);
|
|
}
|
|
}
|
|
|
|
#endif //!_RELEASE_ASSERTS_
|
|
|
|
|
|
/*
|
|
* InitDebugServices
|
|
*
|
|
* @mfunc
|
|
* This function initializes the options for the debug
|
|
* services. If this function is not called, all optional
|
|
* debug services are left off by default.
|
|
* If OPTUSEDEFAULTS is specified for dwOpts, options are
|
|
* loaded from win.ini, otherwise the caller specified
|
|
* options are set. If the caller wishes to specify options
|
|
* they must specify all options they want turned on. Any
|
|
* options not explicitly specified will be turned off.
|
|
* The function also takes a pointer to an assert hook
|
|
* function and a trace hook function.
|
|
*
|
|
* dwOpts - Debug options to be set.
|
|
* pfnAssertHook - Pointer to assert hook function (NULL if none).
|
|
* pfnTraceHook - Pointer to trace hook function (NULL if none).
|
|
*
|
|
*/
|
|
DllExport void WINAPI InitDebugServices(DWORD dwOpts,
|
|
PFNASSERTHOOK pfnAssertHook, PFNTRACEHOOK pfnTraceHook)
|
|
{
|
|
// Check to see if OPTUSEDEFAULTS was specified. If so, get
|
|
// values from win.ini. Otherwise, set options to values
|
|
// specified by caller.
|
|
if (dwOpts & OPTUSEDEFAULTS)
|
|
{
|
|
SETLOGGING(GetProfileIntA("RICHEDIT DEBUG", "LOGGING", 0));
|
|
SETVERBOSE(GetProfileIntA("RICHEDIT DEBUG", "VERBOSE", 0));
|
|
SETINFO(GetProfileIntA("RICHEDIT DEBUG", "INFO", 0));
|
|
SETMEMORY(GetProfileIntA("RICHEDIT DEBUG", "MEMORY", 0));
|
|
SETTRACING(GetProfileIntA("RICHEDIT DEBUG", "TRACE", 0));
|
|
SETTRACEEXT(GetProfileIntA("RICHEDIT DEBUG", "TRACEEXT", 0));
|
|
SETOPT(OPTTRACEDISP, GetProfileIntA("RICHEDIT DEBUG", "TRACEDISP", 0));
|
|
SETOPT(OPTTRACEWRAP, GetProfileIntA("RICHEDIT DEBUG", "TRACEWRAP", 0));
|
|
SETOPT(OPTTRACEEDIT, GetProfileIntA("RICHEDIT DEBUG", "TRACEEDIT", 0));
|
|
SETOPT(OPTTRACETS, GetProfileIntA("RICHEDIT DEBUG", "TRACETS", 0));
|
|
SETOPT(OPTTRACETOM, GetProfileIntA("RICHEDIT DEBUG", "TRACETOM", 0));
|
|
SETOPT(OPTTRACEOLE, GetProfileIntA("RICHEDIT DEBUG", "TRACEOLE", 0));
|
|
SETOPT(OPTTRACEBACK, GetProfileIntA("RICHEDIT DEBUG", "TRACEBACK", 0));
|
|
SETOPT(OPTTRACESEL, GetProfileIntA("RICHEDIT DEBUG", "TRACESEL", 0));
|
|
SETOPT(OPTTRACEHOST, GetProfileIntA("RICHEDIT DEBUG", "TRACEHOST", 0));
|
|
SETOPT(OPTTRACEDTE, GetProfileIntA("RICHEDIT DEBUG", "TRACEDTE", 0));
|
|
SETOPT(OPTTRACEUNDO, GetProfileIntA("RICHEDIT DEBUG", "TRACEUNDO", 0));
|
|
SETOPT(OPTTRACERANG, GetProfileIntA("RICHEDIT DEBUG", "TRACERANG", 0));
|
|
SETOPT(OPTTRACEUTIL, GetProfileIntA("RICHEDIT DEBUG", "TRACEUTIL", 0));
|
|
SETOPT(OPTTRACENOTM, GetProfileIntA("RICHEDIT DEBUG", "TRACENOTM", 0));
|
|
SETOPT(OPTTRACERTFR, GetProfileIntA("RICHEDIT DEBUG", "TRACERTFR", 0));
|
|
SETOPT(OPTTRACERTFW, GetProfileIntA("RICHEDIT DEBUG", "TRACERTFW", 0));
|
|
SETOPT(OPTTRACEPRT, GetProfileIntA("RICHEDIT DEBUG", "TRACEPRT", 0));
|
|
SETOPT(OPTTRACEFE, GetProfileIntA("RICHEDIT DEBUG", "TRACEFE", 0));
|
|
SETOPT(OPTTRACEFONT, GetProfileIntA("RICHEDIT DEBUG", "TRACEFONT", 0));
|
|
}
|
|
else
|
|
{
|
|
//Set up logging before we set dwDebugOptions because
|
|
//SetLogging will not turn logging on if the flag
|
|
//indicates it is already on.
|
|
SETLOGGING(dwOpts & OPTLOGGINGON);
|
|
dwDebugOptions = dwOpts;
|
|
}
|
|
|
|
SETASSERTFN(pfnAssertHook);
|
|
SETTRACEFN(pfnTraceHook);
|
|
}
|
|
|
|
|
|
/*
|
|
* AssertProc
|
|
*
|
|
* @mfunc
|
|
* This is the dialog proc for the assert message.
|
|
/ *
|
|
* lParam - The string to display in the dialog.
|
|
*
|
|
*/
|
|
BOOL CALLBACK AssertProc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
RECT rcDlg, rcDesk;
|
|
|
|
GetWindowRect(hwndDlg, &rcDlg);
|
|
GetWindowRect(GetDesktopWindow(), &rcDesk);
|
|
|
|
SetWindowPos(hwndDlg, HWND_TOP,
|
|
((rcDesk.right - rcDesk.left ) - (rcDlg.right - rcDlg.left))/2,
|
|
((rcDesk.bottom - rcDesk.top ) - (rcDlg.bottom - rcDlg.top))/2,
|
|
0, 0, SWP_NOSIZE);
|
|
|
|
|
|
if (NULL != lParam)
|
|
SetDlgItemTextA(hwndDlg, IDC_MSG, (LPSTR)lParam);
|
|
|
|
//Sometimes we don't always end up on top. I don't know why.
|
|
SetForegroundWindow(hwndDlg);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
//Kill dialog and return button id that was pressed.
|
|
EndDialog(hwndDlg, LOWORD(wParam));
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* AssertThread
|
|
*
|
|
* @mfunc
|
|
* This is the entry point for the thread created for the
|
|
* assert dialog.
|
|
*
|
|
* lParam - Data passed to thread...not used.
|
|
*
|
|
* @rdesc
|
|
* Should not return. It will be explicitly terminated.
|
|
*
|
|
*/
|
|
DWORD WINAPI AssertThread(LPVOID lParam)
|
|
{
|
|
//This should run until it is explicitly terminated in
|
|
//process detach.
|
|
while(TRUE)
|
|
{
|
|
//We go into a wait state until the event is signaled,
|
|
//which means we are handling an assert.
|
|
WaitForSingleObject(hEventAssert1, INFINITE);
|
|
idAssert = DialogBoxParamA(ghMod, MAKEINTRESOURCEA(IDD_ASSERT),
|
|
NULL, (DLGPROC)AssertProc, (LPARAM)szAssert);
|
|
//The asserting thread will be waiting on this event so
|
|
//set it to allow the asserting thread continue.
|
|
SetEvent(hEventAssert2);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
char * __cdecl strrchr (
|
|
const char * string,
|
|
int ch
|
|
)
|
|
{
|
|
char *start = (char *)string;
|
|
|
|
while (*string++) /* find end of string */
|
|
;
|
|
/* search towards front */
|
|
while (--string != start && *string != (char)ch)
|
|
;
|
|
|
|
if (*string == (char)ch) /* char found ? */
|
|
return( (char *)string );
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
/*
|
|
* AssertSzFn
|
|
*
|
|
* @mfunc
|
|
* Display a message for the user and give the
|
|
* option to abort, ignore, or ignore all.
|
|
* Selecting ignore all causes all asserts to be
|
|
* ignored from that time forward. It cannot be
|
|
* reset. If the assert dialog cannot be created
|
|
* A message box is used. The message box has one
|
|
* button (OK) which will cause an abort.
|
|
*
|
|
* szFile - the file the warning occured in.
|
|
* iLine - the line number the warning occured at.
|
|
* szUserMsg - User define message string
|
|
*
|
|
*/
|
|
void AssertSzFn(LPSTR szUserMsg, LPSTR szFile, int iLine)
|
|
{
|
|
char szModuleName[MAX_PATH];
|
|
char * pszModuleName;
|
|
DWORD pid;
|
|
DWORD tid;
|
|
DWORD dwAssertTID;
|
|
|
|
//Check to see if an assert hook has been set. If it has, call
|
|
//it with pointers to all our parameters (they can be modified
|
|
//this way if desired). If the hook returns false, return.
|
|
//Otherwise, continue with our assert with the potentially
|
|
//modified parameters.
|
|
if (NULL != pfnAssert)
|
|
if (!pfnAssert(szUserMsg, szFile, &iLine))
|
|
return;
|
|
|
|
|
|
if( NULL == hAssertThrd )
|
|
{
|
|
if( NULL != hEventAssert1 && NULL != hEventAssert2)
|
|
{
|
|
hAssertThrd = CreateThread(NULL, 0, AssertThread,
|
|
NULL, 0, &dwAssertTID);
|
|
}
|
|
}
|
|
|
|
//This critical section will prevent us from being entered simultaneously
|
|
//by multiple threads. This alone will not prevent reentrance by our own thread
|
|
//once the assert dialog is up. Under normal circumstances a special thread
|
|
//exists to run the assert dialog and Event objects are used to halt this
|
|
//thread while the assert dialog is up (see WaitForSingleObject
|
|
//further down). If the assert thread does not exist, a MessageBox is used
|
|
//and we can be reentered (this is a fallback position and there's
|
|
//not much we can do about it).
|
|
EnterCriticalSection(&csAssert);
|
|
|
|
pid = GetCurrentProcessId();
|
|
tid = GetCurrentThreadId();
|
|
|
|
//Get the module name to include in assert message.
|
|
if (GetModuleFileNameA(NULL, szModuleName, MAX_PATH))
|
|
{
|
|
pszModuleName = strrchr(szModuleName, '\\');
|
|
if (!pszModuleName)
|
|
{
|
|
pszModuleName = szModuleName;
|
|
}
|
|
else
|
|
{
|
|
pszModuleName++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pszModuleName = "Unknown";
|
|
}
|
|
|
|
|
|
//Send a message to the debug output and build a string for the
|
|
//assert dialog. The string depends on whether the user provided
|
|
//a message.
|
|
if (NULL != szUserMsg)
|
|
{
|
|
TRACEASSERTSZ(szUserMsg, szFile, iLine);
|
|
sprintf(szAssert,
|
|
"PROCESS: %s, PID: %d, TID: %d\nFILE: %s (%d)\n%s\n",
|
|
pszModuleName, pid, tid, szFile, iLine, szUserMsg);
|
|
}
|
|
else
|
|
{
|
|
TRACEASSERT(szFile, iLine);
|
|
sprintf(szAssert,
|
|
"PROCESS: %s, PID: %d, TID: %d\nFILE: %s (%d)\n",
|
|
pszModuleName, pid, tid, szFile, iLine);
|
|
}
|
|
|
|
|
|
//If the user did not disable asserts on a previous assert,
|
|
//put up a dialog with the assert message.
|
|
if (!fIgnoreAsserts)
|
|
{
|
|
idAssert = -1;
|
|
|
|
//If we are in the middle of process detach, the assert thread
|
|
//will not execute so pop the dialog here ourselves. Presumably there
|
|
//is little change of reentrancy at this point. If we are not
|
|
//in process detach, let the assert thread handle the assert.
|
|
if (fDllDetach)
|
|
{
|
|
idAssert = DialogBoxParamA(ghMod, MAKEINTRESOURCEA(IDD_ASSERT),
|
|
NULL, (DLGPROC)AssertProc, (LPARAM)szAssert);
|
|
}
|
|
else
|
|
{
|
|
SetEvent(hEventAssert1);
|
|
WaitForSingleObject(hEventAssert2, INFINITE);
|
|
}
|
|
|
|
//The assert thread doesn't exist or the dialogbox create failed so
|
|
//use a message box instead. In this case, since we
|
|
//are obviously having problems, we are only going to
|
|
//give the user one choice...abort.
|
|
if (-1 == idAssert)
|
|
{
|
|
idAssert = MessageBoxA(NULL,
|
|
szAssert,
|
|
"Richedit Assert - (retry will be ignored)",
|
|
MB_SETFOREGROUND | MB_TASKMODAL |
|
|
MB_ICONEXCLAMATION | MB_ABORTRETRYIGNORE);
|
|
|
|
//
|
|
// If id == 0, then an error occurred. There are two possibilities
|
|
// that can cause the error: Access Denied, which means that this
|
|
// process does not have access to the default desktop, and everything
|
|
// else (usually out of memory).
|
|
//
|
|
if (!idAssert)
|
|
{
|
|
if (GetLastError() == ERROR_ACCESS_DENIED)
|
|
{
|
|
//
|
|
// Retry this one with the SERVICE_NOTIFICATION flag on. That
|
|
// should get us to the right desktop.
|
|
//
|
|
idAssert = MessageBoxA( NULL,
|
|
szAssert,
|
|
"Richedit Assert - (retry will be ignored)",
|
|
MB_SETFOREGROUND | MB_TASKMODAL | MB_ICONEXCLAMATION |
|
|
MB_ABORTRETRYIGNORE);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idAssert == ID_IGNOREALL)
|
|
{
|
|
fIgnoreAsserts = TRUE;
|
|
}
|
|
|
|
if (idAssert == IDABORT )
|
|
{
|
|
//This will cause a break when debugging, and
|
|
//an exception leading to termination otherwise.
|
|
DebugBreak();
|
|
return;
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&csAssert);
|
|
}
|
|
|
|
|
|
/*
|
|
* TabLookup
|
|
*
|
|
* @mfunc
|
|
* This function searches an array of TabElem
|
|
* structures looking for an entry whose key
|
|
* matches the one we were given. If found, it
|
|
* copies the string associated with the key into
|
|
* the supplied buffer.
|
|
*
|
|
* Table - TabElem pointer to start of array.
|
|
* TabSize - Size of array in bytes.
|
|
* dwKey - Key to match.
|
|
* szBuf - Buffer to hold string (assumed MAXDEBUGSTRLEN in size).
|
|
*
|
|
* @rdesc
|
|
* FALSE if key not found, TRUE if found.
|
|
*
|
|
*/
|
|
BOOL TabLookup(TabElem * Table, UINT TabSize, DWORD dwKey, LPSTR szBuf)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
UINT cTab, index;
|
|
|
|
cTab = TabSize/sizeof(TabElem);
|
|
|
|
for (index = 0; index < cTab; index++)
|
|
{
|
|
if (Table[index].dwKey == dwKey)
|
|
break;
|
|
}
|
|
|
|
if (index < cTab)
|
|
{
|
|
lstrcpyA(szBuf, Table[index].sz);
|
|
fRet = TRUE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
/*
|
|
* GetHResultSz
|
|
*
|
|
* @mfunc
|
|
* This function fills a buffer with a string associated
|
|
* with a given HRESULT. This string can then be used
|
|
* in the output from TraceMsg.
|
|
*
|
|
* hr - HRESULT on which the string will be based.
|
|
* szBuf - Buffer to hold string (MAXDEBUGSTRLEN in size).
|
|
*
|
|
*/
|
|
void GetHResultSz(HRESULT hr, LPSTR szBuf)
|
|
{
|
|
// Build string based on FormatMessageA
|
|
if (!FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, (DWORD)hr,
|
|
MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
|
|
szBuf, MAXDEBUGSTRLEN, NULL))
|
|
{
|
|
// Build default string
|
|
sprintf(szBuf, "hr = %d: Unrecognized HRESULT.", hr);
|
|
}
|
|
else
|
|
{
|
|
int cch;
|
|
char * pch;
|
|
|
|
//Need to get rid of the CRLF from FormatMessageA.
|
|
pch = szBuf;
|
|
cch = strlen(szBuf);
|
|
pch += (cch - 2);
|
|
*pch = '\0';
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* GetParamSz
|
|
*
|
|
* @mfunc
|
|
* This function fills a buffer with a string associated
|
|
* with a param from the text message handler.
|
|
* This string can then be used in the output from
|
|
* TraceMsg.
|
|
*
|
|
* dwParam - param on which the string will be based.
|
|
* szBuf - Buffer to hold string (MAXDEBUGSTRLEN in size).
|
|
*/
|
|
void GetParamSz(DWORD dwParam, LPSTR szBuf)
|
|
{
|
|
char szTemp[MAXDEBUGSTRLEN];
|
|
|
|
if (!TabLookup(TrcParamTab, sizeof(TrcParamTab), (DWORD)dwParam, szTemp))
|
|
{
|
|
sprintf(szBuf, "PARAM = %d: Unrecognized PARAM.", dwParam);
|
|
}
|
|
else
|
|
{
|
|
sprintf(szBuf, "PARAM: %s", szTemp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* GetDefaultSz
|
|
*
|
|
* @mfunc
|
|
* This function fills a buffer with a string associated
|
|
* with either the value from GetLastError, or with a
|
|
* default string. This string can then be used in the
|
|
* output from TraceMsg.
|
|
*
|
|
* dwError - Value from GetLastError.
|
|
* szBuf - Buffer to hold string (MAXDEBUGSTRLEN in size).
|
|
*
|
|
*/
|
|
void GetDefaultSz(DWORD dwError, LPSTR szBuf)
|
|
{
|
|
//Check to see if we have an error value
|
|
if (dwError)
|
|
{
|
|
// Build string based on FormatMessageA
|
|
if (!FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError,
|
|
MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
|
|
szBuf, MAXDEBUGSTRLEN, NULL))
|
|
{
|
|
// Build default string
|
|
lstrcpyA(szBuf, "Reason unknown.");
|
|
}
|
|
else
|
|
{
|
|
int cch;
|
|
char * pch;
|
|
|
|
//Need to get rid of the CRLF from FormatMessageA.
|
|
pch = szBuf;
|
|
cch = strlen(szBuf);
|
|
pch += (cch - 2);
|
|
*pch = '\0';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Build default string
|
|
lstrcpyA(szBuf, "Reason unknown.");
|
|
}
|
|
}
|
|
|
|
//The following are not used by the release with asserts build
|
|
#ifndef _RELEASE_ASSERTS_
|
|
|
|
/*
|
|
* GetDataSz
|
|
*
|
|
* @mfunc
|
|
* This function fills a buffer with a string representing
|
|
* data passed to TraceMsg in one of it's DWORDS data
|
|
* parameters. This string can then be used in the
|
|
* output from TraceMsg.
|
|
*
|
|
* uDataType - This is the type of data we are dealing with.
|
|
* dwData - This is the data itself.
|
|
* szBuf - Buffer to hold string (MAXDEBUGSTRLEN in size).
|
|
*
|
|
*/
|
|
void GetDataSz(UINT uDataType, DWORD dwData, LPSTR szBuf)
|
|
{
|
|
switch (uDataType)
|
|
{
|
|
// Data is an HRESULT
|
|
case TRCDATAHRESULT:
|
|
GetHResultSz((HRESULT)dwData, szBuf);
|
|
break;
|
|
|
|
// Data is a string (copy to szBuf and pass it through)
|
|
case TRCDATASTRING:
|
|
lstrcpyA(szBuf, (LPSTR)(DWORD_PTR)dwData);
|
|
break;
|
|
|
|
// Data is a parameter value
|
|
case TRCDATAPARAM:
|
|
GetParamSz(dwData, szBuf);
|
|
break;
|
|
|
|
// Get string based on GetLastError
|
|
case TRCDATADEFAULT:
|
|
default:
|
|
GetDefaultSz(dwData, szBuf);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* LogDebugString
|
|
*
|
|
* @mfunc
|
|
* This function writes a string to the log file. The file must
|
|
* be opened already and hLogFile must contain the handle.
|
|
*
|
|
* szDebugMsg - String to write to log file.
|
|
*
|
|
*/
|
|
void LogDebugString(LPSTR szDebugMsg)
|
|
{
|
|
if ((NULL != hLogFile) && (INVALID_HANDLE_VALUE != hLogFile))
|
|
{
|
|
DWORD dwMsgBytes, dwBytes;
|
|
|
|
dwMsgBytes = strlen(szDebugMsg)*sizeof(char);
|
|
|
|
//Prevent other threads from trying to write at same time.
|
|
EnterCriticalSection(&csLog);
|
|
SetFilePointer(hLogFile, 0, NULL, FILE_END);
|
|
WriteFile (hLogFile, szDebugMsg, dwMsgBytes, &dwBytes, NULL);
|
|
LeaveCriticalSection(&csLog);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* TraceMsg
|
|
*
|
|
* @mfunc
|
|
* This is the central message generating facility for
|
|
* the debug tools. All messages to the debug output
|
|
* or log file are generated here. This function takes
|
|
* a DWORD (dwFlags) that consists of packed values that determine
|
|
* the kind of message to generated. It takes two DWORD
|
|
* data parameters that can contain several different
|
|
* types of data (string, HRESULT, etc.) These are interpreted
|
|
* using dwFlags. It also takes the file and line associated with
|
|
* the point in the source where it was called.
|
|
*
|
|
* dwFlags - Packed values tell us how to generate the message.
|
|
* dwData1 - The first of two data parameters.
|
|
* dwData2 - The second of two data parameters.
|
|
* szFile - File name we were called from.
|
|
* iLine - Line number we were called from.
|
|
*
|
|
*/
|
|
void TraceMsg(DWORD dwFlags, DWORD dwData1, DWORD dwData2,
|
|
LPSTR szFile, int iLine)
|
|
{
|
|
//The following three buffers are used to build our message.
|
|
char szTemp[MAXDEBUGSTRLEN];
|
|
char szTemp2[MAXDEBUGSTRLEN];
|
|
char szDebugMsg[MAXDEBUGSTRLEN];
|
|
char* pch;
|
|
int cch;
|
|
TrcFlags trcf; //Used to decode dwFlags
|
|
DWORD pid;
|
|
DWORD tid;
|
|
DWORD dwError;
|
|
int indent, tls;
|
|
|
|
//Check to see if a Trace hook has been set. If it has, call
|
|
//it with pointers to all our parameters (they can be modified
|
|
//this way if desired). If the hook returns false, return.
|
|
//Otherwise, continue with our message output with the potentially
|
|
//modified parameters.
|
|
if (NULL != pfnTrace)
|
|
if (!pfnTrace(&dwFlags, &dwData1, &dwData2, szFile, &iLine))
|
|
return;
|
|
|
|
trcf.dw = dwFlags;
|
|
|
|
//Return if this is an informational message and they are disabled.
|
|
if ((TRCSEVINFO == trcf.fields.uSeverity) && !fInfo)
|
|
return;
|
|
|
|
// Call GetLastError now in case we need it later.
|
|
// This way api calls downstream won't disturb the value
|
|
// we need.
|
|
dwError = GetLastError();
|
|
pid = GetCurrentProcessId();
|
|
tid = GetCurrentThreadId();
|
|
szTemp[0] = '\0';
|
|
szTemp2[0] = '\0';
|
|
szDebugMsg[0] = '\0';
|
|
|
|
// Handle indentation (TLSindent is set by CTrace)
|
|
tls = (int)(DWORD_PTR)TlsGetValue(TlsIndex);
|
|
indent = (tls < 0 ? 0 : tls);
|
|
memset(szDebugMsg, ' ', 2*indent*sizeof(char));
|
|
szDebugMsg[2*indent] = '\0';
|
|
|
|
// Handle severity (Warning, Error, etc.)
|
|
if (TRCSEVNONE != trcf.fields.uSeverity)
|
|
{
|
|
sprintf(szTemp, "%s: ", TrcSeverity[trcf.fields.uSeverity]);
|
|
strcat(szDebugMsg, szTemp);
|
|
}
|
|
|
|
// Interpret the first data value
|
|
if (TRCDATANONE != trcf.fields.uData1)
|
|
{
|
|
if (TRCDATADEFAULT == trcf.fields.uData1)
|
|
dwData1 = dwError;
|
|
GetDataSz(trcf.fields.uData1, dwData1, szTemp2);
|
|
lstrcpyA(szTemp, szDebugMsg);
|
|
wsprintfA(szDebugMsg, "%s%s ", szTemp, szTemp2);
|
|
}
|
|
|
|
// Interpret the second data value.
|
|
if (TRCDATANONE != trcf.fields.uData2)
|
|
{
|
|
if (TRCDATADEFAULT == trcf.fields.uData2)
|
|
dwData2 = dwError;
|
|
GetDataSz(trcf.fields.uData2, dwData2, szTemp2);
|
|
lstrcpyA(szTemp, szDebugMsg);
|
|
wsprintfA(szDebugMsg, "%s%s", szTemp, szTemp2);
|
|
}
|
|
|
|
if (fVerbose)
|
|
{
|
|
// Handle scope (Internal/External call)
|
|
if (TRCSCOPENONE != trcf.fields.uScope)
|
|
{
|
|
sprintf(szTemp, "SCOPE: %s ", TrcScope[trcf.fields.uScope]);
|
|
strcat(szDebugMsg, szTemp);
|
|
}
|
|
|
|
// Handle subsytem (TOM, ITextServices, etc.)
|
|
if (TRCSUBSYSNONE != trcf.fields.uSubSystem)
|
|
{
|
|
sprintf(szTemp, "SUBSYSTEM: %s ", TrcSubsys[trcf.fields.uSubSystem]);
|
|
strcat(szDebugMsg, szTemp);
|
|
}
|
|
|
|
// Handle process ID, thread ID, file and line.
|
|
sprintf(szTemp, "PID: %u TID: %u ", pid, tid);
|
|
strcat(szDebugMsg, szTemp);
|
|
}
|
|
|
|
// Up to now there is no real danger of overflowing our buffer since
|
|
// we were dealing with strings of small size. Now we will be running
|
|
// in to paths and user strings. We will use _snprintf to concatonate
|
|
// new stuff to our message. This is not the most effecient way since
|
|
// it involves alot of copying, but it is a fairly simple way to keep
|
|
// adding to our string without having to worry about how much room is
|
|
// left in the buffer. It will truncate if we go past the end.
|
|
if (NULL != szFile)
|
|
{
|
|
lstrcpyA(szTemp, szDebugMsg);
|
|
|
|
if (0 != iLine)
|
|
{
|
|
wsprintfA(szDebugMsg, "%sFILE: %s (%u) ",
|
|
szTemp, szFile, iLine);
|
|
}
|
|
else
|
|
{
|
|
wsprintfA(szDebugMsg, "%sFILE: %s ",
|
|
szTemp, szFile);
|
|
}
|
|
}
|
|
|
|
// Append a CRLF to the end of the string (make sure we don't overflow)
|
|
cch = strlen(szDebugMsg);
|
|
pch = szDebugMsg;
|
|
if (cch < (MAXDEBUGSTRLEN - 3))
|
|
pch += cch;
|
|
else
|
|
pch += (MAXDEBUGSTRLEN - 3);
|
|
|
|
lstrcpyA(pch, "\r\n");
|
|
|
|
if (fLogging)
|
|
LogDebugString(szDebugMsg);
|
|
|
|
// Write to debug output.
|
|
OutputDebugStringA(szDebugMsg);
|
|
}
|
|
|
|
/*
|
|
* Tracef
|
|
*
|
|
* @mfunc:
|
|
* The given format string and parameters are used to render a
|
|
* string into a buffer. This string is passed to TraceMsg.
|
|
* The severity parameter determines the type of message. The
|
|
* following values are valid: TRCSEVWARN, TRCSEVERR, TRCSEVINFO.
|
|
*
|
|
* Arguments:
|
|
* dwSev Severity of message.
|
|
* szFmt Format string for wvsprintf (qqv)
|
|
*/
|
|
void Tracef(DWORD dwSev, LPSTR szFmt, ...)
|
|
{
|
|
va_list valMarker;
|
|
char rgchTraceTagBuffer[MAXDEBUGSTRLEN];
|
|
|
|
// format out a string
|
|
va_start(valMarker, szFmt);
|
|
wvsprintfA(rgchTraceTagBuffer, szFmt, valMarker);
|
|
va_end(valMarker);
|
|
|
|
if (dwSev == TRCSEVERR)
|
|
TraceMsg(MAKEFLAGS(TRCSUBSYSNONE, TRCSEVERR, TRCSCOPENONE,
|
|
TRCDATASTRING, TRCDATANONE), (DWORD)(DWORD_PTR)(rgchTraceTagBuffer),
|
|
(DWORD)0, NULL, 0);
|
|
else if (dwSev == TRCSEVWARN)
|
|
TraceMsg(MAKEFLAGS(TRCSUBSYSNONE, TRCSEVWARN, TRCSCOPENONE,
|
|
TRCDATASTRING, TRCDATANONE), (DWORD)(DWORD_PTR)(rgchTraceTagBuffer),
|
|
(DWORD)0, NULL, 0);
|
|
else if (dwSev == TRCSEVINFO)
|
|
TraceMsg(MAKEFLAGS(TRCSUBSYSNONE, TRCSEVINFO, TRCSCOPENONE,
|
|
TRCDATASTRING, TRCDATANONE), (DWORD)(DWORD_PTR)(rgchTraceTagBuffer),
|
|
(DWORD)0, NULL, 0);
|
|
else if (dwSev == TRCSEVMEM)
|
|
TraceMsg(MAKEFLAGS(TRCSUBSYSNONE, TRCSEVMEM, TRCSCOPENONE,
|
|
TRCDATASTRING, TRCDATANONE), (DWORD)(DWORD_PTR)(rgchTraceTagBuffer),
|
|
(DWORD)0, NULL, 0);
|
|
else
|
|
TraceMsg(MAKEFLAGS(TRCSUBSYSNONE, TRCSEVNONE, TRCSCOPENONE,
|
|
TRCDATASTRING, TRCDATANONE), (DWORD)(DWORD_PTR)(rgchTraceTagBuffer),
|
|
(DWORD)0, NULL, 0);
|
|
}
|
|
|
|
/*
|
|
* TraceError
|
|
*
|
|
* @mfunc:
|
|
* This function is for compatibility with old debug functionality.
|
|
* An error message is generated and sent to TraceMsg.
|
|
*
|
|
*/
|
|
void TraceError(LPSTR sz, LONG sc)
|
|
{
|
|
if (FAILED(sc))
|
|
{
|
|
char rgchTraceTagBuffer[MAXDEBUGSTRLEN];
|
|
|
|
wsprintfA(rgchTraceTagBuffer,
|
|
"%s, error=%ld (%#08lx).", sz, sc, sc);
|
|
TraceMsg(MAKEFLAGS(TRCSUBSYSNONE, TRCSEVERR, TRCSCOPENONE,
|
|
TRCDATASTRING, TRCDATANONE), (DWORD)(DWORD_PTR)(rgchTraceTagBuffer),
|
|
(DWORD)0, NULL, 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CheckTrace
|
|
*
|
|
* @mfunc
|
|
* This function checks to see if tracing should be performed
|
|
* in a function given the debug options set and the subsystem
|
|
* the function is in.
|
|
* ptrcf - Pointer to TrcFlags structure passed to CTrace.
|
|
*
|
|
* @rdesc
|
|
* True if tracing should be performed, false otherwise.
|
|
*
|
|
*/
|
|
static BOOL CheckTrace(TrcFlags * ptrcf)
|
|
{
|
|
DWORD dwOpt;
|
|
|
|
//Set dwOpt to the correct value for the subsytem we are
|
|
//in.
|
|
switch (ptrcf->fields.uSubSystem)
|
|
{
|
|
case TRCSUBSYSDISP: dwOpt = OPTTRACEDISP; break;
|
|
case TRCSUBSYSWRAP: dwOpt = OPTTRACEWRAP; break;
|
|
case TRCSUBSYSEDIT: dwOpt = OPTTRACEEDIT; break;
|
|
case TRCSUBSYSTS: dwOpt = OPTTRACETS; break;
|
|
case TRCSUBSYSTOM: dwOpt = OPTTRACETOM; break;
|
|
case TRCSUBSYSOLE: dwOpt = OPTTRACEOLE; break;
|
|
case TRCSUBSYSBACK: dwOpt = OPTTRACEBACK; break;
|
|
case TRCSUBSYSSEL: dwOpt = OPTTRACESEL; break;
|
|
case TRCSUBSYSHOST: dwOpt = OPTTRACEHOST; break;
|
|
case TRCSUBSYSDTE: dwOpt = OPTTRACEDTE; break;
|
|
case TRCSUBSYSUNDO: dwOpt = OPTTRACEUNDO; break;
|
|
case TRCSUBSYSRANG: dwOpt = OPTTRACERANG; break;
|
|
case TRCSUBSYSUTIL: dwOpt = OPTTRACEUTIL; break;
|
|
case TRCSUBSYSNOTM: dwOpt = OPTTRACENOTM; break;
|
|
case TRCSUBSYSRTFR: dwOpt = OPTTRACERTFR; break;
|
|
case TRCSUBSYSRTFW: dwOpt = OPTTRACERTFW; break;
|
|
case TRCSUBSYSPRT: dwOpt = OPTTRACEPRT; break;
|
|
case TRCSUBSYSFE: dwOpt = OPTTRACEFE; break;
|
|
case TRCSUBSYSFONT: dwOpt = OPTTRACEFONT; break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
//If there is no tracing at any level enabled, return false.
|
|
if (!ISOPTSET(dwOpt) && !fTrace
|
|
&& !(fTraceExt && (ptrcf->fields.uScope == TRCSCOPEEXTERN)))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTrace::CTrace
|
|
*
|
|
* @mfunc
|
|
* This constructor is used to generate output about the function
|
|
* it is called from. Creating an instance of this class on the
|
|
* stack at the beginning of a function, will cause a trace message
|
|
* to be sent to the debug output. When the function returns, the
|
|
* destructor will be called automatically and another message
|
|
* will be sent to the debug output.
|
|
* This constructor takes several parameters to pass on to
|
|
* TraceMsg and it also stores certain data for use by the destructor.
|
|
*
|
|
* dwFlags - Packed values tell us how to generate the message.
|
|
* dw1 - The first of two data parameters. This must be
|
|
* the name of the function we were called from.
|
|
* dw2 - The second of two data parameters. This will be either
|
|
* unused or it will be a parameter to be interpreted by
|
|
* TraceMsg.
|
|
* szFile - File name we were called from.
|
|
*
|
|
*/
|
|
CTrace::CTrace(DWORD dwFlags, DWORD dw1, DWORD dw2, LPSTR szFile)
|
|
{
|
|
char szFunc[80];
|
|
int tls;
|
|
|
|
trcf.dw = dwFlags;
|
|
|
|
//Return if tracing is not enabled.
|
|
if (!CheckTrace(&trcf))
|
|
return;
|
|
|
|
//Increment indentation level on entrance to function
|
|
tls = (int)(DWORD_PTR)TlsGetValue(TlsIndex);
|
|
tls++;
|
|
TlsSetValue(TlsIndex, (LPVOID)(DWORD_PTR)tls);
|
|
|
|
szFunc[0] = '\0';
|
|
lstrcpyA(szFileName, szFile);
|
|
lstrcpyA(szFuncName, (LPSTR)(DWORD_PTR)dw1);
|
|
|
|
sprintf(szFunc, "IN : %s.", szFuncName);
|
|
|
|
TraceMsg (trcf.dw, (DWORD)(DWORD_PTR)szFunc, dw2, szFileName, 0);
|
|
}
|
|
|
|
|
|
/*
|
|
* CTrace::~CTrace
|
|
*
|
|
* @mfunc
|
|
* This destructor is used to generate output about the function
|
|
* it is called from. Creating an instance of this class on the
|
|
* stack at the beginning of a function, will cause a trace message
|
|
* to be sent to the debug output. When the function returns, the
|
|
* destructor will be called automatically and another message
|
|
* will be sent to the debug output.
|
|
*
|
|
*
|
|
*/
|
|
CTrace::~CTrace()
|
|
{
|
|
char szFunc[80];
|
|
int tls;
|
|
|
|
//Return if tracing is not enabled.
|
|
if (!CheckTrace(&trcf))
|
|
return;
|
|
|
|
szFunc[0] = '\0';
|
|
sprintf(szFunc, "OUT: %s.", szFuncName);
|
|
|
|
trcf.fields.uData2 = TRCDATANONE;
|
|
TraceMsg (trcf.dw, (DWORD)(DWORD_PTR)szFunc, 0, szFileName, 0);
|
|
|
|
//Decrement indentation level on exit from function
|
|
tls = (int)(DWORD_PTR)TlsGetValue(TlsIndex);
|
|
tls--;
|
|
TlsSetValue(TlsIndex, (LPVOID)(DWORD_PTR)tls);
|
|
}
|
|
|
|
#endif //!_RELEASE_ASSERTS_
|
|
|
|
#endif // !!(DEBUG) && !! _RELEASE_ASSERTS_
|