Skip to content

Weakness #10

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Jul 27, 2013
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
29 changes: 27 additions & 2 deletions README.md
Original file line number Diff line number Diff line change
@@ -138,16 +138,18 @@ NAN_METHOD(CalculateAsync) {
* <a href="#api_nan_method"><b><code>NAN_METHOD</code></b></a>
* <a href="#api_nan_getter"><b><code>NAN_GETTER</code></b></a>
* <a href="#api_nan_setter"><b><code>NAN_SETTER</code></b></a>
* <a href="#api_nan_weak_callback"><b><code>NAN_WEAK_CALLBACK</code></b></a>
* <a href="#api_nan_return_value"><b><code>NanReturnValue</code></b></a>
* <a href="#api_nan_return_undefined"><b><code>NanReturnUndefined</code></b></a>
* <a href="#api_nan_scope"><b><code>NanScope</code></b></a>
* <a href="#api_nan_object_wrap_handle"><b><code>NanObjectWrapHandle</code></b></a>
* <a href="#api_nan_make_weak"><b><code>NanMakeWeak</code></b></a>
* <a href="#api_nan_symbol"><b><code>NanSymbol</code></b></a>
* <a href="#api_nan_from_v8_string"><b><code>NanFromV8String</code></b></a>
* <a href="#api_nan_boolean_option_value"><b><code>NanBooleanOptionValue</code></b></a>
* <a href="#api_nan_uint32_option_value"><b><code>NanUInt32OptionValue</code></b></a>
* <a href="#api_nan_throw_error"><b><code>NanThrowError</code></b>, <b><code>NanThrowTypeError</code></b>, <b><code>NanThrowRangeError</code></b>, <b><code>NanThrowError(Local<Value>)</code></b></a>
* <a href="#api_nan_new_buffer_handle"><b><code>NanNewBufferHandle(char *, uint32_t)</code></b>, <b><code>NanNewBufferHandle(uint32_t)</code></b></a>
* <a href="#api_nan_new_buffer_handle"><b><code>NanNewBufferHandle(char *, size_t, FreeCallback, void *)</code></b>, <b><code>NanNewBufferHandle(char *, uint32_t)</code></b>, <b><code>NanNewBufferHandle(uint32_t)</code></b></a>
* <a href="#api_nan_buffer_use"><b><code>NanBufferUse(char *, uint32_t)</code></b></a>
* <a href="#api_nan_has_instance"><b><code>NanHasInstance</code></b></a>
* <a href="#api_nan_persistent_to_local"><b><code>NanPersistentToLocal</code></b></a>
@@ -208,6 +210,22 @@ Use `NAN_SETTER` to declare your V8 accessible setters. Same as `NAN_GETTER` but

You can use `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_SETTER`.

<a name="api_nan_weak_callback"></a>
### NAN_WEAK_CALLBACK(type, cbname)

Use `NAN_WEAK_CALLBACK` to declare your V8 WeakReference callbacks. There is an object argument accessible through `NAN_WEAK_CALLBACK_OBJECT`. The `type` argument gives the type of the `data` argument, accessible through `NAN_WEAK_CALLBACK_DATA(type)`.

```c++
static NAN_WEAK_CALLBACK(BufferReference*, WeakCheck) {
if (NAN_WEAK_CALLBACK_DATA(BufferReference*)->noLongerNeeded_) {
delete NAN_WEAK_CALLBACK_DATA(BufferReference*);
} else {
// Still in use, revive, prevent GC
NanMakeWeak(NAN_WEAK_CALLBACK_OBJECT, NAN_WEAK_CALLBACK_DATA(BufferReference*), &WeakCheck);
}
}
```

<a name="api_nan_return_value"></a>
### NanReturnValue(v8::Handle<v8::Value>)

@@ -258,6 +276,11 @@ When you want to fetch the V8 object handle from a native object you've wrapped
NanObjectWrapHandle(iterator)->Get(v8::String::NewSymbol("end"))
```

<a name="api_nan_make_weak"></a>
### NanMakeWeak(v8::Persistent<T>, parameter, callback)

Make a persistent reference weak.

<a name="api_nan_symbol"></a>
### v8::String NanSymbol(char *)

@@ -313,7 +336,7 @@ return NanThrowError("you must supply a callback argument");
Can also handle any custom object you may want to throw.

<a name="api_nan_new_buffer_handle"></a>
### v8::Local<v8::Object> NanNewBufferHandle(char *, uint32_t), v8::Local<v8::Object> NanNewBufferHandle(uint32_t)
### v8::Local<v8::Object> NanNewBufferHandle(char *, size_t, FreeCallback, void *), v8::Local<v8::Object> NanNewBufferHandle(char *, uint32_t), v8::Local<v8::Object> NanNewBufferHandle(uint32_t)

The `Buffer` API has changed a little in Node 0.11, this helper provides consistent access to `Buffer` creation:

@@ -323,6 +346,8 @@ NanNewBufferHandle((char*)value.data(), value.size());

Can also be used to initialize a `Buffer` with just a `size` argument.

Can also be supplied with a `NAN_WEAK_CALLBACK` and a hint for the garbage collector, when dealing with weak references.

<a name="api_nan_buffer_use"></a>
### v8::Local<v8::Object> NanBufferUse(char*, uint32_t)

74 changes: 56 additions & 18 deletions nan.h
Original file line number Diff line number Diff line change
@@ -95,20 +95,30 @@ static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
, v8::Local<v8::Value> value \
, _NAN_SETTER_ARGS)

# define NAN_WEAK_CALLBACK(type, name) \
void name( \
v8::Isolate* isolate, \
v8::Persistent<v8::Object>* object, \
type data)
# define NAN_WEAK_CALLBACK_OBJECT (*object)
# define NAN_WEAK_CALLBACK_DATA(type) ((type) data)

# define NanScope() v8::HandleScope scope(nan_isolate)
# define NanReturnValue(value) return args.GetReturnValue().Set(value);
# define NanReturnUndefined() return;
# define NanAssignPersistent(type, handle, obj) handle.Reset(nan_isolate, obj);
# define NanReturnValue(value) return args.GetReturnValue().Set(value)
# define NanReturnUndefined() return
# define NanAssignPersistent(type, handle, obj) handle.Reset(nan_isolate, obj)
# define NanObjectWrapHandle(obj) obj->handle()
# define NanMakeWeak(handle, parameter, callback) \
handle.MakeWeak(nan_isolate, parameter, callback)

# define THROW_ERROR(fun, errmsg) \
# define _NAN_THROW_ERROR(fun, errmsg) \

This comment was marked as off-topic.

do { \
NanScope(); \
v8::ThrowException(fun(v8::String::New(errmsg))); \
} while (0);

inline static void NanThrowError(const char* errmsg) {
THROW_ERROR(v8::Exception::Error, errmsg);
_NAN_THROW_ERROR(v8::Exception::Error, errmsg);
}

inline static void NanThrowError(v8::Local<v8::Value> error) {
@@ -117,30 +127,38 @@ static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
}

inline static void NanThrowTypeError(const char* errmsg) {
THROW_ERROR(v8::Exception::TypeError, errmsg);
_NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
}

inline static void NanThrowRangeError(const char* errmsg) {
THROW_ERROR(v8::Exception::RangeError, errmsg);
_NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
}

template<class T> static inline void NanDispose(v8::Persistent<T> &handle) {
handle.Dispose(nan_isolate);
}

static inline v8::Local<v8::Object> NanNewBufferHandle (
char *data, uint32_t size) {
return node::Buffer::New(data, size);
char *data,
size_t length,
node::smalloc::FreeCallback callback,
void *hint) {
return node::Buffer::New(data, length, callback, hint);
}

static inline v8::Local<v8::Object> NanBufferUse(char* data, uint32_t size) {
return node::Buffer::Use(data, size);
static inline v8::Local<v8::Object> NanNewBufferHandle (
char *data, uint32_t size) {
return node::Buffer::New(data, size);
}

static inline v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
return node::Buffer::New(size);
}

static inline v8::Local<v8::Object> NanBufferUse(char* data, uint32_t size) {
return node::Buffer::Use(data, size);
}

template <class TypeName>
inline v8::Local<TypeName> NanPersistentToLocal(
const v8::Persistent<TypeName>& persistent) {
@@ -173,21 +191,29 @@ static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
, v8::Local<v8::Value> value \
, _NAN_SETTER_ARGS)

# define NAN_WEAK_CALLBACK(type, name) void name( \
v8::Persistent<v8::Value> object, \
void *data)
# define NAN_WEAK_CALLBACK_OBJECT object
# define NAN_WEAK_CALLBACK_DATA(type) ((type) data)

# define NanScope() v8::HandleScope scope
# define NanReturnValue(value) return scope.Close(value);
# define NanReturnUndefined() return v8::Undefined();
# define NanReturnValue(value) return scope.Close(value)
# define NanReturnUndefined() return v8::Undefined()
# define NanAssignPersistent(type, handle, obj) \
handle = v8::Persistent<type>::New(obj);
handle = v8::Persistent<type>::New(obj)
# define NanObjectWrapHandle(obj) obj->handle_
# define NanMakeWeak(handle, parameters, callback) \
handle.MakeWeak(parameters, callback)

# define THROW_ERROR(fun, errmsg) \
# define _NAN_THROW_ERROR(fun, errmsg) \
do { \
NanScope(); \
return v8::ThrowException(fun(v8::String::New(errmsg))); \
} while (0);

inline static v8::Handle<v8::Value> NanThrowError(const char* errmsg) {
THROW_ERROR(v8::Exception::Error, errmsg);
_NAN_THROW_ERROR(v8::Exception::Error, errmsg);
}

inline static v8::Handle<v8::Value> NanThrowError(
@@ -197,22 +223,34 @@ static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
}

inline static v8::Handle<v8::Value> NanThrowTypeError(const char* errmsg) {
THROW_ERROR(v8::Exception::TypeError, errmsg);
_NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
}

inline static v8::Handle<v8::Value> NanThrowRangeError(const char* errmsg) {
THROW_ERROR(v8::Exception::RangeError, errmsg);
_NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
}

template<class T> static inline void NanDispose(v8::Persistent<T> &handle) {
handle.Dispose();
}

static inline v8::Local<v8::Object> NanNewBufferHandle (
char *data,
size_t length,
node::Buffer::free_callback callback,
void *hint) {
return v8::Local<v8::Object>::New(node::Buffer::New(data, length, callback, hint)->handle_);
}

static inline v8::Local<v8::Object> NanNewBufferHandle (
char *data, uint32_t size) {
return v8::Local<v8::Object>::New(node::Buffer::New(data, size)->handle_);
}

static inline v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
return v8::Local<v8::Object>::New(node::Buffer::New(size)->handle_);
}

static inline void FreeData(char *data, void *hint) {
delete[] data;
}