开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
debug.cpp
资源名称：shell.rar　[点击查看]
上传用户：xhy777
上传日期：2007-02-14
资源大小：24088k
文件大小：19k
源码类别：

系统编程

开发平台：

Visual C++

debug.cpp：源码内容
  1. /*----------------------------------------------------------------------------
  2. / Title;
  3. /   debug.cpp
  4. /
  5. / Authors;
  6. /   Jeffrey Saathoff (jeffreys)
  7. /
  8. / Notes;
  9. /   Provides printf style debug output
  10. /----------------------------------------------------------------------------*/
  11. #include "stdafx.h"
  12. #include <stdio.h>
  13. #include <comctrlp.h>
  14. #pragma hdrstop
  15. // Define some things for debug.h
  16. //
  17. #define SZ_DEBUGINI         "ccshell.ini"
  18. #define SZ_DEBUGSECTION     "netplwiz"
  19. #define SZ_MODULE           "NETPLWIZ"
  20. #define DECLARE_DEBUG
  21. #include "debug.h"
  23. #ifdef DEBUG
  26. DWORD g_dwTraceMask = 0;
  27. DWORD g_tlsDebug = 0xffffffffL;
  29. #define MAX_CALL_DEPTH  64
  30. #define BUFFER_SIZE     2048
  33. class CDebugStack
  34. {
  35. private:
  36.     DWORD m_dwThreadID;
  37.     LONG m_cDepth;
  38.     struct
  39.     {
  40.         BOOL    fTracedYet;
  41.         LPCTSTR pszFunctionName;
  42.         DWORD   dwMask;
  43.     }
  44.     m_CallStack[MAX_CALL_DEPTH];
  45.     TCHAR m_szStringBuffer[BUFFER_SIZE];
  47. public:
  48.     CDebugStack() : m_dwThreadID(GetCurrentThreadId()), m_cDepth(-1)
  49.     { ZeroMemory(&m_CallStack, SIZEOF(m_CallStack)); }
  51. public:
  52.     void _Indent(LONG iDepth, LPCTSTR pszFormat, ...);
  53.     void _vIndent(LONG iDepth, LPCTSTR pszFormat, va_list va);
  54.     BOOL _TraceProlog(LONG iDepth, BOOL fForce);
  55.     void _TraceEnter(DWORD dwMask, LPCTSTR pName);
  56.     void _TraceLeave(void);
  57.     void _Trace(BOOL bForce, LPCTSTR pszFormat, ...);
  58.     void _vTrace(BOOL bForce, LPCTSTR pszFormat, va_list va);
  59.     void _TraceGUID(LPCTSTR pPrefix, REFGUID rGUID);
  60.     void _TraceAssert(int iLine, LPTSTR pFilename);
  61. };
  62. typedef CDebugStack *PDEBUGSTACK;
  64. class CDebugStackHolder
  65. {
  66. private:
  67.     HDPA m_hDebugStackList;
  68.     CRITICAL_SECTION m_csStackList;
  70. public:
  71.     CDebugStackHolder() : m_hDebugStackList(NULL) { InitializeCriticalSection(&m_csStackList); }
  72.     ~CDebugStackHolder();
  74. public:
  75.     void Add(PDEBUGSTACK pDebugStack);
  76.     void Remove(PDEBUGSTACK pDebugStack);
  77. };
  78. typedef CDebugStackHolder *PDEBUGSTACKHOLDER;
  80. PDEBUGSTACKHOLDER g_pStackHolder = NULL;
  83. /*-----------------------------------------------------------------------------
  84. / _Indent
  85. / -------
  86. /   Output to the debug stream indented by n columns.
  87. /
  88. / In:
  89. /   i = column to indent to.
  90. /   pszFormat -> string to be indented
  91. /
  92. / Out:
  93. /   -
  94. /----------------------------------------------------------------------------*/
  96. void CDebugStack::_Indent(LONG iDepth, LPCTSTR pszFormat, ...)
  97. {
  98.     va_list va;
  100.     va_start(va, pszFormat);
  101.     _vIndent(iDepth, pszFormat, va);
  102.     va_end(va);
  103. }
  106. void CDebugStack::_vIndent(LONG iDepth, LPCTSTR pszFormat, va_list va)
  107. {
  108.     m_szStringBuffer[0] = TEXT('');
  110.     wsprintf(m_szStringBuffer, TEXT("%08x "), m_dwThreadID);
  112.     iDepth = min(iDepth, MAX_CALL_DEPTH - 1);
  113.     for ( ; iDepth > 0 ; iDepth-- )
  114.         lstrcat(m_szStringBuffer, TEXT("  "));
  116.     wvsprintf(m_szStringBuffer + lstrlen(m_szStringBuffer), pszFormat, va);
  117.     lstrcat(m_szStringBuffer, TEXT("n"));
  119.     OutputDebugString(m_szStringBuffer);
  120. }
  123. /*-----------------------------------------------------------------------------
  124. / _TraceProlog
  125. / -------------
  126. /   Handle the prolog to a prefix string, including outputting the
  127. /   function name if we haven't already.
  128. /
  129. / In:
  130. /   iDepth = depth in the call stack
  131. /   fForce = ignore flags
  132. /
  133. / Out:
  134. /   BOOL if trace output should be made
  135. /----------------------------------------------------------------------------*/
  136. BOOL CDebugStack::_TraceProlog(LONG iDepth, BOOL fForce)
  137. {
  138.     if ( iDepth < 0 || iDepth >= MAX_CALL_DEPTH )
  139.         return FALSE;
  141.     if  ( (g_dwTraceMask & m_CallStack[iDepth].dwMask) || fForce )
  142.     {
  143.         if ( !m_CallStack[iDepth].fTracedYet )
  144.         {
  145.             if ( iDepth > 0 )
  146.                 _TraceProlog(iDepth-1, TRUE);
  148.             _Indent(iDepth, m_CallStack[iDepth].pszFunctionName);
  149.             m_CallStack[iDepth].fTracedYet = TRUE;
  150.         }
  152.         return TRUE;
  153.     }
  155.     return FALSE;
  156. }
  159. /*-----------------------------------------------------------------------------
  160. / _TraceEnter
  161. / ------------
  162. /   Set the debugging call stack up to indicate which function we are in.
  163. /
  164. / In:
  165. /   pName -> function name to be displayed in subsequent trace output.
  166. /
  167. / Out:
  168. /   -
  169. /----------------------------------------------------------------------------*/
  170. void CDebugStack::_TraceEnter(DWORD dwMask, LPCTSTR pName)
  171. {
  172.     m_cDepth++;
  174.     if ( m_cDepth < MAX_CALL_DEPTH )
  175.     {
  176.         if ( !pName )    
  177.             pName = TEXT("<no name>");         // no function name given
  179.         m_CallStack[m_cDepth].fTracedYet = FALSE;
  180.         m_CallStack[m_cDepth].pszFunctionName = pName;
  181.         m_CallStack[m_cDepth].dwMask = dwMask;
  183.         //if ( m_cDepth > 0 )
  184.         //    _TraceProlog(m_cDepth-1, FALSE);
  185.     }
  186. }
  189. /*-----------------------------------------------------------------------------
  190. / _TraceLeave
  191. / ------------
  192. /   On exit from a function this will adjust the function stack pointer to 
  193. /   point to our previous function.  If no trace output has been made then 
  194. /   we will output the function name on a single line (to indicate we went somewhere).
  195. /
  196. / In:
  197. /    -
  198. / Out:
  199. /   -
  200. /----------------------------------------------------------------------------*/
  201. void CDebugStack::_TraceLeave(void)
  202. {
  203.     //_TraceProlog(m_cDepth, FALSE);
  205.     //if ( !m_cDepth && m_CallStack[0].fTracedYet )
  206.     //    OutputDebugString(TEXT("n"));
  207.     
  208.     m_cDepth = max(m_cDepth-1, -1);         // account for underflow
  209. }
  212. /*-----------------------------------------------------------------------------
  213. / _Trace
  214. / -------
  215. /   Perform printf formatting to the debugging stream.  We indent the output
  216. /   and stream the function name as required to give some indication of 
  217. /   call stack depth.
  218. /
  219. / In:
  220. /   pszFormat -> printf style formatting string
  221. /   ... = arguments as required for the formatting
  222. /
  223. / Out:
  224. /   -
  225. /----------------------------------------------------------------------------*/
  226. void CDebugStack::_Trace(BOOL bForce, LPCTSTR pszFormat, ...)
  227. {
  228.     va_list va;
  230.     va_start(va, pszFormat);
  231.     _vTrace(bForce, pszFormat, va);
  232.     va_end(va);
  233. }
  236. void CDebugStack::_vTrace(BOOL bForce, LPCTSTR pszFormat, va_list va)
  237. {
  238.     if ( _TraceProlog(m_cDepth, bForce) || bForce )
  239.         _vIndent(m_cDepth+1, pszFormat, va);
  240. }
  243. /*-----------------------------------------------------------------------------
  244. / _TraceGUID
  245. / -----------
  246. /   Given a GUID output it into the debug string, first we try and map it
  247. /   to a name (ie. IShellFolder), if that didn't work then we convert it
  248. /   to its human readable form.
  249. /
  250. / In:
  251. /   pszPrefix -> prefix string
  252. /   lpGuid -> guid to be streamed   
  253. /
  254. / Out:
  255. /   -
  256. /----------------------------------------------------------------------------*/
  257. #ifdef UNICODE
  258. #define MAP_GUID(x)     &x, TEXT(""L#x)
  259. #else
  260. #define MAP_GUID(x)     &x, TEXT(""#x)
  261. #endif
  263. #define MAP_GUID2(x,y)  MAP_GUID(x), MAP_GUID(y)
  265. const struct 
  266. {
  267.     const GUID* m_pGUID;
  268.     LPCTSTR     m_pName;
  269. }
  270. _guid_map[] = 
  271. {
  272.     MAP_GUID(IID_IUnknown),
  273.     MAP_GUID(IID_IClassFactory),
  274.     MAP_GUID(IID_IDropTarget),
  275.     MAP_GUID(IID_IDataObject),
  276.     MAP_GUID(IID_IPersist),
  277.     MAP_GUID(IID_IOleWindow),
  279.     MAP_GUID2(IID_INewShortcutHookA, IID_INewShortcutHookW),
  280.     MAP_GUID(IID_IShellBrowser),
  281.     MAP_GUID(IID_IShellView),
  282.     MAP_GUID(IID_IContextMenu),
  283.     MAP_GUID(IID_IShellIcon),
  284.     MAP_GUID(IID_IShellFolder),
  285.     MAP_GUID(IID_IShellExtInit),
  286.     MAP_GUID(IID_IShellPropSheetExt),
  287.     MAP_GUID(IID_IPersistFolder),  
  288.     MAP_GUID2(IID_IExtractIconA, IID_IExtractIconW),
  289.     MAP_GUID2(IID_IShellLinkA, IID_IShellLinkW),
  290.     MAP_GUID2(IID_IShellCopyHookA, IID_IShellCopyHookW),
  291.     MAP_GUID2(IID_IFileViewerA, IID_IFileViewerW),
  292.     MAP_GUID(IID_ICommDlgBrowser),
  293.     MAP_GUID(IID_IEnumIDList),
  294.     MAP_GUID(IID_IFileViewerSite),
  295.     MAP_GUID(IID_IContextMenu2),
  296.     MAP_GUID2(IID_IShellExecuteHookA, IID_IShellExecuteHookW),
  297.     MAP_GUID(IID_IPropSheetPage),
  298.     MAP_GUID(IID_IShellView2),
  299.     MAP_GUID(IID_IUniformResourceLocator),
  300. };
  302. void CDebugStack::_TraceGUID(LPCTSTR pPrefix, REFGUID rGUID)
  303. {
  304.     TCHAR szGUID[40];
  305.     LPCTSTR pName = NULL;
  306.     int i;
  307.     
  308.     for ( i = 0 ; i < ARRAYSIZE(_guid_map); i++ )
  309.     {
  310.         if ( IsEqualGUID(rGUID, *_guid_map[i].m_pGUID) )
  311.         {
  312.             pName = _guid_map[i].m_pName;
  313.             break;
  314.         }
  315.     }
  317.     if ( !pName )
  318.     {
  319. // StringFromGUID2 only does UNICODE.  SHStringFromGUID goes both ways,
  320. // but requires shlwapip.h and shlwapi.lib.
  321. #ifndef UNICODE
  322.   #error "_TraceGUID needs fixing"
  323. #endif    
  324.         StringFromGUID2(rGUID, szGUID, ARRAYSIZE(szGUID));
  325.         //SHStringFromGUID(rGUID, szGUID, ARRAYSIZE(szGUID));
  326.         pName = szGUID;
  327.     }
  329.     _Trace(FALSE, TEXT("%s %s"), pPrefix, pName);
  330. }
  333. /*-----------------------------------------------------------------------------
  334. / _TraceAssert
  335. / -------------
  336. /   Our assert handler, out faults it the trace mask as enabled assert
  337. /   faulting.
  338. /
  339. / In:
  340. /   iLine = line 
  341. /   pFilename -> filename of the file we asserted in
  342. /
  343. / Out:
  344. /   -
  345. /----------------------------------------------------------------------------*/
  346. void CDebugStack::_TraceAssert(int iLine, LPTSTR pFilename)
  347. {
  348.     // nb: TRUE --> asserts always displayed
  349.     _Trace(TRUE, TEXT("Assert failed in %s, line %d"), pFilename, iLine);
  351.     if ( g_dwTraceMask & TRACE_COMMON_ASSERT )
  352.         DebugBreak();
  353. }
  356. /*-----------------------------------------------------------------------------
  357. / ~CDebugStackHolder
  358. / ------------------
  359. /   Free any DebugStack objects that exist
  360. /
  361. / In:
  362. /   -
  363. /
  364. / Out:
  365. /   -
  366. /----------------------------------------------------------------------------*/
  367. int CALLBACK
  368. _DeleteCB(LPVOID pVoid, LPVOID /*pData*/)
  369. {
  370.     PDEBUGSTACK pDebugStack = (PDEBUGSTACK)pVoid;
  371.     if (pDebugStack)
  372.     {
  373.         //pDebugStack->_Trace(TRUE, TEXT("~CDebugStackHolder destroying DebugStack"));
  374.         delete pDebugStack;
  375.     }
  376.     return 1;
  377. }
  379. CDebugStackHolder::~CDebugStackHolder()
  380. {
  381.     EnterCriticalSection(&m_csStackList);
  383.     if (NULL != m_hDebugStackList)
  384.     {
  385.         DPA_DestroyCallback(m_hDebugStackList, _DeleteCB, NULL);
  386.         m_hDebugStackList = NULL;
  387.     }
  389.     LeaveCriticalSection(&m_csStackList);
  390.     DeleteCriticalSection(&m_csStackList);
  391. }
  394. /*-----------------------------------------------------------------------------
  395. / CDebugStackHolder::Add
  396. / ----------------------
  397. /   Saves the DebugStack object in a list
  398. /
  399. / In:
  400. /   PDEBUGSTACK pointer to the thread's debug stack object
  401. /
  402. / Out:
  403. /   -
  404. /----------------------------------------------------------------------------*/
  405. void
  406. CDebugStackHolder::Add(PDEBUGSTACK pDebugStack)
  407. {
  408.     EnterCriticalSection(&m_csStackList);
  410.     if (NULL == m_hDebugStackList)
  411.         m_hDebugStackList = DPA_Create(4);
  413.     if (NULL != m_hDebugStackList)
  414.         DPA_AppendPtr(m_hDebugStackList, pDebugStack);
  416.     LeaveCriticalSection(&m_csStackList);
  417. }
  420. /*-----------------------------------------------------------------------------
  421. / CDebugStackHolder::Remove
  422. / -------------------------
  423. /   Removes the DebugStack object from the list
  424. /
  425. / In:
  426. /   PDEBUGSTACK pointer to the thread's debug stack object
  427. /
  428. / Out:
  429. /   -
  430. /----------------------------------------------------------------------------*/
  431. void
  432. CDebugStackHolder::Remove(PDEBUGSTACK pDebugStack)
  433. {
  434.     EnterCriticalSection(&m_csStackList);
  436.     if (NULL != m_hDebugStackList)
  437.     {
  438.         int iStack = DPA_GetPtrIndex(m_hDebugStackList, pDebugStack);
  440.         if (-1 != iStack)
  441.             DPA_DeletePtr(m_hDebugStackList, iStack);
  442.     }
  444.     LeaveCriticalSection(&m_csStackList);
  445. }
  448. /*-----------------------------------------------------------------------------
  449. / GetThreadStack
  450. / --------------
  451. /   Create (if necessary) and return the per-thread debug stack object.
  452. /
  453. / In:
  454. /   -
  455. /
  456. / Out:
  457. /   PDEBUGSTACK pointer to the thread's debug stack object
  458. /----------------------------------------------------------------------------*/
  459. PDEBUGSTACK GetThreadStack()
  460. {
  461.     PDEBUGSTACK pDebugStack;
  463.     if (0xffffffffL == g_tlsDebug)
  464.         return NULL;
  466.     pDebugStack = (PDEBUGSTACK)TlsGetValue(g_tlsDebug);
  468.     if (!pDebugStack)
  469.     {
  470.         pDebugStack = new CDebugStack;
  471.         TlsSetValue(g_tlsDebug, pDebugStack);
  473.         if (!g_pStackHolder)
  474.             g_pStackHolder = new CDebugStackHolder;
  476.         if (g_pStackHolder)
  477.             g_pStackHolder->Add(pDebugStack);
  478.     }
  480.     return pDebugStack;
  481. }
  482.     
  484. /*-----------------------------------------------------------------------------
  485. / DoTraceSetMask
  486. / --------------
  487. /   Adjust the trace mask to reflect the state given.
  488. /
  489. / In:
  490. /   dwMask = mask for enabling / disable trace output
  491. /
  492. / Out:
  493. /   -
  494. /----------------------------------------------------------------------------*/
  495. void DoTraceSetMask(DWORD dwMask)
  496. {
  497.     g_dwTraceMask = dwMask;
  498. }
  501. /*-----------------------------------------------------------------------------
  502. / DoTraceSetMaskFromRegKey
  503. / ------------------------
  504. /   Pick up the TraceMask value from the given registry key and
  505. /   set the trace mask using that.
  506. /
  507. / In:
  508. /   hkRoot = handle of open key
  509. /   pszSubKey = name of subkey to open
  510. /
  511. / Out:
  512. /   -
  513. /----------------------------------------------------------------------------*/
  514. void DoTraceSetMaskFromRegKey(HKEY hkRoot, LPCTSTR pszSubKey)
  515. {
  516.     HKEY hKey;
  518.     if (ERROR_SUCCESS == RegOpenKey(hkRoot, pszSubKey, &hKey))
  519.     {
  520.         DWORD dwTraceMask = 0;
  521.         DWORD cbTraceMask = SIZEOF(dwTraceMask);
  523.         RegQueryValueEx(hKey,
  524.                         TEXT("TraceMask"),
  525.                         NULL,
  526.                         NULL,
  527.                         (LPBYTE)&dwTraceMask,
  528.                         &cbTraceMask);
  529.         DoTraceSetMask(dwTraceMask);
  530.         RegCloseKey(hKey);
  531.     }
  532. }
  535. /*-----------------------------------------------------------------------------
  536. / DoTraceSetMaskFromCLSID
  537. / -----------------------
  538. /   Pick up the TraceMask value from the given CLSID value and
  539. /   set the trace mask using that.
  540. /
  541. / In:
  542. /   rCLSID = CLSID to query the value from
  543. /
  544. / Out:
  545. /   -
  546. /----------------------------------------------------------------------------*/
  547. void DoTraceSetMaskFromCLSID(REFCLSID rCLSID)
  548. {
  549.     TCHAR szClsidKey[48] = TEXT("CLSID\");
  550.     int nLength = lstrlen(szClsidKey);
  552. // StringFromGUID2 only does UNICODE.  SHStringFromGUID goes both ways,
  553. // but requires shlwapip.h and shlwapi.lib.
  554. #ifdef UNICODE
  555.     if (0 == StringFromGUID2(rCLSID, szClsidKey + nLength, ARRAYSIZE(szClsidKey) - nLength))
  556. #else
  557. #error "DoTraceSetMaskFromCLSID needs fixing"
  558.     if (0 == SHStringFromGUID(rCLSID, szClsidKey + nLength, ARRAYSIZE(szClsidKey) - nLength))
  559. #endif    
  560.         return;
  562.     DoTraceSetMaskFromRegKey(HKEY_CLASSES_ROOT, szClsidKey);
  563. }
  566. /*-----------------------------------------------------------------------------
  567. / DoTraceEnter
  568. / ------------
  569. /   Set the debugging call stack up to indicate which function we are in.
  570. /
  571. / In:
  572. /   pName -> function name to be displayed in subsequent trace output.
  573. /
  574. / Out:
  575. /   -
  576. /----------------------------------------------------------------------------*/
  577. void DoTraceEnter(DWORD dwMask, LPCTSTR pName)
  578. {
  579.     PDEBUGSTACK pDebugStack = GetThreadStack();
  581.     if (pDebugStack)
  582.         pDebugStack->_TraceEnter(dwMask, pName);
  583. }
  586. /*-----------------------------------------------------------------------------
  587. / DoTraceLeave
  588. / ------------
  589. /   On exit from a function this will adjust the function stack pointer to 
  590. /   point to our previous function.  If no trace output has been made then 
  591. /   we will output the function name on a single line (to indicate we went somewhere).
  592. /
  593. / In:
  594. /    -
  595. / Out:
  596. /   -
  597. /----------------------------------------------------------------------------*/
  598. void DoTraceLeave(void)
  599. {
  600.     PDEBUGSTACK pDebugStack = GetThreadStack();
  602.     if (pDebugStack)
  603.         pDebugStack->_TraceLeave();
  604. }
  607. /*-----------------------------------------------------------------------------
  608. / DoTrace
  609. / -------
  610. /   Perform printf formatting to the debugging stream.  We indent the output
  611. /   and stream the function name as required to give some indication of 
  612. /   call stack depth.
  613. /
  614. / In:
  615. /   pszFormat -> printf style formatting string
  616. /   ... = arguments as required for the formatting
  617. /
  618. / Out:
  619. /   -
  620. /----------------------------------------------------------------------------*/
  621. void DoTrace(LPCTSTR pszFormat, ...)
  622. {
  623.     PDEBUGSTACK pDebugStack = GetThreadStack();
  624.     va_list va;
  626.     if (pDebugStack)
  627.     {
  628.         va_start(va, pszFormat);
  629.         pDebugStack->_vTrace(FALSE, pszFormat, va);
  630.         va_end(va);
  631.     }
  632. }
  635. /*-----------------------------------------------------------------------------
  636. / DoTraceGuid
  637. / -----------
  638. /   Given a GUID output it into the debug string, first we try and map it
  639. /   to a name (ie. IShellFolder), if that didn't work then we convert it
  640. /   to its human readable form.
  641. /
  642. / In:
  643. /   pszPrefix -> prefix string
  644. /   lpGuid -> guid to be streamed   
  645. /
  646. / Out:
  647. /   -
  648. /----------------------------------------------------------------------------*/
  649. void DoTraceGUID(LPCTSTR pPrefix, REFGUID rGUID)
  650. {
  651.     PDEBUGSTACK pDebugStack = GetThreadStack();
  653.     if (pDebugStack)
  654.         pDebugStack->_TraceGUID(pPrefix, rGUID);
  655. }
  658. /*-----------------------------------------------------------------------------
  659. / DoTraceAssert
  660. / -------------
  661. /   Our assert handler, out faults it the trace mask as enabled assert
  662. /   faulting.
  663. /
  664. / In:
  665. /   iLine = line 
  666. /   pFilename -> filename of the file we asserted in
  667. /
  668. / Out:
  669. /   -
  670. /----------------------------------------------------------------------------*/
  671. void DoTraceAssert(int iLine, LPTSTR pFilename)
  672. {
  673.     PDEBUGSTACK pDebugStack = GetThreadStack();
  675.     if (pDebugStack)
  676.         pDebugStack->_TraceAssert(iLine, pFilename);
  677. }
  680. /*-----------------------------------------------------------------------------
  681. / DebugThreadDetach
  682. / DebugProcessAttach
  683. / DebugProcessDetach
  684. / -------------
  685. /   These must be called from DllMain
  686. /
  687. / In:
  688. /   -
  689. /
  690. / Out:
  691. /   -
  692. /----------------------------------------------------------------------------*/
  693. void DebugThreadDetach(void)
  694. {
  695.     PDEBUGSTACK pDebugStack;
  697.     if (0xffffffffL == g_tlsDebug)
  698.         return;
  700.     pDebugStack = (PDEBUGSTACK)TlsGetValue(g_tlsDebug);
  702.     if (pDebugStack)
  703.     {
  704.         if (g_pStackHolder)
  705.             g_pStackHolder->Remove(pDebugStack);
  707.         delete pDebugStack;
  708.         TlsSetValue(g_tlsDebug, NULL);
  709.     }
  710. }
  712. void DebugProcessAttach(void)
  713. {
  714.     g_tlsDebug = TlsAlloc();
  715. }
  717. void DebugProcessDetach(void)
  718. {
  719.     DebugThreadDetach();
  721.     if (NULL != g_pStackHolder)
  722.     {
  723.         delete g_pStackHolder;
  724.         g_pStackHolder = NULL;
  725.     }
  727.     if (0xffffffffL != g_tlsDebug)
  728.     {
  729.         TlsFree(g_tlsDebug);
  730.         g_tlsDebug = 0xffffffffL;
  731.     }
  732. }
  735. #endif  // DEBUG