Updated for new v8

package.json

@@ -37,7 +37,7 @@
     },
     "dependencies": {
         "node-pre-gyp": "0.5.x",
-	"nan": "~0.8.0"
+	"nan": "git://github.com/rvagg/nan.git#0.9-wip"
     },
     "bundledDependencies": [
         "node-pre-gyp"

src/database.cc

@@ -12,10 +12,10 @@ Persistent<FunctionTemplate> Database::constructor_template;
 void Database::Init(Handle<Object> target) {
     NanScope();
 
-    Local<FunctionTemplate> t = FunctionTemplate::New(New);
+    Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New);
 
     t->InstanceTemplate()->SetInternalFieldCount(1);
-    t->SetClassName(String::NewSymbol("Database"));
+    t->SetClassName(NanSymbol("Database"));
 
     NODE_SET_PROTOTYPE_METHOD(t, "close", Close);
     NODE_SET_PROTOTYPE_METHOD(t, "exec", Exec);
@@ -27,15 +27,15 @@ void Database::Init(Handle<Object> target) {
 
     NODE_SET_GETTER(t, "open", OpenGetter);
 
-    NanAssignPersistent(FunctionTemplate, constructor_template, t);
+    NanAssignPersistent(constructor_template, t);
 
-    target->Set(String::NewSymbol("Database"),
+    target->Set(NanSymbol("Database"),
         t->GetFunction());
 }
 
 void Database::Process() {
     if (!open && locked && !queue.empty()) {
-        EXCEPTION(String::New("Database handle is closed"), SQLITE_MISUSE, exception);
+        EXCEPTION(NanNew<String>("Database handle is closed"), SQLITE_MISUSE, exception);
         Local<Value> argv[] = { exception };
         bool called = false;
 
@@ -57,7 +57,7 @@ void Database::Process() {
         // When we couldn't call a callback function, emit an error on the
         // Database object.
         if (!called) {
-            Local<Value> args[] = { String::NewSymbol("error"), exception };
+            Local<Value> args[] = { NanSymbol("error"), exception };
             EMIT_EVENT(NanObjectWrapHandle(this), 2, args);
         }
         return;
@@ -81,14 +81,14 @@ void Database::Process() {
 
 void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) {
     if (!open && locked) {
-        EXCEPTION(String::New("Database is closed"), SQLITE_MISUSE, exception);
+        EXCEPTION(NanNew<String>("Database is closed"), SQLITE_MISUSE, exception);
         Local<Function> cb = NanPersistentToLocal(baton->callback);
         if (!cb.IsEmpty() && cb->IsFunction()) {
             Local<Value> argv[] = { exception };
             TRY_CATCH_CALL(NanObjectWrapHandle(this), cb, 1, argv);
         }
         else {
-            Local<Value> argv[] = { String::NewSymbol("error"), exception };
+            Local<Value> argv[] = { NanSymbol("error"), exception };
             EMIT_EVENT(NanObjectWrapHandle(this), 2, argv);
         }
         return;
@@ -128,8 +128,8 @@ NAN_METHOD(Database::New) {
     Database* db = new Database();
     db->Wrap(args.This());
 
-    args.This()->Set(String::NewSymbol("filename"), args[0]->ToString(), ReadOnly);
-    args.This()->Set(String::NewSymbol("mode"), Integer::New(mode), ReadOnly);
+    args.This()->Set(NanSymbol("filename"), args[0]->ToString(), ReadOnly);
+    args.This()->Set(NanSymbol("mode"), NanNew<Integer>(mode), ReadOnly);
 
     // Start opening the database.
     OpenBaton* baton = new OpenBaton(db, callback, *filename, mode);
@@ -173,12 +173,12 @@ void Database::Work_AfterOpen(uv_work_t* req) {
 
     Local<Value> argv[1];
     if (baton->status != SQLITE_OK) {
-        EXCEPTION(String::New(baton->message.c_str()), baton->status, exception);
+        EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception);
         argv[0] = exception;
     }
     else {
         db->open = true;
-        argv[0] = NanNewLocal<Value>(Null());
+        argv[0] = NanNew(NanNull());
     }
 
     Local<Function> cb = NanPersistentToLocal(baton->callback);
@@ -187,12 +187,12 @@ void Database::Work_AfterOpen(uv_work_t* req) {
         TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv);
     }
     else if (!db->open) {
-        Local<Value> args[] = { String::NewSymbol("error"), argv[0] };
+        Local<Value> args[] = { NanSymbol("error"), argv[0] };
         EMIT_EVENT(NanObjectWrapHandle(db), 2, args);
     }
 
     if (db->open) {
-        Local<Value> args[] = { String::NewSymbol("open") };
+        Local<Value> args[] = { NanSymbol("open") };
         EMIT_EVENT(NanObjectWrapHandle(db), 1, args);
         db->Process();
     }
@@ -203,7 +203,7 @@ void Database::Work_AfterOpen(uv_work_t* req) {
 NAN_GETTER(Database::OpenGetter) {
     NanScope();
     Database* db = ObjectWrap::Unwrap<Database>(args.This());
-    NanReturnValue(Boolean::New(db->open));
+    NanReturnValue(NanNew<Boolean>(db->open));
 }
 
 NAN_METHOD(Database::Close) {
@@ -250,14 +250,14 @@ void Database::Work_AfterClose(uv_work_t* req) {
 
     Local<Value> argv[1];
     if (baton->status != SQLITE_OK) {
-        EXCEPTION(String::New(baton->message.c_str()), baton->status, exception);
+        EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception);
         argv[0] = exception;
     }
     else {
         db->open = false;
         // Leave db->locked to indicate that this db object has reached
         // the end of its life.
-        argv[0] = NanNewLocal<Value>(Null());
+        argv[0] = NanNew(NanNull());
     }
 
     Local<Function> cb = NanPersistentToLocal(baton->callback);
@@ -267,12 +267,12 @@ void Database::Work_AfterClose(uv_work_t* req) {
         TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv);
     }
     else if (db->open) {
-        Local<Value> args[] = { String::NewSymbol("error"), argv[0] };
+        Local<Value> args[] = { NanSymbol("error"), argv[0] };
         EMIT_EVENT(NanObjectWrapHandle(db), 2, args);
     }
 
     if (!db->open) {
-        Local<Value> args[] = { String::NewSymbol("close"), argv[0] };
+        Local<Value> args[] = { NanSymbol("close"), argv[0] };
         EMIT_EVENT(NanObjectWrapHandle(db), 1, args);
         db->Process();
     }
@@ -322,17 +322,17 @@ NAN_METHOD(Database::Configure) {
 
     REQUIRE_ARGUMENTS(2);
 
-    if (args[0]->Equals(String::NewSymbol("trace"))) {
+    if (args[0]->Equals(NanSymbol("trace"))) {
         Local<Function> handle;
         Baton* baton = new Baton(db, handle);
         db->Schedule(RegisterTraceCallback, baton);
     }
-    else if (args[0]->Equals(String::NewSymbol("profile"))) {
+    else if (args[0]->Equals(NanSymbol("profile"))) {
         Local<Function> handle;
         Baton* baton = new Baton(db, handle);
         db->Schedule(RegisterProfileCallback, baton);
     }
-    else if (args[0]->Equals(String::NewSymbol("busyTimeout"))) {
+    else if (args[0]->Equals(NanSymbol("busyTimeout"))) {
         if (!args[1]->IsInt32()) {
             return NanThrowTypeError("Value must be an integer");
         }
@@ -344,7 +344,7 @@ NAN_METHOD(Database::Configure) {
     else {
         return NanThrowError(Exception::Error(String::Concat(
             args[0]->ToString(),
-            String::New(" is not a valid configuration option")
+            NanNew<String>(" is not a valid configuration option")
         )));
     }
 
@@ -393,8 +393,8 @@ void Database::TraceCallback(Database* db, std::string* sql) {
     // Note: This function is called in the main V8 thread.
     NanScope();
     Local<Value> argv[] = {
-        String::NewSymbol("trace"),
-        String::New(sql->c_str())
+        NanSymbol("trace"),
+        NanNew<String>(sql->c_str())
     };
     EMIT_EVENT(NanObjectWrapHandle(db), 2, argv);
     delete sql;
@@ -432,9 +432,9 @@ void Database::ProfileCallback(void* db, const char* sql, sqlite3_uint64 nsecs)
 void Database::ProfileCallback(Database *db, ProfileInfo* info) {
     NanScope();
     Local<Value> argv[] = {
-        String::NewSymbol("profile"),
-        String::New(info->sql.c_str()),
-        Integer::New((double)info->nsecs / 1000000.0)
+        NanSymbol("profile"),
+        NanNew<String>(info->sql.c_str()),
+        NanNew<Integer>((double)info->nsecs / 1000000.0)
     };
     EMIT_EVENT(NanObjectWrapHandle(db), 3, argv);
     delete info;
@@ -476,10 +476,10 @@ void Database::UpdateCallback(Database *db, UpdateInfo* info) {
     NanScope();
 
     Local<Value> argv[] = {
-        String::NewSymbol(sqlite_authorizer_string(info->type)),
-        String::New(info->database.c_str()),
-        String::New(info->table.c_str()),
-        Integer::New(info->rowid),
+        NanSymbol(sqlite_authorizer_string(info->type)),
+        NanNew<String>(info->database.c_str()),
+        NanNew<String>(info->table.c_str()),
+        NanNew<Integer>(info->rowid),
     };
     EMIT_EVENT(NanObjectWrapHandle(db), 4, argv);
     delete info;
@@ -534,19 +534,19 @@ void Database::Work_AfterExec(uv_work_t* req) {
     Local<Function> cb = NanPersistentToLocal(baton->callback);
 
     if (baton->status != SQLITE_OK) {
-        EXCEPTION(String::New(baton->message.c_str()), baton->status, exception);
+        EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception);
 
         if (!cb.IsEmpty() && cb->IsFunction()) {
             Local<Value> argv[] = { exception };
             TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv);
         }
         else {
-            Local<Value> args[] = { String::NewSymbol("error"), exception };
+            Local<Value> args[] = { NanSymbol("error"), exception };
             EMIT_EVENT(NanObjectWrapHandle(db), 2, args);
         }
     }
     else if (!cb.IsEmpty() && cb->IsFunction()) {
-        Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+        Local<Value> argv[] = { NanNew(NanNull()) };
         TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv);
     }
 
@@ -577,7 +577,7 @@ void Database::Work_Wait(Baton* baton) {
 
     Local<Function> cb = NanPersistentToLocal(baton->callback);
     if (!cb.IsEmpty() && cb->IsFunction()) {
-        Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+        Local<Value> argv[] = { NanNew(NanNull()) };
         TRY_CATCH_CALL(NanObjectWrapHandle(baton->db), cb, 1, argv);
     }
 
@@ -637,19 +637,19 @@ void Database::Work_AfterLoadExtension(uv_work_t* req) {
     Local<Function> cb = NanPersistentToLocal(baton->callback);
 
     if (baton->status != SQLITE_OK) {
-        EXCEPTION(String::New(baton->message.c_str()), baton->status, exception);
+        EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception);
 
         if (!cb.IsEmpty() && cb->IsFunction()) {
             Local<Value> argv[] = { exception };
             TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv);
         }
         else {
-            Local<Value> args[] = { String::NewSymbol("error"), exception };
+            Local<Value> args[] = { NanSymbol("error"), exception };
             EMIT_EVENT(NanObjectWrapHandle(db), 2, args);
         }
     }
     else if (!cb.IsEmpty() && cb->IsFunction()) {
-        Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+        Local<Value> argv[] = { NanNew(NanNull()) };
         TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv);
     }
 

src/database.h

@@ -40,11 +40,11 @@ public:
                 db(db_), status(SQLITE_OK) {
             db->Ref();
             request.data = this;
-            NanAssignPersistent(Function, callback, cb_);
+            NanAssignPersistent(callback, cb_);
         }
         virtual ~Baton() {
             db->Unref();
-            callback.Dispose();
+            NanDisposePersistent(callback);
         }
     };
 

src/macros.h

@@ -57,54 +57,54 @@ const char* sqlite_authorizer_string(int type);
 
 #define DEFINE_CONSTANT_INTEGER(target, constant, name)                        \
     (target)->Set(                                                             \
-        String::NewSymbol(#name),                                              \
-        Integer::New(constant),                                                \
+        NanSymbol(#name),                                                      \
+        NanNew<Integer>(constant),                                             \
         static_cast<PropertyAttribute>(ReadOnly | DontDelete)                  \
     );
 
 #define DEFINE_CONSTANT_STRING(target, constant, name)                         \
     (target)->Set(                                                             \
-        String::NewSymbol(#name),                                              \
-        String::NewSymbol(constant),                                           \
+        NanSymbol(#name),                                                      \
+        NanSymbol(constant),                                                   \
         static_cast<PropertyAttribute>(ReadOnly | DontDelete)                  \
     );
 
 
 #define NODE_SET_GETTER(target, name, function)                                \
     (target)->InstanceTemplate()                                               \
-        ->SetAccessor(String::NewSymbol(name), (function));
+        ->SetAccessor(NanSymbol(name), (function));
 
 #define GET_STRING(source, name, property)                                     \
-    String::Utf8Value name((source)->Get(String::NewSymbol(property)));
+    String::Utf8Value name((source)->Get(NanSymbol(property)));
 
 #define GET_INTEGER(source, name, property)                                    \
-    int name = (source)->Get(String::NewSymbol(property))->Int32Value();
+    int name = (source)->Get(NanSymbol(property))->Int32Value();
 
 #define EXCEPTION(msg, errno, name)                                            \
     Local<Value> name = Exception::Error(                                      \
         String::Concat(                                                        \
             String::Concat(                                                    \
-                String::NewSymbol(sqlite_code_string(errno)),                  \
-                String::NewSymbol(": ")                                        \
+                NanSymbol(sqlite_code_string(errno)),                          \
+                NanSymbol(": ")                                                \
             ),                                                                 \
             (msg)                                                              \
         )                                                                      \
     );                                                                         \
     Local<Object> name ##_obj = name->ToObject();                              \
-    name ##_obj->Set(String::NewSymbol("errno"), Integer::New(errno));         \
-    name ##_obj->Set(String::NewSymbol("code"),                                \
-        String::NewSymbol(sqlite_code_string(errno)));
+    name ##_obj->Set(NanSymbol("errno"), NanNew<Integer>(errno));              \
+    name ##_obj->Set(NanSymbol("code"),                                        \
+        NanSymbol(sqlite_code_string(errno)));
 
 
 #define EMIT_EVENT(obj, argc, argv)                                            \
     TRY_CATCH_CALL((obj),                                                      \
-        Local<Function>::Cast((obj)->Get(String::NewSymbol("emit"))),          \
+        Local<Function>::Cast((obj)->Get(NanSymbol("emit"))),                  \
         argc, argv                                                             \
     );
 
 #define TRY_CATCH_CALL(context, callback, argc, argv)                          \
 {   TryCatch try_catch;                                                        \
-    MakeCallback((context), (callback), (argc), (argv));                       \
+    NanMakeCallback((context), (callback), (argc), (argv));                    \
     if (try_catch.HasCaught()) {                                               \
         FatalException(try_catch);                                             \
     }                                                                          }

src/statement.cc

@@ -14,10 +14,10 @@ Persistent<FunctionTemplate> Statement::constructor_template;
 void Statement::Init(Handle<Object> target) {
     NanScope();
 
-    Local<FunctionTemplate> t = FunctionTemplate::New(New);
+    Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New);
 
     t->InstanceTemplate()->SetInternalFieldCount(1);
-    t->SetClassName(String::NewSymbol("Statement"));
+    t->SetClassName(NanSymbol("Statement"));
 
     NODE_SET_PROTOTYPE_METHOD(t, "bind", Bind);
     NODE_SET_PROTOTYPE_METHOD(t, "get", Get);
@@ -27,8 +27,8 @@ void Statement::Init(Handle<Object> target) {
     NODE_SET_PROTOTYPE_METHOD(t, "reset", Reset);
     NODE_SET_PROTOTYPE_METHOD(t, "finalize", Finalize);
 
-    NanAssignPersistent(FunctionTemplate, constructor_template, t);
-    target->Set(String::NewSymbol("Statement"),
+    NanAssignPersistent(constructor_template, t);
+    target->Set(NanSymbol("Statement"),
         t->GetFunction());
 }
 
@@ -63,7 +63,7 @@ template <class T> void Statement::Error(T* baton) {
     Statement* stmt = baton->stmt;
     // Fail hard on logic errors.
     assert(stmt->status != 0);
-    EXCEPTION(String::New(stmt->message.c_str()), stmt->status, exception);
+    EXCEPTION(NanNew<String>(stmt->message.c_str()), stmt->status, exception);
 
     Local<Function> cb = NanPersistentToLocal(baton->callback);
 
@@ -72,7 +72,7 @@ template <class T> void Statement::Error(T* baton) {
         TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv);
     }
     else {
-        Local<Value> argv[] = { String::NewSymbol("error"), exception };
+        Local<Value> argv[] = { NanSymbol("error"), exception };
         EMIT_EVENT(NanObjectWrapHandle(stmt), 2, argv);
     }
 }
@@ -100,7 +100,7 @@ NAN_METHOD(Statement::New) {
     Database* db = ObjectWrap::Unwrap<Database>(args[0]->ToObject());
     Local<String> sql = Local<String>::Cast(args[1]);
 
-    args.This()->Set(String::NewSymbol("sql"), sql, ReadOnly);
+    args.This()->Set(NanSymbol("sql"), sql, ReadOnly);
 
     Statement* stmt = new Statement(db);
     stmt->Wrap(args.This());
@@ -156,7 +156,7 @@ void Statement::Work_AfterPrepare(uv_work_t* req) {
         stmt->prepared = true;
         Local<Function> cb = NanPersistentToLocal(baton->callback);
         if (!cb.IsEmpty() && cb->IsFunction()) {
-            Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+            Local<Value> argv[] = { NanNew(NanNull()) };
             TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv);
         }
     }
@@ -340,7 +340,7 @@ void Statement::Work_AfterBind(uv_work_t* req) {
         // Fire callbacks.
         Local<Function> cb = NanPersistentToLocal(baton->callback);
         if (!cb.IsEmpty() && cb->IsFunction()) {
-            Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+            Local<Value> argv[] = { NanNew(NanNull()) };
             TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv);
         }
     }
@@ -405,11 +405,11 @@ void Statement::Work_AfterGet(uv_work_t* req) {
         if (!cb.IsEmpty() && cb->IsFunction()) {
             if (stmt->status == SQLITE_ROW) {
                 // Create the result array from the data we acquired.
-                Local<Value> argv[] = { NanNewLocal<Value>(Null()), RowToJS(&baton->row) };
+                Local<Value> argv[] = { NanNew(NanNull()), RowToJS(&baton->row) };
                 TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 2, argv);
             }
             else {
-                Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+                Local<Value> argv[] = { NanNew(NanNull()) };
                 TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv);
             }
         }
@@ -473,10 +473,10 @@ void Statement::Work_AfterRun(uv_work_t* req) {
         // Fire callbacks.
         Local<Function> cb = NanPersistentToLocal(baton->callback);
         if (!cb.IsEmpty() && cb->IsFunction()) {
-            NanObjectWrapHandle(stmt)->Set(String::NewSymbol("lastID"), Local<Integer>(Integer::New(baton->inserted_id)));
-            NanObjectWrapHandle(stmt)->Set(String::NewSymbol("changes"), Local<Integer>(Integer::New(baton->changes)));
+            NanObjectWrapHandle(stmt)->Set(NanSymbol("lastID"), NanNew<Integer>(baton->inserted_id));
+            NanObjectWrapHandle(stmt)->Set(NanSymbol("changes"), NanNew<Integer>(baton->changes));
 
-            Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+            Local<Value> argv[] = { NanNew(NanNull()) };
             TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv);
         }
     }
@@ -541,7 +541,7 @@ void Statement::Work_AfterAll(uv_work_t* req) {
         if (!cb.IsEmpty() && cb->IsFunction()) {
             if (baton->rows.size()) {
                 // Create the result array from the data we acquired.
-                Local<Array> result(Array::New(baton->rows.size()));
+                Local<Array> result(NanNew<Array>(baton->rows.size()));
                 Rows::const_iterator it = baton->rows.begin();
                 Rows::const_iterator end = baton->rows.end();
                 for (int i = 0; it < end; ++it, i++) {
@@ -549,14 +549,14 @@ void Statement::Work_AfterAll(uv_work_t* req) {
                     delete *it;
                 }
 
-                Local<Value> argv[] = { NanNewLocal<Value>(Null()), result };
+                Local<Value> argv[] = { NanNew(NanNull()), result };
                 TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 2, argv);
             }
             else {
                 // There were no result rows.
                 Local<Value> argv[] = {
-                    NanNewLocal<Value>(Null()),
-                    NanNewLocal<Value>(Array::New(0))
+                    NanNew(NanNull()),
+                    NanNew<Array>(0)
                 };
                 TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 2, argv);
             }
@@ -582,7 +582,7 @@ NAN_METHOD(Statement::Each) {
         return NanThrowError("Data type is not supported");
     }
     else {
-        NanAssignPersistent(Function, baton->completed, completed);
+        NanAssignPersistent(baton->completed, completed);
         stmt->Schedule(Work_BeginEach, baton);
         NanReturnValue(args.This());
     }
@@ -593,8 +593,8 @@ void Statement::Work_BeginEach(Baton* baton) {
     // the event loop. This prevents dangling events.
     EachBaton* each_baton = static_cast<EachBaton*>(baton);
     each_baton->async = new Async(each_baton->stmt, AsyncEach);
-    NanAssignPersistent(Function, each_baton->async->item_cb, each_baton->callback);
-    NanAssignPersistent(Function, each_baton->async->completed_cb, each_baton->completed);
+    NanAssignPersistent(each_baton->async->item_cb, each_baton->callback);
+    NanAssignPersistent(each_baton->async->completed_cb, each_baton->completed);
 
     STATEMENT_BEGIN(Each);
 }
@@ -667,7 +667,7 @@ void Statement::AsyncEach(uv_async_t* handle, int status) {
         Local<Function> cb = NanPersistentToLocal(async->item_cb);
         if (!cb.IsEmpty() && cb->IsFunction()) {
             Local<Value> argv[2];
-            argv[0] = NanNewLocal<Value>(Null());
+            argv[0] = NanNew(NanNull());
 
             Rows::const_iterator it = rows.begin();
             Rows::const_iterator end = rows.end();
@@ -685,8 +685,8 @@ void Statement::AsyncEach(uv_async_t* handle, int status) {
         if (!cb.IsEmpty() &&
                 cb->IsFunction()) {
             Local<Value> argv[] = {
-                NanNewLocal<Value>(Null()),
-                Integer::New(async->retrieved)
+                NanNew(NanNull()),
+                NanNew<Integer>(async->retrieved)
             };
             TRY_CATCH_CALL(NanObjectWrapHandle(async->stmt), cb, 2, argv);
         }
@@ -735,7 +735,7 @@ void Statement::Work_AfterReset(uv_work_t* req) {
     // Fire callbacks.
     Local<Function> cb = NanPersistentToLocal(baton->callback);
     if (!cb.IsEmpty() && cb->IsFunction()) {
-        Local<Value> argv[] = { NanNewLocal<Value>(Null()) };
+        Local<Value> argv[] = { NanNew(NanNull()) };
         TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv);
     }
 
@@ -743,7 +743,7 @@ void Statement::Work_AfterReset(uv_work_t* req) {
 }
 
 Local<Object> Statement::RowToJS(Row* row) {
-    Local<Object> result(Object::New());
+    Local<Object> result(NanNew<Object>());
 
     Row::const_iterator it = row->begin();
     Row::const_iterator end = row->end();
@@ -754,23 +754,23 @@ Local<Object> Statement::RowToJS(Row* row) {
 
         switch (field->type) {
             case SQLITE_INTEGER: {
-                value = Local<Value>(Number::New(((Values::Integer*)field)->value));
+                value = NanNew<Number>(((Values::Integer*)field)->value);
             } break;
             case SQLITE_FLOAT: {
-                value = Local<Value>(Number::New(((Values::Float*)field)->value));
+                value = NanNew<Number>(((Values::Float*)field)->value);
             } break;
             case SQLITE_TEXT: {
-                value = Local<Value>(String::New(((Values::Text*)field)->value.c_str(), ((Values::Text*)field)->value.size()));
+                value = NanNew<String>(((Values::Text*)field)->value.c_str(), ((Values::Text*)field)->value.size());
             } break;
             case SQLITE_BLOB: {
-                value = NanNewLocal<Value>(NanNewBufferHandle(((Values::Blob*)field)->value, ((Values::Blob*)field)->length));
+                value = NanNew(NanNewBufferHandle(((Values::Blob*)field)->value, ((Values::Blob*)field)->length));
             } break;
             case SQLITE_NULL: {
-                value = NanNewLocal<Value>(Null());
+                value = NanNew(NanNull());
             } break;
         }
 
-        result->Set(String::NewSymbol(field->name.c_str()), value);
+        result->Set(NanSymbol(field->name.c_str()), value);
 
         DELETE_FIELD(field);
     }
@@ -848,7 +848,7 @@ void Statement::CleanQueue() {
     if (prepared && !queue.empty()) {
         // This statement has already been prepared and is now finalized.
         // Fire error for all remaining items in the queue.
-        EXCEPTION(String::New("Statement is already finalized"), SQLITE_MISUSE, exception);
+        EXCEPTION(NanNew<String>("Statement is already finalized"), SQLITE_MISUSE, exception);
         Local<Value> argv[] = { exception };
         bool called = false;
 
@@ -874,7 +874,7 @@ void Statement::CleanQueue() {
         // When we couldn't call a callback function, emit an error on the
         // Statement object.
         if (!called) {
-            Local<Value> args[] = { String::NewSymbol("error"), exception };
+            Local<Value> args[] = { NanSymbol("error"), exception };
             EMIT_EVENT(NanObjectWrapHandle(this), 2, args);
         }
     }

src/statement.h

@@ -88,7 +88,7 @@ public:
         Baton(Statement* stmt_, Handle<Function> cb_) : stmt(stmt_) {
             stmt->Ref();
             request.data = this;
-            NanAssignPersistent(Function, callback, cb_);
+            NanAssignPersistent(callback, cb_);
         }
         virtual ~Baton() {
             for (unsigned int i = 0; i < parameters.size(); i++) {
@@ -96,7 +96,7 @@ public:
                 DELETE_FIELD(field);
             }
             stmt->Unref();
-            callback.Dispose();
+            NanDisposePersistent(callback);
         }
     };
 
@@ -176,8 +176,8 @@ public:
 
         ~Async() {
             stmt->Unref();
-            item_cb.Dispose();
-            completed_cb.Dispose();
+            NanDisposePersistent(item_cb);
+            NanDisposePersistent(completed_cb);
             NODE_SQLITE3_MUTEX_DESTROY
         }
     };