| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_tools.hxx" |
| |
| #define _TOOLS_DEBUG_CXX |
| |
| #if defined (UNX) || defined (GCC) |
| #include <unistd.h> |
| #else |
| #include <direct.h> |
| #endif |
| |
| #include <time.h> |
| #include <cstdarg> // combinations |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdio.h> |
| |
| #ifdef OS2 |
| #define INCL_DOSSEMAPHORES |
| #define INCL_DOSMISC |
| #define INCL_WINDIALOGS |
| #define INCL_WINSHELLDATA |
| #include <svpm.h> |
| #endif |
| |
| #if defined ( WNT ) |
| #ifdef _MSC_VER |
| #pragma warning (push,1) |
| #endif |
| #include <tools/svwin.h> |
| #ifdef _MSC_VER |
| #pragma warning (pop) |
| #endif |
| #endif |
| |
| #include <tools/debug.hxx> |
| #include <rtl/string.h> |
| |
| #include <vector> |
| |
| #include <osl/diagnose.h> |
| |
| // ======================================================================= |
| |
| #ifdef DBG_UTIL |
| |
| // --- DbgErrors --- |
| |
| static sal_Char const DbgError_ProfEnd1[] = "DBG_PROF...() without DBG_PROFSTART(): "; |
| static sal_Char const DbgError_Xtor1[] = "DBG_DTOR() or DBG_CHKTHIS() without DBG_CTOR(): "; |
| |
| static sal_Char const DbgError_CtorDtor1[] = "this == NULL in class "; |
| static sal_Char const DbgError_CtorDtor2[] = "invalid this-Pointer %p in class "; |
| static sal_Char const DbgError_CtorDtor3[] = "Error-Msg from Object %p in class "; |
| |
| static sal_Char const DbgTrace_EnterCtor[] = "Enter Ctor from class "; |
| static sal_Char const DbgTrace_LeaveCtor[] = "Leave Ctor from class "; |
| static sal_Char const DbgTrace_EnterDtor[] = "Enter Dtor from class "; |
| static sal_Char const DbgTrace_LeaveDtor[] = "Leave Dtor from class "; |
| static sal_Char const DbgTrace_EnterMeth[] = "Enter method from class "; |
| static sal_Char const DbgTrace_LeaveMeth[] = "Leave method from class "; |
| |
| // --- PointerList --- |
| |
| #define PBLOCKCOUNT 1024 |
| |
| struct PBlock |
| { |
| void* aData[PBLOCKCOUNT]; |
| sal_uInt16 nCount; |
| PBlock* pPrev; |
| PBlock* pNext; |
| }; |
| |
| class PointerList |
| { |
| private: |
| PBlock* pFirst; |
| PBlock* pLast; |
| sal_uIntPtr nCount; |
| |
| public: |
| PointerList() { pFirst = NULL; pLast = NULL; nCount = 0; } |
| ~PointerList(); |
| |
| void Add( const void* p ); |
| sal_Bool Remove( const void* p ); |
| |
| const void* Get( sal_uIntPtr nPos ) const; |
| sal_Bool IsIn( const void* p ) const; |
| sal_uIntPtr Count() const { return nCount; } |
| }; |
| |
| // --- Datentypen --- |
| |
| #define DBG_MAXNAME 28 |
| |
| struct ProfType |
| { |
| sal_uIntPtr nCount; |
| sal_uIntPtr nTime; |
| sal_uIntPtr nMinTime; |
| sal_uIntPtr nMaxTime; |
| sal_uIntPtr nStart; |
| sal_uIntPtr nContinueTime; |
| sal_uIntPtr nContinueStart; |
| sal_Char aName[DBG_MAXNAME+1]; |
| }; |
| |
| struct XtorType |
| { |
| sal_uIntPtr nCtorCalls; |
| sal_uIntPtr nDtorCalls; |
| sal_uIntPtr nMaxCount; |
| sal_uIntPtr nStatics; |
| sal_Char aName[DBG_MAXNAME+1]; |
| sal_Bool bTest; |
| PointerList aThisList; |
| }; |
| |
| struct DebugData |
| { |
| DbgData aDbgData; |
| sal_uInt16 bInit; |
| DbgPrintLine pDbgPrintMsgBox; |
| DbgPrintLine pDbgPrintWindow; |
| DbgPrintLine pDbgPrintTestTool; |
| DbgPrintLine pDbgAbort; |
| ::std::vector< DbgPrintLine > |
| aDbgPrintUserChannels; |
| PointerList* pProfList; |
| PointerList* pXtorList; |
| DbgTestSolarMutexProc pDbgTestSolarMutex; |
| pfunc_osl_printDetailedDebugMessage |
| pOldDebugMessageFunc; |
| bool bOslIsHooked; |
| |
| DebugData() |
| :bInit( sal_False ) |
| ,pDbgPrintMsgBox( NULL ) |
| ,pDbgPrintWindow( NULL ) |
| ,pDbgPrintTestTool( NULL ) |
| ,pDbgAbort( NULL ) |
| ,pProfList( NULL ) |
| ,pXtorList( NULL ) |
| ,pDbgTestSolarMutex( NULL ) |
| ,pOldDebugMessageFunc( NULL ) |
| ,bOslIsHooked( false ) |
| { |
| aDbgData.nTestFlags = DBG_TEST_RESOURCE | DBG_TEST_MEM_INIT; |
| aDbgData.bOverwrite = sal_True; |
| aDbgData.nTraceOut = DBG_OUT_NULL; |
| aDbgData.nWarningOut = DBG_OUT_NULL; |
| aDbgData.nErrorOut = DBG_OUT_MSGBOX; |
| aDbgData.bMemInit = 0x77; |
| aDbgData.bMemBound = 0x55; |
| aDbgData.bMemFree = 0x33; |
| aDbgData.bHookOSLAssert = sal_True; |
| aDbgData.aDebugName[0] = 0; |
| aDbgData.aInclFilter[0] = 0; |
| aDbgData.aExclFilter[0] = 0; |
| aDbgData.aInclClassFilter[0] = 0; |
| aDbgData.aExclClassFilter[0] = 0; |
| aDbgData.aDbgWinState[0] = 0; |
| } |
| }; |
| |
| #define DBG_TEST_XTOR_EXTRA (DBG_TEST_XTOR_THIS | DBG_TEST_XTOR_FUNC | \ |
| DBG_TEST_XTOR_EXIT | DBG_TEST_XTOR_REPORT ) |
| |
| // ------------------------------ |
| // - statische Verwaltungsdaten - |
| // ------------------------------ |
| |
| static DebugData aDebugData; |
| |
| static sal_Char aCurPath[260]; |
| |
| static int bDbgImplInMain = sal_False; |
| |
| // ======================================================================= |
| |
| #if defined( WNT ) |
| static CRITICAL_SECTION aImplCritDbgSection; |
| #elif defined( OS2 ) |
| static HMTX hImplCritDbgSection = 0; |
| #endif |
| static sal_Bool bImplCritDbgSectionInit = sal_False; |
| |
| // ----------------------------------------------------------------------- |
| |
| void ImplDbgInitLock() |
| { |
| #if defined( WNT ) |
| InitializeCriticalSection( &aImplCritDbgSection ); |
| #elif defined( OS2 ) |
| DosCreateMutexSem( NULL, &hImplCritDbgSection, 0, sal_False ); |
| #endif |
| bImplCritDbgSectionInit = sal_True; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ImplDbgDeInitLock() |
| { |
| #if defined( WNT ) |
| DeleteCriticalSection( &aImplCritDbgSection ); |
| #elif defined( OS2 ) |
| DosCloseMutexSem( hImplCritDbgSection ); |
| #endif |
| bImplCritDbgSectionInit = sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ImplDbgLock() |
| { |
| if ( !bImplCritDbgSectionInit ) |
| return; |
| |
| #if defined( WNT ) |
| EnterCriticalSection( &aImplCritDbgSection ); |
| #elif defined( OS2 ) |
| DosRequestMutexSem( hImplCritDbgSection, SEM_INDEFINITE_WAIT ); |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ImplDbgUnlock() |
| { |
| if ( !bImplCritDbgSectionInit ) |
| return; |
| |
| #if defined( WNT ) |
| LeaveCriticalSection( &aImplCritDbgSection ); |
| #elif defined( OS2 ) |
| DosReleaseMutexSem( hImplCritDbgSection ); |
| #endif |
| } |
| |
| // ======================================================================= |
| |
| #if (defined WNT || defined OS2) && !defined SVX_LIGHT |
| //#define SV_MEMMGR // |
| #endif |
| #ifdef SV_MEMMGR |
| void DbgImpCheckMemory( void* p = NULL ); |
| void DbgImpCheckMemoryDeInit(); |
| void DbgImpMemoryInfo( sal_Char* pBuf ); |
| #endif |
| |
| #define FILE_LINEEND "\n" |
| |
| // ======================================================================= |
| |
| static sal_Bool ImplActivateDebugger( const sal_Char* pMsg ) |
| { |
| #if defined( WNT ) |
| static sal_Char aImplDbgOutBuf[DBG_BUF_MAXLEN]; |
| strcpy( aImplDbgOutBuf, pMsg ); |
| strcat( aImplDbgOutBuf, "\r\n" ); |
| OutputDebugString( aImplDbgOutBuf ); |
| DebugBreak(); |
| return sal_True; |
| #else |
| (void) pMsg; // avoid warning about unused parameter |
| return sal_False; |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Bool ImplCoreDump() |
| { |
| #if defined( WNT ) |
| DebugBreak(); |
| #else |
| long* pTemp = 0; |
| *pTemp = 0xCCCC; |
| #endif |
| return sal_True; |
| } |
| |
| // ======================================================================= |
| |
| static sal_uIntPtr ImplGetPerfTime() |
| { |
| #if defined( WNT ) |
| return (sal_uIntPtr)GetTickCount(); |
| #elif defined( OS2 ) |
| sal_uIntPtr nClock; |
| DosQuerySysInfo( QSV_MS_COUNT, QSV_MS_COUNT, &nClock, sizeof( nClock ) ); |
| return (sal_uIntPtr)nClock; |
| #else |
| static sal_uIntPtr nImplTicksPerSecond = 0; |
| static double dImplTicksPerSecond; |
| sal_uIntPtr nTicks = (sal_uIntPtr)clock(); |
| |
| if ( !nImplTicksPerSecond ) |
| { |
| nImplTicksPerSecond = CLOCKS_PER_SEC; |
| dImplTicksPerSecond = nImplTicksPerSecond; |
| } |
| |
| double fTicks = nTicks; |
| fTicks *= 1000; |
| fTicks /= dImplTicksPerSecond; |
| return (sal_uIntPtr)fTicks; |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| typedef FILE* FILETYPE; |
| #define FileOpen fopen |
| #define FileRead fread |
| #define FileWrite fwrite |
| #define FilePrintF fprintf |
| #define FileClose fclose |
| |
| // ======================================================================= |
| |
| namespace |
| { |
| enum ConfigSection |
| { |
| eOutput, |
| eMemory, |
| eGUI, |
| eObjects, |
| eTest, |
| |
| eUnknown |
| }; |
| |
| void lcl_lineFeed( FILETYPE _pFile ) |
| { |
| FilePrintF( _pFile, "%s", FILE_LINEEND ); |
| } |
| |
| const sal_Char* lcl_getSectionName( ConfigSection _eSection ) |
| { |
| const sal_Char* pSectionName = NULL; |
| switch ( _eSection ) |
| { |
| case eOutput : pSectionName = "output"; break; |
| case eMemory : pSectionName = "memory"; break; |
| case eGUI : pSectionName = "gui"; break; |
| case eObjects : pSectionName = "objects"; break; |
| case eTest : pSectionName = "test"; break; |
| case eUnknown: |
| OSL_ASSERT(false); |
| break; |
| } |
| return pSectionName; |
| } |
| |
| ConfigSection lcl_getSectionFromName( const sal_Char* _pSectionName, size_t _nSectionNameLength ) |
| { |
| if ( strncmp( _pSectionName, "output", _nSectionNameLength < 6 ? _nSectionNameLength : 6 ) == 0 ) |
| return eOutput; |
| if ( strncmp( _pSectionName, "memory", _nSectionNameLength < 6 ? _nSectionNameLength : 6 ) == 0 ) |
| return eMemory; |
| if ( strncmp( _pSectionName, "gui", _nSectionNameLength < 3 ? _nSectionNameLength : 3 ) == 0 ) |
| return eGUI; |
| if ( strncmp( _pSectionName, "objects", _nSectionNameLength < 7 ? _nSectionNameLength : 7 ) == 0 ) |
| return eObjects; |
| if ( strncmp( _pSectionName, "test", _nSectionNameLength < 4 ? _nSectionNameLength : 4 ) == 0 ) |
| return eTest; |
| return eUnknown; |
| } |
| |
| void lcl_startSection( FILETYPE _pFile, ConfigSection _eSection ) |
| { |
| FilePrintF( _pFile, "[%s]%s", lcl_getSectionName( _eSection ), FILE_LINEEND ); |
| } |
| |
| void lcl_writeConfigString( FILETYPE _pFile, const sal_Char* _pKeyName, const sal_Char* _pValue ) |
| { |
| FilePrintF( _pFile, "%s=%s%s", _pKeyName, _pValue, FILE_LINEEND ); |
| } |
| |
| void lcl_writeConfigBoolean( FILETYPE _pFile, const sal_Char* _pKeyName, bool _bValue ) |
| { |
| lcl_writeConfigString( _pFile, _pKeyName, _bValue ? "1" : "0" ); |
| } |
| |
| void lcl_writeConfigFlag( FILETYPE _pFile, const sal_Char* _pKeyName, sal_uIntPtr _nAllFlags, sal_uIntPtr _nCheckFlag ) |
| { |
| lcl_writeConfigBoolean( _pFile, _pKeyName, ( _nAllFlags & _nCheckFlag ) != 0 ); |
| } |
| |
| void lcl_writeConfigOutChannel( FILETYPE _pFile, const sal_Char* _pKeyName, sal_uIntPtr _nValue ) |
| { |
| const sal_Char* names[ DBG_OUT_COUNT ] = |
| { |
| "dev/null", "file", "window", "shell", "messagebox", "testtool", "debugger", "abort" |
| }; |
| lcl_writeConfigString( _pFile, _pKeyName, names[ _nValue ] ); |
| } |
| void lcl_writeHexByte( FILETYPE _pFile, const sal_Char* _pKeyName, sal_uInt8 _nValue ) |
| { |
| sal_Char buf[RTL_STR_MAX_VALUEOFINT32]; |
| rtl_String* stringData = NULL; |
| rtl_string_newFromStr_WithLength( &stringData, buf, rtl_str_valueOfInt32( buf, _nValue, 16 ) ); |
| |
| lcl_writeConfigString( _pFile, _pKeyName, stringData->buffer ); |
| |
| rtl_string_release( stringData ); |
| } |
| bool lcl_isConfigSection( const sal_Char* _pLine, size_t _nLineLen ) |
| { |
| if ( _nLineLen < 2 ) |
| // not even enough space for '[' and ']' |
| return false; |
| if ( ( _pLine[0] == '[' ) && ( _pLine[ _nLineLen - 1 ] == ']' ) ) |
| return true; |
| return false; |
| } |
| bool lcl_isConfigKey( const sal_Char* _pLine, size_t _nLineLen, const sal_Char* _pKeyName ) |
| { |
| size_t nKeyLength = strlen( _pKeyName ); |
| if ( nKeyLength + 1 >= _nLineLen ) |
| // not even long enough for the key name plus "=" plus a one-character value |
| return false; |
| if ( ( strncmp( _pLine, _pKeyName, nKeyLength ) == 0 ) && ( _pLine[ nKeyLength ] == '=' ) ) |
| return true; |
| return false; |
| } |
| sal_Int32 lcl_tryReadConfigString( const sal_Char* _pLine, size_t _nLineLen, const sal_Char* _pKeyName, sal_Char* _pValue, size_t _nValueLen ) |
| { |
| if ( !lcl_isConfigKey( _pLine, _nLineLen, _pKeyName ) ) |
| return 0; |
| size_t nValuePos = strlen( _pKeyName ) + 1; |
| size_t nValueLen = _nLineLen - nValuePos; |
| const sal_Char* pValue = _pLine + nValuePos; |
| strncpy( _pValue, pValue, ( _nValueLen > nValueLen ) ? nValueLen : _nValueLen ); |
| _pValue[ ( _nValueLen > nValueLen ) ? nValueLen : _nValueLen - 1 ] = 0; |
| return strlen( _pValue ); |
| } |
| void lcl_tryReadConfigBoolean( const sal_Char* _pLine, size_t _nLineLen, const sal_Char* _pKeyName, sal_uIntPtr* _out_pnValue ) |
| { |
| sal_Char aBuf[2]; |
| size_t nValueLen = lcl_tryReadConfigString( _pLine, _nLineLen, _pKeyName, aBuf, sizeof( aBuf ) ); |
| if ( nValueLen ) |
| *_out_pnValue = strcmp( aBuf, "1" ) == 0 ? sal_True : sal_False; |
| } |
| void lcl_matchOutputChannel( sal_Char const * i_buffer, sal_uIntPtr* o_value ) |
| { |
| if ( i_buffer == NULL ) |
| return; |
| const sal_Char* names[ DBG_OUT_COUNT ] = |
| { |
| "dev/null", "file", "window", "shell", "messagebox", "testtool", "debugger", "abort" |
| }; |
| for ( sal_uIntPtr name = 0; name < sizeof( names ) / sizeof( names[0] ); ++name ) |
| { |
| if ( strcmp( i_buffer, names[ name ] ) == 0 ) |
| { |
| *o_value = name; |
| return; |
| } |
| } |
| } |
| void lcl_tryReadOutputChannel( const sal_Char* _pLine, size_t _nLineLen, const sal_Char* _pKeyName, sal_uIntPtr* _out_pnValue ) |
| { |
| sal_Char aBuf[20]; |
| size_t nValueLen = lcl_tryReadConfigString( _pLine, _nLineLen, _pKeyName, aBuf, sizeof( aBuf ) ); |
| if ( nValueLen ) |
| lcl_matchOutputChannel( aBuf, _out_pnValue ); |
| } |
| void lcl_tryReadConfigFlag( const sal_Char* _pLine, size_t _nLineLen, const sal_Char* _pKeyName, sal_uIntPtr* _out_pnAllFlags, sal_uIntPtr _nCheckFlag ) |
| { |
| sal_Char aBuf[2]; |
| size_t nValueLen = lcl_tryReadConfigString( _pLine, _nLineLen, _pKeyName, aBuf, sizeof( aBuf ) ); |
| if ( nValueLen ) |
| if ( strcmp( aBuf, "1" ) == 0 ) |
| *_out_pnAllFlags |= _nCheckFlag; |
| else |
| *_out_pnAllFlags &= ~_nCheckFlag; |
| } |
| void lcl_tryReadHexByte( const sal_Char* _pLine, size_t _nLineLen, const sal_Char* _pKeyName, sal_uInt8* _out_pnValue ) |
| { |
| sal_Char aBuf[3]; |
| size_t nValueLen = lcl_tryReadConfigString( _pLine, _nLineLen, _pKeyName, aBuf, sizeof( aBuf ) ); |
| if ( nValueLen ) |
| *_out_pnValue = (sal_uInt8)rtl_str_toInt32( aBuf, 16 ); |
| } |
| } |
| |
| // ======================================================================= |
| |
| PointerList::~PointerList() |
| { |
| PBlock* pBlock = pFirst; |
| while ( pBlock ) |
| { |
| PBlock* pNextBlock = pBlock->pNext; |
| delete pBlock; |
| pBlock = pNextBlock; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void PointerList::Add( const void* p ) |
| { |
| if ( !pFirst ) |
| { |
| pFirst = new PBlock; |
| memset( pFirst->aData, 0, PBLOCKCOUNT * sizeof( void* ) ); |
| pFirst->nCount = 0; |
| pFirst->pPrev = NULL; |
| pFirst->pNext = NULL; |
| pLast = pFirst; |
| } |
| |
| PBlock* pBlock = pFirst; |
| while ( pBlock && (pBlock->nCount == PBLOCKCOUNT) ) |
| pBlock = pBlock->pNext; |
| |
| if ( !pBlock ) |
| { |
| pBlock = new PBlock; |
| memset( pBlock->aData, 0, PBLOCKCOUNT * sizeof( void* ) ); |
| pBlock->nCount = 0; |
| pBlock->pPrev = pLast; |
| pBlock->pNext = NULL; |
| pLast->pNext = pBlock; |
| pLast = pBlock; |
| } |
| |
| sal_uInt16 i = 0; |
| while ( pBlock->aData[i] ) |
| i++; |
| |
| pBlock->aData[i] = (void*)p; |
| pBlock->nCount++; |
| nCount++; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool PointerList::Remove( const void* p ) |
| { |
| if ( !p ) |
| return sal_False; |
| |
| PBlock* pBlock = pFirst; |
| while ( pBlock ) |
| { |
| sal_uInt16 i = 0; |
| while ( i < PBLOCKCOUNT ) |
| { |
| if ( ((sal_uIntPtr)p) == ((sal_uIntPtr)pBlock->aData[i]) ) |
| { |
| pBlock->aData[i] = NULL; |
| pBlock->nCount--; |
| nCount--; |
| |
| if ( !pBlock->nCount ) |
| { |
| if ( pBlock->pPrev ) |
| pBlock->pPrev->pNext = pBlock->pNext; |
| if ( pBlock->pNext ) |
| pBlock->pNext->pPrev = pBlock->pPrev; |
| if ( pBlock == pFirst ) |
| pFirst = pBlock->pNext; |
| if ( pBlock == pLast ) |
| pLast = pBlock->pPrev; |
| delete pBlock; |
| } |
| |
| return sal_True; |
| } |
| i++; |
| } |
| |
| pBlock = pBlock->pNext; |
| } |
| |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| const void* PointerList::Get( sal_uIntPtr nPos ) const |
| { |
| if ( nCount <= nPos ) |
| return NULL; |
| |
| PBlock* pBlock = pFirst; |
| sal_uIntPtr nStart = 0; |
| while ( pBlock ) |
| { |
| sal_uInt16 i = 0; |
| while ( i < PBLOCKCOUNT ) |
| { |
| if ( pBlock->aData[i] ) |
| { |
| nStart++; |
| if ( (nStart-1) == nPos ) |
| return pBlock->aData[i]; |
| } |
| |
| i++; |
| } |
| |
| pBlock = pBlock->pNext; |
| } |
| |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool PointerList::IsIn( const void* p ) const |
| { |
| if ( !p ) |
| return sal_False; |
| |
| PBlock* pBlock = pFirst; |
| while ( pBlock ) |
| { |
| sal_uInt16 i = 0; |
| while ( i < PBLOCKCOUNT ) |
| { |
| if ( ((sal_uIntPtr)p) == ((sal_uIntPtr)pBlock->aData[i]) ) |
| return sal_True; |
| i++; |
| } |
| |
| pBlock = pBlock->pNext; |
| } |
| |
| return sal_False; |
| } |
| |
| |
| // ======================================================================= |
| |
| static void DbgGetDbgFileName( sal_Char* pStr, sal_Int32 nMaxLen ) |
| { |
| #if defined( UNX ) |
| const sal_Char* pName = getenv("DBGSV_INIT"); |
| if ( !pName ) |
| pName = ".dbgsv.init"; |
| strncpy( pStr, pName, nMaxLen ); |
| #elif defined( WNT ) |
| const sal_Char* pName = getenv("DBGSV_INIT"); |
| if ( pName ) |
| strncpy( pStr, pName, nMaxLen ); |
| else |
| GetProfileStringA( "sv", "dbgsv", "dbgsv.ini", pStr, nMaxLen ); |
| #elif defined( OS2 ) |
| PrfQueryProfileString( HINI_PROFILE, (PSZ)"SV", (PSZ)"DBGSV", |
| "dbgsv.ini", (PSZ)pStr, nMaxLen ); |
| #else |
| strncpy( pStr, "dbgsv.ini", nMaxLen ); |
| #endif |
| pStr[ nMaxLen - 1 ] = 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void DbgGetLogFileName( sal_Char* pStr ) |
| { |
| #if defined( UNX ) |
| const sal_Char* pName = getenv("DBGSV_LOG"); |
| if ( !pName ) |
| pName = "dbgsv.log"; |
| strcpy( pStr, pName ); |
| #elif defined( WNT ) |
| const sal_Char* pName = getenv("DBGSV_LOG"); |
| if ( pName ) |
| strcpy( pStr, pName ); |
| else |
| GetProfileStringA( "sv", "dbgsvlog", "dbgsv.log", pStr, 200 ); |
| #elif defined( OS2 ) |
| PrfQueryProfileString( HINI_PROFILE, (PSZ)"SV", (PSZ)"DBGSVLOG", |
| "dbgsv.log", (PSZ)pStr, 200 ); |
| #else |
| strcpy( pStr, "dbgsv.log" ); |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void DbgDebugBeep() |
| { |
| #if defined( WNT ) |
| MessageBeep( MB_ICONHAND ); |
| #elif defined( OS2 ) |
| WinAlarm( HWND_DESKTOP, WA_ERROR ); |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static DebugData* GetDebugData() |
| { |
| if ( !aDebugData.bInit ) |
| { |
| aDebugData.bInit = sal_True; |
| |
| // Default Debug-Namen setzen |
| DbgGetLogFileName( aDebugData.aDbgData.aDebugName ); |
| |
| // DEBUG.INI-File |
| sal_Char aBuf[ 4096 ]; |
| DbgGetDbgFileName( aBuf, sizeof( aBuf ) ); |
| FILETYPE pIniFile = FileOpen( aBuf, "r" ); |
| if ( pIniFile != NULL ) |
| { |
| ConfigSection eCurrentSection = eUnknown; |
| |
| // no sophisticated algorithm here, assume that the whole file fits into aBuf ... |
| sal_uIntPtr nReallyRead = FileRead( aBuf, 1, sizeof( aBuf ) / sizeof( sal_Char ) - 1, pIniFile ); |
| aBuf[ nReallyRead ] = 0; |
| const sal_Char* pLine = aBuf; |
| while ( const sal_Char* pNextLine = strstr( pLine, FILE_LINEEND ) ) |
| { |
| size_t nLineLength = pNextLine - pLine; |
| |
| if ( lcl_isConfigSection( pLine, nLineLength ) ) |
| eCurrentSection = lcl_getSectionFromName( pLine + 1, nLineLength - 2 ); |
| |
| // elements of the [output] section |
| if ( eCurrentSection == eOutput ) |
| { |
| lcl_tryReadConfigString( pLine, nLineLength, "log_file", aDebugData.aDbgData.aDebugName, sizeof( aDebugData.aDbgData.aDebugName ) ); |
| lcl_tryReadConfigBoolean( pLine, nLineLength, "overwrite", &aDebugData.aDbgData.bOverwrite ); |
| lcl_tryReadConfigString( pLine, nLineLength, "include", aDebugData.aDbgData.aInclFilter, sizeof( aDebugData.aDbgData.aInclFilter ) ); |
| lcl_tryReadConfigString( pLine, nLineLength, "exclude", aDebugData.aDbgData.aExclFilter, sizeof( aDebugData.aDbgData.aExclFilter ) ); |
| lcl_tryReadConfigString( pLine, nLineLength, "include_class", aDebugData.aDbgData.aInclClassFilter, sizeof( aDebugData.aDbgData.aInclClassFilter ) ); |
| lcl_tryReadConfigString( pLine, nLineLength, "exclude_class", aDebugData.aDbgData.aExclClassFilter, sizeof( aDebugData.aDbgData.aExclClassFilter ) ); |
| lcl_tryReadOutputChannel( pLine, nLineLength, "trace", &aDebugData.aDbgData.nTraceOut ); |
| lcl_tryReadOutputChannel( pLine, nLineLength, "warning", &aDebugData.aDbgData.nWarningOut ); |
| lcl_tryReadOutputChannel( pLine, nLineLength, "error", &aDebugData.aDbgData.nErrorOut ); |
| lcl_tryReadConfigBoolean( pLine, nLineLength, "oslhook", &aDebugData.aDbgData.bHookOSLAssert ); |
| } |
| |
| // elements of the [memory] section |
| if ( eCurrentSection == eMemory ) |
| { |
| lcl_tryReadConfigFlag( pLine, nLineLength, "initialize", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_INIT ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "overwrite", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_OVERWRITE ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "overwrite_free", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_OVERWRITEFREE ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "pointer", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_POINTER ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "report", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_REPORT ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "trace", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_TRACE ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "new_and_delete", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_NEWDEL ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "object_test", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_XTOR ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "sys_alloc", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_SYSALLOC ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "leak_report", &aDebugData.aDbgData.nTestFlags, DBG_TEST_MEM_LEAKREPORT ); |
| |
| lcl_tryReadHexByte( pLine, nLineLength, "init_byte", &aDebugData.aDbgData.bMemInit ); |
| lcl_tryReadHexByte( pLine, nLineLength, "bound_byte", &aDebugData.aDbgData.bMemBound ); |
| lcl_tryReadHexByte( pLine, nLineLength, "free_byte", &aDebugData.aDbgData.bMemFree ); |
| } |
| |
| // elements of the [gui] section |
| if ( eCurrentSection == eGUI ) |
| { |
| lcl_tryReadConfigString( pLine, nLineLength, "debug_window_state", aDebugData.aDbgData.aDbgWinState, sizeof( aDebugData.aDbgData.aDbgWinState ) ); |
| } |
| |
| // elements of the [objects] section |
| if ( eCurrentSection == eObjects ) |
| { |
| lcl_tryReadConfigFlag( pLine, nLineLength, "check_this", &aDebugData.aDbgData.nTestFlags, DBG_TEST_XTOR_THIS ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "check_function", &aDebugData.aDbgData.nTestFlags, DBG_TEST_XTOR_FUNC ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "check_exit", &aDebugData.aDbgData.nTestFlags, DBG_TEST_XTOR_EXIT ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "generate_report", &aDebugData.aDbgData.nTestFlags, DBG_TEST_XTOR_REPORT ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "trace", &aDebugData.aDbgData.nTestFlags, DBG_TEST_XTOR_TRACE ); |
| } |
| |
| // elements of the [test] section |
| if ( eCurrentSection == eTest ) |
| { |
| lcl_tryReadConfigFlag( pLine, nLineLength, "profiling", &aDebugData.aDbgData.nTestFlags, DBG_TEST_PROFILING ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "resources", &aDebugData.aDbgData.nTestFlags, DBG_TEST_RESOURCE ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "dialog", &aDebugData.aDbgData.nTestFlags, DBG_TEST_DIALOG ); |
| lcl_tryReadConfigFlag( pLine, nLineLength, "bold_app_font", &aDebugData.aDbgData.nTestFlags, DBG_TEST_BOLDAPPFONT ); |
| } |
| |
| pLine = pNextLine + strlen( FILE_LINEEND ); |
| } |
| |
| FileClose( pIniFile ); |
| } |
| else |
| { |
| lcl_matchOutputChannel( getenv( "DBGSV_TRACE_OUT" ), &aDebugData.aDbgData.nTraceOut ); |
| lcl_matchOutputChannel( getenv( "DBGSV_WARNING_OUT" ), &aDebugData.aDbgData.nWarningOut ); |
| lcl_matchOutputChannel( getenv( "DBGSV_ERROR_OUT" ), &aDebugData.aDbgData.nErrorOut ); |
| |
| } |
| |
| getcwd( aCurPath, sizeof( aCurPath ) ); |
| |
| // Daten initialisieren |
| if ( aDebugData.aDbgData.nTestFlags & DBG_TEST_XTOR ) |
| aDebugData.pXtorList = new PointerList; |
| if ( aDebugData.aDbgData.nTestFlags & DBG_TEST_PROFILING ) |
| aDebugData.pProfList = new PointerList; |
| } |
| |
| return &aDebugData; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| inline DebugData* ImplGetDebugData() |
| { |
| if ( !aDebugData.bInit ) |
| return GetDebugData(); |
| else |
| return &aDebugData; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static FILETYPE ImplDbgInitFile() |
| { |
| static sal_Bool bFileInit = sal_False; |
| |
| sal_Char aBuf[4096]; |
| getcwd( aBuf, sizeof( aBuf ) ); |
| chdir( aCurPath ); |
| |
| DebugData* pData = GetDebugData(); |
| FILETYPE pDebugFile; |
| |
| if ( !bFileInit ) |
| { |
| bFileInit = sal_True; |
| |
| if ( pData->aDbgData.bOverwrite ) |
| pDebugFile = FileOpen( pData->aDbgData.aDebugName, "w" ); |
| else |
| pDebugFile = FileOpen( pData->aDbgData.aDebugName, "a" ); |
| |
| if ( pDebugFile ) |
| { |
| time_t nTime = time( 0 ); |
| tm* pTime; |
| #ifdef UNX |
| tm aTime; |
| pTime = localtime_r( &nTime, &aTime ); |
| #else |
| pTime = localtime( &nTime ); |
| #endif |
| |
| // Header ausgeben |
| FilePrintF( pDebugFile, "******************************************************************************%s", FILE_LINEEND ); |
| FilePrintF( pDebugFile, "%s%s", pData->aDbgData.aDebugName, FILE_LINEEND ); |
| if ( pTime ) |
| FilePrintF( pDebugFile, "%s%s", asctime( pTime ), FILE_LINEEND ); |
| } |
| } |
| else |
| pDebugFile = FileOpen( pData->aDbgData.aDebugName, "a" ); |
| |
| chdir( aBuf ); |
| |
| return pDebugFile; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplDbgPrintFile( const sal_Char* pLine ) |
| { |
| FILETYPE pDebugFile = ImplDbgInitFile(); |
| |
| if ( pDebugFile ) |
| { |
| FilePrintF( pDebugFile, "%s%s", pLine, FILE_LINEEND ); |
| FileClose( pDebugFile ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static int ImplStrSearch( const sal_Char* pSearchStr, int nSearchLen, |
| const sal_Char* pStr, int nLen ) |
| { |
| int nPos = 0; |
| while ( nPos+nSearchLen <= nLen ) |
| { |
| if ( strncmp( pStr+nPos, pSearchStr, nSearchLen ) == 0 ) |
| return 1; |
| nPos++; |
| } |
| |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static int ImplDbgFilter( const sal_Char* pFilter, const sal_Char* pMsg, |
| int bEmpty ) |
| { |
| int nStrLen = strlen( pFilter ); |
| if ( !nStrLen ) |
| return bEmpty; |
| |
| int nMsgLen = strlen( pMsg ); |
| const sal_Char* pTok = pFilter; |
| int nTok = 0; |
| while ( pTok[nTok] ) |
| { |
| if ( pTok[nTok] == ';' ) |
| { |
| if ( nTok && ImplStrSearch( pTok, nTok, pMsg, nMsgLen ) ) |
| return sal_True; |
| |
| pTok += nTok+1; |
| nTok = 0; |
| } |
| |
| nTok++; |
| } |
| |
| if ( nTok && ImplStrSearch( pTok, nTok, pMsg, nMsgLen ) ) |
| return sal_True; |
| else |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| extern "C" |
| void SAL_CALL dbg_printOslDebugMessage( const sal_Char * pszFileName, sal_Int32 nLine, const sal_Char * pszMessage ) |
| { |
| DbgOut( pszMessage ? pszMessage : "assertion failed!", DBG_OUT_ERROR, pszFileName, (sal_uInt16)nLine ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void DebugInit() |
| { |
| bDbgImplInMain = sal_True; |
| ImplDbgInitLock(); |
| |
| DebugData* pData = GetDebugData(); |
| if( pData->aDbgData.bHookOSLAssert && ! pData->bOslIsHooked ) |
| { |
| pData->pOldDebugMessageFunc = osl_setDetailedDebugMessageFunc( &dbg_printOslDebugMessage ); |
| pData->bOslIsHooked = true; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void DebugDeInit() |
| { |
| DebugData* pData = GetDebugData(); |
| sal_uIntPtr i; |
| sal_uIntPtr nCount; |
| sal_uIntPtr nOldOut; |
| |
| if( pData->bOslIsHooked ) |
| { |
| osl_setDetailedDebugMessageFunc( pData->pOldDebugMessageFunc ); |
| pData->bOslIsHooked = sal_False; |
| } |
| |
| // Statistik-Ausgaben immer in File |
| nOldOut = pData->aDbgData.nTraceOut; |
| pData->aDbgData.nTraceOut = DBG_OUT_FILE; |
| |
| // Xtor-Liste ausgeben |
| if ( pData->pXtorList && pData->pXtorList->Count() && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_REPORT) ) |
| { |
| DbgOutf( "------------------------------------------------------------------------------" ); |
| DbgOutf( "Object Report" ); |
| DbgOutf( "------------------------------------------------------------------------------" ); |
| DbgOutf( "%-27s : %-9s : %-9s : %-7s : %-3s : %-6s :", |
| "XTor-List", "Ctor", "Dtor", "MaxInst", "St.", "Diff." ); |
| DbgOutf( "----------------------------:-----------:-----------:---------:----:---------:" ); |
| for( i = 0, nCount = pData->pXtorList->Count(); i < nCount; i++ ) |
| { |
| XtorType* pXtorData = (XtorType*)pData->pXtorList->Get( i ); |
| if ( pXtorData->bTest ) |
| { |
| // Static-Objekte dazurechnen |
| pXtorData->nDtorCalls += pXtorData->nStatics; |
| if ( pXtorData->nStatics && (pXtorData->nDtorCalls > pXtorData->nCtorCalls) ) |
| pXtorData->nDtorCalls = pXtorData->nCtorCalls; |
| DbgOutf( "%-27s : %9lu : %9lu : %7lu : %3lu : %4lu %-1s :", |
| pXtorData->aName, pXtorData->nCtorCalls, pXtorData->nDtorCalls, |
| pXtorData->nMaxCount, pXtorData->nStatics, |
| pXtorData->nCtorCalls - pXtorData->nDtorCalls, |
| (pXtorData->nCtorCalls - pXtorData->nDtorCalls) ? "!" : " " ); |
| } |
| } |
| DbgOutf( "==============================================================================" ); |
| } |
| |
| // Aufraeumen |
| if ( pData->pXtorList ) |
| { |
| for( i = 0, nCount = pData->pXtorList->Count(); i < nCount; i++ ) |
| { |
| XtorType* pXtorData = (XtorType*)pData->pXtorList->Get( i ); |
| delete pXtorData; |
| } |
| delete pData->pXtorList; |
| pData->pXtorList = NULL; |
| } |
| |
| // Alles auf sal_False setzen, damit globale Variablen nicht das |
| // System zum Abstuerzen bringt. Dabei muessen aber die |
| // Memory-Flags erhalten bleiben, da sonst new/delete in globalen |
| // Variablen abstuerzen, da die Pointeranpassung dann nicht mehr richtig |
| // funktioniert |
| pData->aDbgData.nTraceOut = nOldOut; |
| pData->aDbgData.nTestFlags &= (DBG_TEST_MEM | DBG_TEST_PROFILING); |
| pData->aDbgPrintUserChannels.clear(); |
| pData->pDbgPrintTestTool = NULL; |
| pData->pDbgPrintWindow = NULL; |
| pData->pOldDebugMessageFunc = NULL; |
| ImplDbgDeInitLock(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void DebugGlobalDeInit() |
| { |
| DebugData* pData = GetDebugData(); |
| sal_uIntPtr i; |
| sal_uIntPtr nCount; |
| sal_uIntPtr nOldOut; |
| |
| // Statistik-Ausgaben immer in File |
| nOldOut = pData->aDbgData.nTraceOut; |
| pData->aDbgData.nTraceOut = DBG_OUT_FILE; |
| |
| // Profileliste ausgeben |
| if ( pData->pProfList && pData->pProfList->Count() ) |
| { |
| DbgOutf( "------------------------------------------------------------------------------" ); |
| DbgOutf( "Profiling Report" ); |
| DbgOutf( "------------------------------------------------------------------------------" ); |
| DbgOutf( "%-25s : %-9s : %-6s : %-6s : %-6s : %-9s :", |
| "Prof-List (ms)", "Time", "Min", "Max", "Ave", "Count" ); |
| DbgOutf( "--------------------------:-----------:--------:--------:--------:-----------:" ); |
| for( i = 0, nCount = pData->pProfList->Count(); i < nCount; i++ ) |
| { |
| ProfType* pProfData = (ProfType*)pData->pProfList->Get( i ); |
| sal_uIntPtr nAve = pProfData->nTime / pProfData->nCount; |
| DbgOutf( "%-25s : %9lu : %6lu : %6lu : %6lu : %9lu :", |
| pProfData->aName, pProfData->nTime, |
| pProfData->nMinTime, pProfData->nMaxTime, nAve, |
| pProfData->nCount ); |
| } |
| DbgOutf( "==============================================================================" ); |
| } |
| |
| // Aufraeumen |
| if ( pData->pProfList ) |
| { |
| for( i = 0, nCount = pData->pProfList->Count(); i < nCount; i++ ) |
| { |
| ProfType* pProfData = (ProfType*)pData->pProfList->Get( i ); |
| delete pProfData; |
| } |
| delete pData->pProfList; |
| pData->pProfList = NULL; |
| } |
| |
| #ifdef SV_MEMMGR |
| DbgImpCheckMemoryDeInit(); |
| #endif |
| |
| // Profiling-Flags ausschalten |
| pData->aDbgData.nTraceOut = nOldOut; |
| pData->aDbgData.nTestFlags &= ~DBG_TEST_PROFILING; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ImpDbgOutfBuf( sal_Char* pBuf, const sal_Char* pFStr, ... ) |
| { |
| va_list pList; |
| |
| va_start( pList, pFStr ); |
| sal_Char aBuf[DBG_BUF_MAXLEN]; |
| vsprintf( aBuf, pFStr, pList ); |
| va_end( pList ); |
| |
| strcat( pBuf, aBuf ); |
| strcat( pBuf, "\n" ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void DebugXTorInfo( sal_Char* pBuf ) |
| { |
| DebugData* pData = GetDebugData(); |
| sal_uIntPtr i; |
| sal_uIntPtr nCount; |
| |
| // Xtor-Liste ausgeben |
| if ( pData->pXtorList && pData->pXtorList->Count() && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_REPORT) ) |
| { |
| ImpDbgOutfBuf( pBuf, "------------------------------------------------------------------------------" ); |
| ImpDbgOutfBuf( pBuf, "Object Report" ); |
| ImpDbgOutfBuf( pBuf, "------------------------------------------------------------------------------" ); |
| ImpDbgOutfBuf( pBuf, "%-27s : %-9s : %-9s : %-7s : %-3s : %-6s :", |
| "XTor-List", "Ctor", "Dtor", "MaxInst", "St.", "Diff." ); |
| ImpDbgOutfBuf( pBuf, "----------------------------:-----------:-----------:---------:----:---------:" ); |
| for( i = 0, nCount = pData->pXtorList->Count(); i < nCount; i++ ) |
| { |
| XtorType* pXtorData = (XtorType*)pData->pXtorList->Get( i ); |
| if ( pXtorData->bTest ) |
| { |
| ImpDbgOutfBuf( pBuf, "%-27s : %9lu : %9lu : %7lu : %3lu : %6lu :", |
| pXtorData->aName, pXtorData->nCtorCalls, pXtorData->nDtorCalls, |
| pXtorData->nMaxCount, pXtorData->nStatics, |
| pXtorData->nCtorCalls - pXtorData->nDtorCalls ); |
| } |
| } |
| ImpDbgOutfBuf( pBuf, "==============================================================================" ); |
| ImpDbgOutfBuf( pBuf, "" ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| sal_Bool ImplDbgFilterMessage( const sal_Char* pMsg ) |
| { |
| DebugData* pData = GetDebugData(); |
| if ( !ImplDbgFilter( pData->aDbgData.aInclFilter, pMsg, sal_True ) ) |
| return sal_True; |
| if ( ImplDbgFilter( pData->aDbgData.aExclFilter, pMsg, sal_False ) ) |
| return sal_True; |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void* DbgFunc( sal_uInt16 nAction, void* pParam ) |
| { |
| DebugData* pDebugData = ImplGetDebugData(); |
| |
| if ( nAction == DBG_FUNC_GETDATA ) |
| return (void*)&(pDebugData->aDbgData); |
| else if ( nAction == DBG_FUNC_GETPRINTMSGBOX ) |
| return (void*)(long)(pDebugData->pDbgPrintMsgBox); |
| else if ( nAction == DBG_FUNC_FILTERMESSAGE ) |
| if ( ImplDbgFilterMessage( (const sal_Char*) pParam ) ) |
| return (void*) -1; |
| else |
| return (void*) 0; // aka NULL |
| else |
| |
| { |
| switch ( nAction ) |
| { |
| case DBG_FUNC_DEBUGSTART: |
| DebugInit(); |
| break; |
| |
| case DBG_FUNC_DEBUGEND: |
| DebugDeInit(); |
| break; |
| |
| case DBG_FUNC_GLOBALDEBUGEND: |
| DebugGlobalDeInit(); |
| break; |
| |
| case DBG_FUNC_SETPRINTMSGBOX: |
| pDebugData->pDbgPrintMsgBox = (DbgPrintLine)(long)pParam; |
| break; |
| |
| case DBG_FUNC_SETPRINTWINDOW: |
| pDebugData->pDbgPrintWindow = (DbgPrintLine)(long)pParam; |
| break; |
| |
| case DBG_FUNC_SETPRINTTESTTOOL: |
| pDebugData->pDbgPrintTestTool = (DbgPrintLine)(long)pParam; |
| break; |
| |
| case DBG_FUNC_SET_ABORT: |
| pDebugData->pDbgAbort = (DbgPrintLine)(long)pParam; |
| break; |
| |
| case DBG_FUNC_SAVEDATA: |
| { |
| const DbgData* pData = static_cast< const DbgData* >( pParam ); |
| |
| sal_Char aBuf[ 4096 ]; |
| DbgGetDbgFileName( aBuf, sizeof( aBuf ) ); |
| FILETYPE pIniFile = FileOpen( aBuf, "w" ); |
| if ( pIniFile == NULL ) |
| break; |
| |
| lcl_startSection( pIniFile, eOutput ); |
| lcl_writeConfigString( pIniFile, "log_file", pData->aDebugName ); |
| lcl_writeConfigBoolean( pIniFile, "overwrite", pData->bOverwrite ); |
| lcl_writeConfigString( pIniFile, "include", pData->aInclFilter ); |
| lcl_writeConfigString( pIniFile, "exclude", pData->aExclFilter ); |
| lcl_writeConfigString( pIniFile, "include_class", pData->aInclClassFilter ); |
| lcl_writeConfigString( pIniFile, "exclude_class", pData->aExclClassFilter ); |
| lcl_writeConfigOutChannel( pIniFile, "trace", pData->nTraceOut ); |
| lcl_writeConfigOutChannel( pIniFile, "warning", pData->nWarningOut ); |
| lcl_writeConfigOutChannel( pIniFile, "error", pData->nErrorOut ); |
| lcl_writeConfigBoolean( pIniFile, "oslhook", pData->bHookOSLAssert ); |
| |
| lcl_lineFeed( pIniFile ); |
| lcl_startSection( pIniFile, eMemory ); |
| lcl_writeConfigFlag( pIniFile, "initialize", pData->nTestFlags, DBG_TEST_MEM_INIT ); |
| lcl_writeConfigFlag( pIniFile, "overwrite", pData->nTestFlags, DBG_TEST_MEM_OVERWRITE ); |
| lcl_writeConfigFlag( pIniFile, "overwrite_free", pData->nTestFlags, DBG_TEST_MEM_OVERWRITEFREE ); |
| lcl_writeConfigFlag( pIniFile, "pointer", pData->nTestFlags, DBG_TEST_MEM_POINTER ); |
| lcl_writeConfigFlag( pIniFile, "report", pData->nTestFlags, DBG_TEST_MEM_REPORT ); |
| lcl_writeConfigFlag( pIniFile, "trace", pData->nTestFlags, DBG_TEST_MEM_TRACE ); |
| lcl_writeConfigFlag( pIniFile, "new_and_delete", pData->nTestFlags, DBG_TEST_MEM_NEWDEL ); |
| lcl_writeConfigFlag( pIniFile, "object_test", pData->nTestFlags, DBG_TEST_MEM_XTOR ); |
| lcl_writeConfigFlag( pIniFile, "sys_alloc", pData->nTestFlags, DBG_TEST_MEM_SYSALLOC ); |
| lcl_writeConfigFlag( pIniFile, "leak_report", pData->nTestFlags, DBG_TEST_MEM_LEAKREPORT ); |
| |
| lcl_lineFeed( pIniFile ); |
| lcl_writeHexByte( pIniFile, "init_byte", pData->bMemInit ); |
| lcl_writeHexByte( pIniFile, "bound_byte", pData->bMemBound ); |
| lcl_writeHexByte( pIniFile, "free_byte", pData->bMemFree ); |
| |
| lcl_lineFeed( pIniFile ); |
| lcl_startSection( pIniFile, eGUI ); |
| lcl_writeConfigString( pIniFile, "debug_window_state", pData->aDbgWinState ); |
| |
| lcl_lineFeed( pIniFile ); |
| lcl_startSection( pIniFile, eObjects ); |
| lcl_writeConfigFlag( pIniFile, "check_this", pData->nTestFlags, DBG_TEST_XTOR_THIS ); |
| lcl_writeConfigFlag( pIniFile, "check_function", pData->nTestFlags, DBG_TEST_XTOR_FUNC ); |
| lcl_writeConfigFlag( pIniFile, "check_exit", pData->nTestFlags, DBG_TEST_XTOR_EXIT ); |
| lcl_writeConfigFlag( pIniFile, "generate_report", pData->nTestFlags, DBG_TEST_XTOR_REPORT ); |
| lcl_writeConfigFlag( pIniFile, "trace", pData->nTestFlags, DBG_TEST_XTOR_TRACE ); |
| |
| lcl_lineFeed( pIniFile ); |
| lcl_startSection( pIniFile, eTest ); |
| lcl_writeConfigFlag( pIniFile, "profiling", pData->nTestFlags, DBG_TEST_PROFILING ); |
| lcl_writeConfigFlag( pIniFile, "resources", pData->nTestFlags, DBG_TEST_RESOURCE ); |
| lcl_writeConfigFlag( pIniFile, "dialog", pData->nTestFlags, DBG_TEST_DIALOG ); |
| lcl_writeConfigFlag( pIniFile, "bold_app_font", pData->nTestFlags, DBG_TEST_BOLDAPPFONT ); |
| |
| FileClose( pIniFile ); |
| } |
| break; |
| |
| case DBG_FUNC_MEMTEST: |
| #ifdef SV_MEMMGR |
| DbgImpCheckMemory( pParam ); |
| #endif |
| break; |
| |
| case DBG_FUNC_XTORINFO: |
| DebugXTorInfo( (sal_Char*)pParam ); |
| break; |
| |
| case DBG_FUNC_MEMINFO: |
| #ifdef SV_MEMMGR |
| DbgImpMemoryInfo( (sal_Char*)pParam ); |
| #endif |
| break; |
| |
| case DBG_FUNC_COREDUMP: |
| ImplCoreDump(); |
| break; |
| |
| case DBG_FUNC_ALLERROROUT: |
| return (void*)(sal_uIntPtr)sal_True; |
| |
| case DBG_FUNC_SETTESTSOLARMUTEX: |
| pDebugData->pDbgTestSolarMutex = (DbgTestSolarMutexProc)(long)pParam; |
| break; |
| |
| case DBG_FUNC_TESTSOLARMUTEX: |
| if ( pDebugData->pDbgTestSolarMutex ) |
| pDebugData->pDbgTestSolarMutex(); |
| break; |
| |
| case DBG_FUNC_PRINTFILE: |
| ImplDbgPrintFile( (const sal_Char*)pParam ); |
| break; |
| case DBG_FUNC_UPDATEOSLHOOK: |
| { |
| const DbgData* pData = static_cast< const DbgData* >( pParam ); |
| pDebugData->aDbgData.bHookOSLAssert = pData->bHookOSLAssert; |
| if( pDebugData->bOslIsHooked && ! pData->bHookOSLAssert ) |
| { |
| osl_setDetailedDebugMessageFunc( pDebugData->pOldDebugMessageFunc ); |
| pDebugData->bOslIsHooked = sal_False; |
| } |
| else if( ! pDebugData->bOslIsHooked && pData->bHookOSLAssert ) |
| { |
| pDebugData->pOldDebugMessageFunc = osl_setDetailedDebugMessageFunc( &dbg_printOslDebugMessage ); |
| pDebugData->bOslIsHooked = sal_True; |
| } |
| } |
| break; |
| } |
| |
| return NULL; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| DbgChannelId DbgRegisterUserChannel( DbgPrintLine pProc ) |
| { |
| DebugData* pData = ImplGetDebugData(); |
| pData->aDbgPrintUserChannels.push_back( pProc ); |
| return (DbgChannelId)( pData->aDbgPrintUserChannels.size() - 1 + DBG_OUT_USER_CHANNEL_0 ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void DbgProf( sal_uInt16 nAction, DbgDataType* pDbgData ) |
| { |
| // Ueberhaupt Profiling-Test an |
| DebugData* pData = ImplGetDebugData(); |
| |
| if ( !(pData->aDbgData.nTestFlags & DBG_TEST_PROFILING) ) |
| return; |
| |
| sal_Char aBuf[DBG_BUF_MAXLEN]; |
| ProfType* pProfData = (ProfType*)pDbgData->pData; |
| sal_uIntPtr nTime; |
| if ( (nAction != DBG_PROF_START) && !pProfData ) |
| { |
| strcpy( aBuf, DbgError_ProfEnd1 ); |
| strcat( aBuf, pDbgData->pName ); |
| DbgError( aBuf ); |
| return; |
| } |
| |
| switch ( nAction ) |
| { |
| case DBG_PROF_START: |
| if ( !pDbgData->pData ) |
| { |
| pDbgData->pData = (void*)new ProfType; |
| pProfData = (ProfType*)pDbgData->pData; |
| strncpy( pProfData->aName, pDbgData->pName, DBG_MAXNAME ); |
| pProfData->aName[DBG_MAXNAME] = '\0'; |
| pProfData->nCount = 0; |
| pProfData->nTime = 0; |
| pProfData->nMinTime = 0xFFFFFFFF; |
| pProfData->nMaxTime = 0; |
| pProfData->nStart = 0xFFFFFFFF; |
| pProfData->nContinueTime = 0; |
| pProfData->nContinueStart = 0xFFFFFFFF; |
| pData->pProfList->Add( (void*)pProfData ); |
| } |
| |
| if ( pProfData->nStart == 0xFFFFFFFF ) |
| { |
| pProfData->nStart = ImplGetPerfTime(); |
| pProfData->nCount++; |
| } |
| break; |
| |
| case DBG_PROF_STOP: |
| nTime = ImplGetPerfTime(); |
| |
| if ( pProfData->nStart == 0xFFFFFFFF ) |
| { |
| DbgError( DbgError_ProfEnd1 ); |
| return; |
| } |
| |
| if ( pProfData->nContinueStart != 0xFFFFFFFF ) |
| { |
| pProfData->nContinueTime += ImplGetPerfTime() - pProfData->nContinueStart; |
| pProfData->nContinueStart = 0xFFFFFFFF; |
| } |
| |
| nTime -= pProfData->nStart; |
| nTime -= pProfData->nContinueTime; |
| |
| if ( nTime < pProfData->nMinTime ) |
| pProfData->nMinTime = nTime; |
| |
| if ( nTime > pProfData->nMaxTime ) |
| pProfData->nMaxTime = nTime; |
| |
| pProfData->nTime += nTime; |
| |
| pProfData->nStart = 0xFFFFFFFF; |
| pProfData->nContinueTime = 0; |
| pProfData->nContinueStart = 0xFFFFFFFF; |
| break; |
| |
| case DBG_PROF_CONTINUE: |
| if ( pProfData->nContinueStart != 0xFFFFFFFF ) |
| { |
| pProfData->nContinueTime += ImplGetPerfTime() - pProfData->nContinueStart; |
| pProfData->nContinueStart = 0xFFFFFFFF; |
| } |
| break; |
| |
| case DBG_PROF_PAUSE: |
| if ( pProfData->nContinueStart == 0xFFFFFFFF ) |
| pProfData->nContinueStart = ImplGetPerfTime(); |
| break; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void DbgXtor( DbgDataType* pDbgData, sal_uInt16 nAction, const void* pThis, |
| DbgUsr fDbgUsr ) |
| { |
| DebugData* pData = ImplGetDebugData(); |
| |
| // Verbindung zu Debug-Memory-Manager testen |
| #ifdef SV_MEMMGR |
| if ( pData->aDbgData.nTestFlags & DBG_TEST_MEM_XTOR ) |
| DbgImpCheckMemory(); |
| #endif |
| |
| // Schnell-Test |
| if ( !(pData->aDbgData.nTestFlags & DBG_TEST_XTOR) ) |
| return; |
| |
| XtorType* pXtorData = (XtorType*)pDbgData->pData; |
| if ( !pXtorData ) |
| { |
| pDbgData->pData = (void*)new XtorType; |
| pXtorData = (XtorType*)pDbgData->pData; |
| strncpy( pXtorData->aName, pDbgData->pName, DBG_MAXNAME ); |
| pXtorData->aName[DBG_MAXNAME] = '\0'; |
| pXtorData->nCtorCalls = 0; |
| pXtorData->nDtorCalls = 0; |
| pXtorData->nMaxCount = 0; |
| pXtorData->nStatics = 0; |
| pXtorData->bTest = sal_True; |
| pData->pXtorList->Add( (void*)pXtorData ); |
| |
| if ( !ImplDbgFilter( pData->aDbgData.aInclClassFilter, pXtorData->aName, sal_True ) ) |
| pXtorData->bTest = sal_False; |
| if ( ImplDbgFilter( pData->aDbgData.aExclClassFilter, pXtorData->aName, sal_False ) ) |
| pXtorData->bTest = sal_False; |
| } |
| if ( !pXtorData->bTest ) |
| return; |
| |
| sal_Char aBuf[DBG_BUF_MAXLEN]; |
| sal_uInt16 nAct = nAction & ~DBG_XTOR_DTOROBJ; |
| |
| // Trace (Enter) |
| if ( (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_TRACE) && |
| !(nAction & DBG_XTOR_DTOROBJ) ) |
| { |
| if ( nAct != DBG_XTOR_CHKOBJ ) |
| { |
| if ( nAct == DBG_XTOR_CTOR ) |
| strcpy( aBuf, DbgTrace_EnterCtor ); |
| else if ( nAct == DBG_XTOR_DTOR ) |
| strcpy( aBuf, DbgTrace_EnterDtor ); |
| else |
| strcpy( aBuf, DbgTrace_EnterMeth ); |
| strcat( aBuf, pDbgData->pName ); |
| DbgTrace( aBuf ); |
| } |
| } |
| |
| // Sind noch Xtor-Tests als Trace an |
| if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXTRA ) |
| { |
| // DBG_CTOR-Aufruf vor allen anderen DBG_XTOR-Aufrufen |
| if ( ((nAction & ~DBG_XTOR_DTOROBJ) != DBG_XTOR_CTOR) && !pDbgData->pData ) |
| { |
| strcpy( aBuf, DbgError_Xtor1 ); |
| strcat( aBuf, pDbgData->pName ); |
| DbgError( aBuf ); |
| return; |
| } |
| |
| // Testen, ob This-Pointer gueltig |
| if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_THIS ) |
| { |
| if ( (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXIT) || |
| !(nAction & DBG_XTOR_DTOROBJ) ) |
| { |
| // This-Pointer == NULL |
| if ( !pThis ) |
| { |
| strcpy( aBuf, DbgError_CtorDtor1 ); |
| strcat( aBuf, pDbgData->pName ); |
| DbgError( aBuf ); |
| return; |
| } |
| |
| if ( (nAction & ~DBG_XTOR_DTOROBJ) != DBG_XTOR_CTOR ) |
| { |
| if ( !pXtorData->aThisList.IsIn( pThis ) ) |
| { |
| sprintf( aBuf, DbgError_CtorDtor2, pThis ); |
| strcat( aBuf, pDbgData->pName ); |
| DbgError( aBuf ); |
| } |
| } |
| } |
| } |
| |
| // Function-Test durchfuehren und Verwaltungsdaten updaten |
| const sal_Char* pMsg = NULL; |
| switch ( nAction & ~DBG_XTOR_DTOROBJ ) |
| { |
| case DBG_XTOR_CTOR: |
| if ( nAction & DBG_XTOR_DTOROBJ ) |
| { |
| if ( fDbgUsr && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXIT) && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) |
| pMsg = fDbgUsr( pThis ); |
| } |
| else |
| { |
| pXtorData->nCtorCalls++; |
| if ( !bDbgImplInMain ) |
| pXtorData->nStatics++; |
| if ( (pXtorData->nCtorCalls-pXtorData->nDtorCalls) > pXtorData->nMaxCount ) |
| pXtorData->nMaxCount = pXtorData->nCtorCalls - pXtorData->nDtorCalls; |
| |
| if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_THIS ) |
| pXtorData->aThisList.Add( pThis ); |
| } |
| break; |
| |
| case DBG_XTOR_DTOR: |
| if ( nAction & DBG_XTOR_DTOROBJ ) |
| { |
| pXtorData->nDtorCalls++; |
| if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_THIS ) |
| pXtorData->aThisList.Remove( pThis ); |
| } |
| else |
| { |
| if ( fDbgUsr && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) |
| pMsg = fDbgUsr( pThis ); |
| } |
| break; |
| |
| case DBG_XTOR_CHKTHIS: |
| case DBG_XTOR_CHKOBJ: |
| if ( nAction & DBG_XTOR_DTOROBJ ) |
| { |
| if ( fDbgUsr && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXIT) && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) |
| pMsg = fDbgUsr( pThis ); |
| } |
| else |
| { |
| if ( fDbgUsr && |
| (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) |
| pMsg = fDbgUsr( pThis ); |
| } |
| break; |
| } |
| |
| // Gegebenenfalls Fehlermeldung ausgeben |
| if ( pMsg ) |
| { |
| sprintf( aBuf, DbgError_CtorDtor3, pThis ); |
| strcat( aBuf, pDbgData->pName ); |
| strcat( aBuf, ": \n" ); |
| strcat( aBuf, pMsg ); |
| DbgError( aBuf ); |
| } |
| } |
| |
| // Trace (Leave) |
| if ( (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_TRACE) && |
| (nAction & DBG_XTOR_DTOROBJ) ) |
| { |
| if ( nAct != DBG_XTOR_CHKOBJ ) |
| { |
| if ( nAct == DBG_XTOR_CTOR ) |
| strcpy( aBuf, DbgTrace_LeaveCtor ); |
| else if ( nAct == DBG_XTOR_DTOR ) |
| strcpy( aBuf, DbgTrace_LeaveDtor ); |
| else |
| strcpy( aBuf, DbgTrace_LeaveMeth ); |
| strcat( aBuf, pDbgData->pName ); |
| DbgTrace( aBuf ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void DbgOut( const sal_Char* pMsg, sal_uInt16 nDbgOut, const sal_Char* pFile, sal_uInt16 nLine ) |
| { |
| static sal_Bool bIn = sal_False; |
| if ( bIn ) |
| return; |
| bIn = sal_True; |
| |
| DebugData* pData = GetDebugData(); |
| sal_Char const * pStr; |
| sal_uIntPtr nOut; |
| int nBufLen = 0; |
| |
| if ( nDbgOut == DBG_OUT_ERROR ) |
| { |
| nOut = pData->aDbgData.nErrorOut; |
| pStr = "Error: "; |
| if ( pData->aDbgData.nErrorOut == DBG_OUT_FILE ) |
| DbgDebugBeep(); |
| } |
| else if ( nDbgOut == DBG_OUT_WARNING ) |
| { |
| nOut = pData->aDbgData.nWarningOut; |
| pStr = "Warning: "; |
| } |
| else |
| { |
| nOut = pData->aDbgData.nTraceOut; |
| pStr = NULL; |
| } |
| |
| if ( nOut == DBG_OUT_NULL ) |
| { |
| bIn = sal_False; |
| return; |
| } |
| |
| if ( ImplDbgFilterMessage( pMsg ) ) |
| { |
| bIn = sal_False; |
| return; |
| } |
| |
| ImplDbgLock(); |
| |
| sal_Char aBufOut[DBG_BUF_MAXLEN]; |
| if ( pStr ) |
| { |
| strcpy( aBufOut, pStr ); |
| nBufLen = strlen( pStr ); |
| } |
| else |
| aBufOut[0] = '\0'; |
| |
| int nMsgLen = strlen( pMsg ); |
| if ( nBufLen+nMsgLen > DBG_BUF_MAXLEN ) |
| { |
| int nCopyLen = DBG_BUF_MAXLEN-nBufLen-3; |
| strncpy( &(aBufOut[nBufLen]), pMsg, nCopyLen ); |
| strcpy( &(aBufOut[nBufLen+nCopyLen]), "..." ); |
| } |
| else |
| strcpy( &(aBufOut[nBufLen]), pMsg ); |
| |
| if ( pFile && nLine && (nBufLen+nMsgLen < DBG_BUF_MAXLEN) ) |
| { |
| if ( nOut == DBG_OUT_MSGBOX ) |
| strcat( aBufOut, "\n" ); |
| else |
| strcat( aBufOut, " " ); |
| strcat( aBufOut, "From File " ); |
| strcat( aBufOut, pFile ); |
| strcat( aBufOut, " at Line " ); |
| |
| // Line in String umwandeln und dranhaengen |
| sal_Char aLine[9]; |
| sal_Char* pLine = &aLine[7]; |
| sal_uInt16 i; |
| memset( aLine, 0, sizeof( aLine ) ); |
| do |
| { |
| i = nLine % 10; |
| pLine--; |
| *(pLine) = (sal_Char)i + 48; |
| nLine /= 10; |
| } |
| while ( nLine ); |
| strcat( aBufOut, pLine ); |
| } |
| |
| if ( ( nOut >= DBG_OUT_USER_CHANNEL_0 ) && ( nOut - DBG_OUT_USER_CHANNEL_0 < pData->aDbgPrintUserChannels.size() ) ) |
| { |
| DbgPrintLine pPrinter = pData->aDbgPrintUserChannels[ nOut - DBG_OUT_USER_CHANNEL_0 ]; |
| if ( pPrinter ) |
| pPrinter( aBufOut ); |
| else |
| nOut = DBG_OUT_DEBUGGER; |
| } |
| |
| if ( nOut == DBG_OUT_ABORT ) |
| { |
| if ( pData->pDbgAbort != NULL ) |
| pData->pDbgAbort( aBufOut ); |
| abort(); |
| } |
| |
| if ( nOut == DBG_OUT_DEBUGGER ) |
| { |
| if ( !ImplActivateDebugger( aBufOut ) ) |
| nOut = DBG_OUT_TESTTOOL; |
| } |
| |
| if ( nOut == DBG_OUT_TESTTOOL ) |
| { |
| if ( pData->pDbgPrintTestTool ) |
| pData->pDbgPrintTestTool( aBufOut ); |
| else |
| nOut = DBG_OUT_MSGBOX; |
| } |
| |
| if ( nOut == DBG_OUT_MSGBOX ) |
| { |
| if ( pData->pDbgPrintMsgBox ) |
| pData->pDbgPrintMsgBox( aBufOut ); |
| else |
| nOut = DBG_OUT_WINDOW; |
| } |
| |
| if ( nOut == DBG_OUT_WINDOW ) |
| { |
| if ( pData->pDbgPrintWindow ) |
| pData->pDbgPrintWindow( aBufOut ); |
| else |
| nOut = DBG_OUT_FILE; |
| } |
| |
| switch ( nOut ) |
| { |
| case DBG_OUT_SHELL: |
| DbgPrintShell( aBufOut ); |
| break; |
| case DBG_OUT_FILE: |
| ImplDbgPrintFile( aBufOut ); |
| break; |
| } |
| |
| ImplDbgUnlock(); |
| |
| bIn = sal_False; |
| } |
| |
| void DbgPrintShell(char const * message) { |
| fprintf(stderr, "%s\n", message); |
| #if defined WNT |
| OutputDebugStringA(message); |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void DbgOutTypef( sal_uInt16 nDbgOut, const sal_Char* pFStr, ... ) |
| { |
| va_list pList; |
| |
| va_start( pList, pFStr ); |
| sal_Char aBuf[DBG_BUF_MAXLEN]; |
| vsprintf( aBuf, pFStr, pList ); |
| va_end( pList ); |
| |
| DbgOut( aBuf, nDbgOut ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void DbgOutf( const sal_Char* pFStr, ... ) |
| { |
| va_list pList; |
| |
| va_start( pList, pFStr ); |
| sal_Char aBuf[DBG_BUF_MAXLEN]; |
| vsprintf( aBuf, pFStr, pList ); |
| va_end( pList ); |
| |
| DbgOut( aBuf ); |
| } |
| |
| // ======================================================================= |
| |
| #else |
| |
| void* DbgFunc( sal_uInt16, void* ) { return NULL; } |
| |
| void DbgProf( sal_uInt16, DbgDataType* ) {} |
| void DbgXtor( DbgDataType*, sal_uInt16, const void*, DbgUsr ) {} |
| |
| void DbgOut( const sal_Char*, sal_uInt16, const sal_Char*, sal_uInt16 ) {} |
| void DbgOutTypef( sal_uInt16, const sal_Char*, ... ) {} |
| void DbgOutf( const sal_Char*, ... ) {} |
| |
| #endif |
