summaryrefslogtreecommitdiff
path: root/include/tools/debug.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'include/tools/debug.hxx')
-rw-r--r--include/tools/debug.hxx496
1 files changed, 496 insertions, 0 deletions
diff --git a/include/tools/debug.hxx b/include/tools/debug.hxx
new file mode 100644
index 000000000000..54160502257a
--- /dev/null
+++ b/include/tools/debug.hxx
@@ -0,0 +1,496 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * 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 .
+ */
+#ifndef _TOOLS_DEBUG_HXX
+#define _TOOLS_DEBUG_HXX
+
+#include "tools/toolsdllapi.h"
+
+#include <sal/detail/log.h>
+#include <sal/types.h>
+#include <tools/solar.h>
+
+/** The facilities provided by this header are deprecated. True assertions
+ (that detect broken program logic) should use standard assert (which aborts
+ if an assertion fails, and is controlled by the standard NDEBUG macro).
+ Logging of warnings (e.g., about malformed input) and traces (e.g., about
+ steps taken while executing some protocol) should use the facilities
+ provided by sal/log.hxx.
+
+ Because the assertion macro (DBG_ASSERT) has been used for
+ true assertions as well as to log warnings, it maps to SAL_WARN instead of
+ standard assert. The warning and error macros (DBG_ASSERTWARNING,
+ DBG_WARNING, DBG_WARNING1, ..., DBG_WARNING3, DBG_ERRORFILE) all map to
+ SAL_INFO.
+*/
+
+#ifdef DBG_UTIL
+
+typedef void (*DbgPrintLine)( const sal_Char* pLine );
+typedef const sal_Char* (*DbgUsr)(const void* pThis );
+typedef void (*DbgTestSolarMutexProc)();
+
+#define DBG_BUF_MAXLEN 16384
+
+#define DBG_TEST_XTOR (0x00000FFF)
+#define DBG_TEST_XTOR_THIS (0x00000001)
+#define DBG_TEST_XTOR_FUNC (0x00000002)
+#define DBG_TEST_XTOR_EXIT (0x00000004)
+#define DBG_TEST_XTOR_REPORT (0x00000008)
+#define DBG_TEST_XTOR_TRACE (0x00000010)
+
+#define DBG_TEST_PROFILING (0x01000000)
+#define DBG_TEST_RESOURCE (0x02000000)
+#define DBG_TEST_DIALOG (0x04000000)
+#define DBG_TEST_BOLDAPPFONT (0x08000000)
+
+#define DBG_OUT_NULL 0
+#define DBG_OUT_FILE 1
+#define DBG_OUT_WINDOW 2
+#define DBG_OUT_SHELL 3
+#define DBG_OUT_MSGBOX 4
+#define DBG_OUT_TESTTOOL 5
+#define DBG_OUT_DEBUGGER 6
+#define DBG_OUT_ABORT 7
+
+#define DBG_OUT_COUNT 8
+
+// user (runtime) defined output channels
+#define DBG_OUT_USER_CHANNEL_0 100
+
+struct DbgData
+{
+ sal_uIntPtr nTestFlags;
+ sal_uIntPtr bOverwrite;
+ sal_uIntPtr nTraceOut;
+ sal_uIntPtr nWarningOut;
+ sal_uIntPtr nErrorOut;
+ sal_uIntPtr bHookOSLAssert;
+ sal_Char aDebugName[260];
+ sal_Char aInclFilter[512];
+ sal_Char aExclFilter[512];
+ sal_Char aInclClassFilter[512];
+ sal_Char aExclClassFilter[512];
+ sal_Char aDbgWinState[50]; // DbgGUIData for VCL
+};
+
+struct DbgDataType
+{
+ void* pData;
+ sal_Char const * pName;
+};
+
+// Dbg prototypes
+#define DBG_FUNC_DEBUGSTART 1
+#define DBG_FUNC_DEBUGEND 2
+#define DBG_FUNC_GLOBALDEBUGEND 3
+#define DBG_FUNC_GETDATA 4
+#define DBG_FUNC_SAVEDATA 5
+#define DBG_FUNC_SETPRINTMSGBOX 6
+#define DBG_FUNC_SETPRINTWINDOW 7
+#define DBG_FUNC_SETPRINTTESTTOOL 8
+#define DBG_FUNC_XTORINFO 10
+#define DBG_FUNC_COREDUMP 12
+#define DBG_FUNC_ALLERROROUT 13
+#define DBG_FUNC_SETTESTSOLARMUTEX 14
+#define DBG_FUNC_TESTSOLARMUTEX 15
+#define DBG_FUNC_PRINTFILE 16
+#define DBG_FUNC_GETPRINTMSGBOX 17
+#define DBG_FUNC_FILTERMESSAGE 18 // new for #i38967
+#define DBG_FUNC_UPDATEOSLHOOK 19
+#define DBG_FUNC_SET_ABORT 20
+
+TOOLS_DLLPUBLIC void* DbgFunc( sal_uInt16 nAction, void* pData = NULL );
+
+inline void DbgUpdateOslHook( DbgData* pData )
+{
+ DbgFunc( DBG_FUNC_UPDATEOSLHOOK, pData );
+}
+
+inline void DbgDebugStart()
+{
+ DbgFunc( DBG_FUNC_DEBUGSTART );
+}
+
+inline void DbgDebugEnd()
+{
+ DbgFunc( DBG_FUNC_DEBUGEND );
+}
+
+inline void DbgGlobalDebugEnd()
+{
+ DbgFunc( DBG_FUNC_GLOBALDEBUGEND );
+}
+
+inline void DbgSetPrintMsgBox( DbgPrintLine pProc )
+{
+ DbgFunc( DBG_FUNC_SETPRINTMSGBOX, (void*)(long)pProc );
+}
+
+inline DbgPrintLine DbgGetPrintMsgBox()
+{
+ return (DbgPrintLine)(long)DbgFunc( DBG_FUNC_GETPRINTMSGBOX );
+}
+
+inline void DbgSetPrintWindow( DbgPrintLine pProc )
+{
+ DbgFunc( DBG_FUNC_SETPRINTWINDOW, (void*)(long)pProc );
+}
+
+inline void DbgSetPrintTestTool( DbgPrintLine pProc )
+{
+ DbgFunc( DBG_FUNC_SETPRINTTESTTOOL, (void*)(long)pProc );
+}
+
+inline void DbgSetAbort( DbgPrintLine pProc )
+{
+ DbgFunc( DBG_FUNC_SET_ABORT, (void*)(long)pProc );
+}
+
+typedef sal_uInt16 DbgChannelId;
+
+/** registers a user-defined channel for emitting the diagnostic messages
+
+ Note that such a user-defined channel cannot be revoked during the lifetime
+ of the process. Thus, it's the caller's responsibility to ensure that the
+ procedure to which ->pProc points remains valid.
+
+ @param pProc
+ the function for emitting the diagnostic messages
+ @return
+ a unique number for this channel, which can be used for ->DbgData::nErrorOut,
+ ->DbgData::nWarningOut and ->DbgData::nTraceOut
+ @see DBG_OUT_USER_CHANNEL_0
+
+ (In theory, this function could replace the other hard-coded channels. Well, at least
+ the ones for MsgBox, Window, Shell, TestTool. Perhaps in the next life ...)
+*/
+TOOLS_DLLPUBLIC DbgChannelId DbgRegisterUserChannel( DbgPrintLine pProc );
+
+inline sal_Bool DbgFilterMessage( const char* pMsg )
+{
+ return (sal_Bool)(long) DbgFunc( DBG_FUNC_FILTERMESSAGE, (void*)pMsg );
+}
+
+inline int DbgIsAllErrorOut()
+{
+ return (DbgFunc( DBG_FUNC_ALLERROROUT ) != 0);
+}
+
+inline DbgData* DbgGetData()
+{
+ return (DbgData*)DbgFunc( DBG_FUNC_GETDATA );
+}
+
+inline void DbgSaveData( const DbgData& rData )
+{
+ DbgFunc( DBG_FUNC_SAVEDATA, (void*)&rData );
+}
+
+inline sal_uIntPtr DbgIsTraceOut()
+{
+ DbgData* pData = DbgGetData();
+ if ( pData )
+ return (pData->nTraceOut != DBG_OUT_NULL);
+ else
+ return sal_False;
+}
+
+inline sal_uIntPtr DbgIsWarningOut()
+{
+ DbgData* pData = DbgGetData();
+ if ( pData )
+ return (pData->nWarningOut != DBG_OUT_NULL);
+ else
+ return sal_False;
+}
+
+inline sal_uIntPtr DbgIsErrorOut()
+{
+ DbgData* pData = DbgGetData();
+ if ( pData )
+ return (pData->nErrorOut != DBG_OUT_NULL);
+ else
+ return sal_False;
+}
+
+inline sal_uIntPtr DbgGetErrorOut() // Testtool: test whether to collect OSL_ASSERTions as well
+{
+ DbgData* pData = DbgGetData();
+ if ( pData )
+ return pData->nErrorOut;
+ else
+ return DBG_OUT_NULL;
+}
+
+inline sal_uIntPtr DbgIsAssertWarning()
+{
+ return DbgIsWarningOut();
+}
+
+inline sal_uIntPtr DbgIsAssert()
+{
+ return DbgIsErrorOut();
+}
+
+inline sal_uIntPtr DbgIsResource()
+{
+ DbgData* pData = DbgGetData();
+ if ( pData )
+ return pData->nTestFlags & DBG_TEST_RESOURCE;
+ else
+ return sal_False;
+}
+
+inline sal_uIntPtr DbgIsDialog()
+{
+ DbgData* pData = DbgGetData();
+ if ( pData )
+ return pData->nTestFlags & DBG_TEST_DIALOG;
+ else
+ return sal_False;
+}
+
+inline sal_uIntPtr DbgIsBoldAppFont()
+{
+ DbgData* pData = DbgGetData();
+ if ( pData )
+ return pData->nTestFlags & DBG_TEST_BOLDAPPFONT;
+ else
+ return sal_False;
+}
+
+inline void DbgXtorInfo( sal_Char* pBuf )
+{
+ DbgFunc( DBG_FUNC_XTORINFO, (void*)pBuf );
+}
+
+inline void DbgCoreDump()
+{
+ DbgFunc( DBG_FUNC_COREDUMP );
+}
+
+inline void DbgSetTestSolarMutex( DbgTestSolarMutexProc pProc )
+{
+ DbgFunc( DBG_FUNC_SETTESTSOLARMUTEX, (void*)(long)pProc );
+}
+
+inline void DbgTestSolarMutex()
+{
+ DbgFunc( DBG_FUNC_TESTSOLARMUTEX );
+}
+
+inline void DbgPrintFile( const sal_Char* pLine )
+{
+ DbgFunc( DBG_FUNC_PRINTFILE, (void*)(sal_Char*)pLine );
+}
+
+// Dbg output
+#define DBG_OUT_TRACE 1
+#define DBG_OUT_WARNING 2
+#define DBG_OUT_ERROR 3
+
+TOOLS_DLLPUBLIC void DbgOut( const sal_Char* pMsg, sal_uInt16 nOutType = DBG_OUT_TRACE,
+ const sal_Char* pFile = NULL, sal_uInt16 nLine = 0 );
+TOOLS_DLLPUBLIC void DbgPrintShell(char const * message);
+TOOLS_DLLPUBLIC void DbgOutTypef( sal_uInt16 nOutType, const sal_Char* pFStr, ... );
+TOOLS_DLLPUBLIC void DbgOutf( const sal_Char* pFStr, ... );
+TOOLS_DLLPUBLIC void ImpDbgOutfBuf( sal_Char* pBuf, const sal_Char* pFStr, ... );
+
+// Dbg test functions
+
+#define DBG_PROF_START 1
+#define DBG_PROF_STOP 2
+#define DBG_PROF_CONTINUE 3
+#define DBG_PROF_PAUSE 4
+
+TOOLS_DLLPUBLIC void DbgProf( sal_uInt16 nAction, DbgDataType* );
+
+#define DBG_XTOR_CTOR 1
+#define DBG_XTOR_DTOR 2
+#define DBG_XTOR_CHKTHIS 3
+#define DBG_XTOR_CHKOBJ 4
+#define DBG_XTOR_DTOROBJ 0x8000
+
+TOOLS_DLLPUBLIC void DbgXtor( DbgDataType* pDbgData,
+ sal_uInt16 nAction, const void* pThis, DbgUsr fDbgUsr );
+
+class DbgXtorObj
+{
+private:
+ DbgDataType* pDbgData;
+ const void* pThis;
+ DbgUsr fDbgUsr;
+ sal_uInt16 nAction;
+
+public:
+ DbgXtorObj( DbgDataType* pData,
+ sal_uInt16 nAct, const void* pThs, DbgUsr fUsr )
+ {
+ DbgXtor( pData, nAct, pThs, fUsr );
+ pDbgData = pData;
+ nAction = nAct;
+ pThis = pThs;
+ fDbgUsr = fUsr;
+ }
+
+ ~DbgXtorObj()
+ {
+ DbgXtor( pDbgData, nAction | DBG_XTOR_DTOROBJ,
+ pThis, fDbgUsr );
+ }
+};
+
+// (internally used) defines
+
+#define DBG_FUNC( aName ) DbgName_##aName()
+#define DBG_NAME( aName ) static DbgDataType aImpDbgData_##aName = { 0, #aName }; \
+ DbgDataType* DBG_FUNC( aName ) { return &aImpDbgData_##aName; }
+#define DBG_NAMEEX_VISIBILITY( aName, vis ) vis DbgDataType* DBG_FUNC( aName );
+#define DBG_NAMEEX( aName ) DBG_NAMEEX_VISIBILITY( aName, )
+
+// (externally used) defines
+
+#define DBG_DEBUGSTART() DbgDebugStart()
+#define DBG_DEBUGEND() DbgDebugEnd()
+#define DBG_GLOBALDEBUGEND() DbgGlobalDebugEnd()
+
+#define DBG_PROFSTART( aName ) \
+ DbgProf( DBG_PROF_START, DBG_FUNC( aName ) )
+
+#define DBG_PROFSTOP( aName ) \
+ DbgProf( DBG_PROF_STOP, DBG_FUNC( aName ) )
+
+#define DBG_PROFCONTINUE( aName ) \
+ DbgProf( DBG_PROF_CONTINUE, DBG_FUNC( aName ) )
+
+#define DBG_PROFPAUSE( aName ) \
+ DbgProf( DBG_PROF_PAUSE, DBG_FUNC( aName ) )
+
+#define DBG_CTOR( aName, fTest ) \
+ DbgXtorObj aDbgXtorObj( DBG_FUNC( aName ), \
+ DBG_XTOR_CTOR, \
+ (const void*)this, \
+ fTest )
+
+#define DBG_DTOR( aName, fTest ) \
+ DbgXtorObj aDbgXtorObj( DBG_FUNC( aName ), \
+ DBG_XTOR_DTOR, \
+ (const void*)this, \
+ fTest )
+
+#define DBG_CHKTHIS( aName, fTest ) \
+ DbgXtorObj aDbgXtorObj( DBG_FUNC( aName ), \
+ DBG_XTOR_CHKTHIS, \
+ (const void*)this, \
+ fTest )
+
+#define DBG_CHKOBJ( pObj, aName, fTest ) \
+ DbgXtor( DBG_FUNC( aName ), DBG_XTOR_CHKOBJ, \
+ (const void*)pObj, (DbgUsr)fTest )
+
+#define DBG_ASSERTWARNING( sCon, aWarning ) \
+ SAL_DETAIL_INFO_IF_FORMAT(!(sCon), "legacy.tools", aWarning)
+
+#define DBG_ASSERT( sCon, aError ) \
+ SAL_DETAIL_WARN_IF_FORMAT(!(sCon), "legacy.tools", aError)
+
+#define DBG_WARNING( aWarning ) \
+ SAL_DETAIL_INFO_IF_FORMAT(true, "legacy.tools", aWarning)
+#define DBG_WARNING1( aWarning, x1 ) \
+ SAL_DETAIL_INFO_IF_FORMAT(true, "legacy.tools", aWarning, x1)
+#define DBG_WARNING2( aWarning, x1, x2 ) \
+ SAL_DETAIL_INFO_IF_FORMAT(true, "legacy.tools", aWarning, x1, x2)
+#define DBG_WARNING3( aWarning, x1, x2, x3 ) \
+ SAL_DETAIL_INFO_IF_FORMAT(true, "legacy.tools", aWarning, x1, x2, x3)
+
+#define DBG_ERRORFILE( aError ) \
+ SAL_DETAIL_INFO_IF_FORMAT(true, "legacy.tools", aError, __FILE__, __LINE__)
+
+#define DBG_TESTSOLARMUTEX() \
+do \
+{ \
+ DbgTestSolarMutex(); \
+} while(0)
+
+// en-/disable debug defines
+
+#define DBG_INSTOUTTRACE( nOut ) \
+do \
+{ \
+ DbgGetData()->nTraceOut = nOut; \
+} while(0)
+
+#define DBG_INSTOUTWARNING( nOut ) \
+do \
+{ \
+ DbgGetData()->nWarningOut = nOut; \
+} while(0)
+
+#define DBG_INSTOUTERROR( nOut ) \
+do \
+{ \
+ DbgGetData()->nErrorOut = nOut; \
+} while(0)
+
+#else
+// NO DBG_UITL
+
+struct DbgData;
+struct DbgDataType;
+
+typedef void (*DbgPrintLine)( const sal_Char* pLine );
+typedef const sal_Char* (*DbgUsr)(const void* pThis );
+
+#define DBG_DEBUGSTART() ((void)0)
+#define DBG_DEBUGEND() ((void)0)
+#define DBG_GLOBALDEBUGEND() ((void)0)
+
+#define DBG_NAME( aName )
+#define DBG_NAMEEX( aName )
+#define DBG_NAMEEX_VISIBILITY( aName, vis )
+
+#define DBG_PROFSTART( aName ) ((void)0)
+#define DBG_PROFSTOP( aName ) ((void)0)
+#define DBG_PROFCONTINUE( aName ) ((void)0)
+#define DBG_PROFPAUSE( aName ) ((void)0)
+
+#define DBG_CTOR( aName, fTest ) ((void)0)
+#define DBG_DTOR( aName, fTest ) ((void)0)
+#define DBG_CHKTHIS( aName, fTest ) ((void)0)
+#define DBG_CHKOBJ( pObj, aName, fTest ) ((void)0)
+
+#define DBG_ASSERTWARNING( sCon, aWarning ) ((void)0)
+#define DBG_ASSERT( sCon, aError ) ((void)0)
+#define DBG_WARNING( aWarning ) ((void)0)
+#define DBG_WARNING1( aWarning, x1 ) ((void)0)
+#define DBG_WARNING2( aWarning, x1, x2 ) ((void)0)
+#define DBG_WARNING3( aWarning, x1, x2, x3 ) ((void)0)
+#define DBG_ERRORFILE( aError ) ((void)0)
+
+#define DBG_TESTSOLARMUTEX() ((void)0)
+
+#define DBG_INSTOUTTRACE( nOut ) ((void)0)
+#define DBG_INSTOUTWARNING( nOut ) ((void)0)
+#define DBG_INSTOUTERROR( nOut ) ((void)0)
+
+#endif
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-10 20:32:32 +0000