lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

src: fix whitespace/indent cpplint warnings 

PR-URL: https://github.com/nodejs/node/pull/7462
Reviewed-By: Trevor Norris <trev.norris@gmail.com>
v7.x
Ben Noordhuis 9 years ago
parent
0daffdf3fd
commit
97aeb0ae12
4 changed files with 249 additions and 248 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 152
      src/node_internals.h
  2. 71
      src/node_watchdog.h
  3. 112
      src/string_bytes.cc
  4. 162
      src/util.h

152
src/node_internals.h
View File

@ -213,82 +213,82 @@ void ClearFatalExceptionHandlers(Environment* env);
enum NodeInstanceType { MAIN, WORKER, REMOTE_DEBUG_SERVER }; enum NodeInstanceType { MAIN, WORKER, REMOTE_DEBUG_SERVER };
class NodeInstanceData { class NodeInstanceData {
public: public:
NodeInstanceData(NodeInstanceType node_instance_type, NodeInstanceData(NodeInstanceType node_instance_type,
uv_loop_t* event_loop, uv_loop_t* event_loop,
int argc, int argc,
const char** argv, const char** argv,
int exec_argc, int exec_argc,
const char** exec_argv, const char** exec_argv,
bool use_debug_agent_flag) bool use_debug_agent_flag)
: node_instance_type_(node_instance_type), : node_instance_type_(node_instance_type),
exit_code_(1), exit_code_(1),
event_loop_(event_loop), event_loop_(event_loop),
argc_(argc), argc_(argc),
argv_(argv), argv_(argv),
exec_argc_(exec_argc), exec_argc_(exec_argc),
exec_argv_(exec_argv), exec_argv_(exec_argv),
use_debug_agent_flag_(use_debug_agent_flag) { use_debug_agent_flag_(use_debug_agent_flag) {
CHECK_NE(event_loop_, nullptr); CHECK_NE(event_loop_, nullptr);
} }
uv_loop_t* event_loop() const { uv_loop_t* event_loop() const {
return event_loop_; return event_loop_;
} }
int exit_code() { int exit_code() {
CHECK(is_main()); CHECK(is_main());
return exit_code_; return exit_code_;
} }
void set_exit_code(int exit_code) { void set_exit_code(int exit_code) {
CHECK(is_main()); CHECK(is_main());
exit_code_ = exit_code; exit_code_ = exit_code;
} }
bool is_main() { bool is_main() {
return node_instance_type_ == MAIN; return node_instance_type_ == MAIN;
} }
bool is_worker() { bool is_worker() {
return node_instance_type_ == WORKER; return node_instance_type_ == WORKER;
} }
bool is_remote_debug_server() { bool is_remote_debug_server() {
return node_instance_type_ == REMOTE_DEBUG_SERVER; return node_instance_type_ == REMOTE_DEBUG_SERVER;
} }
int argc() { int argc() {
return argc_; return argc_;
} }
const char** argv() { const char** argv() {
return argv_; return argv_;
} }
int exec_argc() { int exec_argc() {
return exec_argc_; return exec_argc_;
} }
const char** exec_argv() { const char** exec_argv() {
return exec_argv_; return exec_argv_;
} }
bool use_debug_agent() { bool use_debug_agent() {
return is_main() && use_debug_agent_flag_; return is_main() && use_debug_agent_flag_;
} }
private: private:
const NodeInstanceType node_instance_type_; const NodeInstanceType node_instance_type_;
int exit_code_; int exit_code_;
uv_loop_t* const event_loop_; uv_loop_t* const event_loop_;
const int argc_; const int argc_;
const char** argv_; const char** argv_;
const int exec_argc_; const int exec_argc_;
const char** exec_argv_; const char** exec_argv_;
const bool use_debug_agent_flag_; const bool use_debug_agent_flag_;
DISALLOW_COPY_AND_ASSIGN(NodeInstanceData); DISALLOW_COPY_AND_ASSIGN(NodeInstanceData);
}; };
namespace Buffer { namespace Buffer {

71
src/node_watchdog.h
View File

@ -39,56 +39,57 @@ class Watchdog {
}; };
class SigintWatchdog { class SigintWatchdog {
public: public:
explicit SigintWatchdog(v8::Isolate* isolate); explicit SigintWatchdog(v8::Isolate* isolate);
~SigintWatchdog(); ~SigintWatchdog();
void Dispose(); void Dispose();
v8::Isolate* isolate() { return isolate_; } v8::Isolate* isolate() { return isolate_; }
bool HasReceivedSignal() { return received_signal_; } bool HasReceivedSignal() { return received_signal_; }
void HandleSigint(); void HandleSigint();
private:
void Destroy(); private:
void Destroy();
v8::Isolate* isolate_; v8::Isolate* isolate_;
bool received_signal_; bool received_signal_;
bool destroyed_; bool destroyed_;
}; };
class SigintWatchdogHelper { class SigintWatchdogHelper {
public: public:
static SigintWatchdogHelper* GetInstance() { return &instance; } static SigintWatchdogHelper* GetInstance() { return &instance; }
void Register(SigintWatchdog* watchdog); void Register(SigintWatchdog* watchdog);
void Unregister(SigintWatchdog* watchdog); void Unregister(SigintWatchdog* watchdog);
int Start(); int Start();
bool Stop(); bool Stop();
private: private:
SigintWatchdogHelper(); SigintWatchdogHelper();
~SigintWatchdogHelper(); ~SigintWatchdogHelper();
static bool InformWatchdogsAboutSignal(); static bool InformWatchdogsAboutSignal();
static SigintWatchdogHelper instance; static SigintWatchdogHelper instance;
int start_stop_count_; int start_stop_count_;
uv_mutex_t mutex_; uv_mutex_t mutex_;
uv_mutex_t list_mutex_; uv_mutex_t list_mutex_;
std::vector<SigintWatchdog*> watchdogs_; std::vector<SigintWatchdog*> watchdogs_;
bool has_pending_signal_; bool has_pending_signal_;
#ifdef __POSIX__ #ifdef __POSIX__
pthread_t thread_; pthread_t thread_;
uv_sem_t sem_; uv_sem_t sem_;
bool has_running_thread_; bool has_running_thread_;
bool stopping_; bool stopping_;
static void* RunSigintWatchdog(void* arg); static void* RunSigintWatchdog(void* arg);
static void HandleSignal(int signum); static void HandleSignal(int signum);
#else #else
static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType); static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType);
#endif #endif
}; };

112
src/string_bytes.cc
View File

@ -27,78 +27,78 @@ using v8::Value;
template <typename ResourceType, typename TypeName> template <typename ResourceType, typename TypeName>
class ExternString: public ResourceType { class ExternString: public ResourceType {
public: public:
~ExternString() override { ~ExternString() override {
free(const_cast<TypeName*>(data_)); free(const_cast<TypeName*>(data_));
isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length()); isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length());
} }
const TypeName* data() const override {
return data_;
}
size_t length() const override { const TypeName* data() const override {
return length_; return data_;
} }
int64_t byte_length() const { size_t length() const override {
return length() * sizeof(*data()); return length_;
} }
static Local<String> NewFromCopy(Isolate* isolate, int64_t byte_length() const {
const TypeName* data, return length() * sizeof(*data());
size_t length) { }
EscapableHandleScope scope(isolate);
if (length == 0) static Local<String> NewFromCopy(Isolate* isolate,
return scope.Escape(String::Empty(isolate)); const TypeName* data,
size_t length) {
EscapableHandleScope scope(isolate);
TypeName* new_data = if (length == 0)
static_cast<TypeName*>(malloc(length * sizeof(*new_data))); return scope.Escape(String::Empty(isolate));
if (new_data == nullptr) {
return Local<String>();
}
memcpy(new_data, data, length * sizeof(*new_data));
return scope.Escape(ExternString<ResourceType, TypeName>::New(isolate, TypeName* new_data =
new_data, static_cast<TypeName*>(malloc(length * sizeof(*new_data)));
length)); if (new_data == nullptr) {
return Local<String>();
} }
memcpy(new_data, data, length * sizeof(*new_data));
// uses "data" for external resource, and will be free'd on gc return scope.Escape(ExternString<ResourceType, TypeName>::New(isolate,
static Local<String> New(Isolate* isolate, new_data,
const TypeName* data, length));
size_t length) { }
EscapableHandleScope scope(isolate);
if (length == 0) // uses "data" for external resource, and will be free'd on gc
return scope.Escape(String::Empty(isolate)); static Local<String> New(Isolate* isolate,
const TypeName* data,
size_t length) {
EscapableHandleScope scope(isolate);
ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate, if (length == 0)
data, return scope.Escape(String::Empty(isolate));
length);
MaybeLocal<String> str = NewExternal(isolate, h_str);
isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
if (str.IsEmpty()) { ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
delete h_str; data,
return Local<String>(); length);
} MaybeLocal<String> str = NewExternal(isolate, h_str);
isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
return scope.Escape(str.ToLocalChecked()); if (str.IsEmpty()) {
delete h_str;
return Local<String>();
} }
inline Isolate* isolate() const { return isolate_; } return scope.Escape(str.ToLocalChecked());
}
inline Isolate* isolate() const { return isolate_; }
private: private:
ExternString(Isolate* isolate, const TypeName* data, size_t length) ExternString(Isolate* isolate, const TypeName* data, size_t length)
: isolate_(isolate), data_(data), length_(length) { } : isolate_(isolate), data_(data), length_(length) { }
static MaybeLocal<String> NewExternal(Isolate* isolate, static MaybeLocal<String> NewExternal(Isolate* isolate,
ExternString* h_str); ExternString* h_str);
Isolate* isolate_; Isolate* isolate_;
const TypeName* data_; const TypeName* data_;
size_t length_; size_t length_;
}; };

162
src/util.h
View File

@ -213,99 +213,99 @@ inline bool StringEqualNoCaseN(const char* a, const char* b, size_t length);
// the stack is used, otherwise malloc(). // the stack is used, otherwise malloc().
template <typename T, size_t kStackStorageSize = 1024> template <typename T, size_t kStackStorageSize = 1024>
class MaybeStackBuffer { class MaybeStackBuffer {
public: public:
const T* out() const { const T* out() const {
return buf_; return buf_;
} }
T* out() { T* out() {
return buf_; return buf_;
} }
// operator* for compatibility with `v8::String::(Utf8)Value` // operator* for compatibility with `v8::String::(Utf8)Value`
T* operator*() { T* operator*() {
return buf_; return buf_;
} }
const T* operator*() const { const T* operator*() const {
return buf_; return buf_;
} }
size_t length() const { size_t length() const {
return length_; return length_;
} }
// Call to make sure enough space for `storage` entries is available. // Call to make sure enough space for `storage` entries is available.
// There can only be 1 call to AllocateSufficientStorage or Invalidate // There can only be 1 call to AllocateSufficientStorage or Invalidate
// per instance. // per instance.
void AllocateSufficientStorage(size_t storage) { void AllocateSufficientStorage(size_t storage) {
if (storage <= kStackStorageSize) { if (storage <= kStackStorageSize) {
buf_ = buf_st_; buf_ = buf_st_;
} else { } else {
// Guard against overflow. // Guard against overflow.
CHECK_LE(storage, sizeof(T) * storage); CHECK_LE(storage, sizeof(T) * storage);
buf_ = static_cast<T*>(malloc(sizeof(T) * storage)); buf_ = static_cast<T*>(malloc(sizeof(T) * storage));
CHECK_NE(buf_, nullptr); 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();
} }
~MaybeStackBuffer() { // Remember how much was allocated to check against that in SetLength().
if (buf_ != buf_st_) length_ = storage;
free(buf_); }
}
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: private:
size_t length_; size_t length_;
T* buf_; T* buf_;
T buf_st_[kStackStorageSize]; T buf_st_[kStackStorageSize];
}; };
class Utf8Value : public MaybeStackBuffer<char> { class Utf8Value : public MaybeStackBuffer<char> {
public: public:
explicit Utf8Value(v8::Isolate* isolate, v8::Local<v8::Value> value); explicit Utf8Value(v8::Isolate* isolate, v8::Local<v8::Value> value);
}; };
class TwoByteValue : public MaybeStackBuffer<uint16_t> { class TwoByteValue : public MaybeStackBuffer<uint16_t> {
public: public:
explicit TwoByteValue(v8::Isolate* isolate, v8::Local<v8::Value> value); explicit TwoByteValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
}; };
class BufferValue : public MaybeStackBuffer<char> { class BufferValue : public MaybeStackBuffer<char> {
public: public:
explicit BufferValue(v8::Isolate* isolate, v8::Local<v8::Value> value); explicit BufferValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
}; };
} // namespace node } // namespace node

Write Preview
Loading…
Cancel
Save