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>
v4.x
Ben Noordhuis 8 years ago
committed by Myles Borins
parent
066064d65f
commit
4f4d3e77ef
3 changed files with 207 additions and 207 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 144
      src/node_internals.h
  2. 108
      src/string_bytes.cc
  3. 162
      src/util.h

144
src/node_internals.h
View File

@ -247,78 +247,78 @@ void ClearFatalExceptionHandlers(Environment* env);
enum NodeInstanceType { MAIN, WORKER };
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;
}
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;
}
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 {

108
src/string_bytes.cc
View File

@ -27,75 +27,75 @@ using v8::MaybeLocal;
template <typename ResourceType, typename TypeName>
class ExternString: public ResourceType {
public:
~ExternString() override {
free(const_cast<TypeName*>(data_));
isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length());
}
const TypeName* data() const override {
return data_;
}
public:
~ExternString() override {
free(const_cast<TypeName*>(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<String> 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<String> NewFromCopy(Isolate* isolate,
const TypeName* data,
size_t length) {
EscapableHandleScope scope(isolate);
TypeName* new_data =
static_cast<TypeName*>(malloc(length * sizeof(*new_data)));
if (new_data == nullptr) {
return Local<String>();
}
memcpy(new_data, data, length * sizeof(*new_data));
if (length == 0)
return scope.Escape(String::Empty(isolate));
return scope.Escape(ExternString<ResourceType, TypeName>::New(isolate,
new_data,
length));
TypeName* new_data =
static_cast<TypeName*>(malloc(length * sizeof(*new_data)));
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
static Local<String> New(Isolate* isolate,
const TypeName* data,
size_t length) {
EscapableHandleScope scope(isolate);
return scope.Escape(ExternString<ResourceType, TypeName>::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<String> New(Isolate* isolate,
const TypeName* data,
size_t length) {
EscapableHandleScope scope(isolate);
if (length == 0)
return scope.Escape(String::Empty(isolate));
ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
data,
length);
MaybeLocal<String> str = String::NewExternal(isolate, h_str);
isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
data,
length);
MaybeLocal<String> str = String::NewExternal(isolate, h_str);
isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
if (str.IsEmpty()) {
delete h_str;
return Local<String>();
}
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:
ExternString(Isolate* isolate, const TypeName* data, size_t length)
: isolate_(isolate), data_(data), length_(length) { }
Isolate* isolate_;
const TypeName* data_;
size_t length_;
private:
ExternString(Isolate* isolate, const TypeName* data, size_t length)
: isolate_(isolate), data_(data), length_(length) { }
Isolate* isolate_;
const TypeName* data_;
size_t length_;
};

162
src/util.h
View File

@ -194,99 +194,99 @@ inline bool StringEqualNoCase(const char* a, const char* b);
// the stack is used, otherwise malloc().
template <typename T, size_t kStackStorageSize = 1024>
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<T*>(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<T*>(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<char> {
public:
explicit Utf8Value(v8::Isolate* isolate, v8::Local<v8::Value> value);
public:
explicit Utf8Value(v8::Isolate* isolate, v8::Local<v8::Value> value);
};
class TwoByteValue : public MaybeStackBuffer<uint16_t> {
public:
explicit TwoByteValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
public:
explicit TwoByteValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
};
class BufferValue : public MaybeStackBuffer<char> {
public:
explicit BufferValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
public:
explicit BufferValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
};
} // namespace node

Write Preview
Loading…
Cancel
Save