blob: 8e86cd8564aad96e1ad5c724064f04e01e9ef022 [file] [log] [blame]
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed 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.
// Module Overview: Starboard Logging module
//
// Defines debug logging functions.
#ifndef STARBOARD_LOG_H_
#define STARBOARD_LOG_H_
#include <stdarg.h>
#ifdef __cplusplus
#include <sstream>
#include <string>
#endif
#include "starboard/export.h"
#include "starboard/system.h"
#ifdef __cplusplus
extern "C" {
#endif
// The priority at which a message should be logged. The platform may be
// configured to filter logs by priority, or render them differently.
typedef enum SbLogPriority {
kSbLogPriorityUnknown = 0,
kSbLogPriorityInfo,
kSbLogPriorityWarning,
kSbLogPriorityError,
kSbLogPriorityFatal,
} SbLogPriority;
// Writes |message| to the platform's debug output log.
//
// |priority|: The SbLogPriority at which the message should be logged. Note
// that passing |kSbLogPriorityFatal| does not terminate the program. Such a
// policy must be enforced at the application level. In fact, |priority| may
// be completely ignored on many platforms.
// |message|: The message to be logged. No formatting is required to be done
// on the value, including newline termination. That said, platforms can
// adjust the message to be more suitable for their output method by
// wrapping the text, stripping unprintable characters, etc.
SB_EXPORT void SbLog(SbLogPriority priority, const char* message);
// A bare-bones log output method that is async-signal-safe, i.e. safe to call
// from an asynchronous signal handler (e.g. a |SIGSEGV| handler). It should not
// do any additional formatting.
//
// |message|: The message to be logged.
SB_EXPORT void SbLogRaw(const char* message);
// Dumps the stack of the current thread to the log in an async-signal-safe
// manner, i.e. safe to call from an asynchronous signal handler (e.g. a
// |SIGSEGV| handler). Does not include SbLogRawDumpStack itself.
//
// |frames_to_skip|: The number of frames to skip from the top of the stack
// when dumping the current thread to the log. This parameter lets you remove
// noise from helper functions that might end up on top of every stack dump
// so that the stack dump is just the relevant function stack where the
// problem occurred.
SB_EXPORT void SbLogRawDumpStack(int frames_to_skip);
// A formatted log output method that is async-signal-safe, i.e. safe to call
// from an asynchronous signal handler (e.g. a |SIGSEGV| handler).
SB_EXPORT void SbLogRawFormat(const char* format, va_list args)
SB_PRINTF_FORMAT(1, 0);
// Inline wrapper of SbLogFormat to convert from ellipsis to va_args.
static SB_C_INLINE void SbLogRawFormatF(const char* format, ...)
SB_PRINTF_FORMAT(1, 2);
void SbLogRawFormatF(const char* format, ...) {
va_list args;
va_start(args, format);
SbLogRawFormat(format, args);
va_end(args);
}
// A log output method that additionally performs a string format on the
// data being logged.
SB_EXPORT void SbLogFormat(const char* format, va_list args)
SB_PRINTF_FORMAT(1, 0);
// Inline wrapper of SbLogFormat that converts from ellipsis to va_args.
static SB_C_INLINE void SbLogFormatF(const char* format, ...)
SB_PRINTF_FORMAT(1, 2);
void SbLogFormatF(const char* format, ...) {
va_list args;
va_start(args, format);
SbLogFormat(format, args);
va_end(args);
}
// Flushes the log buffer on some platforms.
SB_EXPORT void SbLogFlush();
// Indicates whether the log output goes to a TTY or is being redirected.
SB_EXPORT bool SbLogIsTty();
#ifdef __cplusplus
} // extern "C"
#endif
#if defined(__LB_SHELL__FOR_RELEASE__)
#define SB_LOGGING_IS_OFFICIAL_BUILD 1
#else
#define SB_LOGGING_IS_OFFICIAL_BUILD 0
#endif
#ifdef __cplusplus
// If we are a C++ program, then we provide a selected subset of base/logging
// macros and assertions. See that file for more comments.
namespace starboard {
namespace logging {
SB_EXPORT void SetMinLogLevel(SbLogPriority level);
SB_EXPORT SbLogPriority GetMinLogLevel();
SB_EXPORT void Break();
// An object which will dumps the stack to the given ostream, without adding any
// frames of its own. |skip_frames| is the number of frames to skip in the dump.
struct SB_EXPORT Stack {
explicit Stack(int skip_frames) : skip_frames(skip_frames) {}
int skip_frames;
};
SB_EXPORT std::ostream& operator<<(std::ostream& out, const Stack& stack);
SB_EXPORT std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
return out << wstr.c_str();
}
#if defined(__cplusplus_winrt)
inline std::ostream& operator<<(std::ostream& out, ::Platform::String ^ str) {
return out << std::wstring(str->Begin(), str->End());
}
#endif
const SbLogPriority SB_LOG_INFO = kSbLogPriorityInfo;
const SbLogPriority SB_LOG_WARNING = kSbLogPriorityWarning;
const SbLogPriority SB_LOG_ERROR = kSbLogPriorityError;
const SbLogPriority SB_LOG_FATAL = kSbLogPriorityFatal;
const SbLogPriority SB_LOG_0 = SB_LOG_ERROR;
class SB_EXPORT LogMessage {
public:
LogMessage(const char* file, int line, SbLogPriority priority);
~LogMessage();
std::ostream& stream() { return stream_; }
private:
void Init(const char* file, int line);
SbLogPriority priority_;
std::ostringstream stream_;
size_t message_start_; // Offset of the start of the message (past prefix
// info).
// The file and line information passed in to the constructor.
const char* file_;
const int line_;
};
class LogMessageVoidify {
public:
LogMessageVoidify() {}
// This has to be an operator with a precedence lower than << but
// higher than ?:
void operator&(std::ostream&) {}
};
} // namespace logging
} // namespace starboard
#define SB_LOG_MESSAGE_INFO \
::starboard::logging::LogMessage(__FILE__, __LINE__, \
::starboard::logging::SB_LOG_INFO)
#define SB_LOG_MESSAGE_WARNING \
::starboard::logging::LogMessage(__FILE__, __LINE__, \
::starboard::logging::SB_LOG_WARNING)
#define SB_LOG_MESSAGE_ERROR \
::starboard::logging::LogMessage(__FILE__, __LINE__, \
::starboard::logging::SB_LOG_ERROR)
#define SB_LOG_MESSAGE_FATAL \
::starboard::logging::LogMessage(__FILE__, __LINE__, \
::starboard::logging::SB_LOG_FATAL)
// Compatibility with base/logging.h which defines ERROR to be 0 to workaround
// some system header defines that do the same thing.
#define SB_LOG_MESSAGE_0 SB_LOG_MESSAGE_ERROR
#define SB_LOG_STREAM(severity) SB_LOG_MESSAGE_##severity.stream()
#define SB_LAZY_STREAM(stream, condition) \
!(condition) ? (void)0 : ::starboard::logging::LogMessageVoidify() & (stream)
#define SB_LOG_IS_ON(severity) \
((::starboard::logging::SB_LOG_##severity) >= \
::starboard::logging::GetMinLogLevel())
#define SB_LOG_IF(severity, condition) \
SB_LAZY_STREAM(SB_LOG_STREAM(severity), SB_LOG_IS_ON(severity) && (condition))
#define SB_LOG(severity) SB_LOG_IF(severity, true)
#define SB_EAT_STREAM_PARAMETERS SB_LOG_IF(INFO, false)
#define SB_STACK_IF(severity, condition) \
SB_LOG_IF(severity, condition) << "\n" << ::starboard::logging::Stack(0)
#define SB_STACK(severity) SB_STACK_IF(severity, true)
#if SB_LOGGING_IS_OFFICIAL_BUILD
#define SB_CHECK(condition) \
!(condition) ? ::starboard::logging::Break() : SB_EAT_STREAM_PARAMETERS
#define SB_DCHECK(condition) SB_EAT_STREAM_PARAMETERS
#elif defined(_PREFAST_)
#define SB_CHECK(condition) \
__analysis_assume(condition), SB_EAT_STREAM_PARAMETERS
#define SB_DCHECK(condition) SB_CHECK(condition)
#else
#define SB_CHECK(condition) \
SB_LOG_IF(FATAL, !(condition)) << "Check failed: " #condition ". "
#define SB_DCHECK(condition) SB_CHECK(condition)
#endif // SB_LOGGING_IS_OFFICIAL_BUILD
#if SB_LOGGING_IS_OFFICIAL_BUILD
#define SB_DLOG_IS_ON(severity) false
#define SB_DLOG_IF(severity, condition) SB_EAT_STREAM_PARAMETERS
#else // SB_LOGGING_IS_OFFICIAL_BUILD
#define SB_DLOG_IS_ON(severity) SB_LOG_IS_ON(severity)
#define SB_DLOG_IF(severity, condition) SB_LOG_IF(severity, condition)
#endif // SB_LOGGING_IS_OFFICIAL_BUILD
#define SB_DLOG(severity) SB_DLOG_IF(severity, SB_DLOG_IS_ON(severity))
#define SB_DSTACK(severity) SB_STACK_IF(severity, SB_DLOG_IS_ON(severity))
#define SB_NOTREACHED() SB_DCHECK(false)
#if SB_IS(COMPILER_GCC)
#define SB_NOTIMPLEMENTED_MSG \
"Not implemented reached in " << __PRETTY_FUNCTION__
#else
#define SB_NOTIMPLEMENTED_MSG "Not implemented reached in " << __FUNCTION__
#endif
#if !defined(SB_NOTIMPLEMENTED_POLICY)
#if SB_LOGGING_IS_OFFICIAL_BUILD
#define SB_NOTIMPLEMENTED_POLICY 0
#else
#define SB_NOTIMPLEMENTED_POLICY 5
#endif
#endif // !defined(SB_NOTIMPLEMENTED_POLICY)
#if SB_NOTIMPLEMENTED_POLICY == 0
#define SB_NOTIMPLEMENTED() SB_EAT_STREAM_PARAMETERS
#elif SB_NOTIMPLEMENTED_POLICY == 1
#define SB_NOTIMPLEMENTED() SB_COMPILE_ASSERT(false, NOT_IMPLEMENTED)
#elif SB_NOTIMPLEMENTED_POLICY == 2
#define SB_NOTIMPLEMENTED() SB_COMPILE_ASSERT(false, NOT_IMPLEMENTED)
#elif SB_NOTIMPLEMENTED_POLICY == 3
#define SB_NOTIMPLEMENTED() SB_NOTREACHED()
#elif SB_NOTIMPLEMENTED_POLICY == 4
#define SB_NOTIMPLEMENTED() SB_LOG(ERROR) << SB_NOTIMPLEMENTED_MSG
#elif SB_NOTIMPLEMENTED_POLICY == 5
#define SB_NOTIMPLEMENTED() \
do { \
static int count = 0; \
SB_LOG_IF(ERROR, 0 == count++) << SB_NOTIMPLEMENTED_MSG; \
} while (0); \
SB_EAT_STREAM_PARAMETERS
#endif
#else // __cplusplus
// We also provide a very small subset for straight-C users.
#define SB_NOTIMPLEMENTED_IN(X) "Not implemented reached in " #X
#if SB_IS(COMPILER_GCC)
#define SB_NOTIMPLEMENTED_MSG SB_NOTIMPLEMENTED_IN(__PRETTY_FUNCTION__)
#else
#define SB_NOTIMPLEMENTED_MSG SB_NOTIMPLEMENTED_IN(__FUNCTION__)
#endif
#define SB_CHECK(condition) \
do { \
if (!(condition)) { \
SbLog(kSbLogPriorityError, "Check failed: " #condition "."); \
SbSystemBreakIntoDebugger(); \
} \
} while (0)
#if SB_LOGGING_IS_OFFICIAL_BUILD
#define SB_NOTIMPLEMENTED()
#define SB_DCHECK(condition)
#else
#define SB_DCHECK(condition) SB_CHECK(condition)
#define SB_NOTIMPLEMENTED() \
do { \
static int count = 0; \
if (0 == count++) { \
SbLog(kSbLogPriorityError, SB_NOTIMPLEMENTED_MSG); \
} \
} while (0)
#endif
#define SB_NOTREACHED() SB_DCHECK(false)
#endif // __cplusplus
#endif // STARBOARD_LOG_H_