From 3fa643b069c9032b63c5d753b525d6bb75e07484 Mon Sep 17 00:00:00 2001 From: Ben Noordhuis Date: Tue, 28 Jun 2016 21:21:21 +0200 Subject: [PATCH] src: fix whitespace/indent cpplint warnings PR-URL: https://github.com/nodejs/node/pull/7462 Reviewed-By: Trevor Norris --- src/node_internals.h | 152 ++++++++++++++++++++-------------------- src/node_watchdog.h | 71 +++++++++---------- src/string_bytes.cc | 112 +++++++++++++++--------------- src/util.h | 162 +++++++++++++++++++++---------------------- 4 files changed, 249 insertions(+), 248 deletions(-) diff --git a/src/node_internals.h b/src/node_internals.h index 7ae587e1bc090c..f9370c0a29d14e 100644 --- a/src/node_internals.h +++ b/src/node_internals.h @@ -231,82 +231,82 @@ void ClearFatalExceptionHandlers(Environment* env); enum NodeInstanceType { MAIN, WORKER, REMOTE_DEBUG_SERVER }; class NodeInstanceData { - public: - NodeInstanceData(NodeInstanceType node_instance_type, - uv_loop_t* event_loop, - int argc, - const char** argv, - int exec_argc, - const char** exec_argv, - bool use_debug_agent_flag) - : node_instance_type_(node_instance_type), - exit_code_(1), - event_loop_(event_loop), - argc_(argc), - argv_(argv), - exec_argc_(exec_argc), - exec_argv_(exec_argv), - use_debug_agent_flag_(use_debug_agent_flag) { - CHECK_NE(event_loop_, nullptr); - } - - uv_loop_t* event_loop() const { - return event_loop_; - } - - int exit_code() { - CHECK(is_main()); - return exit_code_; - } - - void set_exit_code(int exit_code) { - CHECK(is_main()); - exit_code_ = exit_code; - } - - bool is_main() { - return node_instance_type_ == MAIN; - } - - bool is_worker() { - return node_instance_type_ == WORKER; - } - - bool is_remote_debug_server() { - return node_instance_type_ == REMOTE_DEBUG_SERVER; - } - - int argc() { - return argc_; - } - - const char** argv() { - return argv_; - } - - int exec_argc() { - return exec_argc_; - } - - const char** exec_argv() { - return exec_argv_; - } - - bool use_debug_agent() { - return is_main() && use_debug_agent_flag_; - } - - private: - const NodeInstanceType node_instance_type_; - int exit_code_; - uv_loop_t* const event_loop_; - const int argc_; - const char** argv_; - const int exec_argc_; - const char** exec_argv_; - const bool use_debug_agent_flag_; - - DISALLOW_COPY_AND_ASSIGN(NodeInstanceData); + public: + NodeInstanceData(NodeInstanceType node_instance_type, + uv_loop_t* event_loop, + int argc, + const char** argv, + int exec_argc, + const char** exec_argv, + bool use_debug_agent_flag) + : node_instance_type_(node_instance_type), + exit_code_(1), + event_loop_(event_loop), + argc_(argc), + argv_(argv), + exec_argc_(exec_argc), + exec_argv_(exec_argv), + use_debug_agent_flag_(use_debug_agent_flag) { + CHECK_NE(event_loop_, nullptr); + } + + uv_loop_t* event_loop() const { + return event_loop_; + } + + int exit_code() { + CHECK(is_main()); + return exit_code_; + } + + void set_exit_code(int exit_code) { + CHECK(is_main()); + exit_code_ = exit_code; + } + + bool is_main() { + return node_instance_type_ == MAIN; + } + + bool is_worker() { + return node_instance_type_ == WORKER; + } + + bool is_remote_debug_server() { + return node_instance_type_ == REMOTE_DEBUG_SERVER; + } + + int argc() { + return argc_; + } + + const char** argv() { + return argv_; + } + + int exec_argc() { + return exec_argc_; + } + + const char** exec_argv() { + return exec_argv_; + } + + bool use_debug_agent() { + return is_main() && use_debug_agent_flag_; + } + + private: + const NodeInstanceType node_instance_type_; + int exit_code_; + uv_loop_t* const event_loop_; + const int argc_; + const char** argv_; + const int exec_argc_; + const char** exec_argv_; + const bool use_debug_agent_flag_; + + DISALLOW_COPY_AND_ASSIGN(NodeInstanceData); }; namespace Buffer { diff --git a/src/node_watchdog.h b/src/node_watchdog.h index 56d5af322b0523..d56b7624de9c12 100644 --- a/src/node_watchdog.h +++ b/src/node_watchdog.h @@ -39,56 +39,57 @@ class Watchdog { }; class SigintWatchdog { - public: - explicit SigintWatchdog(v8::Isolate* isolate); - ~SigintWatchdog(); + public: + explicit SigintWatchdog(v8::Isolate* isolate); + ~SigintWatchdog(); - void Dispose(); + void Dispose(); - v8::Isolate* isolate() { return isolate_; } - bool HasReceivedSignal() { return received_signal_; } - void HandleSigint(); - private: - void Destroy(); + v8::Isolate* isolate() { return isolate_; } + bool HasReceivedSignal() { return received_signal_; } + void HandleSigint(); + + private: + void Destroy(); - v8::Isolate* isolate_; - bool received_signal_; - bool destroyed_; + v8::Isolate* isolate_; + bool received_signal_; + bool destroyed_; }; class SigintWatchdogHelper { - public: - static SigintWatchdogHelper* GetInstance() { return &instance; } - void Register(SigintWatchdog* watchdog); - void Unregister(SigintWatchdog* watchdog); + public: + static SigintWatchdogHelper* GetInstance() { return &instance; } + void Register(SigintWatchdog* watchdog); + void Unregister(SigintWatchdog* watchdog); - int Start(); - bool Stop(); + int Start(); + bool Stop(); - private: - SigintWatchdogHelper(); - ~SigintWatchdogHelper(); + private: + SigintWatchdogHelper(); + ~SigintWatchdogHelper(); - static bool InformWatchdogsAboutSignal(); - static SigintWatchdogHelper instance; + static bool InformWatchdogsAboutSignal(); + static SigintWatchdogHelper instance; - int start_stop_count_; + int start_stop_count_; - uv_mutex_t mutex_; - uv_mutex_t list_mutex_; - std::vector watchdogs_; - bool has_pending_signal_; + uv_mutex_t mutex_; + uv_mutex_t list_mutex_; + std::vector watchdogs_; + bool has_pending_signal_; #ifdef __POSIX__ - pthread_t thread_; - uv_sem_t sem_; - bool has_running_thread_; - bool stopping_; + pthread_t thread_; + uv_sem_t sem_; + bool has_running_thread_; + bool stopping_; - static void* RunSigintWatchdog(void* arg); - static void HandleSignal(int signum); + static void* RunSigintWatchdog(void* arg); + static void HandleSignal(int signum); #else - static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType); + static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType); #endif }; diff --git a/src/string_bytes.cc b/src/string_bytes.cc index 8a327deac2f439..882340ae048bf3 100644 --- a/src/string_bytes.cc +++ b/src/string_bytes.cc @@ -27,78 +27,78 @@ using v8::Value; template class ExternString: public ResourceType { - public: - ~ExternString() override { - free(const_cast(data_)); - isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length()); - } - - const TypeName* data() const override { - return data_; - } + public: + ~ExternString() override { + free(const_cast(data_)); + isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length()); + } - size_t length() const override { - return length_; - } + const TypeName* data() const override { + return data_; + } - int64_t byte_length() const { - return length() * sizeof(*data()); - } + size_t length() const override { + return length_; + } - static Local NewFromCopy(Isolate* isolate, - const TypeName* data, - size_t length) { - EscapableHandleScope scope(isolate); + int64_t byte_length() const { + return length() * sizeof(*data()); + } - if (length == 0) - return scope.Escape(String::Empty(isolate)); + static Local NewFromCopy(Isolate* isolate, + const TypeName* data, + size_t length) { + EscapableHandleScope scope(isolate); - TypeName* new_data = - static_cast(malloc(length * sizeof(*new_data))); - if (new_data == nullptr) { - return Local(); - } - memcpy(new_data, data, length * sizeof(*new_data)); + if (length == 0) + return scope.Escape(String::Empty(isolate)); - return scope.Escape(ExternString::New(isolate, - new_data, - length)); + TypeName* new_data = + static_cast(malloc(length * sizeof(*new_data))); + if (new_data == nullptr) { + return Local(); } + memcpy(new_data, data, length * sizeof(*new_data)); - // uses "data" for external resource, and will be free'd on gc - static Local New(Isolate* isolate, - const TypeName* data, - size_t length) { - EscapableHandleScope scope(isolate); + return scope.Escape(ExternString::New(isolate, + new_data, + length)); + } - if (length == 0) - return scope.Escape(String::Empty(isolate)); + // uses "data" for external resource, and will be free'd on gc + static Local New(Isolate* isolate, + const TypeName* data, + size_t length) { + EscapableHandleScope scope(isolate); - ExternString* h_str = new ExternString(isolate, - data, - length); - MaybeLocal str = NewExternal(isolate, h_str); - isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length()); + if (length == 0) + return scope.Escape(String::Empty(isolate)); - if (str.IsEmpty()) { - delete h_str; - return Local(); - } + ExternString* h_str = new ExternString(isolate, + data, + length); + MaybeLocal str = NewExternal(isolate, h_str); + isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length()); - return scope.Escape(str.ToLocalChecked()); + if (str.IsEmpty()) { + delete h_str; + return Local(); } - inline Isolate* isolate() const { return isolate_; } + return scope.Escape(str.ToLocalChecked()); + } + + inline Isolate* isolate() const { return isolate_; } - private: - ExternString(Isolate* isolate, const TypeName* data, size_t length) - : isolate_(isolate), data_(data), length_(length) { } - static MaybeLocal NewExternal(Isolate* isolate, - ExternString* h_str); + private: + ExternString(Isolate* isolate, const TypeName* data, size_t length) + : isolate_(isolate), data_(data), length_(length) { } + static MaybeLocal NewExternal(Isolate* isolate, + ExternString* h_str); - Isolate* isolate_; - const TypeName* data_; - size_t length_; + Isolate* isolate_; + const TypeName* data_; + size_t length_; }; diff --git a/src/util.h b/src/util.h index dd2da89e4e9d7b..0a6b5e0dbef9c5 100644 --- a/src/util.h +++ b/src/util.h @@ -213,99 +213,99 @@ inline bool StringEqualNoCaseN(const char* a, const char* b, size_t length); // the stack is used, otherwise malloc(). template class MaybeStackBuffer { - public: - const T* out() const { - return buf_; - } - - T* out() { - return buf_; - } - - // operator* for compatibility with `v8::String::(Utf8)Value` - T* operator*() { - return buf_; - } - - const T* operator*() const { - return buf_; - } - - size_t length() const { - return length_; - } - - // Call to make sure enough space for `storage` entries is available. - // There can only be 1 call to AllocateSufficientStorage or Invalidate - // per instance. - void AllocateSufficientStorage(size_t storage) { - if (storage <= kStackStorageSize) { - buf_ = buf_st_; - } else { - // Guard against overflow. - CHECK_LE(storage, sizeof(T) * storage); - - buf_ = static_cast(malloc(sizeof(T) * storage)); - CHECK_NE(buf_, nullptr); - } - - // Remember how much was allocated to check against that in SetLength(). - length_ = storage; - } - - void SetLength(size_t length) { - // length_ stores how much memory was allocated. - CHECK_LE(length, length_); - length_ = length; - } - - void SetLengthAndZeroTerminate(size_t length) { - // length_ stores how much memory was allocated. - CHECK_LE(length + 1, length_); - SetLength(length); - - // T() is 0 for integer types, nullptr for pointers, etc. - buf_[length] = T(); - } - - // Make derefencing this object return nullptr. - // Calling this is mutually exclusive with calling - // AllocateSufficientStorage. - void Invalidate() { - CHECK_EQ(buf_, buf_st_); - length_ = 0; - buf_ = nullptr; - } - - MaybeStackBuffer() : length_(0), buf_(buf_st_) { - // Default to a zero-length, null-terminated buffer. - buf_[0] = T(); + public: + const T* out() const { + return buf_; + } + + T* out() { + return buf_; + } + + // operator* for compatibility with `v8::String::(Utf8)Value` + T* operator*() { + return buf_; + } + + const T* operator*() const { + return buf_; + } + + size_t length() const { + return length_; + } + + // Call to make sure enough space for `storage` entries is available. + // There can only be 1 call to AllocateSufficientStorage or Invalidate + // per instance. + void AllocateSufficientStorage(size_t storage) { + if (storage <= kStackStorageSize) { + buf_ = buf_st_; + } else { + // Guard against overflow. + CHECK_LE(storage, sizeof(T) * storage); + + buf_ = static_cast(malloc(sizeof(T) * storage)); + CHECK_NE(buf_, nullptr); } - ~MaybeStackBuffer() { - if (buf_ != buf_st_) - free(buf_); - } + // Remember how much was allocated to check against that in SetLength(). + length_ = storage; + } + + void SetLength(size_t length) { + // length_ stores how much memory was allocated. + CHECK_LE(length, length_); + length_ = length; + } + + void SetLengthAndZeroTerminate(size_t length) { + // length_ stores how much memory was allocated. + CHECK_LE(length + 1, length_); + SetLength(length); + + // T() is 0 for integer types, nullptr for pointers, etc. + buf_[length] = T(); + } + + // Make derefencing this object return nullptr. + // Calling this is mutually exclusive with calling + // AllocateSufficientStorage. + void Invalidate() { + CHECK_EQ(buf_, buf_st_); + length_ = 0; + buf_ = nullptr; + } + + MaybeStackBuffer() : length_(0), buf_(buf_st_) { + // Default to a zero-length, null-terminated buffer. + buf_[0] = T(); + } + + ~MaybeStackBuffer() { + if (buf_ != buf_st_) + free(buf_); + } - private: - size_t length_; - T* buf_; - T buf_st_[kStackStorageSize]; + private: + size_t length_; + T* buf_; + T buf_st_[kStackStorageSize]; }; class Utf8Value : public MaybeStackBuffer { - public: - explicit Utf8Value(v8::Isolate* isolate, v8::Local value); + public: + explicit Utf8Value(v8::Isolate* isolate, v8::Local value); }; class TwoByteValue : public MaybeStackBuffer { - public: - explicit TwoByteValue(v8::Isolate* isolate, v8::Local value); + public: + explicit TwoByteValue(v8::Isolate* isolate, v8::Local value); }; class BufferValue : public MaybeStackBuffer { - public: - explicit BufferValue(v8::Isolate* isolate, v8::Local value); + public: + explicit BufferValue(v8::Isolate* isolate, v8::Local value); }; } // namespace node