wip
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 <cstdlib> // for getenv
-#include <cstring> // for memchr
-#include <string>
+# include <cstdlib> // for getenv
+# include <cstring> // for memchr
+# include <string>
-#include "config.h"
+# include "config.h"
-#ifdef GLOG_USE_GFLAGS
+# ifdef GLOG_USE_GFLAGS
-# include <gflags/gflags.h>
+# include <gflags/gflags.h>
-#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<unsigned>(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 @@
#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 @@
# 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 <pthread.h>
@@ -258,7 +258,9 @@
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 @@
}
// 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 <non-terminal>+ syntax.
using ParseFunc = bool (*)(State*);
@@ -450,10 +450,7 @@
}
*state = copy;
- if (ParseName(state) || ParseSpecialName(state)) {
- return true;
- }
- return false;
+ return ParseName(state) || ParseSpecialName(state);
}
// <name> ::= <nested-name>
@@ -472,10 +469,7 @@
*state = copy;
// Less greedy than <unscoped-template-name> <template-args>.
- if (ParseUnscopedName(state)) {
- return true;
- }
- return false;
+ return ParseUnscopedName(state);
}
// <unscoped-name> ::= <unqualified-name>
@@ -538,9 +532,8 @@
MaybeCancelLastSeparator(state);
if (has_something && ParseTemplateArgs(state)) {
return ParsePrefix(state);
- } else {
- break;
}
+ break;
}
return true;
}
@@ -627,7 +620,7 @@
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 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 @@
*state = copy;
// Less greedy than <template-template-param> <template-args>.
- if (ParseTemplateParam(state)) {
- return true;
- }
-
- return false;
+ return ParseTemplateParam(state);
}
// <CV-qualifiers> ::= [r] [V] [K]
@@ -940,9 +929,9 @@
// 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<int>(ParseOneCharToken(state, 'r'));
+ num_cv_qualifiers += static_cast<int>(ParseOneCharToken(state, 'V'));
+ num_cv_qualifiers += static_cast<int>(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 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 @@
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 @@
# 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 @@
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 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 @@
// 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 @@
// 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 @@
#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 @@
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<int> 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<int> 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 @@
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<int> 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 @@
} // 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 @@
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<size_t>(pptr() - pbase()); }
@@ -1406,9 +1408,8 @@
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 @@
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 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 @@
// converted to LogStream and the message will be computed and then
// quietly discarded.
template <class T>
-inline NullStream& operator<<(NullStream& str, const T&) {
+inline NullStream& operator<<(NullStream& str, const T& /*unused*/) {
return str;
}
@@ -1828,7 +1829,7 @@
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 @@
#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 @@
// 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 @@
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 @@
// 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 <fcntl.h>
#include <sys/stat.h>
@@ -256,7 +256,7 @@
// Benchmark tools.
-#define BENCHMARK(n) static BenchmarkRegisterer __benchmark_##n(#n, &n);
+#define BENCHMARK(n) static BenchmarkRegisterer __benchmark_##n(#n, &(n));
map<string, void (*)(int)> g_benchlist; // the benchmarks to run
@@ -330,7 +330,7 @@
}
// Remove output redirection
- void StopCapture() {
+ void StopCapture() const {
// Restore original stream
if (uncaptured_fd_ != -1) {
fflush(nullptr);
@@ -420,9 +420,13 @@
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 @@
// 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 @@
}
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 @@
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 @@
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 @@
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 @@
} // 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 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 @@
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 @@
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 @@
bool enabled() const { return enabled_; }
private:
- vector<string> GetOverdueLogNames(string log_directory, unsigned int days,
- const string& base_filename,
- const string& filename_extension) const;
+ static vector<string> 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 @@
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 @@
return;
}
- if (logger_ && logger_ != &fileobject_) {
+ if ((logger_ != nullptr) && logger_ != &fileobject_) {
// Delete user-specified logger set via SetLogger().
delete logger_;
}
@@ -704,7 +711,9 @@
// Prevent any subtle race conditions by wrapping a mutex lock around
// all this stuff.
MutexLock l(&sink_mutex_);
- if (!sinks_) sinks_ = new vector<LogSink*>;
+ if (sinks_ == nullptr) {
+ sinks_ = new vector<LogSink*>;
+ }
sinks_->push_back(destination);
}
@@ -713,7 +722,7 @@
// 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 @@
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::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 @@
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 @@
: 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 @@
flags = flags | O_EXCL;
}
int fd = open(filename, flags, static_cast<mode_t>(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 @@
const string linkname =
symlink_basename_ + '.' + LogSeverityNames[severity_];
string linkpath;
- if (slash)
+ if (slash != nullptr) {
linkpath = string(
filename, static_cast<size_t>(slash - filename + 1)); // get dirname
+ }
linkpath += linkname;
unlink(linkpath.c_str()); // delete old one if it exists
@@ -1128,7 +1139,7 @@
// 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 @@
}
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 @@
// 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 @@
// 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 @@
}
}
// 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 @@
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 @@
vector<string> 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<string> overdue_log_names;
@@ -1397,8 +1414,8 @@
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 @@
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//<base_filename>.<create_time>.<pid>"
// after: "/tmp/<base_filename>.<create_time>.<pid>"
@@ -1513,7 +1530,7 @@
}
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 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 @@
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 @@
// 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<LogMessage::LogStream*>(&os);
#else
@@ -2218,7 +2235,7 @@
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 @@
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 @@
}
}
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 @@
"/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 @@
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 @@
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 @@
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<int>(strncmp(procfd_prefix, path, strlen(procfd_prefix)) !=
+ 0) != 0) {
+ flags |= O_NOFOLLOW;
+ }
# endif
int fd = open(path, flags);
@@ -2467,9 +2489,15 @@
// 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<off_t>(limit)) goto out_close_fd;
- if (statbuf.st_size <= static_cast<off_t>(keep)) goto out_close_fd;
+ if (!S_ISREG(statbuf.st_mode)) {
+ goto out_close_fd;
+ }
+ if (statbuf.st_size <= static_cast<off_t>(limit)) {
+ goto out_close_fd;
+ }
+ if (statbuf.st_size <= static_cast<off_t>(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 @@
// Copy the last "keep" bytes of the file to the beginning of the file
read_offset = statbuf.st_size - static_cast<off_t>(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<size_t>(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 @@
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 @@
// 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<intptr_t>(rc) < sys_nerr) {
- // This means an error on MacOSX or FreeBSD.
- return -1;
- }
-#endif
- strncat(buf, rc, len - 1);
- return 0;
- }
+ if (reinterpret_cast<intptr_t>(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 @@
const long hour_secs = 3600;
// If the Daylight Saving Time(isDst) is active subtract an hour from the
// current timestamp.
- gmtoffset_ =
- static_cast<long int>(timestamp_ - gmt_sec + (isDst ? hour_secs : 0));
+ gmtoffset_ = static_cast<long int>(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 @@
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 @@
}
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 @@
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 @@
// 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 @@
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 @@
#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 <sys/syscall.h> // for syscall()
#endif
#ifdef HAVE_UNISTD_H
-# include <unistd.h>
#endif
#if (defined(HAVE_SYSCALL_H) || defined(HAVE_SYS_SYSCALL_H)) && \
@@ -96,7 +95,9 @@
va_start(ap, format);
int n = std::vsnprintf(*buf, *size, format, ap);
va_end(ap);
- if (n < 0 || static_cast<size_t>(n) > *size) return false;
+ if (n < 0 || static_cast<size_t>(n) > *size) {
+ return false;
+ }
*size -= static_cast<size_t>(n);
*buf += n;
return true;
@@ -113,7 +114,9 @@
#if defined(__GNUC__)
# pragma GCC diagnostic pop
#endif
- if (n < 0 || static_cast<size_t>(n) > *size) return false;
+ if (n < 0 || static_cast<size_t>(n) > *size) {
+ return false;
+ }
*size -= static_cast<size_t>(n);
*buf += n;
return true;
@@ -125,11 +128,11 @@
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 @@
{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 @@
# 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_t*>(ucontext_in_void);
+ auto* context = reinterpret_cast<ucontext_t*>(ucontext_in_void);
return (void*)context->PC_FROM_UCONTEXT;
}
# else
@@ -192,7 +192,7 @@
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 @@
// 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 @@
&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 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 @@
*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 @@
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 @@
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 @@
# 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 @@
//-----------------------------------------------------------------------//
-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 @@
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<uintptr_t>(new_sp) -
reinterpret_cast<uintptr_t>(old_sp) >
@@ -67,7 +69,9 @@
} 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<uintptr_t>(new_sp) -
reinterpret_cast<uintptr_t>(old_sp) >
@@ -139,7 +143,7 @@
#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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
ssize_t n_read = ReadFromOffset(fd, &header_name, name_len, name_offset);
if (n_read == -1) {
return false;
- } else if (static_cast<size_t>(n_read) != name_len) {
+ }
+ if (static_cast<size_t>(n_read) != name_len) {
// Short read -- name could be at end of file.
continue;
}
@@ -386,7 +387,7 @@
close(fd_);
}
}
- int get() { return fd_; }
+ int get() const { return fd_; }
private:
FileDescriptor(const FileDescriptor&) = delete;
@@ -613,7 +614,7 @@
}
// 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 @@
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 @@
// 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 @@
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 @@
}
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 char symbol[4096];
if (Symbolize(pc, symbol, sizeof(symbol))) {
return symbol;
- } else {
- return nullptr;
}
+ return nullptr;
}
# endif
@@ -237,7 +236,8 @@
// 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 @@
// 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 @@
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 @@
#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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
}
// 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 @@
// 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 @@
// 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 @@
}
#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<size_t>(base_end - base) : strlen(base);
+ base_end != nullptr ? static_cast<size_t>(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 @@
// 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 <cwchar>
/* 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 @@
/* Allocate new _WDIR structure */
dirp = (_WDIR*)malloc(sizeof(struct _WDIR));
- if (!dirp) {
+ if (dirp == nullptr) {
return nullptr;
}
@@ -507,7 +507,7 @@
*/
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 @@
* 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 @@
/* Allocate memory for DIR structure */
dirp = (DIR*)malloc(sizeof(struct DIR));
- if (!dirp) {
+ if (dirp == nullptr) {
return nullptr;
}
{
@@ -642,7 +642,7 @@
/* 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 @@
/* 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 @@
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 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 @@
/* 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 @@
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 @@
pass = 1;
}
- if (pass) {
+ if (pass != 0) {
/* Store the temporary entry to pointer table */
files[size++] = tmp;
tmp = nullptr;
@@ -913,12 +913,12 @@
}
/* 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 @@
/* 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 @@
}
/* Length of resulting multi-byte string WITH zero terminator */
- if (pReturnValue) {
+ if (pReturnValue != nullptr) {
*pReturnValue = n + 1;
}
@@ -997,9 +997,9 @@
/* 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 @@
}
/* Length of resulting multi-bytes string WITH zero-terminator */
- if (pReturnValue) {
+ if (pReturnValue != nullptr) {
*pReturnValue = n + 1;
}
