Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

499 lines
11 KiB

//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1998 - 1998
//
// File: dbg_.cpp
//
//--------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////
// debug helpers
#if defined(_USE_MTFRMWK_TRACE) || defined(_USE_MTFRMWK_ASSERT)
#ifndef _MTFRMWK_INI_FILE
#define _MTFRMWK_INI_FILE (L"\\system32\\mtfrmwk.ini")
#endif
UINT GetInfoFromIniFile(LPCWSTR lpszSection, LPCWSTR lpszKey, INT nDefault = 0)
{
static LPCWSTR lpszFile = _MTFRMWK_INI_FILE;
WCHAR szFilePath[2*MAX_PATH];
UINT nLen = ::GetSystemWindowsDirectory(szFilePath, 2*MAX_PATH);
if (nLen == 0)
return nDefault;
wcscat(szFilePath, lpszFile);
return ::GetPrivateProfileInt(lpszSection, lpszKey, nDefault, szFilePath);
}
#endif // defined(_USE_MTFRMWK_TRACE) || defined(_USE_MTFRMWK_ASSERT)
#if defined(_USE_MTFRMWK_TRACE)
DWORD g_dwTrace = ::GetInfoFromIniFile(L"Debug", L"Trace");
void MtFrmwkTrace(LPCTSTR lpszFormat, ...)
{
if (g_dwTrace == 0)
return;
va_list args;
va_start(args, lpszFormat);
int nBuf;
WCHAR szBuffer[512];
nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer)/sizeof(WCHAR), lpszFormat, args);
// was there an error? was the expanded string too long?
ASSERT(nBuf >= 0);
::OutputDebugString(szBuffer);
va_end(args);
}
#endif
#if defined(DBG)
void MtFrmwkLogFile(LPCTSTR lpszFormat, ...)
{
va_list args;
va_start(args, lpszFormat);
int nBuf;
WCHAR szBuffer[512];
nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer)/sizeof(WCHAR), lpszFormat, args);
CLogFile* _dlog = CLogFile::GetInstance();
if (_dlog)
{
_dlog->writeln(szBuffer);
}
va_end(args);
}
void MtFrmwkLogFileIfLog(BOOL bLog, LPCTSTR lpszFormat, ...)
{
if (bLog)
{
va_list args;
va_start(args, lpszFormat);
int nBuf;
WCHAR szBuffer[512];
nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer)/sizeof(WCHAR), lpszFormat, args);
CLogFile* _dlog = CLogFile::GetInstance();
if (_dlog)
{
_dlog->writeln(szBuffer);
}
va_end(args);
}
}
#endif
//
// Copied and modified from burnslib on 12-07-1999 by JeffJon
// Needed file logging on DnsSetup call from DCPromo.
// I wanted it to behave like the DCPromo log but including all of
// burnslib required too many alterations in the debugging behavior
// already in place.
//
extern CString LOGFILE_NAME = _T("");
static CLogFile* log_instance = 0;
//
// # of spaces per indentation level
//
static const int TAB = 2;
static int margin = 0;
//
// index to Thread Local Storage slot where the per-thread debug state is
// kept. Initialized in Startup
//
static DWORD tls_index = 0;
CLogFile* CLogFile::GetInstance()
{
if (!log_instance && !LOGFILE_NAME.IsEmpty())
{
log_instance = new CLogFile(LOGFILE_NAME);
}
return log_instance;
}
void CLogFile::KillInstance()
{
delete log_instance;
log_instance = 0;
}
BOOL PathExists(PCWSTR pszPath)
{
DWORD attrs = GetFileAttributes(pszPath);
if (attrs != 0xFFFFFFFF)
{
return TRUE;
}
return FALSE;
}
HANDLE OpenFile(PCWSTR pszPath)
{
//
// remove the last element of the path to form the parent directory
//
HANDLE handle = ::CreateFile(pszPath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
0,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
0);
return handle;
}
PCWSTR GetSystemRootDirectory()
{
static CString SYSTEMROOT;
WCHAR buf[MAX_PATH + 1];
DWORD result = ::GetWindowsDirectory(buf, MAX_PATH + 1);
ASSERT(result != 0 && result <= MAX_PATH);
if (result == 0 || result > MAX_PATH)
{
return NULL;
}
SYSTEMROOT = buf;
return (PCWSTR)SYSTEMROOT;
}
// locate the log file with the highest-numbered extension, then add 1 and
// return the result.
int DetermineNextLogNumber(PCWSTR logDir, PCWSTR logBaseName)
{
ASSERT(logDir != NULL);
ASSERT(logBaseName != NULL);
int largest = 0;
CString filespec = CString(logDir) + L"\\" + CString(logBaseName) + L".*.log";
WIN32_FIND_DATA findData;
HANDLE ff = ::FindFirstFile(filespec, &findData);
if (ff != INVALID_HANDLE_VALUE)
{
for (;;)
{
CString current = findData.cFileName;
// grab the text between the dots: "nnn" in foo.nnn.ext
// first dot
int pos = current.Find(L".");
if (pos == -1)
{
continue;
}
CString extension = current.Right(current.GetLength() - pos - 1);
// second dot
pos = extension.Find(L".");
if (pos == -1)
{
continue;
}
extension = extension.Left(pos);
long i = 0;
i = wcstol(extension, L'\0', 10);
largest = max(i, largest);
if (!::FindNextFile(ff, &findData))
{
::FindClose(ff);
break;
}
}
}
// roll over after 255
return (++largest & 0xFF);
}
// Determine the name of the log file. If a log file of that name already
// exists, rename the existing file to a numbered backup. Create the new
// log file, return a handle to it.
//
HANDLE OpenNewLogFile(PCWSTR pszLogBaseName, CString& logName)
{
CString logDir = CString(GetSystemRootDirectory()) + L"\\debug";
int i = DetermineNextLogNumber(logDir, pszLogBaseName);
CString szCount;
szCount.Format(L"%d", i);
logName = logDir + L"\\" + pszLogBaseName + L"." + szCount + L".log";
HANDLE result = OpenFile(logName);
return result;
}
// Create a new log.
//
// logBaseName - base name of the log. If logging-to-file is active, then a
// file in the %windir%\debug folder will be created/used. The name of the
// file is of the form %windir%\debug\logBaseName.log. If a file by that name
// already exists, then the existing file will be renamed
// %windir%\debug\logBaseName.xxx.log, where xxx is an integer 1 greater than
// the last so-numbered file in that directory.
CLogFile::CLogFile(PCWSTR pszLogBaseName)
:
szBase_name(pszLogBaseName),
file_handle(INVALID_HANDLE_VALUE),
trace_line_number(0)
{
ASSERT(pszLogBaseName != NULL);
if (pszLogBaseName != NULL)
{
CString logName;
file_handle = OpenNewLogFile(pszLogBaseName, logName);
if (file_handle != INVALID_HANDLE_VALUE)
{
CString szOpeningFile;
szOpeningFile.Format(L"opening log file %ws", logName);
writeln(szOpeningFile);
}
}
SYSTEMTIME localtime;
::GetLocalTime(&localtime);
CString szTime;
szTime.Format(L"%d/%d/%d %d:%d:%d.%d",
localtime.wMonth,
localtime.wDay,
localtime.wYear,
localtime.wHour,
localtime.wMinute,
localtime.wSecond,
localtime.wMilliseconds);
writeln(szTime);
}
CLogFile::~CLogFile()
{
if (IsOpen())
{
writeln(L"closing log file");
::CloseHandle(file_handle);
file_handle = INVALID_HANDLE_VALUE;
}
}
// guarded by caller
void CLogFile::indent()
{
//
// indent by adding to the margin
//
margin += TAB;
}
BOOL CLogFile::IsOpen() const
{
return file_handle != INVALID_HANDLE_VALUE;
}
// guarded by caller
void CLogFile::outdent()
{
//
// outdent by subtracting from the margin
//
ASSERT(margin >= TAB);
margin = max(0, margin - TAB);
}
void ConvertStringToANSI(PCWSTR pszWide, PSTR* ppAnsi)
{
//
// determine the size of the buffer required to hold the ANSI string
//
int bufsize = ::WideCharToMultiByte(CP_ACP, 0, pszWide, static_cast<int>(wcslen(pszWide)), 0, 0, 0, 0);
if (bufsize > 0)
{
*ppAnsi = new CHAR[bufsize + 1];
if (*ppAnsi == NULL)
{
return;
}
memset(*ppAnsi, 0, bufsize + 1);
size_t result = ::WideCharToMultiByte(CP_ACP,
0,
pszWide,
static_cast<int>(wcslen(pszWide)),
*ppAnsi,
bufsize + 1,
0,
0);
ASSERT(result);
if (!result)
{
*ppAnsi = NULL;
}
}
}
//
// Spews output to the log according to the current logging type and
// output options in effect.
//
// type - log output type of this output spewage.
//
// text - the spewage. This is prefaced with the log name, thread id, spewage
// line number, and current indentation.
//
void CLogFile::writeln(PCWSTR pszText)
{
CString white(L' ',margin);
CString t;
t.Format(L"%ws t:0x%x %3d %ws%ws\r\n",
LOGFILE_NAME,
::GetCurrentThreadId(),
trace_line_number,
white,
pszText);
if (IsOpen())
{
ASSERT(file_handle != INVALID_HANDLE_VALUE);
ASSERT(!t.IsEmpty());
PSTR pAnsi;
ConvertStringToANSI(t, &pAnsi);
size_t bytesToWrite = sizeof(CHAR) * strlen(pAnsi);
DWORD bytes_written = 0;
BOOL success =::WriteFile(file_handle,
pAnsi,
static_cast<ULONG>(bytesToWrite),
&bytes_written,
0);
ASSERT(success);
ASSERT(bytes_written == bytesToWrite);
delete[] pAnsi;
}
trace_line_number++;
}
CScopeTracer::CScopeTracer(BOOL bLog, PCWSTR pszMessage_)
:
szMessage(pszMessage_),
m_bLog(bLog)
{
// build this string once, instead of using the string literal in the
// below expression (which would implicitly build the string on each
// evaluation of that expression) as a slight performance gain.
static const CString ENTER(L"Enter ");
if (m_bLog)
{
CLogFile* li = CLogFile::GetInstance();
li->writeln(ENTER + szMessage);
li->indent();
}
}
CScopeTracer::~CScopeTracer()
{
// build this string once, instead of using the string literal in the
// below expression (which would implicitly build the string on each
// evaluation of that expression) as a slight performance gain.
static const CString EXIT(L"Exit ");
if (m_bLog)
{
CLogFile* li = CLogFile::GetInstance();
li->outdent();
li->writeln(EXIT + szMessage);
}
}
#if defined(_USE_MTFRMWK_ASSERT)
DWORD g_dwAssert = ::GetInfoFromIniFile(L"Debug", L"Assert");
BOOL MtFrmwkAssertFailedLine(LPCSTR lpszFileName, int nLine)
{
if (g_dwAssert == 0)
return FALSE;
WCHAR szMessage[_MAX_PATH*2];
// assume the debugger or auxiliary port
wsprintf(szMessage, _T("Assertion Failed: File %hs, Line %d\n"),
lpszFileName, nLine);
OutputDebugString(szMessage);
// display the assert
int nCode = ::MessageBox(NULL, szMessage, _T("Assertion Failed!"),
MB_TASKMODAL|MB_ICONHAND|MB_ABORTRETRYIGNORE|MB_SETFOREGROUND);
OutputDebugString(L"after message box\n");
if (nCode == IDIGNORE)
{
return FALSE; // ignore
}
if (nCode == IDRETRY)
{
return TRUE; // will cause DebugBreak
}
abort(); // should not return
return TRUE;
}
#endif // _USE_MTFRMWK_ASSERT