#ifdef _DEBUG

#define TRACE              ::AfxTrace

#define TRACE0(sz)              ::AfxTrace(_T("%s"), _T(sz))
#define TRACE1(sz, p1)          ::AfxTrace(_T(sz), p1)
#define TRACE2(sz, p1, p2)      ::AfxTrace(_T(sz), p1, p2)
#define TRACE3(sz, p1, p2, p3)  ::AfxTrace(_T(sz), p1, p2, p3)

#else

inline void AFX_CDECL AfxTrace(LPCTSTR, ...) { }

#define TRACE              1 ? (void)0 : ::AfxTrace
#define TRACE0(sz)
#define TRACE1(sz, p1)
#define TRACE2(sz, p1, p2)
#define TRACE3(sz, p1, p2, p3)
#endif

 

MFC调试输出的核心函数是AfxTrace,其代码如下:

#ifdef _DEBUG   // entire file

#ifdef AFX_AUX_SEG
#pragma code_seg(AFX_AUX_SEG)
#endif

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/
// Helper routines that can be called from debugger

void AFXAPI AfxDump(const CObject* pOb)
{
 afxDump << pOb;
}

/
// Diagnostic Trace

void AFX_CDECL AfxTrace(LPCTSTR lpszFormat, ...)
{
#ifdef _DEBUG // all AfxTrace output is controlled by afxTraceEnabled
 if (!afxTraceEnabled)
  return;
#endif

 va_list args;
 va_start(args, lpszFormat);

 int nBuf;
 TCHAR szBuffer[512];

 nBuf = _vsntprintf(szBuffer, _countof(szBuffer), lpszFormat, args);

 // was there an error? was the expanded string too long?
 ASSERT(nBuf >= 0);

 if ((afxTraceFlags & traceMultiApp) && (AfxGetApp() != NULL))
  afxDump << AfxGetApp()->m_pszExeName << ": ";
  afxDump << szBuffer;

 va_end(args);
}
#endif //_DEBUG

 

三 全局DumpDC

AFX_DATADEF CDumpContext afxDump;

 

 

class CDumpContext
{
public:
 CDumpContext(CFile* pFile = NULL);

// Attributes
 int GetDepth() const;      // 0 => this object, 1 => children objects
 void SetDepth(int nNewDepth);

// Operations
 CDumpContext& operator<<(LPCTSTR lpsz);
#ifdef _UNICODE
 CDumpContext& operator<<(LPCSTR lpsz);  // automatically widened
#else
 CDumpContext& operator<<(LPCWSTR lpsz); // automatically thinned
#endif
 CDumpContext& operator<<(const void* lp);
 CDumpContext& operator<<(const CObject* pOb);
 CDumpContext& operator<<(const CObject& ob);
 CDumpContext& operator<<(BYTE by);
 CDumpContext& operator<<(WORD w);
 CDumpContext& operator<<(UINT u);
 CDumpContext& operator<<(LONG l);
 CDumpContext& operator<<(DWORD dw);
 CDumpContext& operator<<(float f);
 CDumpContext& operator<<(double d);
 CDumpContext& operator<<(int n);
 void HexDump(LPCTSTR lpszLine, BYTE* pby, int nBytes, int nWidth);
 void Flush();

// Implementation
protected:
 // dump context objects cannot be copied or assigned
 CDumpContext(const CDumpContext& dcSrc);
 void operator=(const CDumpContext& dcSrc);
 void OutputString(LPCTSTR lpsz);

 int m_nDepth;

public:
 CFile* m_pFile;
};

 

void CDumpContext::HexDump(LPCTSTR lpszLine, BYTE* pby,
 int nBytes, int nWidth)
// do a simple hex-dump (8 per line) to a CDumpContext
//  the "lpszLine" is a string to print at the start of each line
//    (%lx should be used to expand the current address)
{
 ASSERT(nBytes > 0);
 ASSERT(nWidth > 0);
 ASSERT(AfxIsValidString(lpszLine));
 ASSERT(AfxIsValidAddress(pby, nBytes, FALSE));

#ifdef _DEBUG // all CDumpContext output is controlled by afxTraceEnabled
 if (!afxTraceEnabled)
  return;
#endif //_DEBUG

 int nRow = 0;
 TCHAR szBuffer[32];

 while (nBytes--)
 {
  if (nRow == 0)
  {
   wsprintf(szBuffer, lpszLine, pby);
   *this << szBuffer;
  }

  wsprintf(szBuffer, _T(" %02X"), *pby++);
  *this << szBuffer;

  if (++nRow >= nWidth)
  {
   *this << _T("/n");
   nRow = 0;
  }
 }
 if (nRow != 0)
  *this << _T("/n");
}

/

#ifdef _UNICODE
// special version for ANSI characters
CDumpContext& CDumpContext::operator<<(LPCSTR lpsz)
{
 if (lpsz == NULL)
 {
  OutputString(L"(NULL)");
  return *this;
 }

#ifdef _DEBUG // all CDumpContext output is controlled by afxTraceEnabled
 if (!afxTraceEnabled)
  return *this;
#endif //_DEBUG

 // limited length
 TCHAR szBuffer[512];
 _mbstowcsz(szBuffer, lpsz, _countof(szBuffer));
 return *this << szBuffer;
}

 

CDumpContext& CDumpContext::operator<<(LPCTSTR lpsz)
{
 if (lpsz == NULL)
 {
  OutputString(_T("(NULL)"));
  return *this;
 }

#ifdef _DEBUG // all CDumpContext output is controlled by afxTraceEnabled
 if (!afxTraceEnabled)
  return *this;
#endif //_DEBUG

 if (m_pFile == NULL)
 {
  TCHAR szBuffer[512];
  LPTSTR lpBuf = szBuffer;
  while (*lpsz != '/0')
  {
   if (lpBuf > szBuffer + _countof(szBuffer) - 3)
   {
    *lpBuf = '/0';
    OutputString(szBuffer);
    lpBuf = szBuffer;
   }
   if (*lpsz == '/n')
    *lpBuf++ = '/r';
   *lpBuf++ = *lpsz++;
  }
  *lpBuf = '/0';
  OutputString(szBuffer);
  return *this;
 }

 m_pFile->Write(lpsz, lstrlen(lpsz)*sizeof(TCHAR));
 return *this;
}

 

void CDumpContext::Flush()
{
 if (m_pFile)
  m_pFile->Flush();
}

void CDumpContext::OutputString(LPCTSTR lpsz)
{
#ifdef _DEBUG
 // all CDumpContext output is controlled by afxTraceEnabled
 if (!afxTraceEnabled)
  return;
#endif

 // use C-runtime/OutputDebugString when m_pFile is NULL
 if (m_pFile == NULL)
 {
  AfxOutputDebugString(lpsz);
  return;
 }

 // otherwise, write the string to the file
 m_pFile->Write(lpsz, lstrlen(lpsz)*sizeof(TCHAR));
}

 

#ifdef _UNICODE
#define AfxOutputDebugString(lpsz) /
 do /
 { /
  USES_CONVERSION; /
  _RPT0(_CRT_WARN, W2CA(lpsz)); /
 } while (0)
#else
#define AfxOutputDebugString(lpsz) _RPT0(_CRT_WARN, lpsz)
#endif

 

#ifdef _DEBUG

#define _RPT0(rptno, msg) /
        do { if ((1 == _CrtDbgReport(rptno, NULL, 0, NULL, "%s", msg))) /
                _CrtDbgBreak(); } while (0)
#endif

 

 

_CRTIMP int __cdecl _CrtDbgReport(
        int nRptType,
        const char * szFile,
        int nLine,
        const char * szModule,
        const char * szFormat,
        ...
        )
{
        int retval;
        va_list arglist;
        char szLineMessage[MAX_MSG] = {0};
        char szOutMessage[MAX_MSG] = {0};
        char szUserMessage[MAX_MSG] = {0};
        #define ASSERTINTRO1 "Assertion failed: "
        #define ASSERTINTRO2 "Assertion failed!"

        va_start(arglist, szFormat);

        if (nRptType < 0 || nRptType >= _CRT_ERRCNT)
            return -1;

        /*
         * handle the (hopefully rare) case of
         *
         * 1) ASSERT while already dealing with an ASSERT
         *      or
         * 2) two threads asserting at the same time
         */
        if (_CRT_ASSERT == nRptType && _CrtInterlockedIncrement(&_crtAssertBusy) > 0)
        {
            /* use only 'safe' functions -- must not assert in here! */
#ifdef _WIN32
            static int (APIENTRY *pfnwsprintfA)(LPSTR, LPCSTR, ...) = NULL;

            if (NULL == pfnwsprintfA)
            {
                HANDLE hlib = LoadLibrary("user32.dll");

                if (NULL == hlib || NULL == (pfnwsprintfA =
                            (int (APIENTRY *)(LPSTR, LPCSTR, ...))
                            GetProcAddress(hlib, "wsprintfA")))
                    return -1;
            }

            (*pfnwsprintfA)( szOutMessage,
                "Second Chance Assertion Failed: File %s, Line %d/n",
                szFile, nLine);

            OutputDebugString(szOutMessage);
#else  /* _WIN32 */
            strcpy(szOutMessage, "Second Chance Assertion Failed: File ");
            strcat(szOutMessage, szFile);
            strcat(szOutMessage, ", Line ");
            numtostring(nLine, &szOutMessage[strlen(szOutMessage)]);
            strcat(szOutMessage, "/n");
            _CrtOutputDebugString(szOutMessage);
#endif  /* _WIN32 */

            _CrtInterlockedDecrement(&_crtAssertBusy);

            _CrtDbgBreak();
            return -1;
        }

        if (szFormat && _vsnprintf(szUserMessage,
                       MAX_MSG-max(sizeof(ASSERTINTRO1),sizeof(ASSERTINTRO2)),
                       szFormat,
                       arglist) < 0)
            strcpy(szUserMessage, TOOLONGMSG);

        if (_CRT_ASSERT == nRptType)
            strcpy(szLineMessage, szFormat ? ASSERTINTRO1 : ASSERTINTRO2);

        strcat(szLineMessage, szUserMessage);

        if (_CRT_ASSERT == nRptType)
        {
            if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE)
                strcat(szLineMessage, "/r");
            strcat(szLineMessage, "/n");
        }

        if (szFile)
        {
            if (_snprintf(szOutMessage, MAX_MSG, "%s(%d) : %s",
                szFile, nLine, szLineMessage) < 0)
            strcpy(szOutMessage, TOOLONGMSG);
        }
        else
            strcpy(szOutMessage, szLineMessage);

        /* user hook may handle report */
        if (_pfnReportHook && (*_pfnReportHook)(nRptType, szOutMessage, &retval))
        {
            if (_CRT_ASSERT == nRptType)
                _CrtInterlockedDecrement(&_crtAssertBusy);
            return retval;
        }

        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE)
        {
            if (_CrtDbgFile[nRptType] != _CRTDBG_INVALID_HFILE)
            {
#ifdef _WIN32
                DWORD written;
                WriteFile(_CrtDbgFile[nRptType], szOutMessage, strlen(szOutMessage), &written, NULL);
#else  /* _WIN32 */
                long written = strlen(szOutMessage);

                FSWrite((short)_CrtDbgFile[nRptType], &written, szOutMessage);
#endif  /* _WIN32 */
            }
        }

        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_DEBUG)
        {
#ifdef _WIN32
            OutputDebugString(szOutMessage);
#else  /* _WIN32 */
            _CrtOutputDebugString(szOutMessage);
#endif  /* _WIN32 */
        }

        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_WNDW)
        {
            char szLine[20];

            retval = CrtMessageWindow(nRptType, szFile, nLine ? _itoa(nLine, szLine, 10) : NULL, szModule, szUserMessage);
            if (_CRT_ASSERT == nRptType)
                _CrtInterlockedDecrement(&_crtAssertBusy);
            return retval;
        }

        if (_CRT_ASSERT == nRptType)
            _CrtInterlockedDecrement(&_crtAssertBusy);
        /* ignore */
        return FALSE;
}

VOID
WINAPI
OutputDebugStringA(LPCSTR _OutputString)
{
 _SEH2_TRY
 {
  ULONG_PTR a_nArgs[2];

  a_nArgs[0] = (ULONG_PTR)(strlen(_OutputString) + 1);
  a_nArgs[1] = (ULONG_PTR)_OutputString;

  /* send the string to the user-mode debugger */
  RaiseException(DBG_PRINTEXCEPTION_C, 0, 2, a_nArgs);
 }
 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 {
  /* no user-mode debugger: try the systemwide debug message monitor, or the
     kernel debugger as a last resort */

  /* mutex used to synchronize invocations of OutputDebugString */
  static HANDLE s_hDBMonMutex = NULL;
  /* true if we already attempted to open/create the mutex */
  static BOOL s_bDBMonMutexTriedOpen = FALSE;

  /* local copy of the mutex handle */
  volatile HANDLE hDBMonMutex = s_hDBMonMutex;
  /* handle to the Section of the shared buffer */
  volatile HANDLE hDBMonBuffer = NULL;

  /* pointer to the mapped view of the shared buffer. It consist of the current
     process id followed by the message string */
  struct { DWORD ProcessId; CHAR Buffer[1]; } * pDBMonBuffer = NULL;

  /* event: signaled by the debug message monitor when OutputDebugString can write
     to the shared buffer */
  volatile HANDLE hDBMonBufferReady = NULL;

  /* event: to be signaled by OutputDebugString when it's done writing to the
     shared buffer */
  volatile HANDLE hDBMonDataReady = NULL;

  /* mutex not opened, and no previous attempts to open/create it */
  if(hDBMonMutex == NULL && !s_bDBMonMutexTriedOpen)
  {
   /* open/create the mutex */
   hDBMonMutex = K32CreateDBMonMutex();
   /* store the handle */
   s_hDBMonMutex = hDBMonMutex;
  }

  _SEH2_TRY
  {
   volatile PCHAR a_cBuffer = NULL;

   /* opening the mutex failed */
   if(hDBMonMutex == NULL)
   {
    /* remember next time */
    s_bDBMonMutexTriedOpen = TRUE;
   }
   /* opening the mutex succeeded */
   else
   {
    do
    {
     /* synchronize with other invocations of OutputDebugString */
     WaitForSingleObject(hDBMonMutex, INFINITE);

     /* buffer of the system-wide debug message monitor */
     hDBMonBuffer = OpenFileMappingW(SECTION_MAP_WRITE, FALSE, L"DBWIN_BUFFER");

     /* couldn't open the buffer: send the string to the kernel debugger */
     if(hDBMonBuffer == NULL) break;

     /* map the buffer */
     pDBMonBuffer = MapViewOfFile(hDBMonBuffer,
             SECTION_MAP_READ | SECTION_MAP_WRITE,
             0,
             0,
             0);

     /* couldn't map the buffer: send the string to the kernel debugger */
     if(pDBMonBuffer == NULL) break;

     /* open the event signaling that the buffer can be accessed */
     hDBMonBufferReady = OpenEventW(SYNCHRONIZE, FALSE, L"DBWIN_BUFFER_READY");

     /* couldn't open the event: send the string to the kernel debugger */
     if(hDBMonBufferReady == NULL) break;

     /* open the event to be signaled when the buffer has been filled */
     hDBMonDataReady = OpenEventW(EVENT_MODIFY_STATE, FALSE, L"DBWIN_DATA_READY");
    }
    while(0);

    /* we couldn't connect to the system-wide debug message monitor: send the
       string to the kernel debugger */
    if(hDBMonDataReady == NULL) ReleaseMutex(hDBMonMutex);
   }

   _SEH2_TRY
   {
    /* size of the current output block */
    volatile SIZE_T nRoundLen;

    /* size of the remainder of the string */
    volatile SIZE_T nOutputStringLen;

    /* output the whole string */
    nOutputStringLen = strlen(_OutputString);

    do
    {
     /* we're connected to the debug monitor:
        write the current block to the shared buffer */
     if(hDBMonDataReady)
     {
      /* wait a maximum of 10 seconds for the debug monitor
         to finish processing the shared buffer */
      if(WaitForSingleObject(hDBMonBufferReady, 10000) != WAIT_OBJECT_0)
      {
       /* timeout or failure: give up */
       break;
      }

      /* write the process id into the buffer */
      pDBMonBuffer->ProcessId = GetCurrentProcessId();

      /* write only as many bytes as they fit in the buffer */
      if(nOutputStringLen > (PAGE_SIZE - sizeof(DWORD) - 1))
       nRoundLen = PAGE_SIZE - sizeof(DWORD) - 1;
      else
       nRoundLen = nOutputStringLen;

      /* copy the current block into the buffer */
      memcpy(pDBMonBuffer->Buffer, _OutputString, nRoundLen);

      /* null-terminate the current block */
      pDBMonBuffer->Buffer[nRoundLen] = 0;

      /* signal that the data contains meaningful data and can be read */
      SetEvent(hDBMonDataReady);
     }
     /* else, send the current block to the kernel debugger */
     else
     {
      /* output in blocks of 512 characters */
      a_cBuffer = (CHAR*)HeapAlloc(GetProcessHeap(), 0, 512);

      if (!a_cBuffer)
      {
       DbgPrint("OutputDebugStringA: Failed/n");
       break;
      }

      /* write a maximum of 511 bytes */
      if(nOutputStringLen > 510)
       nRoundLen = 510;
      else
       nRoundLen = nOutputStringLen;

      /* copy the current block */
      memcpy(a_cBuffer, _OutputString, nRoundLen);

      /* null-terminate the current block */
      a_cBuffer[nRoundLen] = 0;

      /* send the current block to the kernel debugger */
       DbgPrint("%s", a_cBuffer);

      if (a_cBuffer)
      {
       HeapFree(GetProcessHeap(), 0, a_cBuffer);
       a_cBuffer = NULL;
      }
     }

     /* move to the next block */
     _OutputString += nRoundLen;
     nOutputStringLen -= nRoundLen;
    }
    /* repeat until the string has been fully output */
    while (nOutputStringLen > 0);
   }
   /* ignore access violations and let other exceptions fall through */
   _SEH2_EXCEPT((_SEH2_GetExceptionCode() == STATUS_ACCESS_VIOLATION) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
   {
    if (a_cBuffer)
     HeapFree(GetProcessHeap(), 0, a_cBuffer);

    /* string copied verbatim from Microsoft's kernel32.dll */
    DbgPrint("/nOutputDebugString faulted during output/n");
   }
   _SEH2_END;
  }
  _SEH2_FINALLY
  {
   /* close all the still open resources */
   if(hDBMonBufferReady) CloseHandle(hDBMonBufferReady);
   if(pDBMonBuffer) UnmapViewOfFile(pDBMonBuffer);
   if(hDBMonBuffer) CloseHandle(hDBMonBuffer);
   if(hDBMonDataReady) CloseHandle(hDBMonDataReady);

   /* leave the critical section */
   if(hDBMonDataReady != NULL)
    ReleaseMutex(hDBMonMutex);
  }
  _SEH2_END;
 }
 _SEH2_END;
}