From ebbae478e4e7c0ffc94a6368ba77ce41eafa26cb Mon Sep 17 00:00:00 2001 From: Sergiu Deitsch Date: Sat, 30 Dec 2023 22:09:15 +0100 Subject: [PATCH] wip --- src/base/commandlineflags.h | 94 ++++++++--------- src/base/googleinit.h | 8 +- src/base/mutex.h | 6 +- src/demangle.cc | 31 ++---- src/demangle_unittest.cc | 9 +- src/glog/log_severity.h | 10 +- src/glog/logging.h | 93 +++++++++-------- src/glog/raw_logging.h | 14 +-- src/glog/stl_logging.h | 4 +- src/glog/vlog_is_on.h | 12 +-- src/googletest.h | 40 ++++--- src/logging.cc | 191 ++++++++++++++++++++-------------- src/logging_unittest.cc | 52 ++++++--- src/raw_logging.cc | 19 ++-- src/signalhandler.cc | 10 +- src/signalhandler_unittest.cc | 5 +- src/stacktrace_powerpc-inl.h | 18 +++- src/stacktrace_unittest.cc | 4 +- src/stacktrace_x86-inl.h | 10 +- src/stl_logging_unittest.cc | 6 +- src/striplog_unittest.cc | 9 +- src/symbolize.cc | 15 +-- src/symbolize_unittest.cc | 6 +- src/utilities.cc | 14 ++- src/utilities.h | 8 +- src/vlog_is_on.cc | 36 ++++--- src/windows/dirent.h | 46 ++++---- 27 files changed, 427 insertions(+), 343 deletions(-) diff --git a/src/base/commandlineflags.h b/src/base/commandlineflags.h index 3d31a86..88e2dde 100644 --- a/src/base/commandlineflags.h +++ b/src/base/commandlineflags.h @@ -45,69 +45,69 @@ // We also put the type of the variable in the namespace, so that // people can't DECLARE_int32 something that they DEFINE_bool'd // elsewhere. -#ifndef BASE_COMMANDLINEFLAGS_H__ -#define BASE_COMMANDLINEFLAGS_H__ +#ifndef BASE_COMMANDLINEFLAGS_H_ +# define BASE_COMMANDLINEFLAGS_H_ -#include // for getenv -#include // for memchr -#include +# include // for getenv +# include // for memchr +# include -#include "config.h" +# include "config.h" -#ifdef GLOG_USE_GFLAGS +# ifdef GLOG_USE_GFLAGS -# include +# include -#else +# else -# include "glog/logging.h" +# include "glog/logging.h" -# define DECLARE_VARIABLE(type, shorttype, name, tn) \ - namespace fL##shorttype { \ - extern GLOG_EXPORT type FLAGS_##name; \ - } \ - using fL##shorttype::FLAGS_##name -# define DEFINE_VARIABLE(type, shorttype, name, value, meaning, tn) \ - namespace fL##shorttype { \ - GLOG_EXPORT type FLAGS_##name(value); \ - char FLAGS_no##name; \ - } \ - using fL##shorttype::FLAGS_##name +# define DECLARE_VARIABLE(type, shorttype, name, tn) \ + namespace fL##shorttype { \ + extern GLOG_EXPORT type FLAGS_##name; \ + } \ + using fL##shorttype::FLAGS_##name +# define DEFINE_VARIABLE(type, shorttype, name, value, meaning, tn) \ + namespace fL##shorttype { \ + GLOG_EXPORT type FLAGS_##name(value); \ + char FLAGS_no##name; \ + } \ + using fL##shorttype::FLAGS_##name // bool specialization -# define DECLARE_bool(name) DECLARE_VARIABLE(bool, B, name, bool) -# define DEFINE_bool(name, value, meaning) \ - DEFINE_VARIABLE(bool, B, name, value, meaning, bool) +# define DECLARE_bool(name) DECLARE_VARIABLE(bool, B, name, bool) +# define DEFINE_bool(name, value, meaning) \ + DEFINE_VARIABLE(bool, B, name, value, meaning, bool) // int32 specialization -# define DECLARE_int32(name) DECLARE_VARIABLE(google::int32, I, name, int32) -# define DEFINE_int32(name, value, meaning) \ - DEFINE_VARIABLE(google::int32, I, name, value, meaning, int32) +# define DECLARE_int32(name) DECLARE_VARIABLE(google::int32, I, name, int32) +# define DEFINE_int32(name, value, meaning) \ + DEFINE_VARIABLE(google::int32, I, name, value, meaning, int32) // uint32 specialization -# ifndef DECLARE_uint32 -# define DECLARE_uint32(name) \ - DECLARE_VARIABLE(google::uint32, U, name, uint32) -# endif // DECLARE_uint64 -# define DEFINE_uint32(name, value, meaning) \ - DEFINE_VARIABLE(google::uint32, U, name, value, meaning, uint32) +# ifndef DECLARE_uint32 +# define DECLARE_uint32(name) \ + DECLARE_VARIABLE(google::uint32, U, name, uint32) +# endif // DECLARE_uint64 +# define DEFINE_uint32(name, value, meaning) \ + DEFINE_VARIABLE(google::uint32, U, name, value, meaning, uint32) // 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 -# define DEFINE_string(name, value, meaning) \ - namespace fLS { \ - std::string FLAGS_##name##_buf(value); \ - GLOG_EXPORT std::string& FLAGS_##name = FLAGS_##name##_buf; \ - char FLAGS_no##name; \ - } \ - using fLS::FLAGS_##name +# define DECLARE_string(name) \ + namespace fLS { \ + extern GLOG_EXPORT std::string& FLAGS_##name; \ + } \ + using fLS::FLAGS_##name +# define DEFINE_string(name, value, meaning) \ + namespace fLS { \ + std::string FLAGS_##name##_buf(value); \ + GLOG_EXPORT std::string& FLAGS_##name = FLAGS_##name##_buf; \ + char FLAGS_no##name; \ + } \ + using fLS::FLAGS_##name -#endif // GLOG_USE_GFLAGS +# endif // GLOG_USE_GFLAGS // Define GLOG_DEFINE_* using DEFINE_* . By using these macros, we // have GLOG_* environ variables even if we have gflags installed. @@ -146,4 +146,4 @@ ? (dflt) \ : static_cast(strtoul(getenv(envname), nullptr, 10))) -#endif // BASE_COMMANDLINEFLAGS_H__ +#endif // BASE_COMMANDLINEFLAGS_H_ diff --git a/src/base/googleinit.h b/src/base/googleinit.h index bf569b8..5dcba36 100644 --- a/src/base/googleinit.h +++ b/src/base/googleinit.h @@ -30,13 +30,13 @@ // --- // Author: Jacob Hoffman-Andrews -#ifndef _GOOGLEINIT_H -#define _GOOGLEINIT_H +#ifndef GOOGLEINIT_H +# define GOOGLEINIT_H class GoogleInitializer { public: using void_function = void (*)(); - GoogleInitializer(const char*, void_function f) { f(); } + GoogleInitializer(const char* /*unused*/, void_function f) { f(); } }; #define REGISTER_MODULE_INITIALIZER(name, body) \ @@ -46,4 +46,4 @@ class GoogleInitializer { #name, google_init_module_##name); \ } -#endif /* _GOOGLEINIT_H */ +#endif /* GOOGLEINIT_H */ diff --git a/src/base/mutex.h b/src/base/mutex.h index bb74246..b063811 100644 --- a/src/base/mutex.h +++ b/src/base/mutex.h @@ -136,7 +136,7 @@ typedef CRITICAL_SECTION MutexType; # ifdef __linux__ # ifndef _XOPEN_SOURCE // Some other header might have already set it for // us. -# define _XOPEN_SOURCE 500 // may be needed to get the rwlock calls +# define XOPEN_SOURCE 500 // may be needed to get the rwlock calls # endif # endif # include @@ -258,7 +258,9 @@ void Mutex::ReaderUnlock() { Unlock(); } Mutex::Mutex() { SetIsSafe(); - if (is_safe_ && pthread_rwlock_init(&mutex_, nullptr) != 0) abort(); + if (is_safe_ && pthread_rwlock_init(&mutex_, nullptr) != 0) { + abort(); + } } Mutex::~Mutex() { SAFE_PTHREAD(pthread_rwlock_destroy); } void Mutex::Lock() { SAFE_PTHREAD(pthread_rwlock_wrlock); } diff --git a/src/demangle.cc b/src/demangle.cc index 2a6126b..0a1ee0e 100644 --- a/src/demangle.cc +++ b/src/demangle.cc @@ -199,7 +199,7 @@ static bool ParseCharClass(State* state, const char* char_class) { } // This function is used for handling an optional non-terminal. -static bool Optional(bool) { return true; } +static bool Optional(bool /*unused*/) { return true; } // This function is used for handling + syntax. using ParseFunc = bool (*)(State*); @@ -450,10 +450,7 @@ static bool ParseEncoding(State* state) { } *state = copy; - if (ParseName(state) || ParseSpecialName(state)) { - return true; - } - return false; + return ParseName(state) || ParseSpecialName(state); } // ::= @@ -472,10 +469,7 @@ static bool ParseName(State* state) { *state = copy; // Less greedy than . - if (ParseUnscopedName(state)) { - return true; - } - return false; + return ParseUnscopedName(state); } // ::= @@ -538,9 +532,8 @@ static bool ParsePrefix(State* state) { MaybeCancelLastSeparator(state); if (has_something && ParseTemplateArgs(state)) { return ParsePrefix(state); - } else { - break; } + break; } return true; } @@ -627,7 +620,7 @@ static bool ParseNumber(State* state, int* number_out) { static bool ParseFloatNumber(State* state) { const char* p = state->mangled_cur; for (; *p != '\0'; ++p) { - if (!IsDigit(*p) && !(*p >= 'a' && *p <= 'f')) { + if (!IsDigit(*p) && (*p < 'a' || *p > 'f')) { break; } } @@ -643,7 +636,7 @@ static bool ParseFloatNumber(State* state) { static bool ParseSeqId(State* state) { const char* p = state->mangled_cur; for (; *p != '\0'; ++p) { - if (!IsDigit(*p) && !(*p >= 'A' && *p <= 'Z')) { + if (!IsDigit(*p) && (*p < 'A' || *p > 'Z')) { break; } } @@ -928,11 +921,7 @@ static bool ParseType(State* state) { *state = copy; // Less greedy than . - if (ParseTemplateParam(state)) { - return true; - } - - return false; + return ParseTemplateParam(state); } // ::= [r] [V] [K] @@ -940,9 +929,9 @@ static bool ParseType(State* state) { // ParseType(). static bool ParseCVQualifiers(State* state) { int num_cv_qualifiers = 0; - num_cv_qualifiers += ParseOneCharToken(state, 'r'); - num_cv_qualifiers += ParseOneCharToken(state, 'V'); - num_cv_qualifiers += ParseOneCharToken(state, 'K'); + num_cv_qualifiers += static_cast(ParseOneCharToken(state, 'r')); + num_cv_qualifiers += static_cast(ParseOneCharToken(state, 'V')); + num_cv_qualifiers += static_cast(ParseOneCharToken(state, 'K')); return num_cv_qualifiers > 0; } diff --git a/src/demangle_unittest.cc b/src/demangle_unittest.cc index 6df41fe..d1a0f79 100644 --- a/src/demangle_unittest.cc +++ b/src/demangle_unittest.cc @@ -58,9 +58,8 @@ static const char* DemangleIt(const char* const mangled) { static char demangled[4096]; if (Demangle(mangled, demangled, sizeof(demangled))) { return demangled; - } else { - return mangled; } + return mangled; } #if defined(GLOG_OS_WINDOWS) @@ -159,10 +158,10 @@ int main(int argc, char** argv) { cout << DemangleIt(line.c_str()) << endl; } return 0; - } else if (argc > 1) { + } + if (argc > 1) { cout << DemangleIt(argv[1]) << endl; return 0; - } else { - return RUN_ALL_TESTS(); } + return RUN_ALL_TESTS(); } diff --git a/src/glog/log_severity.h b/src/glog/log_severity.h index 99f4b52..8586852 100644 --- a/src/glog/log_severity.h +++ b/src/glog/log_severity.h @@ -27,8 +27,12 @@ // (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 BASE_LOG_SEVERITY_H__ -#define BASE_LOG_SEVERITY_H__ +#ifndef BASE_LOG_SEVERITY_H_ +#define BASE_LOG_SEVERITY_H_ + +#if defined(GLOG_USE_GLOG_EXPORT) +# include "glog/export.h" +#endif // The recommended semantics of the log levels are as follows: // @@ -95,4 +99,4 @@ enum { DEBUG_MODE = 1 }; # define IF_DEBUG_MODE(x) x #endif -#endif // BASE_LOG_SEVERITY_H__ +#endif // BASE_LOG_SEVERITY_H_ diff --git a/src/glog/logging.h b/src/glog/logging.h index b69fc50..e93e4ac 100644 --- a/src/glog/logging.h +++ b/src/glog/logging.h @@ -90,16 +90,16 @@ namespace google { -typedef std::int32_t int32; -typedef std::uint32_t uint32; -typedef std::int64_t int64; -typedef std::uint64_t uint64; +using int32 = std::int32_t; +using uint32 = std::uint32_t; +using int64 = std::int64_t; +using uint64 = std::uint64_t; -typedef double WallTime; +using WallTime = double; struct GLOG_EXPORT LogMessageTime { LogMessageTime(); - LogMessageTime(std::tm t); + explicit LogMessageTime(std::tm t); LogMessageTime(std::time_t timestamp, WallTime now); const time_t& timestamp() const { return timestamp_; } @@ -143,8 +143,8 @@ struct LogMessageInfo { const LogMessageTime& time; }; -typedef void (*CustomPrefixCallback)(std::ostream& s, const LogMessageInfo& l, - void* data); +using CustomPrefixCallback = void (*)(std::ostream&, const LogMessageInfo&, + void*); } // namespace google @@ -632,9 +632,10 @@ GLOG_EXPORT bool IsGoogleLoggingInitialized(); GLOG_EXPORT void ShutdownGoogleLogging(); #if defined(__GNUC__) -typedef void (*logging_fail_func_t)() __attribute__((noreturn)); +typedef void (*logging_fail_func_t)() + __attribute__((noreturn)); // NOLINT(modernize-use-using) #else -typedef void (*logging_fail_func_t)(); +using logging_fail_func_t = void (*)(); #endif // Install a function which will be called after LOG(FATAL). @@ -711,10 +712,11 @@ class LogSink; // defined below // A container for a string pointer which can be evaluated to a bool - // true iff the pointer is nullptr. struct CheckOpString { + // NOLINTNEXTLINE(google-explicit-constructor) CheckOpString(std::string* str) : str_(str) {} // No destructor: if str_ is non-nullptr, we're about to LOG(FATAL), // so there's no point in cleaning up str_. - operator bool() const { + explicit operator bool() const noexcept { return GOOGLE_PREDICT_BRANCH_NOT_TAKEN(str_ != nullptr); } std::string* str_; @@ -749,8 +751,8 @@ struct DummyClassToDefineOperator {}; // Define global operator<< to declare using ::operator<<. // This declaration will allow use to use CHECK macros for user // defined classes which have operator<< (e.g., stl_logging.h). -inline std::ostream& operator<<(std::ostream& out, - const google::DummyClassToDefineOperator&) { +inline std::ostream& operator<<( + std::ostream& out, const google::DummyClassToDefineOperator& /*unused*/) { return out; } @@ -964,8 +966,8 @@ DECLARE_CHECK_STROP_IMPL(strcasecmp, false) #define CHECK_STRCASEEQ(s1, s2) CHECK_STROP(strcasecmp, ==, true, s1, s2) #define CHECK_STRCASENE(s1, s2) CHECK_STROP(strcasecmp, !=, false, s1, s2) -#define CHECK_INDEX(I, A) CHECK(I < (sizeof(A) / sizeof(A[0]))) -#define CHECK_BOUND(B, A) CHECK(B <= (sizeof(A) / sizeof(A[0]))) +#define CHECK_INDEX(I, A) CHECK((I) < (sizeof(A) / sizeof((A)[0]))) +#define CHECK_BOUND(B, A) CHECK((B) <= (sizeof(A) / sizeof((A)[0]))) #define CHECK_DOUBLE_EQ(val1, val2) \ do { \ @@ -1088,23 +1090,23 @@ namespace google { GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \ __FILE__, __LINE__, &LOG_OCCURRENCES_MOD_N, sizeof(int), "")); \ ++LOG_OCCURRENCES; \ - if (++LOG_OCCURRENCES_MOD_N > n) LOG_OCCURRENCES_MOD_N -= n; \ + if (++LOG_OCCURRENCES_MOD_N > (n)) LOG_OCCURRENCES_MOD_N -= (n); \ if (LOG_OCCURRENCES_MOD_N == 1) \ google::LogMessage(__FILE__, __LINE__, google::GLOG_##severity, \ - LOG_OCCURRENCES, &what_to_do) \ + LOG_OCCURRENCES, (what_to_do)) \ .stream() -#define SOME_KIND_OF_LOG_IF_EVERY_N(severity, condition, n, what_to_do) \ - static std::atomic LOG_OCCURRENCES(0), LOG_OCCURRENCES_MOD_N(0); \ - GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \ - __FILE__, __LINE__, &LOG_OCCURRENCES, sizeof(int), "")); \ - GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \ - __FILE__, __LINE__, &LOG_OCCURRENCES_MOD_N, sizeof(int), "")); \ - ++LOG_OCCURRENCES; \ - if ((condition) && \ - ((LOG_OCCURRENCES_MOD_N = (LOG_OCCURRENCES_MOD_N + 1) % n) == (1 % n))) \ - google::LogMessage(__FILE__, __LINE__, google::GLOG_##severity, \ - LOG_OCCURRENCES, &what_to_do) \ +#define SOME_KIND_OF_LOG_IF_EVERY_N(severity, condition, n, what_to_do) \ + static std::atomic LOG_OCCURRENCES(0), LOG_OCCURRENCES_MOD_N(0); \ + GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \ + __FILE__, __LINE__, &LOG_OCCURRENCES, sizeof(int), "")); \ + GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \ + __FILE__, __LINE__, &LOG_OCCURRENCES_MOD_N, sizeof(int), "")); \ + ++LOG_OCCURRENCES; \ + if ((condition) && ((LOG_OCCURRENCES_MOD_N = \ + (LOG_OCCURRENCES_MOD_N + 1) % (n)) == (1 % (n)))) \ + google::LogMessage(__FILE__, __LINE__, google::GLOG_##severity, \ + LOG_OCCURRENCES, (what_to_do)) \ .stream() #define SOME_KIND_OF_PLOG_EVERY_N(severity, n, what_to_do) \ @@ -1114,20 +1116,20 @@ namespace google { GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \ __FILE__, __LINE__, &LOG_OCCURRENCES_MOD_N, sizeof(int), "")); \ ++LOG_OCCURRENCES; \ - if (++LOG_OCCURRENCES_MOD_N > n) LOG_OCCURRENCES_MOD_N -= n; \ + if (++LOG_OCCURRENCES_MOD_N > (n)) LOG_OCCURRENCES_MOD_N -= (n); \ if (LOG_OCCURRENCES_MOD_N == 1) \ google::ErrnoLogMessage(__FILE__, __LINE__, google::GLOG_##severity, \ - LOG_OCCURRENCES, &what_to_do) \ + LOG_OCCURRENCES, (what_to_do)) \ .stream() #define SOME_KIND_OF_LOG_FIRST_N(severity, n, what_to_do) \ static std::atomic LOG_OCCURRENCES(0); \ GLOG_IFDEF_THREAD_SANITIZER(AnnotateBenignRaceSized( \ __FILE__, __LINE__, &LOG_OCCURRENCES, sizeof(int), "")); \ - if (LOG_OCCURRENCES <= n) ++LOG_OCCURRENCES; \ - if (LOG_OCCURRENCES <= n) \ + if (LOG_OCCURRENCES <= (n)) ++LOG_OCCURRENCES; \ + if (LOG_OCCURRENCES <= (n)) \ google::LogMessage(__FILE__, __LINE__, google::GLOG_##severity, \ - LOG_OCCURRENCES, &what_to_do) \ + LOG_OCCURRENCES, (what_to_do)) \ .stream() namespace glog_internal_namespace_ { @@ -1141,23 +1143,23 @@ GLOG_EXPORT bool IsFailureSignalHandlerInstalled(); } // namespace glog_internal_namespace_ #define LOG_EVERY_N(severity, n) \ - SOME_KIND_OF_LOG_EVERY_N(severity, (n), google::LogMessage::SendToLog) + SOME_KIND_OF_LOG_EVERY_N(severity, (n), &google::LogMessage::SendToLog) #define LOG_EVERY_T(severity, T) SOME_KIND_OF_LOG_EVERY_T(severity, (T)) #define SYSLOG_EVERY_N(severity, n) \ SOME_KIND_OF_LOG_EVERY_N(severity, (n), \ - google::LogMessage::SendToSyslogAndLog) + &google::LogMessage::SendToSyslogAndLog) #define PLOG_EVERY_N(severity, n) \ - SOME_KIND_OF_PLOG_EVERY_N(severity, (n), google::LogMessage::SendToLog) + SOME_KIND_OF_PLOG_EVERY_N(severity, (n), &google::LogMessage::SendToLog) #define LOG_FIRST_N(severity, n) \ - SOME_KIND_OF_LOG_FIRST_N(severity, (n), google::LogMessage::SendToLog) + SOME_KIND_OF_LOG_FIRST_N(severity, (n), &google::LogMessage::SendToLog) #define LOG_IF_EVERY_N(severity, condition, n) \ SOME_KIND_OF_LOG_IF_EVERY_N(severity, (condition), (n), \ - google::LogMessage::SendToLog) + &google::LogMessage::SendToLog) // We want the special COUNTER value available for LOG_EVERY_X()'ed messages enum PRIVATE_Counter { COUNTER }; @@ -1324,7 +1326,7 @@ class GLOG_EXPORT LogStreamBuf : public std::streambuf { LogStreamBuf(char* buf, int len) { setp(buf, buf + len - 2); } // This effectively ignores overflow. - int_type overflow(int_type ch) { return ch; } + int_type overflow(int_type ch) override { return ch; } // Legacy public ostrstream method. size_t pcount() const { return static_cast(pptr() - pbase()); } @@ -1406,9 +1408,8 @@ class GLOG_EXPORT LogMessage { LogStream* self_; // Consistency check hack }; - public: // icc 8 requires this typedef to avoid an internal compiler error. - typedef void (LogMessage::*SendMethod)(); + using SendMethod = void (LogMessage::*)(); LogMessage(const char* file, int line, LogSeverity severity, int64 ctr, SendMethod send_method); @@ -1495,7 +1496,7 @@ class GLOG_EXPORT LogMessage { void (LogMessage::*send_method)()); // Used to fill in crash information during LOG(FATAL) failures. - void RecordCrashReason(glog_internal_namespace_::CrashReason* reason); + static void RecordCrashReason(glog_internal_namespace_::CrashReason* reason); // Counts of messages sent at each priority: static int64 num_messages_[NUM_SEVERITIES]; // under log_mutex @@ -1576,10 +1577,10 @@ class GLOG_EXPORT ErrnoLogMessage : public LogMessage { class GLOG_EXPORT LogMessageVoidify { public: - LogMessageVoidify() {} + LogMessageVoidify() = default; // This has to be an operator with a precedence lower than << but // higher than ?: - void operator&(std::ostream&) {} + void operator&(std::ostream& /*unused*/) {} }; // Flushes all log files that contains messages that are at least of @@ -1817,7 +1818,7 @@ class GLOG_EXPORT NullStream : public LogMessage::LogStream { // converted to LogStream and the message will be computed and then // quietly discarded. template -inline NullStream& operator<<(NullStream& str, const T&) { +inline NullStream& operator<<(NullStream& str, const T& /*unused*/) { return str; } @@ -1828,7 +1829,7 @@ class GLOG_EXPORT NullStreamFatal : public NullStream { using NullStream::NullStream; [[noreturn]] // Prevent the linker from discarding the destructor. - GLOG_USED ~NullStreamFatal(); + GLOG_USED ~NullStreamFatal() override; }; // Install a signal handler that will dump signal information and a stack diff --git a/src/glog/raw_logging.h b/src/glog/raw_logging.h index b30e540..a3e877a 100644 --- a/src/glog/raw_logging.h +++ b/src/glog/raw_logging.h @@ -97,28 +97,28 @@ namespace google { #if !defined(STRIP_LOG) || STRIP_LOG == 0 # define RAW_LOG_INFO(...) \ - google::RawLog__(google::GLOG_INFO, __FILE__, __LINE__, __VA_ARGS__) + google::RawLog_(google::GLOG_INFO, __FILE__, __LINE__, __VA_ARGS__) #else # 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__) + google::RawLog_(google::GLOG_WARNING, __FILE__, __LINE__, __VA_ARGS__) #else # 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__) + google::RawLog_(google::GLOG_ERROR, __FILE__, __LINE__, __VA_ARGS__) #else # 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__) + google::RawLog_(google::GLOG_FATAL, __FILE__, __LINE__, __VA_ARGS__) #else # define RAW_LOG_FATAL(...) \ do { \ @@ -160,14 +160,14 @@ namespace google { // 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 // as called from file:line. // This does not allocate memory or acquire locks. -GLOG_EXPORT void RawLog__(LogSeverity severity, const char* file, int line, - const char* format, ...) +GLOG_EXPORT void RawLog_(LogSeverity severity, const char* file, int line, + const char* format, ...) #if defined(__has_attribute) # if __has_attribute(used) __attribute__((__format__(__printf__, 4, 5))) diff --git a/src/glog/stl_logging.h b/src/glog/stl_logging.h index 3689df2..ee8399f 100644 --- a/src/glog/stl_logging.h +++ b/src/glog/stl_logging.h @@ -127,7 +127,9 @@ template 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) { - if (i > 0) out << ' '; + if (i > 0) { + out << ' '; + } out << *begin; } if (begin != end) { diff --git a/src/glog/vlog_is_on.h b/src/glog/vlog_is_on.h index 914a57d..e069b3e 100644 --- a/src/glog/vlog_is_on.h +++ b/src/glog/vlog_is_on.h @@ -79,8 +79,8 @@ __FILE__, __LINE__, &vlocal__, sizeof(google::SiteFlag), "")); \ google::int32 verbose_level__ = (verboselevel); \ (vlocal__.level == nullptr \ - ? google::InitVLOG3__(&vlocal__, &FLAGS_v, __FILE__, \ - verbose_level__) \ + ? google::InitVLOG3_(&vlocal__, &FLAGS_v, __FILE__, \ + verbose_level__) \ : *vlocal__.level >= verbose_level__); \ }) #else @@ -116,9 +116,9 @@ 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_(google::SiteFlag* site_flag, + google::int32* site_default, + const char* fname, + google::int32 verbose_level); #endif // BASE_VLOG_IS_ON_H_ diff --git a/src/googletest.h b/src/googletest.h index 8a6e3eb..3d8b3c6 100644 --- a/src/googletest.h +++ b/src/googletest.h @@ -33,7 +33,7 @@ #ifdef GOOGLETEST_H__ # error You must not include this file twice. #endif -#define GOOGLETEST_H__ +#define GOOGLETEST_H_ #include #include @@ -256,7 +256,7 @@ static inline void CalledAbort() { // Benchmark tools. -#define BENCHMARK(n) static BenchmarkRegisterer __benchmark_##n(#n, &n); +#define BENCHMARK(n) static BenchmarkRegisterer __benchmark_##n(#n, &(n)); map g_benchlist; // the benchmarks to run @@ -330,7 +330,7 @@ class CapturedStream { } // Remove output redirection - void StopCapture() { + void StopCapture() const { // Restore original stream if (uncaptured_fd_ != -1) { fflush(nullptr); @@ -420,9 +420,13 @@ static inline bool IsLoggingPrefix(const string& s) { if (s.size() != kLoggingPrefixLength) { return false; } - if (!strchr("IWEF", s[0])) return false; + if (strchr("IWEF", s[0]) == nullptr) { + return false; + } for (size_t i = 1; i <= 8; ++i) { - if (!isdigit(s[i]) && s[i] != "YEARDATE"[i - 1]) return false; + if ((isdigit(s[i]) == 0) && s[i] != "YEARDATE"[i - 1]) { + return false; + } } return true; } @@ -433,7 +437,10 @@ static inline bool IsLoggingPrefix(const string& s) { // I20200102 030405 logging_unittest.cc:345] RAW: vlog -1 // => IYEARDATE TIME__ logging_unittest.cc:LINE] RAW: vlog -1 static inline string MungeLine(const string& line) { - string before, logcode_date, time, thread_lineinfo; + string before; + string logcode_date; + string time; + string thread_lineinfo; std::size_t begin_of_logging_prefix = 0; for (; begin_of_logging_prefix + kLoggingPrefixLength < line.size(); ++begin_of_logging_prefix) { @@ -444,7 +451,8 @@ static inline string MungeLine(const string& line) { } if (begin_of_logging_prefix + kLoggingPrefixLength >= line.size()) { return line; - } else if (begin_of_logging_prefix > 0) { + } + if (begin_of_logging_prefix > 0) { before = line.substr(0, begin_of_logging_prefix - 1); } std::istringstream iss(line.substr(begin_of_logging_prefix)); @@ -482,7 +490,7 @@ static inline string Munge(const string& filename) { CHECK(fp != nullptr) << filename << ": couldn't open"; char buf[4096]; string result; - while (fgets(buf, 4095, fp)) { + while (fgets(buf, 4095, fp) != nullptr) { string line = MungeLine(buf); const size_t str_size = 256; char null_str[str_size]; @@ -583,7 +591,7 @@ class Thread { public: virtual ~Thread() = default; - void SetJoinable(bool) {} + void SetJoinable(bool /*unused*/) {} #if defined(GLOG_OS_WINDOWS) && !defined(GLOG_OS_CYGWIN) void Start() { handle_ = CreateThread(nullptr, 0, &Thread::InvokeThreadW, this, 0, &th_); @@ -592,7 +600,7 @@ class Thread { void Join() { WaitForSingleObject(handle_, INFINITE); } #elif defined(HAVE_PTHREAD) void Start() { pthread_create(&th_, nullptr, &Thread::InvokeThread, this); } - void Join() { pthread_join(th_, nullptr); } + void Join() const { pthread_join(th_, nullptr); } #else void Start() {} void Join() {} @@ -638,8 +646,8 @@ void (*g_new_hook)() = nullptr; } // namespace google -void* operator new(size_t size, const std::nothrow_t&) noexcept { - if (google::g_new_hook) { +void* operator new(size_t size, const std::nothrow_t& /*unused*/) noexcept { + if (google::g_new_hook != nullptr) { google::g_new_hook(); } return malloc(size); @@ -659,8 +667,12 @@ void* operator new[](size_t size) GOOGLE_GLOG_THROW_BAD_ALLOC { void operator delete(void* p) noexcept { free(p); } -void operator delete(void* p, size_t) noexcept { ::operator delete(p); } +void operator delete(void* p, size_t /*unused*/) noexcept { + ::operator delete(p); +} void operator delete[](void* p) noexcept { ::operator delete(p); } -void operator delete[](void* p, size_t) noexcept { ::operator delete(p); } +void operator delete[](void* p, size_t /*unused*/) noexcept { + ::operator delete(p); +} diff --git a/src/logging.cc b/src/logging.cc index 4607402..82729fb 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -27,7 +27,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -#define _GNU_SOURCE 1 // needed for O_NOFOLLOW and pread()/pwrite() +enum { + GNU_SOURCE = 1 // needed for O_NOFOLLOW and pread()/pwrite() +}; #include "glog/logging.h" @@ -127,10 +129,10 @@ using std::fdopen; static bool BoolFromEnv(const char* varname, bool defval) { const char* const valstr = getenv(varname); - if (!valstr) { + if (valstr == nullptr) { return defval; } - return memchr("tTyY1\0", valstr[0], 6) != nullptr; + return strchr("tTyY1\0", valstr[0]) != nullptr; } GLOG_DEFINE_bool(timestamp_in_logfile_name, @@ -289,11 +291,14 @@ static bool TerminalSupportsColor() { const char* const term = getenv("TERM"); if (term != nullptr && term[0] != '\0') { term_supports_color = - !strcmp(term, "xterm") || !strcmp(term, "xterm-color") || - !strcmp(term, "xterm-256color") || !strcmp(term, "screen-256color") || - !strcmp(term, "konsole") || !strcmp(term, "konsole-16color") || - !strcmp(term, "konsole-256color") || !strcmp(term, "screen") || - !strcmp(term, "linux") || !strcmp(term, "cygwin"); + (strcmp(term, "xterm") == 0) || (strcmp(term, "xterm-color") == 0) || + (strcmp(term, "xterm-256color") == 0) || + (strcmp(term, "screen-256color") == 0) || + (strcmp(term, "konsole") == 0) || + (strcmp(term, "konsole-16color") == 0) || + (strcmp(term, "konsole-256color") == 0) || + (strcmp(term, "screen") == 0) || (strcmp(term, "linux") == 0) || + (strcmp(term, "cygwin") == 0); } #endif return term_supports_color; @@ -507,15 +512,16 @@ class LogCleaner { bool enabled() const { return enabled_; } private: - vector GetOverdueLogNames(string log_directory, unsigned int days, - const string& base_filename, - const string& filename_extension) const; + static vector GetOverdueLogNames(string log_directory, + unsigned int days, + const string& base_filename, + const string& filename_extension); - bool IsLogFromCurrentProject(const string& filepath, - const string& base_filename, - const string& filename_extension) const; + static bool IsLogFromCurrentProject(const string& filepath, + const string& base_filename, + const string& filename_extension); - bool IsLogLastModifiedOver(const string& filepath, unsigned int days) const; + static bool IsLogLastModifiedOver(const string& filepath, unsigned int days); bool enabled_{false}; unsigned int overdue_days_{7}; @@ -530,8 +536,9 @@ class LogDestination { public: friend class LogMessage; friend void ReprintFatalMessage(); - friend base::Logger* base::GetLogger(LogSeverity); - friend void base::SetLogger(LogSeverity, base::Logger*); + friend base::Logger* base::GetLogger(LogSeverity /*severity*/); + friend void base::SetLogger(LogSeverity /*severity*/, + base::Logger* /*logger*/); // These methods are just forwarded to by their global versions. static void SetLogDestination(LogSeverity severity, @@ -651,7 +658,7 @@ void LogDestination::SetLoggerImpl(base::Logger* logger) { return; } - if (logger_ && logger_ != &fileobject_) { + if ((logger_ != nullptr) && logger_ != &fileobject_) { // Delete user-specified logger set via SetLogger(). delete logger_; } @@ -704,7 +711,9 @@ inline void LogDestination::AddLogSink(LogSink* destination) { // Prevent any subtle race conditions by wrapping a mutex lock around // all this stuff. MutexLock l(&sink_mutex_); - if (!sinks_) sinks_ = new vector; + if (sinks_ == nullptr) { + sinks_ = new vector; + } sinks_->push_back(destination); } @@ -713,7 +722,7 @@ inline void LogDestination::RemoveLogSink(LogSink* destination) { // all this stuff. MutexLock l(&sink_mutex_); // This doesn't keep the sinks in order, but who cares? - if (sinks_) { + if (sinks_ != nullptr) { sinks_->erase(std::remove(sinks_->begin(), sinks_->end(), destination), sinks_->end()); } @@ -899,7 +908,7 @@ inline void LogDestination::LogToSinks(LogSeverity severity, const char* message, size_t message_len) { ReaderMutexLock l(&sink_mutex_); - if (sinks_) { + if (sinks_ != nullptr) { for (size_t i = sinks_->size(); i-- > 0;) { (*sinks_)[i]->send(severity, full_filename, base_filename, line, logmsgtime, message, message_len); @@ -909,7 +918,7 @@ inline void LogDestination::LogToSinks(LogSeverity severity, inline void LogDestination::WaitForSinks(LogMessage::LogMessageData* data) { ReaderMutexLock l(&sink_mutex_); - if (sinks_) { + if (sinks_ != nullptr) { for (size_t i = sinks_->size(); i-- > 0;) { (*sinks_)[i]->WaitTillSent(); } @@ -926,7 +935,7 @@ LogDestination* LogDestination::log_destinations_[NUM_SEVERITIES]; inline LogDestination* LogDestination::log_destination(LogSeverity severity) { assert(severity >= 0 && severity < NUM_SEVERITIES); - if (!log_destinations_[severity]) { + if (log_destinations_[severity] == nullptr) { log_destinations_[severity] = new LogDestination(severity, nullptr); } return log_destinations_[severity]; @@ -976,7 +985,6 @@ LogFileObject::LogFileObject(LogSeverity severity, const char* base_filename) : base_filename_selected_(base_filename != nullptr), base_filename_((base_filename != nullptr) ? base_filename : ""), symlink_basename_(glog_internal_namespace_::ProgramInvocationShortName()), - filename_extension_(), severity_(severity), @@ -1057,7 +1065,9 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) { flags = flags | O_EXCL; } int fd = open(filename, flags, static_cast(FLAGS_logfile_mode)); - if (fd == -1) return false; + if (fd == -1) { + return false; + } #ifdef HAVE_FCNTL // Mark the file close-on-exec. We don't really care if this fails fcntl(fd, F_SETFD, FD_CLOEXEC); @@ -1116,9 +1126,10 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) { const string linkname = symlink_basename_ + '.' + LogSeverityNames[severity_]; string linkpath; - if (slash) + if (slash != nullptr) { linkpath = string( filename, static_cast(slash - filename + 1)); // get dirname + } linkpath += linkname; unlink(linkpath.c_str()); // delete old one if it exists @@ -1128,7 +1139,7 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) { // We must have unistd.h. // Make the symlink be relative (in the same dir) so that if the // entire log directory gets relocated the link is still valid. - const char* linkdest = slash ? (slash + 1) : filename; + const char* linkdest = slash != nullptr ? (slash + 1) : filename; if (symlink(linkdest, linkpath.c_str()) != 0) { // silently ignore failures } @@ -1158,7 +1169,9 @@ void LogFileObject::Write(bool force_flush, time_t timestamp, } if (file_length_ >> 20U >= MaxLogSize() || PidHasChanged()) { - if (file_ != nullptr) fclose(file_); + if (file_ != nullptr) { + fclose(file_); + } file_ = nullptr; file_length_ = bytes_since_flush_ = dropped_mem_length_ = 0; rollover_attempt_ = kRolloverAttemptFrequency - 1; @@ -1169,7 +1182,9 @@ void LogFileObject::Write(bool force_flush, time_t timestamp, // Try to rollover the log file every 32 log messages. The only time // this could matter would be when we have trouble creating the log // file. If that happens, we'll lose lots of log messages, of course! - if (++rollover_attempt_ != kRolloverAttemptFrequency) return; + if (++rollover_attempt_ != kRolloverAttemptFrequency) { + return; + } rollover_attempt_ = 0; struct ::tm tm_time; @@ -1217,7 +1232,9 @@ void LogFileObject::Write(bool force_flush, time_t timestamp, // called after holding on to log_mutex. We don't want to // attempt to hold on to the same mutex, and get into a // deadlock. Simply use a name like invalid-user. - if (uidname.empty()) uidname = "invalid-user"; + if (uidname.empty()) { + uidname = "invalid-user"; + } stripped_filename = stripped_filename + '.' + hostname + '.' + uidname + ".log." + LogSeverityNames[severity_] + '.'; @@ -1235,7 +1252,7 @@ void LogFileObject::Write(bool force_flush, time_t timestamp, } } // If we never succeeded, we have to give up - if (success == false) { + if (!success) { perror("Could not create logging file"); fprintf(stderr, "COULD NOT CREATE A LOGGINGFILE %s!", time_pid_string.c_str()); @@ -1291,10 +1308,10 @@ void LogFileObject::Write(bool force_flush, time_t timestamp, errno == ENOSPC) { // disk full, stop writing to disk stop_writing = true; // until the disk is return; - } else { - file_length_ += message_len; - bytes_since_flush_ += message_len; } + file_length_ += message_len; + bytes_since_flush_ += message_len; + } else { if (CycleClock_Now() >= next_flush_time_) { stop_writing = false; // check to see if disk has free space. @@ -1389,7 +1406,7 @@ void LogCleaner::Run(bool base_filename_selected, const string& base_filename, vector LogCleaner::GetOverdueLogNames( string log_directory, unsigned int days, const string& base_filename, - const string& filename_extension) const { + const string& filename_extension) { // The names of overdue logs. vector overdue_log_names; @@ -1397,8 +1414,8 @@ vector LogCleaner::GetOverdueLogNames( DIR* dir; struct dirent* ent; - if ((dir = opendir(log_directory.c_str()))) { - while ((ent = readdir(dir))) { + if ((dir = opendir(log_directory.c_str())) != nullptr) { + while ((ent = readdir(dir)) != nullptr) { if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) { continue; } @@ -1425,9 +1442,9 @@ vector LogCleaner::GetOverdueLogNames( return overdue_log_names; } -bool LogCleaner::IsLogFromCurrentProject( - const string& filepath, const string& base_filename, - const string& filename_extension) const { +bool LogCleaner::IsLogFromCurrentProject(const string& filepath, + const string& base_filename, + const string& filename_extension) { // We should remove duplicated delimiters from `base_filename`, e.g., // before: "/tmp//.." // after: "/tmp/.." @@ -1513,7 +1530,7 @@ bool LogCleaner::IsLogFromCurrentProject( } bool LogCleaner::IsLogLastModifiedOver(const string& filepath, - unsigned int days) const { + unsigned int days) { // Try to get the last modified time of this file. struct stat file_stat; @@ -1783,7 +1800,7 @@ static time_t fatal_time; static char fatal_message[256]; void ReprintFatalMessage() { - if (fatal_message[0]) { + if (fatal_message[0] != 0) { const size_t n = strlen(fatal_message); if (!FLAGS_logtostderr) { // Also write to stderr (don't color to avoid terminal checks) @@ -1868,7 +1885,7 @@ void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) { if (!FLAGS_logtostderr && !FLAGS_logtostdout) { for (auto& log_destination : LogDestination::log_destinations_) { - if (log_destination) { + if (log_destination != nullptr) { log_destination->logger_->Write(true, 0, "", 0); } } @@ -2018,7 +2035,7 @@ int64 LogMessage::num_messages(int severity) { // Output the COUNTER value. This is only valid if ostream is a // LogStream. -ostream& operator<<(ostream& os, const PRIVATE_Counter&) { +ostream& operator<<(ostream& os, const PRIVATE_Counter& /*unused*/) { #ifdef DISABLE_RTTI LogMessage::LogStream* log = static_cast(&os); #else @@ -2218,7 +2235,7 @@ static inline void trim(std::string& s) { static bool SendEmailInternal(const char* dest, const char* subject, const char* body, bool use_logging) { #ifndef GLOG_OS_EMSCRIPTEN - if (dest && *dest) { + if ((dest != nullptr) && (*dest != 0)) { // Split the comma-separated list of email addresses, validate each one and // build a sanitized new comma-separated string without whitespace. std::istringstream ss(dest); @@ -2286,7 +2303,7 @@ static bool SendEmailInternal(const char* dest, const char* subject, FILE* pipe = popen(cmd.c_str(), "w"); if (pipe != nullptr) { // Add the body if we have one - if (body) { + if (body != nullptr) { fwrite(body, sizeof(char), strlen(body), pipe); } bool ok = pclose(pipe) != -1; @@ -2300,12 +2317,11 @@ static bool SendEmailInternal(const char* dest, const char* subject, } } return ok; + } + if (use_logging) { + LOG(ERROR) << "Unable to send mail to " << dest; } else { - if (use_logging) { - LOG(ERROR) << "Unable to send mail to " << dest; - } else { - fprintf(stderr, "Unable to send mail to %s\n", dest); - } + fprintf(stderr, "Unable to send mail to %s\n", dest); } } #else @@ -2350,8 +2366,10 @@ static void GetTempDirectories(vector* list) { "/tmp", }; - for (auto d : candidates) { - if (!d) continue; // Empty env var + for (const auto* d : candidates) { + if (d == nullptr) { + continue; // Empty env var + } // Make sure we don't surprise anyone who's expecting a '/' string dstr = d; @@ -2361,7 +2379,7 @@ static void GetTempDirectories(vector* list) { list->push_back(dstr); struct stat statbuf; - if (!stat(d, &statbuf) && S_ISDIR(statbuf.st_mode)) { + if ((stat(d, &statbuf) == 0) && S_ISDIR(statbuf.st_mode)) { // We found a dir that exists - we're done. return; } @@ -2415,7 +2433,7 @@ void GetExistingTempDirectories(vector* list) { while (i_dir != list->end()) { // zero arg to access means test for existence; no constant // defined on windows - if (access(i_dir->c_str(), 0)) { + if (access(i_dir->c_str(), 0) != 0) { i_dir = list->erase(i_dir); } else { ++i_dir; @@ -2428,13 +2446,17 @@ void TruncateLogFile(const char* path, uint64 limit, uint64 keep) { struct stat statbuf; const int kCopyBlockSize = 8 << 10; char copybuf[kCopyBlockSize]; - off_t read_offset, write_offset; + off_t read_offset; + off_t write_offset; // Don't follow symlinks unless they're our own fd symlinks in /proc int flags = O_RDWR; // TODO(hamaji): Support other environments. # ifdef GLOG_OS_LINUX const char* procfd_prefix = "/proc/self/fd/"; - if (strncmp(procfd_prefix, path, strlen(procfd_prefix))) flags |= O_NOFOLLOW; + if (static_cast(strncmp(procfd_prefix, path, strlen(procfd_prefix)) != + 0) != 0) { + flags |= O_NOFOLLOW; + } # endif int fd = open(path, flags); @@ -2467,9 +2489,15 @@ void TruncateLogFile(const char* path, uint64 limit, uint64 keep) { // See if the path refers to a regular file bigger than the // specified limit - if (!S_ISREG(statbuf.st_mode)) goto out_close_fd; - if (statbuf.st_size <= static_cast(limit)) goto out_close_fd; - if (statbuf.st_size <= static_cast(keep)) goto out_close_fd; + if (!S_ISREG(statbuf.st_mode)) { + goto out_close_fd; + } + if (statbuf.st_size <= static_cast(limit)) { + goto out_close_fd; + } + if (statbuf.st_size <= static_cast(keep)) { + goto out_close_fd; + } // This log file is too large - we need to truncate it LOG(INFO) << "Truncating " << path << " to " << keep << " bytes"; @@ -2477,19 +2505,23 @@ void TruncateLogFile(const char* path, uint64 limit, uint64 keep) { // Copy the last "keep" bytes of the file to the beginning of the file read_offset = statbuf.st_size - static_cast(keep); write_offset = 0; - ssize_t bytesin, bytesout; + ssize_t bytesin; + ssize_t bytesout; while ((bytesin = pread(fd, copybuf, sizeof(copybuf), read_offset)) > 0) { bytesout = pwrite(fd, copybuf, static_cast(bytesin), write_offset); if (bytesout == -1) { PLOG(ERROR) << "Unable to write to " << path; break; - } else if (bytesout != bytesin) { + } + if (bytesout != bytesin) { LOG(ERROR) << "Expected to write " << bytesin << ", wrote " << bytesout; } read_offset += bytesin; write_offset += bytesout; } - if (bytesin == -1) PLOG(ERROR) << "Unable to read from " << path; + if (bytesin == -1) { + PLOG(ERROR) << "Unable to read from " << path; + } // Truncate the remainder of the file. If someone else writes to the // end of the file after our last read() above, we lose their latest @@ -2525,7 +2557,7 @@ void TruncateStdoutStderr() { string* Check##func##expected##Impl(const char* s1, const char* s2, \ const char* names) { \ bool equal = s1 == s2 || (s1 && s2 && !func(s1, s2)); \ - if (equal == expected) \ + if (equal == (expected)) \ return nullptr; \ else { \ ostringstream ss; \ @@ -2571,25 +2603,22 @@ int posix_strerror_r(int err, char* buf, size_t len) { // If the function succeeded, we can use its exit code to determine the // semantics implemented by glibc - if (!rc) { + if (rc == nullptr) { return 0; - } else { - // GNU semantics detected - if (rc == buf) { - return 0; - } else { - buf[0] = '\000'; + } // GNU semantics detected + if (rc == buf) { + return 0; + } + buf[0] = '\000'; #if defined(GLOG_OS_MACOSX) || defined(GLOG_OS_FREEBSD) || \ defined(GLOG_OS_OPENBSD) - if (reinterpret_cast(rc) < sys_nerr) { - // This means an error on MacOSX or FreeBSD. - return -1; - } -#endif - strncat(buf, rc, len - 1); - return 0; - } + if (reinterpret_cast(rc) < sys_nerr) { + // This means an error on MacOSX or FreeBSD. + return -1; } +#endif + strncat(buf, rc, len - 1); + return 0; } string StrError(int err) { @@ -2733,8 +2762,8 @@ void LogMessageTime::CalcGmtOffset() { const long hour_secs = 3600; // If the Daylight Saving Time(isDst) is active subtract an hour from the // current timestamp. - gmtoffset_ = - static_cast(timestamp_ - gmt_sec + (isDst ? hour_secs : 0)); + gmtoffset_ = static_cast(timestamp_ - gmt_sec + + (isDst != 0 ? hour_secs : 0)); } } // namespace google diff --git a/src/logging_unittest.cc b/src/logging_unittest.cc index 6c254f1..f9d70fb 100644 --- a/src/logging_unittest.cc +++ b/src/logging_unittest.cc @@ -137,14 +137,30 @@ static void CheckFailure(int a, int b, const char* file, int line, const char* msg); static void BM_Check3(int n) { while (n-- > 0) { - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); - if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } + if (n < x) { + CheckFailure(n, x, __FILE__, __LINE__, "n < x"); + } } } BENCHMARK(BM_Check3) @@ -166,8 +182,8 @@ static void BM_Check2(int n) { } BENCHMARK(BM_Check2) -static void CheckFailure(int, int, const char* /* file */, int /* line */, - const char* /* msg */) {} +static void CheckFailure(int /*unused*/, int /*unused*/, const char* /* file */, + int /* line */, const char* /* msg */) {} static void BM_logspeed(int n) { while (n-- > 0) { @@ -969,8 +985,10 @@ static void TestOneTruncate(const char* path, uint64 limit, uint64 keep, int fd; CHECK_ERR(fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0600)); - const char *discardstr = "DISCARDME!", *keepstr = "KEEPME!"; - const size_t discard_size = strlen(discardstr), keep_size = strlen(keepstr); + const char* discardstr = "DISCARDME!"; + const char* keepstr = "KEEPME!"; + const size_t discard_size = strlen(discardstr); + const size_t keep_size = strlen(keepstr); // Fill the file with the requested data; first discard data, then kept data size_t written = 0; @@ -1296,7 +1314,7 @@ class TestWaitingLogSink : public LogSink { // Push it to Writer thread if we are the original logging thread. // Note: Something like ThreadLocalLogSink is a better choice // to do thread-specific LogSink logic for real. - if (pthread_equal(tid_, pthread_self())) { + if (pthread_equal(tid_, pthread_self()) != 0) { writer_.Buffer(ToString(severity, base_filename, line, logmsgtime, message, message_len)); } @@ -1304,7 +1322,9 @@ class TestWaitingLogSink : public LogSink { void WaitTillSent() override { // Wait for Writer thread if we are the original logging thread. - if (pthread_equal(tid_, pthread_self())) writer_.Wait(); + if (pthread_equal(tid_, pthread_self()) != 0) { + writer_.Wait(); + } } private: @@ -1495,10 +1515,10 @@ TEST(LogBacktraceAt, DoesBacktraceAtRightLineWhenEnabled) { #endif // HAVE_LIB_GMOCK struct UserDefinedClass { - bool operator==(const UserDefinedClass&) const { return true; } + bool operator==(const UserDefinedClass& /*unused*/) const { return true; } }; -inline ostream& operator<<(ostream& out, const UserDefinedClass&) { +inline ostream& operator<<(ostream& out, const UserDefinedClass& /*unused*/) { out << "OK"; return out; } diff --git a/src/raw_logging.cc b/src/raw_logging.cc index b27e201..1d85368 100644 --- a/src/raw_logging.cc +++ b/src/raw_logging.cc @@ -58,7 +58,6 @@ # include // for syscall() #endif #ifdef HAVE_UNISTD_H -# include #endif #if (defined(HAVE_SYSCALL_H) || defined(HAVE_SYS_SYSCALL_H)) && \ @@ -96,7 +95,9 @@ static bool DoRawLog(char** buf, size_t* size, const char* format, ...) { va_start(ap, format); int n = std::vsnprintf(*buf, *size, format, ap); va_end(ap); - if (n < 0 || static_cast(n) > *size) return false; + if (n < 0 || static_cast(n) > *size) { + return false; + } *size -= static_cast(n); *buf += n; return true; @@ -113,7 +114,9 @@ inline static bool VADoRawLog(char** buf, size_t* size, const char* format, #if defined(__GNUC__) # pragma GCC diagnostic pop #endif - if (n < 0 || static_cast(n) > *size) return false; + if (n < 0 || static_cast(n) > *size) { + return false; + } *size -= static_cast(n); *buf += n; return true; @@ -125,11 +128,11 @@ static CrashReason crash_reason; static char crash_buf[kLogBufSize + 1] = {0}; // Will end in '\0' GLOG_ATTRIBUTE_FORMAT(printf, 4, 5) -void RawLog__(LogSeverity severity, const char* file, int line, - const char* format, ...) { - if (!(FLAGS_logtostdout || FLAGS_logtostderr || - severity >= FLAGS_stderrthreshold || FLAGS_alsologtostderr || - !IsGoogleLoggingInitialized())) { +void RawLog_(LogSeverity severity, const char* file, int line, + const char* format, ...) { + if (!FLAGS_logtostdout && !FLAGS_logtostderr && + severity < FLAGS_stderrthreshold && !FLAGS_alsologtostderr && + IsGoogleLoggingInitialized()) { return; // this stderr log message is suppressed } // can't call localtime_r here: it can allocate diff --git a/src/signalhandler.cc b/src/signalhandler.cc index 2c3ec6d..6c62070 100644 --- a/src/signalhandler.cc +++ b/src/signalhandler.cc @@ -71,7 +71,7 @@ const struct { {SIGTERM, "SIGTERM"}, }; -static bool kFailureSignalHandlerInstalled = false; +bool kFailureSignalHandlerInstalled = false; #if !defined(GLOG_OS_WINDOWS) // Returns the program counter from signal context, nullptr if unknown. @@ -79,7 +79,7 @@ void* GetPC(void* ucontext_in_void) { # if (defined(HAVE_UCONTEXT_H) || defined(HAVE_SYS_UCONTEXT_H)) && \ defined(PC_FROM_UCONTEXT) if (ucontext_in_void != nullptr) { - ucontext_t* context = reinterpret_cast(ucontext_in_void); + auto* context = reinterpret_cast(ucontext_in_void); return (void*)context->PC_FROM_UCONTEXT; } # else @@ -192,7 +192,7 @@ void DumpSignalInfo(int signal_number, siginfo_t* siginfo) { MinimalFormatter formatter(buf, sizeof(buf)); formatter.AppendString("*** "); - if (signal_name) { + if (signal_name != nullptr) { formatter.AppendString(signal_name); } else { // Use the signal number if the name is unknown. The signal name @@ -270,7 +270,7 @@ void InvokeDefaultSignalHandler(int signal_number) { // dumping stuff while another thread is doing it. Our policy is to let // the first thread dump stuff and let other threads wait. // See also comments in FailureSignalHandler(). -static pthread_t* g_entered_thread_id_pointer = nullptr; +pthread_t* g_entered_thread_id_pointer = nullptr; // Dumps signal and stack frame information, and invokes the default // signal handler once our job is done. @@ -299,7 +299,7 @@ void FailureSignalHandler(int signal_number, siginfo_t* signal_info, &my_thread_id); if (old_thread_id_pointer != nullptr) { // We've already entered the signal handler. What should we do? - if (pthread_equal(my_thread_id, *g_entered_thread_id_pointer)) { + if (pthread_equal(my_thread_id, *g_entered_thread_id_pointer) != 0) { // It looks the current thread is reentering the signal handler. // Something must be going wrong (maybe we are reentering by another // type of signal?). Kill ourself by the default signal handler. diff --git a/src/signalhandler_unittest.cc b/src/signalhandler_unittest.cc index 06c169e..6184087 100644 --- a/src/signalhandler_unittest.cc +++ b/src/signalhandler_unittest.cc @@ -51,7 +51,7 @@ using namespace GFLAGS_NAMESPACE; using namespace google; -static void* DieInThread(void*) { +static void* DieInThread(void* /*unused*/) { // We assume pthread_t is an integral number or a pointer, rather // than a complex struct. In some environments, pthread_self() // returns an uint64 but in some other environments pthread_self() @@ -89,8 +89,9 @@ int main(int argc, char** argv) { *a = 0; } else if (command == "loop") { fprintf(stderr, "looping\n"); - while (true) + while (true) { ; + } } else if (command == "die_in_thread") { # if defined(HAVE_PTHREAD) pthread_t thread; diff --git a/src/stacktrace_powerpc-inl.h b/src/stacktrace_powerpc-inl.h index 168f472..be0d46a 100644 --- a/src/stacktrace_powerpc-inl.h +++ b/src/stacktrace_powerpc-inl.h @@ -55,20 +55,28 @@ static void** NextStackFrame(void** old_sp) { if (STRICT_UNWINDING) { // With the stack growing downwards, older stack frame must be // at a greater address that the current one. - if (new_sp <= old_sp) return nullptr; + if (new_sp <= old_sp) { + return nullptr; + } // Assume stack frames larger than 100,000 bytes are bogus. - if ((uintptr_t)new_sp - (uintptr_t)old_sp > 100000) return nullptr; + if ((uintptr_t)new_sp - (uintptr_t)old_sp > 100000) { + return nullptr; + } } else { // In the non-strict mode, allow discontiguous stack frames. // (alternate-signal-stacks for example). - if (new_sp == old_sp) return nullptr; + if (new_sp == old_sp) { + return nullptr; + } // And allow frames upto about 1MB. if ((new_sp > old_sp) && ((uintptr_t)new_sp - (uintptr_t)old_sp > 1000000)) { return nullptr; } } - if ((uintptr_t)new_sp & (sizeof(void*) - 1)) return nullptr; + if ((uintptr_t)new_sp & (sizeof(void*) - 1)) { + return nullptr; + } return new_sp; } @@ -102,7 +110,7 @@ int GetStackTrace(void** result, int max_depth, int skip_count) { skip_count++; int n = 0; - while (sp && n < max_depth) { + while ((sp != nullptr) && n < max_depth) { if (skip_count > 0) { skip_count--; } else { diff --git a/src/stacktrace_unittest.cc b/src/stacktrace_unittest.cc index 9060a2a..c4eb475 100644 --- a/src/stacktrace_unittest.cc +++ b/src/stacktrace_unittest.cc @@ -123,7 +123,7 @@ static void CheckRetAddrIsInFunction(void* ret_addr, # pragma clang diagnostic ignored "-Wgnu-label-as-value" # endif -void ATTRIBUTE_NOINLINE CheckStackTrace(int); +void ATTRIBUTE_NOINLINE CheckStackTrace(int /*i*/); static void ATTRIBUTE_NOINLINE CheckStackTraceLeaf() { const int STACK_LEN = 10; void* stack[STACK_LEN]; @@ -229,7 +229,7 @@ static //-----------------------------------------------------------------------// -int main(int, char** argv) { +int main(int /*unused*/, char** argv) { FLAGS_logtostderr = true; InitGoogleLogging(argv[0]); diff --git a/src/stacktrace_x86-inl.h b/src/stacktrace_x86-inl.h index 3ca9f68..902e8a7 100644 --- a/src/stacktrace_x86-inl.h +++ b/src/stacktrace_x86-inl.h @@ -57,7 +57,9 @@ static void** NextStackFrame(void** old_sp) { if (STRICT_UNWINDING) { // With the stack growing downwards, older stack frame must be // at a greater address that the current one. - if (new_sp <= old_sp) return nullptr; + if (new_sp <= old_sp) { + return nullptr; + } // Assume stack frames larger than 100,000 bytes are bogus. if (reinterpret_cast(new_sp) - reinterpret_cast(old_sp) > @@ -67,7 +69,9 @@ static void** NextStackFrame(void** old_sp) { } else { // In the non-strict mode, allow discontiguous stack frames. // (alternate-signal-stacks for example). - if (new_sp == old_sp) return nullptr; + if (new_sp == old_sp) { + return nullptr; + } // And allow frames upto about 1MB. if ((new_sp > old_sp) && (reinterpret_cast(new_sp) - reinterpret_cast(old_sp) > @@ -139,7 +143,7 @@ int GetStackTrace(void** result, int max_depth, int skip_count) { #endif int n = 0; - while (sp && n < max_depth) { + while ((sp != nullptr) && n < max_depth) { if (*(sp + 1) == nullptr) { // In 64-bit code, we often see a frame that // points to itself and has a return address of 0. diff --git a/src/stl_logging_unittest.cc b/src/stl_logging_unittest.cc index 5a8ae2a..ab49c2b 100644 --- a/src/stl_logging_unittest.cc +++ b/src/stl_logging_unittest.cc @@ -79,7 +79,9 @@ static void TestSTLLogging() { string expected; for (int i = 0; i < 100; i++) { v.push_back(i); - if (i > 0) expected += ' '; + if (i > 0) { + expected += ' '; + } const size_t buf_size = 256; char buf[buf_size]; std::snprintf(buf, buf_size, "%d", i); @@ -107,7 +109,7 @@ static void TestSTLLogging() { } } -int main(int, char**) { +int main(int /*unused*/, char** /*unused*/) { TestSTLLogging(); std::cout << "PASS\n"; return 0; diff --git a/src/striplog_unittest.cc b/src/striplog_unittest.cc index 086ea31..5f1eefb 100644 --- a/src/striplog_unittest.cc +++ b/src/striplog_unittest.cc @@ -51,19 +51,18 @@ int CheckNoReturn(bool b) { if (b) { LOG(FATAL) << "Fatal"; return 0; // Workaround for MSVC warning C4715 - } else { - return 0; } + return 0; } struct A {}; -std::ostream& operator<<(std::ostream& str, const A&) { return str; } +std::ostream& operator<<(std::ostream& str, const A& /*unused*/) { return str; } namespace { void handle_abort(int /*code*/) { std::exit(EXIT_FAILURE); } } // namespace -int main(int, char* argv[]) { +int main(int /*unused*/, char* argv[]) { #if defined(_MSC_VER) // Avoid presenting an interactive dialog that will cause the test to time // out. @@ -74,7 +73,7 @@ int main(int, char* argv[]) { FLAGS_logtostderr = true; InitGoogleLogging(argv[0]); if (FLAGS_check_mode) { - printf("%s\n", DEBUG_MODE ? "dbg" : "opt"); + printf("%s\n", DEBUG_MODE != 0U ? "dbg" : "opt"); return 0; } LOG(INFO) << "TESTMESSAGE INFO"; diff --git a/src/symbolize.cc b/src/symbolize.cc index 4ef2926..2fddc77 100644 --- a/src/symbolize.cc +++ b/src/symbolize.cc @@ -264,7 +264,8 @@ bool GetSectionHeaderByName(int fd, const char* name, size_t name_len, ssize_t n_read = ReadFromOffset(fd, &header_name, name_len, name_offset); if (n_read == -1) { return false; - } else if (static_cast(n_read) != name_len) { + } + if (static_cast(n_read) != name_len) { // Short read -- name could be at end of file. continue; } @@ -386,7 +387,7 @@ struct FileDescriptor { close(fd_); } } - int get() { return fd_; } + int get() const { return fd_; } private: FileDescriptor(const FileDescriptor&) = delete; @@ -613,7 +614,7 @@ static ATTRIBUTE_NOINLINE int OpenObjectFileContainingPcAndGetStartAddress( } // Check start and end addresses. - if (!(start_address <= pc && pc < end_address)) { + if (start_address > pc || pc >= end_address) { continue; // We skip this map. PC isn't in this map. } @@ -760,7 +761,7 @@ static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* out, out[0] = '\0'; SafeAppendString("(", out, out_size); - if (g_symbolize_open_object_file_callback) { + if (g_symbolize_open_object_file_callback != nullptr) { object_fd = g_symbolize_open_object_file_callback( pc0, start_address, base_address, out + 1, out_size - 1); } else { @@ -776,7 +777,7 @@ static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* out, // Check whether a file name was returned. if (object_fd < 0) { # endif - if (out[1]) { + if (out[1] != 0) { // The object file containing PC was determined successfully however the // object file was not opened successfully. This is still considered // success because the object file name and offset are known and tools @@ -794,7 +795,7 @@ static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* out, if (elf_type == -1) { return false; } - if (g_symbolize_callback) { + if (g_symbolize_callback != nullptr) { // Run the call back if it's installed. // Note: relocation (and much of the rest of this code) will be // wrong for prelinked shared libraries and PIE executables. @@ -808,7 +809,7 @@ static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* out, } if (!GetSymbolFromObjectFile(wrapped_object_fd.get(), pc0, out, out_size, base_address)) { - if (out[1] && !g_symbolize_callback) { + if ((out[1] != 0) && (g_symbolize_callback == nullptr)) { // The object file containing PC was opened successfully however the // symbol was not found. The object may have been stripped. This is still // considered success because the object file name and offset are known diff --git a/src/symbolize_unittest.cc b/src/symbolize_unittest.cc index c6a03c9..ee3d35f 100644 --- a/src/symbolize_unittest.cc +++ b/src/symbolize_unittest.cc @@ -66,9 +66,8 @@ static const char* TrySymbolize(void* pc) { static char symbol[4096]; if (Symbolize(pc, symbol, sizeof(symbol))) { return symbol; - } else { - return nullptr; } + return nullptr; } # endif @@ -237,7 +236,8 @@ static const char* SymbolizeStackConsumption(void* pc, int* stack_consumed) { // Set up SIGUSR1 and SIGUSR2 signal handlers (and save the older ones). struct sigaction sa; memset(&sa, 0, sizeof(struct sigaction)); - struct sigaction old_sa1, old_sa2; + struct sigaction old_sa1; + struct sigaction old_sa2; sigemptyset(&sa.sa_mask); sa.sa_flags = SA_ONSTACK; diff --git a/src/utilities.cc b/src/utilities.cc index 20ee02d..3d6a945 100644 --- a/src/utilities.cc +++ b/src/utilities.cc @@ -90,7 +90,7 @@ using DebugWriter = void(const char*, void*); // For some environments, add two extra bytes for the leading "0x". static const int kPrintfPointerFieldWidth = 2 + 2 * sizeof(void*); -static void DebugWriteToStderr(const char* data, void*) { +static void DebugWriteToStderr(const char* data, void* /*unused*/) { // This one is signal-safe. if (write(STDERR_FILENO, data, strlen(data)) < 0) { // Ignore errors. @@ -188,10 +188,8 @@ namespace glog_internal_namespace_ { const char* ProgramInvocationShortName() { if (g_program_invocation_short_name != nullptr) { return g_program_invocation_short_name; - } else { - // TODO(hamaji): Use /proc/self/cmdline and so? - return "UNKNOWN"; - } + } // TODO(hamaji): Use /proc/self/cmdline and so? + return "UNKNOWN"; } #ifdef GLOG_OS_WINDOWS @@ -304,7 +302,7 @@ const char* const_basename(const char* filepath) { #ifdef GLOG_OS_WINDOWS // Look for either path separator in Windows if (!base) base = strrchr(filepath, '\\'); #endif - return base ? (base + 1) : filepath; + return base != nullptr ? (base + 1) : filepath; } static string g_my_user_name; @@ -325,7 +323,7 @@ static void MyUserNameInitializer() { char buffer[1024] = {'\0'}; uid_t uid = geteuid(); int pwuid_res = getpwuid_r(uid, &pwd, buffer, sizeof(buffer), &result); - if (pwuid_res == 0 && result) { + if (pwuid_res == 0 && (result != nullptr)) { g_my_user_name = pwd.pw_name; } else { std::snprintf(buffer, sizeof(buffer), "uid%d", uid); @@ -361,7 +359,7 @@ void InitGoogleLoggingUtilities(const char* argv0) { #ifdef GLOG_OS_WINDOWS if (!slash) slash = strrchr(argv0, '\\'); #endif - g_program_invocation_short_name = slash ? slash + 1 : argv0; + g_program_invocation_short_name = slash != nullptr ? slash + 1 : argv0; #ifdef HAVE_STACKTRACE InstallFailureFunction(&DumpStackTraceAndExit); diff --git a/src/utilities.h b/src/utilities.h index f19c630..843da86 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -31,12 +31,12 @@ // // Define utilities for glog internal usage. -#ifndef UTILITIES_H__ -#define UTILITIES_H__ +#ifndef UTILITIES_H_ +#define UTILITIES_H_ // printf macros for size_t, in the style of inttypes.h #ifdef _LP64 -# define __PRIS_PREFIX "z" +# define PRIS_PREFIX "z" #else # define __PRIS_PREFIX #endif @@ -234,4 +234,4 @@ void ShutdownGoogleLoggingUtilities(); using namespace google::glog_internal_namespace_; -#endif // UTILITIES_H__ +#endif // UTILITIES_H_ diff --git a/src/vlog_is_on.cc b/src/vlog_is_on.cc index b514acf..62c1cdb 100644 --- a/src/vlog_is_on.cc +++ b/src/vlog_is_on.cc @@ -78,16 +78,24 @@ GLOG_EXPORT bool SafeFNMatch_(const char* pattern, size_t patt_len, size_t p = 0; size_t s = 0; while (true) { - if (p == patt_len && s == str_len) return true; - if (p == patt_len) return false; - if (s == str_len) return p + 1 == patt_len && pattern[p] == '*'; + if (p == patt_len && s == str_len) { + return true; + } + if (p == patt_len) { + return false; + } + if (s == str_len) { + return p + 1 == patt_len && pattern[p] == '*'; + } if (pattern[p] == str[s] || pattern[p] == '?') { p += 1; s += 1; continue; } if (pattern[p] == '*') { - if (p + 1 == patt_len) return true; + if (p + 1 == patt_len) { + return true; + } do { if (SafeFNMatch_(pattern + (p + 1), patt_len - (p + 1), str + s, str_len - s)) { @@ -147,7 +155,7 @@ static void VLOG2Initializer() { auto* info = new VModuleInfo; info->module_pattern = pattern; info->vlog_level = module_level; - if (head) { + if (head != nullptr) { tail->next = info; } else { head = info; @@ -156,10 +164,12 @@ static void VLOG2Initializer() { } // Skip past this entry vmodule = strchr(sep, ','); - if (vmodule == nullptr) break; + if (vmodule == nullptr) { + break; + } vmodule++; // Skip past "," } - if (head) { // Put them into the list at the head: + if (head != nullptr) { // Put them into the list at the head: tail->next = vmodule_list; vmodule_list = head; } @@ -200,7 +210,7 @@ int SetVLOGLevel(const char* module_pattern, int log_level) { // We traverse the list fully because the pattern can match several items // from the list. - while (item) { + while (item != nullptr) { if (SafeFNMatch_(module_pattern, pattern_len, item->base_name, item->base_len)) { // Redirect the cached value to its module override. @@ -219,8 +229,8 @@ int SetVLOGLevel(const char* module_pattern, int log_level) { // NOTE: Individual VLOG statements cache the integer log level pointers. // NOTE: This function must not allocate memory or require any locks. -bool InitVLOG3__(SiteFlag* site_flag, int32* level_default, const char* fname, - int32 verbose_level) { +bool InitVLOG3_(SiteFlag* site_flag, int32* level_default, const char* fname, + int32 verbose_level) { MutexLock l(&vmodule_lock); bool read_vmodule_flag = inited_vmodule; if (!read_vmodule_flag) { @@ -243,10 +253,10 @@ bool InitVLOG3__(SiteFlag* site_flag, int32* level_default, const char* fname, } #endif - base = base ? (base + 1) : fname; + base = base != nullptr ? (base + 1) : fname; const char* base_end = strchr(base, '.'); size_t base_length = - base_end ? static_cast(base_end - base) : strlen(base); + base_end != nullptr ? static_cast(base_end - base) : strlen(base); // Trim out trailing "-inl" if any if (base_length >= 4 && (memcmp(base + base_length - 4, "-inl", 4) == 0)) { @@ -280,7 +290,7 @@ bool InitVLOG3__(SiteFlag* site_flag, int32* level_default, const char* fname, // SetVModule is called afterwards with new modules. // The performance penalty here is neglible, because InitVLOG3__ is called // once per site. - if (site_flag_value == level_default && !site_flag->base_name) { + if (site_flag_value == level_default && (site_flag->base_name == nullptr)) { site_flag->base_name = base; site_flag->base_len = base_length; site_flag->next = cached_site_list; diff --git a/src/windows/dirent.h b/src/windows/dirent.h index 7e818ef..9441d0e 100644 --- a/src/windows/dirent.h +++ b/src/windows/dirent.h @@ -37,10 +37,10 @@ #include /* Indicates that d_type field is available in dirent structure */ -#define _DIRENT_HAVE_D_TYPE +#define DIRENT_HAVE_D_TYPE /* Indicates that d_namlen field is available in dirent structure */ -#define _DIRENT_HAVE_D_NAMLEN +#define DIRENT_HAVE_D_NAMLEN /* Entries missing from MSVC 6.0 */ #if !defined(FILE_ATTRIBUTE_DEVICE) @@ -206,10 +206,10 @@ #endif /* Return the exact length of the file name without zero terminator */ -#define _D_EXACT_NAMLEN(p) ((p)->d_namlen) +#define D_EXACT_NAMLEN(p) ((p)->d_namlen) /* Return the maximum size of a file name */ -#define _D_ALLOC_NAMLEN(p) ((PATH_MAX) + 1) +#define D_ALLOC_NAMLEN(p) ((PATH_MAX) + 1) #ifdef __cplusplus extern "C" { @@ -345,7 +345,7 @@ static _WDIR* _wopendir(const wchar_t* dirname) { /* Allocate new _WDIR structure */ dirp = (_WDIR*)malloc(sizeof(struct _WDIR)); - if (!dirp) { + if (dirp == nullptr) { return nullptr; } @@ -507,7 +507,7 @@ static int _wreaddir_r(_WDIR* dirp, struct _wdirent* entry, */ static int _wclosedir(_WDIR* dirp) { int ok; - if (dirp) { + if (dirp != nullptr) { /* Release search handle */ if (dirp->handle != INVALID_HANDLE_VALUE) { FindClose(dirp->handle); @@ -533,7 +533,7 @@ static int _wclosedir(_WDIR* dirp) { * file name again. */ static void _wrewinddir(_WDIR* dirp) { - if (dirp) { + if (dirp != nullptr) { /* Release existing search handle */ if (dirp->handle != INVALID_HANDLE_VALUE) { FindClose(dirp->handle); @@ -632,7 +632,7 @@ static DIR* opendir(const char* dirname) { /* Allocate memory for DIR structure */ dirp = (DIR*)malloc(sizeof(struct DIR)); - if (!dirp) { + if (dirp == nullptr) { return nullptr; } { @@ -642,7 +642,7 @@ static DIR* opendir(const char* dirname) { /* Convert directory name to wide-character string */ error = dirent_mbstowcs_s(&n, wname, PATH_MAX + 1, dirname, PATH_MAX + 1); - if (error) { + if (error != 0) { /* * Cannot convert file name to wide-character string. This * occurs if the string contains invalid multi-byte sequences or @@ -654,7 +654,7 @@ static DIR* opendir(const char* dirname) { /* Open directory stream using wide-character name */ dirp->wdirp = _wopendir(wname); - if (!dirp->wdirp) { + if (dirp->wdirp == nullptr) { goto exit_free; } } @@ -718,7 +718,7 @@ static int readdir_r(DIR* dirp, struct dirent* entry, struct dirent** result) { datap->cAlternateFileName, PATH_MAX + 1); } - if (!error) { + if (error == 0) { DWORD attr; /* Length of file name excluding zero terminator */ @@ -771,7 +771,7 @@ static int readdir_r(DIR* dirp, struct dirent* entry, struct dirent** result) { */ static int closedir(DIR* dirp) { int ok; - if (dirp) { + if (dirp != nullptr) { /* Close wide-character directory stream */ ok = _wclosedir(dirp->wdirp); dirp->wdirp = nullptr; @@ -814,7 +814,7 @@ static int scandir(const char* dirname, struct dirent*** namelist, /* Open directory stream */ dir = opendir(dirname); - if (dir) { + if (dir != nullptr) { /* Read directory entries to memory */ while (1) { /* Enlarge pointer table to make room for another pointer */ @@ -861,7 +861,7 @@ static int scandir(const char* dirname, struct dirent*** namelist, int pass; /* Determine whether to include the entry in result */ - if (filter) { + if (filter != nullptr) { /* Let the filter function decide */ pass = filter(tmp); } else { @@ -869,7 +869,7 @@ static int scandir(const char* dirname, struct dirent*** namelist, pass = 1; } - if (pass) { + if (pass != 0) { /* Store the temporary entry to pointer table */ files[size++] = tmp; tmp = nullptr; @@ -913,12 +913,12 @@ static int scandir(const char* dirname, struct dirent*** namelist, } /* Close directory stream */ - if (dir) { + if (dir != nullptr) { closedir(dir); } /* Pass pointer table to caller */ - if (namelist) { + if (namelist != nullptr) { *namelist = files; } return result; @@ -953,9 +953,9 @@ static int dirent_mbstowcs_s(size_t* pReturnValue, wchar_t* wcstr, /* Convert to wide-character string (or count characters) */ n = mbstowcs(wcstr, mbstr, sizeInWords); - if (!wcstr || n < count) { + if ((wcstr == nullptr) || n < count) { /* Zero-terminate output buffer */ - if (wcstr && sizeInWords) { + if ((wcstr != nullptr) && (sizeInWords != 0U)) { if (n >= sizeInWords) { n = sizeInWords - 1; } @@ -963,7 +963,7 @@ static int dirent_mbstowcs_s(size_t* pReturnValue, wchar_t* wcstr, } /* Length of resulting multi-byte string WITH zero terminator */ - if (pReturnValue) { + if (pReturnValue != nullptr) { *pReturnValue = n + 1; } @@ -997,9 +997,9 @@ static int dirent_wcstombs_s(size_t* pReturnValue, char* mbstr, /* Convert to multi-byte string (or count the number of bytes needed) */ n = wcstombs(mbstr, wcstr, sizeInBytes); - if (!mbstr || n < count) { + if ((mbstr == nullptr) || n < count) { /* Zero-terminate output buffer */ - if (mbstr && sizeInBytes) { + if ((mbstr != nullptr) && (sizeInBytes != 0U)) { if (n >= sizeInBytes) { n = sizeInBytes - 1; } @@ -1007,7 +1007,7 @@ static int dirent_wcstombs_s(size_t* pReturnValue, char* mbstr, } /* Length of resulting multi-bytes string WITH zero-terminator */ - if (pReturnValue) { + if (pReturnValue != nullptr) { *pReturnValue = n + 1; }