Auto update
This commit is contained in:
parent
67a260f5bc
commit
96135a6fe7
57 changed files with 4865 additions and 4717 deletions
191
glog/arm64-v8a/include/glog/flags.h
Normal file
191
glog/arm64-v8a/include/glog/flags.h
Normal file
|
|
@ -0,0 +1,191 @@
|
|||
// Copyright (c) 2024, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
|
||||
#ifndef GLOG_FLAGS_H
|
||||
#define GLOG_FLAGS_H
|
||||
|
||||
#include <string>
|
||||
|
||||
#if defined(GLOG_USE_GFLAGS)
|
||||
# include <gflags/gflags.h>
|
||||
#endif
|
||||
|
||||
#if defined(GLOG_USE_GLOG_EXPORT)
|
||||
# include "glog/export.h"
|
||||
#endif
|
||||
|
||||
#if !defined(GLOG_EXPORT)
|
||||
# error <glog/flags.h> was not included correctly. See the documention for how to consume the library.
|
||||
#endif
|
||||
|
||||
#include "glog/platform.h"
|
||||
#include "glog/types.h"
|
||||
|
||||
#pragma push_macro("DECLARE_VARIABLE")
|
||||
#pragma push_macro("DECLARE_bool")
|
||||
#pragma push_macro("DECLARE_string")
|
||||
#pragma push_macro("DECLARE_int32")
|
||||
#pragma push_macro("DECLARE_uint32")
|
||||
|
||||
#ifdef DECLARE_VARIABLE
|
||||
# undef DECLARE_VARIABLE
|
||||
#endif
|
||||
|
||||
#ifdef DECLARE_bool
|
||||
# undef DECLARE_bool
|
||||
#endif
|
||||
|
||||
#ifdef DECLARE_string
|
||||
# undef DECLARE_string
|
||||
#endif
|
||||
|
||||
#ifdef DECLARE_int32
|
||||
# undef DECLARE_int32
|
||||
#endif
|
||||
|
||||
#ifdef DECLARE_uint32
|
||||
# undef DECLARE_uint32
|
||||
#endif
|
||||
|
||||
#ifndef DECLARE_VARIABLE
|
||||
# define DECLARE_VARIABLE(type, shorttype, name, tn) \
|
||||
namespace fL##shorttype { \
|
||||
extern GLOG_EXPORT type FLAGS_##name; \
|
||||
} \
|
||||
using fL##shorttype::FLAGS_##name
|
||||
|
||||
// bool specialization
|
||||
# define DECLARE_bool(name) DECLARE_VARIABLE(bool, B, name, bool)
|
||||
|
||||
// int32 specialization
|
||||
# define DECLARE_int32(name) DECLARE_VARIABLE(google::int32, I, name, int32)
|
||||
|
||||
# if !defined(DECLARE_uint32)
|
||||
// uint32 specialization
|
||||
# define DECLARE_uint32(name) \
|
||||
DECLARE_VARIABLE(google::uint32, U, name, uint32)
|
||||
# endif // !defined(DECLARE_uint32) && !defined(GLOG_USE_GFLAGS)
|
||||
|
||||
// Special case for string, because we have to specify the namespace
|
||||
// std::string, which doesn't play nicely with our FLAG__namespace hackery.
|
||||
# define DECLARE_string(name) \
|
||||
namespace fLS { \
|
||||
extern GLOG_EXPORT std::string& FLAGS_##name; \
|
||||
} \
|
||||
using fLS::FLAGS_##name
|
||||
#endif
|
||||
|
||||
DECLARE_int32(logemaillevel);
|
||||
DECLARE_int32(logcleansecs);
|
||||
|
||||
#ifdef GLOG_OS_LINUX
|
||||
DECLARE_bool(drop_log_memory);
|
||||
#endif
|
||||
DECLARE_string(alsologtoemail);
|
||||
DECLARE_string(log_backtrace_at);
|
||||
|
||||
// Set whether appending a timestamp to the log file name
|
||||
DECLARE_bool(timestamp_in_logfile_name);
|
||||
|
||||
// Set whether log messages go to stdout instead of logfiles
|
||||
DECLARE_bool(logtostdout);
|
||||
|
||||
// Set color messages logged to stdout (if supported by terminal).
|
||||
DECLARE_bool(colorlogtostdout);
|
||||
|
||||
// Set whether log messages go to stderr instead of logfiles
|
||||
DECLARE_bool(logtostderr);
|
||||
|
||||
// Set whether log messages go to stderr in addition to logfiles.
|
||||
DECLARE_bool(alsologtostderr);
|
||||
|
||||
// Set color messages logged to stderr (if supported by terminal).
|
||||
DECLARE_bool(colorlogtostderr);
|
||||
|
||||
// Log messages at a level >= this flag are automatically sent to
|
||||
// stderr in addition to log files.
|
||||
DECLARE_int32(stderrthreshold);
|
||||
|
||||
// Set whether the log file header should be written upon creating a file.
|
||||
DECLARE_bool(log_file_header);
|
||||
|
||||
// Set whether the log prefix should be prepended to each line of output.
|
||||
DECLARE_bool(log_prefix);
|
||||
|
||||
// Set whether the year should be included in the log prefix.
|
||||
DECLARE_bool(log_year_in_prefix);
|
||||
|
||||
// Log messages at a level <= this flag are buffered.
|
||||
// Log messages at a higher level are flushed immediately.
|
||||
DECLARE_int32(logbuflevel);
|
||||
|
||||
// Sets the maximum number of seconds which logs may be buffered for.
|
||||
DECLARE_int32(logbufsecs);
|
||||
|
||||
// Log suppression level: messages logged at a lower level than this
|
||||
// are suppressed.
|
||||
DECLARE_int32(minloglevel);
|
||||
|
||||
// If specified, logfiles are written into this directory instead of the
|
||||
// default logging directory.
|
||||
DECLARE_string(log_dir);
|
||||
|
||||
// Set the log file mode.
|
||||
DECLARE_int32(logfile_mode);
|
||||
|
||||
// Sets the path of the directory into which to put additional links
|
||||
// to the log files.
|
||||
DECLARE_string(log_link);
|
||||
|
||||
DECLARE_int32(v); // in vlog_is_on.cc
|
||||
|
||||
DECLARE_string(vmodule); // also in vlog_is_on.cc
|
||||
|
||||
// Sets the maximum log file size (in MB).
|
||||
DECLARE_uint32(max_log_size);
|
||||
|
||||
// Sets whether to avoid logging to the disk if the disk is full.
|
||||
DECLARE_bool(stop_logging_if_full_disk);
|
||||
|
||||
// Use UTC time for logging
|
||||
DECLARE_bool(log_utc_time);
|
||||
|
||||
// Mailer used to send logging email
|
||||
DECLARE_string(logmailer);
|
||||
|
||||
DECLARE_bool(symbolize_stacktrace);
|
||||
|
||||
#pragma pop_macro("DECLARE_VARIABLE")
|
||||
#pragma pop_macro("DECLARE_bool")
|
||||
#pragma pop_macro("DECLARE_string")
|
||||
#pragma pop_macro("DECLARE_int32")
|
||||
#pragma pop_macro("DECLARE_uint32")
|
||||
|
||||
#endif // GLOG_FLAGS_H
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) 2007, Google Inc.
|
||||
// Copyright (c) 2024, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
|
|
@ -30,6 +30,16 @@
|
|||
#ifndef BASE_LOG_SEVERITY_H__
|
||||
#define BASE_LOG_SEVERITY_H__
|
||||
|
||||
#if defined(GLOG_USE_GLOG_EXPORT)
|
||||
# include "glog/export.h"
|
||||
#endif
|
||||
|
||||
#if !defined(GLOG_EXPORT)
|
||||
# error <glog/log_severity.h> was not included correctly. See the documention for how to consume the library.
|
||||
#endif
|
||||
|
||||
namespace google {
|
||||
|
||||
// The recommended semantics of the log levels are as follows:
|
||||
//
|
||||
// INFO:
|
||||
|
|
@ -48,27 +58,43 @@
|
|||
// Variables of type LogSeverity are widely taken to lie in the range
|
||||
// [0, NUM_SEVERITIES-1]. Be careful to preserve this assumption if
|
||||
// you ever need to change their values or add a new severity.
|
||||
typedef int LogSeverity;
|
||||
|
||||
const int GLOG_INFO = 0, GLOG_WARNING = 1, GLOG_ERROR = 2, GLOG_FATAL = 3,
|
||||
NUM_SEVERITIES = 4;
|
||||
enum LogSeverity {
|
||||
GLOG_INFO = 0,
|
||||
GLOG_WARNING = 1,
|
||||
GLOG_ERROR = 2,
|
||||
GLOG_FATAL = 3,
|
||||
#ifndef GLOG_NO_ABBREVIATED_SEVERITIES
|
||||
# ifdef ERROR
|
||||
# ifdef ERROR
|
||||
# error ERROR macro is defined. Define GLOG_NO_ABBREVIATED_SEVERITIES before including logging.h. See the document for detail.
|
||||
# endif
|
||||
const int INFO = GLOG_INFO, WARNING = GLOG_WARNING,
|
||||
ERROR = GLOG_ERROR, FATAL = GLOG_FATAL;
|
||||
# endif
|
||||
INFO = GLOG_INFO,
|
||||
WARNING = GLOG_WARNING,
|
||||
ERROR = GLOG_ERROR,
|
||||
FATAL = GLOG_FATAL
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(__cpp_inline_variables)
|
||||
# if (__cpp_inline_variables >= 201606L)
|
||||
# define GLOG_INLINE_VARIABLE inline
|
||||
# endif // (__cpp_inline_variables >= 201606L)
|
||||
#endif // defined(__cpp_inline_variables)
|
||||
|
||||
#if !defined(GLOG_INLINE_VARIABLE)
|
||||
# define GLOG_INLINE_VARIABLE
|
||||
#endif // !defined(GLOG_INLINE_VARIABLE)
|
||||
|
||||
GLOG_INLINE_VARIABLE
|
||||
constexpr int NUM_SEVERITIES = 4;
|
||||
|
||||
// DFATAL is FATAL in debug mode, ERROR in normal mode
|
||||
#ifdef NDEBUG
|
||||
#define DFATAL_LEVEL ERROR
|
||||
# define DFATAL_LEVEL ERROR
|
||||
#else
|
||||
#define DFATAL_LEVEL FATAL
|
||||
# define DFATAL_LEVEL FATAL
|
||||
#endif
|
||||
|
||||
extern GLOG_EXPORT const char* const LogSeverityNames[NUM_SEVERITIES];
|
||||
|
||||
// NDEBUG usage helpers related to (RAW_)DCHECK:
|
||||
//
|
||||
// DEBUG_MODE is for small !NDEBUG uses like
|
||||
|
|
@ -89,10 +115,12 @@ extern GLOG_EXPORT const char* const LogSeverityNames[NUM_SEVERITIES];
|
|||
//
|
||||
#ifdef NDEBUG
|
||||
enum { DEBUG_MODE = 0 };
|
||||
#define IF_DEBUG_MODE(x)
|
||||
# define IF_DEBUG_MODE(x)
|
||||
#else
|
||||
enum { DEBUG_MODE = 1 };
|
||||
#define IF_DEBUG_MODE(x) x
|
||||
# define IF_DEBUG_MODE(x) x
|
||||
#endif
|
||||
|
||||
} // namespace google
|
||||
|
||||
#endif // BASE_LOG_SEVERITY_H__
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) 2008, Google Inc.
|
||||
// Copyright (c) 2024, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
|
|
@ -35,24 +35,28 @@
|
|||
#define GLOG_PLATFORM_H
|
||||
|
||||
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
|
||||
#define GLOG_OS_WINDOWS
|
||||
# define GLOG_OS_WINDOWS
|
||||
#elif defined(__CYGWIN__) || defined(__CYGWIN32__)
|
||||
#define GLOG_OS_CYGWIN
|
||||
# define GLOG_OS_CYGWIN
|
||||
#elif defined(linux) || defined(__linux) || defined(__linux__)
|
||||
#ifndef GLOG_OS_LINUX
|
||||
#define GLOG_OS_LINUX
|
||||
#endif
|
||||
# ifndef GLOG_OS_LINUX
|
||||
# define GLOG_OS_LINUX
|
||||
# endif
|
||||
# if defined(__ANDROID__)
|
||||
# define GLOG_OS_ANDROID
|
||||
# endif
|
||||
#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
|
||||
#define GLOG_OS_MACOSX
|
||||
# define GLOG_OS_MACOSX
|
||||
#elif defined(__FreeBSD__)
|
||||
#define GLOG_OS_FREEBSD
|
||||
# define GLOG_OS_FREEBSD
|
||||
#elif defined(__NetBSD__)
|
||||
#define GLOG_OS_NETBSD
|
||||
# define GLOG_OS_NETBSD
|
||||
#elif defined(__OpenBSD__)
|
||||
#define GLOG_OS_OPENBSD
|
||||
#else
|
||||
# define GLOG_OS_OPENBSD
|
||||
#elif defined(__EMSCRIPTEN__)
|
||||
# define GLOG_OS_EMSCRIPTEN
|
||||
// TODO(hamaji): Add other platforms.
|
||||
#error Platform not supported by glog. Please consider to contribute platform information by submitting a pull request on Github.
|
||||
#endif
|
||||
|
||||
#endif // GLOG_PLATFORM_H
|
||||
#endif // GLOG_PLATFORM_H
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) 2006, Google Inc.
|
||||
// Copyright (c) 2024, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
|
|
@ -36,19 +36,19 @@
|
|||
#ifndef GLOG_RAW_LOGGING_H
|
||||
#define GLOG_RAW_LOGGING_H
|
||||
|
||||
#include <ctime>
|
||||
#if defined(GLOG_USE_GLOG_EXPORT)
|
||||
# include "glog/export.h"
|
||||
#endif
|
||||
|
||||
#if !defined(GLOG_EXPORT)
|
||||
# error <glog/raw_logging.h> was not included correctly. See the documention for how to consume the library.
|
||||
#endif
|
||||
|
||||
#include "glog/log_severity.h"
|
||||
#include "glog/vlog_is_on.h"
|
||||
|
||||
namespace google {
|
||||
|
||||
#include <glog/log_severity.h>
|
||||
#include <glog/logging.h>
|
||||
#include <glog/vlog_is_on.h>
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wvariadic-macros"
|
||||
#endif
|
||||
|
||||
// This is similar to LOG(severity) << format... and VLOG(level) << format..,
|
||||
// but
|
||||
// * it is to be used ONLY by low-level modules that can't use normal LOG()
|
||||
|
|
@ -63,108 +63,101 @@ namespace google {
|
|||
// These will print an almost standard log lines like this to stderr only:
|
||||
// E20200821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
|
||||
// I20200821 211317 file.cc:142] RAW: status is 20
|
||||
#define RAW_LOG(severity, ...) \
|
||||
do { \
|
||||
switch (google::GLOG_ ## severity) { \
|
||||
case 0: \
|
||||
RAW_LOG_INFO(__VA_ARGS__); \
|
||||
break; \
|
||||
case 1: \
|
||||
RAW_LOG_WARNING(__VA_ARGS__); \
|
||||
break; \
|
||||
case 2: \
|
||||
RAW_LOG_ERROR(__VA_ARGS__); \
|
||||
break; \
|
||||
case 3: \
|
||||
RAW_LOG_FATAL(__VA_ARGS__); \
|
||||
break; \
|
||||
default: \
|
||||
break; \
|
||||
} \
|
||||
#define RAW_LOG(severity, ...) \
|
||||
do { \
|
||||
switch (google::GLOG_##severity) { \
|
||||
case 0: \
|
||||
RAW_LOG_INFO(__VA_ARGS__); \
|
||||
break; \
|
||||
case 1: \
|
||||
RAW_LOG_WARNING(__VA_ARGS__); \
|
||||
break; \
|
||||
case 2: \
|
||||
RAW_LOG_ERROR(__VA_ARGS__); \
|
||||
break; \
|
||||
case 3: \
|
||||
RAW_LOG_FATAL(__VA_ARGS__); \
|
||||
break; \
|
||||
default: \
|
||||
break; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// The following STRIP_LOG testing is performed in the header file so that it's
|
||||
// possible to completely compile out the logging code and the log messages.
|
||||
#if !defined(STRIP_LOG) || STRIP_LOG == 0
|
||||
#define RAW_VLOG(verboselevel, ...) \
|
||||
do { \
|
||||
if (VLOG_IS_ON(verboselevel)) { \
|
||||
RAW_LOG_INFO(__VA_ARGS__); \
|
||||
} \
|
||||
} while (0)
|
||||
# define RAW_VLOG(verboselevel, ...) \
|
||||
do { \
|
||||
if (VLOG_IS_ON(verboselevel)) { \
|
||||
RAW_LOG_INFO(__VA_ARGS__); \
|
||||
} \
|
||||
} while (0)
|
||||
#else
|
||||
#define RAW_VLOG(verboselevel, ...) RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG == 0
|
||||
# define RAW_VLOG(verboselevel, ...) RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG == 0
|
||||
|
||||
#if !defined(STRIP_LOG) || STRIP_LOG == 0
|
||||
#define RAW_LOG_INFO(...) google::RawLog__(google::GLOG_INFO, \
|
||||
__FILE__, __LINE__, __VA_ARGS__)
|
||||
# define RAW_LOG_INFO(...) \
|
||||
google::RawLog__(google::GLOG_INFO, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define RAW_LOG_INFO(...) google::RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG == 0
|
||||
# define RAW_LOG_INFO(...) google::RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG == 0
|
||||
|
||||
#if !defined(STRIP_LOG) || STRIP_LOG <= 1
|
||||
#define RAW_LOG_WARNING(...) google::RawLog__(google::GLOG_WARNING, \
|
||||
__FILE__, __LINE__, __VA_ARGS__)
|
||||
# define RAW_LOG_WARNING(...) \
|
||||
google::RawLog__(google::GLOG_WARNING, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define RAW_LOG_WARNING(...) google::RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG <= 1
|
||||
# define RAW_LOG_WARNING(...) google::RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG <= 1
|
||||
|
||||
#if !defined(STRIP_LOG) || STRIP_LOG <= 2
|
||||
#define RAW_LOG_ERROR(...) google::RawLog__(google::GLOG_ERROR, \
|
||||
__FILE__, __LINE__, __VA_ARGS__)
|
||||
# define RAW_LOG_ERROR(...) \
|
||||
google::RawLog__(google::GLOG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define RAW_LOG_ERROR(...) google::RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG <= 2
|
||||
# define RAW_LOG_ERROR(...) google::RawLogStub__(0, __VA_ARGS__)
|
||||
#endif // STRIP_LOG <= 2
|
||||
|
||||
#if !defined(STRIP_LOG) || STRIP_LOG <= 3
|
||||
#define RAW_LOG_FATAL(...) google::RawLog__(google::GLOG_FATAL, \
|
||||
__FILE__, __LINE__, __VA_ARGS__)
|
||||
# define RAW_LOG_FATAL(...) \
|
||||
google::RawLog__(google::GLOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define RAW_LOG_FATAL(...) \
|
||||
do { \
|
||||
google::RawLogStub__(0, __VA_ARGS__); \
|
||||
exit(EXIT_FAILURE); \
|
||||
} while (0)
|
||||
#endif // STRIP_LOG <= 3
|
||||
# define RAW_LOG_FATAL(...) \
|
||||
do { \
|
||||
google::RawLogStub__(0, __VA_ARGS__); \
|
||||
exit(EXIT_FAILURE); \
|
||||
} while (0)
|
||||
#endif // STRIP_LOG <= 3
|
||||
|
||||
// Similar to CHECK(condition) << message,
|
||||
// but for low-level modules: we use only RAW_LOG that does not allocate memory.
|
||||
// We do not want to provide args list here to encourage this usage:
|
||||
// if (!cond) RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
|
||||
// so that the args are not computed when not needed.
|
||||
#define RAW_CHECK(condition, message) \
|
||||
do { \
|
||||
if (!(condition)) { \
|
||||
RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
|
||||
} \
|
||||
#define RAW_CHECK(condition, message) \
|
||||
do { \
|
||||
if (!(condition)) { \
|
||||
RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// Debug versions of RAW_LOG and RAW_CHECK
|
||||
#ifndef NDEBUG
|
||||
|
||||
#define RAW_DLOG(severity, ...) RAW_LOG(severity, __VA_ARGS__)
|
||||
#define RAW_DCHECK(condition, message) RAW_CHECK(condition, message)
|
||||
# define RAW_DLOG(severity, ...) RAW_LOG(severity, __VA_ARGS__)
|
||||
# define RAW_DCHECK(condition, message) RAW_CHECK(condition, message)
|
||||
|
||||
#else // NDEBUG
|
||||
|
||||
#define RAW_DLOG(severity, ...) \
|
||||
while (false) \
|
||||
RAW_LOG(severity, __VA_ARGS__)
|
||||
#define RAW_DCHECK(condition, message) \
|
||||
while (false) \
|
||||
RAW_CHECK(condition, message)
|
||||
# define RAW_DLOG(severity, ...) \
|
||||
while (false) RAW_LOG(severity, __VA_ARGS__)
|
||||
# define RAW_DCHECK(condition, message) \
|
||||
while (false) RAW_CHECK(condition, message)
|
||||
|
||||
#endif // NDEBUG
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
// Stub log function used to work around for unused variable warnings when
|
||||
// building with STRIP_LOG > 0.
|
||||
static inline void RawLogStub__(int /* ignored */, ...) {
|
||||
}
|
||||
static inline void RawLogStub__(int /* ignored */, ...) {}
|
||||
|
||||
// Helper function to implement RAW_LOG and RAW_VLOG
|
||||
// Logs format... at "severity" level, reporting it
|
||||
|
|
@ -172,8 +165,12 @@ static inline void RawLogStub__(int /* ignored */, ...) {
|
|||
// This does not allocate memory or acquire locks.
|
||||
GLOG_EXPORT void RawLog__(LogSeverity severity, const char* file, int line,
|
||||
const char* format, ...)
|
||||
__attribute__((__format__(__printf__, 4, 5)));
|
||||
|
||||
}
|
||||
#if defined(__has_attribute)
|
||||
# if __has_attribute(used)
|
||||
__attribute__((__format__(__printf__, 4, 5)))
|
||||
# endif
|
||||
#endif
|
||||
;
|
||||
} // namespace google
|
||||
|
||||
#endif // GLOG_RAW_LOGGING_H
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) 2003, Google Inc.
|
||||
// Copyright (c) 2023, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
|
|
@ -35,140 +35,86 @@
|
|||
// vector<int> v1, v2;
|
||||
// CHECK_EQ(v1, v2);
|
||||
//
|
||||
// If you want to use this header file with hash maps or slist, you
|
||||
// need to define macros before including this file:
|
||||
//
|
||||
// - GLOG_STL_LOGGING_FOR_UNORDERED - <unordered_map> and <unordered_set>
|
||||
// - GLOG_STL_LOGGING_FOR_TR1_UNORDERED - <tr1/unordered_(map|set)>
|
||||
// - GLOG_STL_LOGGING_FOR_EXT_HASH - <ext/hash_(map|set)>
|
||||
// - GLOG_STL_LOGGING_FOR_EXT_SLIST - <ext/slist>
|
||||
//
|
||||
|
||||
#ifndef UTIL_GTL_STL_LOGGING_INL_H_
|
||||
#define UTIL_GTL_STL_LOGGING_INL_H_
|
||||
|
||||
#if !1
|
||||
# error We do not support stl_logging for this compiler
|
||||
#endif
|
||||
#ifndef GLOG_STL_LOGGING_H
|
||||
#define GLOG_STL_LOGGING_H
|
||||
|
||||
#include <deque>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <ostream>
|
||||
#include <set>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#if defined(GLOG_STL_LOGGING_FOR_UNORDERED) && __cplusplus >= 201103L
|
||||
# include <unordered_map>
|
||||
# include <unordered_set>
|
||||
#endif
|
||||
|
||||
#ifdef GLOG_STL_LOGGING_FOR_TR1_UNORDERED
|
||||
# include <tr1/unordered_map>
|
||||
# include <tr1/unordered_set>
|
||||
#endif
|
||||
|
||||
#ifdef GLOG_STL_LOGGING_FOR_EXT_HASH
|
||||
# include <ext/hash_set>
|
||||
# include <ext/hash_map>
|
||||
#endif
|
||||
#ifdef GLOG_STL_LOGGING_FOR_EXT_SLIST
|
||||
# include <ext/slist>
|
||||
#endif
|
||||
|
||||
// Forward declare these two, and define them after all the container streams
|
||||
// operators so that we can recurse from pair -> container -> container -> pair
|
||||
// properly.
|
||||
template<class First, class Second>
|
||||
template <class First, class Second>
|
||||
std::ostream& operator<<(std::ostream& out, const std::pair<First, Second>& p);
|
||||
|
||||
namespace google {
|
||||
|
||||
template<class Iter>
|
||||
template <class Iter>
|
||||
void PrintSequence(std::ostream& out, Iter begin, Iter end);
|
||||
|
||||
}
|
||||
|
||||
#define OUTPUT_TWO_ARG_CONTAINER(Sequence) \
|
||||
template<class T1, class T2> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
#define OUTPUT_TWO_ARG_CONTAINER(Sequence) \
|
||||
template <class T1, class T2> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
|
||||
OUTPUT_TWO_ARG_CONTAINER(std::vector)
|
||||
OUTPUT_TWO_ARG_CONTAINER(std::deque)
|
||||
OUTPUT_TWO_ARG_CONTAINER(std::list)
|
||||
#ifdef GLOG_STL_LOGGING_FOR_EXT_SLIST
|
||||
OUTPUT_TWO_ARG_CONTAINER(__gnu_cxx::slist)
|
||||
#endif
|
||||
|
||||
#undef OUTPUT_TWO_ARG_CONTAINER
|
||||
|
||||
#define OUTPUT_THREE_ARG_CONTAINER(Sequence) \
|
||||
template<class T1, class T2, class T3> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2, T3>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
#define OUTPUT_THREE_ARG_CONTAINER(Sequence) \
|
||||
template <class T1, class T2, class T3> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2, T3>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
|
||||
OUTPUT_THREE_ARG_CONTAINER(std::set)
|
||||
OUTPUT_THREE_ARG_CONTAINER(std::multiset)
|
||||
|
||||
#undef OUTPUT_THREE_ARG_CONTAINER
|
||||
|
||||
#define OUTPUT_FOUR_ARG_CONTAINER(Sequence) \
|
||||
template<class T1, class T2, class T3, class T4> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2, T3, T4>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
#define OUTPUT_FOUR_ARG_CONTAINER(Sequence) \
|
||||
template <class T1, class T2, class T3, class T4> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2, T3, T4>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
|
||||
OUTPUT_FOUR_ARG_CONTAINER(std::map)
|
||||
OUTPUT_FOUR_ARG_CONTAINER(std::multimap)
|
||||
#if defined(GLOG_STL_LOGGING_FOR_UNORDERED) && __cplusplus >= 201103L
|
||||
OUTPUT_FOUR_ARG_CONTAINER(std::unordered_set)
|
||||
OUTPUT_FOUR_ARG_CONTAINER(std::unordered_multiset)
|
||||
#endif
|
||||
#ifdef GLOG_STL_LOGGING_FOR_TR1_UNORDERED
|
||||
OUTPUT_FOUR_ARG_CONTAINER(std::tr1::unordered_set)
|
||||
OUTPUT_FOUR_ARG_CONTAINER(std::tr1::unordered_multiset)
|
||||
#endif
|
||||
#ifdef GLOG_STL_LOGGING_FOR_EXT_HASH
|
||||
OUTPUT_FOUR_ARG_CONTAINER(__gnu_cxx::hash_set)
|
||||
OUTPUT_FOUR_ARG_CONTAINER(__gnu_cxx::hash_multiset)
|
||||
#endif
|
||||
|
||||
#undef OUTPUT_FOUR_ARG_CONTAINER
|
||||
|
||||
#define OUTPUT_FIVE_ARG_CONTAINER(Sequence) \
|
||||
template<class T1, class T2, class T3, class T4, class T5> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2, T3, T4, T5>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
#define OUTPUT_FIVE_ARG_CONTAINER(Sequence) \
|
||||
template <class T1, class T2, class T3, class T4, class T5> \
|
||||
inline std::ostream& operator<<(std::ostream& out, \
|
||||
const Sequence<T1, T2, T3, T4, T5>& seq) { \
|
||||
google::PrintSequence(out, seq.begin(), seq.end()); \
|
||||
return out; \
|
||||
}
|
||||
|
||||
#if defined(GLOG_STL_LOGGING_FOR_UNORDERED) && __cplusplus >= 201103L
|
||||
OUTPUT_FIVE_ARG_CONTAINER(std::unordered_map)
|
||||
OUTPUT_FIVE_ARG_CONTAINER(std::unordered_multimap)
|
||||
#endif
|
||||
#ifdef GLOG_STL_LOGGING_FOR_TR1_UNORDERED
|
||||
OUTPUT_FIVE_ARG_CONTAINER(std::tr1::unordered_map)
|
||||
OUTPUT_FIVE_ARG_CONTAINER(std::tr1::unordered_multimap)
|
||||
#endif
|
||||
#ifdef GLOG_STL_LOGGING_FOR_EXT_HASH
|
||||
OUTPUT_FIVE_ARG_CONTAINER(__gnu_cxx::hash_map)
|
||||
OUTPUT_FIVE_ARG_CONTAINER(__gnu_cxx::hash_multimap)
|
||||
#endif
|
||||
|
||||
#undef OUTPUT_FIVE_ARG_CONTAINER
|
||||
|
||||
template<class First, class Second>
|
||||
template <class First, class Second>
|
||||
inline std::ostream& operator<<(std::ostream& out,
|
||||
const std::pair<First, Second>& p) {
|
||||
out << '(' << p.first << ", " << p.second << ')';
|
||||
|
|
@ -177,7 +123,7 @@ inline std::ostream& operator<<(std::ostream& out,
|
|||
|
||||
namespace google {
|
||||
|
||||
template<class Iter>
|
||||
template <class Iter>
|
||||
inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
|
||||
// Output at most 100 elements -- appropriate if used for logging.
|
||||
for (int i = 0; begin != end && i < 100; ++i, ++begin) {
|
||||
|
|
@ -189,7 +135,7 @@ inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
|
|||
}
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace google
|
||||
|
||||
// Note that this is technically undefined behavior! We are adding things into
|
||||
// the std namespace for a reason though -- we are providing new operations on
|
||||
|
|
@ -215,6 +161,8 @@ inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
|
|||
// move all of the *definitions* into namespace std, bet we need to ensure no
|
||||
// one references them first. This lets us take that step. We cannot define them
|
||||
// in both because that would create ambiguous overloads when both are found.
|
||||
namespace std { using ::operator<<; }
|
||||
namespace std {
|
||||
using ::operator<<;
|
||||
}
|
||||
|
||||
#endif // UTIL_GTL_STL_LOGGING_INL_H_
|
||||
#endif // GLOG_STL_LOGGING_H
|
||||
|
|
|
|||
81
glog/arm64-v8a/include/glog/types.h
Normal file
81
glog/arm64-v8a/include/glog/types.h
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
|
||||
// Copyright (c) 2024, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
|
||||
#ifndef GLOG_TYPES_H
|
||||
#define GLOG_TYPES_H
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
namespace google {
|
||||
|
||||
using int32 = std::int32_t;
|
||||
using uint32 = std::uint32_t;
|
||||
using int64 = std::int64_t;
|
||||
using uint64 = std::uint64_t;
|
||||
|
||||
} // namespace google
|
||||
|
||||
#if defined(__has_feature)
|
||||
# if __has_feature(thread_sanitizer)
|
||||
# define GLOG_SANITIZE_THREAD 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined(GLOG_SANITIZE_THREAD) && defined(__SANITIZE_THREAD__) && \
|
||||
__SANITIZE_THREAD__
|
||||
# define GLOG_SANITIZE_THREAD 1
|
||||
#endif
|
||||
|
||||
#if defined(GLOG_SANITIZE_THREAD)
|
||||
# define GLOG_IFDEF_THREAD_SANITIZER(X) X
|
||||
#else
|
||||
# define GLOG_IFDEF_THREAD_SANITIZER(X)
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# define GLOG_MSVC_PUSH_DISABLE_WARNING(n) \
|
||||
__pragma(warning(push)) __pragma(warning(disable : n))
|
||||
# define GLOG_MSVC_POP_WARNING() __pragma(warning(pop))
|
||||
#else
|
||||
# define GLOG_MSVC_PUSH_DISABLE_WARNING(n)
|
||||
# define GLOG_MSVC_POP_WARNING()
|
||||
#endif
|
||||
|
||||
#if defined(GLOG_SANITIZE_THREAD)
|
||||
// We need to identify the static variables as "benign" races
|
||||
// to avoid noisy reports from TSAN.
|
||||
extern "C" void AnnotateBenignRaceSized(const char* file, int line,
|
||||
const volatile void* mem, size_t size,
|
||||
const char* description);
|
||||
#endif // defined(GLOG_SANITIZE_THREAD)
|
||||
|
||||
#endif // GLOG_TYPES_H
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) 1999, 2007, Google Inc.
|
||||
// Copyright (c) 2024, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
|
|
@ -58,10 +58,21 @@
|
|||
// CAVEAT: --vmodule functionality is not available in non gcc compilers.
|
||||
//
|
||||
|
||||
#ifndef BASE_VLOG_IS_ON_H_
|
||||
#define BASE_VLOG_IS_ON_H_
|
||||
#ifndef GLOG_VLOG_IS_ON_H
|
||||
#define GLOG_VLOG_IS_ON_H
|
||||
|
||||
#include <glog/log_severity.h>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(GLOG_USE_GLOG_EXPORT)
|
||||
# include "glog/export.h"
|
||||
#endif
|
||||
|
||||
#if !defined(GLOG_EXPORT)
|
||||
# error <glog/vlog_is_on.h> was not included correctly. See the documention for how to consume the library.
|
||||
#endif
|
||||
|
||||
#include "glog/flags.h"
|
||||
#include "glog/types.h"
|
||||
|
||||
#if defined(__GNUC__)
|
||||
// We emit an anonymous static int* variable at every VLOG_IS_ON(n) site.
|
||||
|
|
@ -70,19 +81,25 @@
|
|||
// it's either FLAGS_v or an appropriate internal variable
|
||||
// matching the current source file that represents results of
|
||||
// parsing of --vmodule flag and/or SetVLOGLevel calls.
|
||||
#define VLOG_IS_ON(verboselevel) \
|
||||
__extension__ \
|
||||
({ static google::SiteFlag vlocal__ = {NULL, NULL, 0, NULL}; \
|
||||
google::int32 verbose_level__ = (verboselevel); \
|
||||
(vlocal__.level == NULL ? google::InitVLOG3__(&vlocal__, &FLAGS_v, \
|
||||
__FILE__, verbose_level__) : *vlocal__.level >= verbose_level__); \
|
||||
})
|
||||
# define VLOG_IS_ON(verboselevel) \
|
||||
__extension__({ \
|
||||
static google::SiteFlag vlocal__ = {nullptr, nullptr, 0, nullptr}; \
|
||||
GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \
|
||||
__FILE__, __LINE__, &vlocal__, sizeof(google::SiteFlag), "")); \
|
||||
google::int32 verbose_level__ = (verboselevel); \
|
||||
(vlocal__.level == nullptr \
|
||||
? google::InitVLOG3__(&vlocal__, &FLAGS_v, __FILE__, \
|
||||
verbose_level__) \
|
||||
: *vlocal__.level >= verbose_level__); \
|
||||
})
|
||||
#else
|
||||
// GNU extensions not available, so we do not support --vmodule.
|
||||
// Dynamic value of FLAGS_v always controls the logging level.
|
||||
#define VLOG_IS_ON(verboselevel) (FLAGS_v >= (verboselevel))
|
||||
# define VLOG_IS_ON(verboselevel) (FLAGS_v >= (verboselevel))
|
||||
#endif
|
||||
|
||||
namespace google {
|
||||
|
||||
// Set VLOG(_IS_ON) level for module_pattern to log_level.
|
||||
// This lets us dynamically control what is normally set by the --vmodule flag.
|
||||
// Returns the level that previously applied to module_pattern.
|
||||
|
|
@ -96,13 +113,13 @@ extern GLOG_EXPORT int SetVLOGLevel(const char* module_pattern, int log_level);
|
|||
// Various declarations needed for VLOG_IS_ON above: =========================
|
||||
|
||||
struct SiteFlag {
|
||||
google::int32* level;
|
||||
int32* level;
|
||||
const char* base_name;
|
||||
size_t base_len;
|
||||
std::size_t base_len;
|
||||
SiteFlag* next;
|
||||
};
|
||||
|
||||
// Helper routine which determines the logging info for a particalur VLOG site.
|
||||
// Helper routine which determines the logging info for a particular VLOG site.
|
||||
// site_flag is the address of the site-local pointer to the controlling
|
||||
// verbosity level
|
||||
// site_default is the default to use for *site_flag
|
||||
|
|
@ -110,9 +127,10 @@ struct SiteFlag {
|
|||
// verbose_level is the argument to VLOG_IS_ON
|
||||
// We will return the return value for VLOG_IS_ON
|
||||
// and if possible set *site_flag appropriately.
|
||||
extern GLOG_EXPORT bool InitVLOG3__(
|
||||
google::SiteFlag* site_flag,
|
||||
google::int32* site_default, const char* fname,
|
||||
google::int32 verbose_level);
|
||||
extern GLOG_EXPORT bool InitVLOG3__(SiteFlag* site_flag,
|
||||
int32* site_default,
|
||||
const char* fname,
|
||||
int32 verbose_level);
|
||||
} // namespace google
|
||||
|
||||
#endif // BASE_VLOG_IS_ON_H_
|
||||
#endif // GLOG_VLOG_IS_ON_H
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue