log.hxx

Go to the documentation of this file.

/* -*- 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 is part of LibreOffice published API.
 */
 
#ifndef INCLUDED_SAL_LOG_HXX
#define INCLUDED_SAL_LOG_HXX
 
#include "sal/config.h"
 
#include <cstdlib>
#include <sstream>
#include <string>
 
#include "sal/detail/log.h"
#include "sal/saldllapi.h"
#include "sal/types.h"
 
// Avoid the use of other sal code in this header as much as possible, so that
// this code can be called from other sal code without causing endless
// recursion.
 
 
enum sal_detail_LogAction
{
    SAL_DETAIL_LOG_ACTION_IGNORE,
    SAL_DETAIL_LOG_ACTION_LOG,
    SAL_DETAIL_LOG_ACTION_FATAL
};
 
extern "C" SAL_DLLPUBLIC void SAL_CALL sal_detail_log(
    sal_detail_LogLevel level, char const * area, char const * where,
    char const * message, sal_uInt32 backtraceDepth);
 
extern "C" SAL_DLLPUBLIC void SAL_CALL sal_detail_set_log_selector(char const *logSelector);
 
// the return value is actually "enum sal_detail_LogAction", but due to ABI
// compatibility, it's left as the original "sal_Bool" / "unsigned char".
extern "C" SAL_DLLPUBLIC unsigned char SAL_CALL sal_detail_log_report(
    sal_detail_LogLevel level, char const * area);
 
namespace sal { namespace detail {
 
inline void log(
    sal_detail_LogLevel level, char const * area, char const * where,
    std::ostringstream const & stream, sal_uInt32 backtraceDepth)
{
    // An alternative would be to have sal_detail_log take a std::ostringstream
    // pointer (via a C void pointer); the advantage would be smaller client
    // code (the ".str().c_str()" part would move into the implementation of
    // sal_detail_log) and potential for proper support of embedded null
    // characters within the message, but the disadvantage would be dependence
    // on the C++ ABI; as a compromise, the ".str().c_str()" part has been moved
    // to this inline function so that it is potentially only emitted once per
    // dynamic library:
    sal_detail_log(level, area, where, stream.str().c_str(), backtraceDepth);
}
 
// Special handling of the common case where the message consists of just a
// string literal, to produce smaller call-site code:
 
struct StreamStart {};
 
struct StreamString {
    StreamString(char const * s): string(s) {}
 
    char const * string;
 
    typedef char Result;
};
 
struct StreamIgnore {
    typedef struct { char a[2]; } Result;
};
 
inline StreamString operator <<(
    SAL_UNUSED_PARAMETER StreamStart const &, char const * s)
{
    return StreamString(s);
}
 
template< typename T > inline StreamIgnore operator <<(
    SAL_UNUSED_PARAMETER StreamStart const &, SAL_UNUSED_PARAMETER T const &)
{
    std::abort();
#if defined _MSC_VER && _MSC_VER < 1700
    return StreamIgnore();
#endif
}
 
template< typename T > inline StreamIgnore operator <<(
    SAL_UNUSED_PARAMETER StreamString const &, SAL_UNUSED_PARAMETER T const &)
{
    std::abort();
#if defined _MSC_VER && _MSC_VER < 1700
    return StreamIgnore();
#endif
}
 
template< typename T > inline StreamIgnore operator <<(
    SAL_UNUSED_PARAMETER StreamIgnore const &, SAL_UNUSED_PARAMETER T const &)
{
    std::abort();
#if defined _MSC_VER && _MSC_VER < 1700
    return StreamIgnore();
#endif
}
 
template< typename T > typename T::Result getResult(T const &);
 
inline char const * unwrapStream(StreamString const & s) { return s.string; }
 
inline char const * unwrapStream(SAL_UNUSED_PARAMETER StreamIgnore const &) {
    std::abort();
#if defined _MSC_VER && _MSC_VER < 1700
    return 0;
#endif
}
 
} }
 
// to prevent using a local variable, which can eventually shadow,
// resulting in compiler warnings (or even errors with -Werror)
#define SAL_DETAIL_LOG_STREAM_PRIVATE_(level, area, where, stream) \
    if (sizeof ::sal::detail::getResult( \
            ::sal::detail::StreamStart() << stream) == 1) \
    { \
        ::sal_detail_log( \
            (level), (area), (where), \
            ::sal::detail::unwrapStream( \
                ::sal::detail::StreamStart() << stream), \
            0); \
    } else { \
        ::std::ostringstream sal_detail_stream; \
        sal_detail_stream << stream; \
        ::sal::detail::log( \
            (level), (area), (where), sal_detail_stream, 0); \
    }
 
#define SAL_DETAIL_LOG_STREAM(condition, level, area, where, stream) \
    do { \
        if (SAL_UNLIKELY(condition)) \
        { \
            switch (sal_detail_log_report(level, area)) \
            { \
            case SAL_DETAIL_LOG_ACTION_IGNORE: break; \
            case SAL_DETAIL_LOG_ACTION_LOG: \
                SAL_DETAIL_LOG_STREAM_PRIVATE_(level, area, where, stream); \
                break; \
            case SAL_DETAIL_LOG_ACTION_FATAL: \
                SAL_DETAIL_LOG_STREAM_PRIVATE_(level, area, where, stream); \
                std::abort(); \
                break; \
            } \
        } \
    } while (false)
 
 
#define SAL_WHERE SAL_DETAIL_WHERE
 
#if defined _LIBCPP_VERSION \
    || (defined _GLIBCXX_RELEASE \
        && (_GLIBCXX_RELEASE >= 12 || (_GLIBCXX_RELEASE == 11 && __GLIBCXX__ > 20210428))) \
    || (defined _MSC_VER && _MSC_VER >= 1915)
#define SAL_STREAM(stream) \
    (::std::ostringstream() << stream).str()
#else
#define SAL_STREAM(stream) \
    (dynamic_cast< ::std::ostringstream & >(::std::ostringstream() << stream).str())
#endif
 
#define SAL_INFO(area, stream) \
    SAL_DETAIL_LOG_STREAM( \
        SAL_DETAIL_ENABLE_LOG_INFO, ::SAL_DETAIL_LOG_LEVEL_INFO, area, \
        SAL_WHERE, stream)
 
#define SAL_INFO_IF(condition, area, stream)  \
    SAL_DETAIL_LOG_STREAM( \
        SAL_DETAIL_ENABLE_LOG_INFO && (condition), \
        ::SAL_DETAIL_LOG_LEVEL_INFO, area, SAL_WHERE, stream)
 
#define SAL_WARN(area, stream) \
    SAL_DETAIL_LOG_STREAM( \
        SAL_DETAIL_ENABLE_LOG_WARN, ::SAL_DETAIL_LOG_LEVEL_WARN, area, \
        SAL_WHERE, stream)
 
#define SAL_WARN_IF(condition, area, stream)   \
    SAL_DETAIL_LOG_STREAM( \
        SAL_DETAIL_ENABLE_LOG_WARN && (condition), \
        ::SAL_DETAIL_LOG_LEVEL_WARN, area, SAL_WHERE, stream)
 
#define SAL_DEBUG(stream) \
    SAL_DETAIL_LOG_STREAM( \
        SAL_LOG_TRUE, ::SAL_DETAIL_LOG_LEVEL_DEBUG, NULL, NULL, stream)
 
#define SAL_DEBUG_IF(condition, stream)   \
    SAL_DETAIL_LOG_STREAM( \
        (condition), ::SAL_DETAIL_LOG_LEVEL_DEBUG, NULL, NULL, stream)
 
#define SAL_DEBUG_BACKTRACE(stream, backtraceDepth) \
    do { \
        if (sizeof ::sal::detail::getResult( \
                ::sal::detail::StreamStart() << stream) == 1) \
        { \
            ::sal_detail_log( \
                ::SAL_DETAIL_LOG_LEVEL_DEBUG, NULL, NULL, \
                ::sal::detail::unwrapStream( \
                    ::sal::detail::StreamStart() << stream), \
                backtraceDepth); \
        } else { \
            ::std::ostringstream sal_detail_stream; \
            sal_detail_stream << stream; \
            ::sal::detail::log( \
                ::SAL_DETAIL_LOG_LEVEL_DEBUG, NULL, NULL, sal_detail_stream, \
                backtraceDepth); \
        } \
    } while (false)
 
 
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */