adapt to V8 7.0

fivdi · Sep 29, 2018 · 92af5c2 · 92af5c2
1 parent 95e91f2
commit 92af5c2
Show file tree

Hide file tree

Showing 16 changed files with 75 additions and 67 deletions.
diff --git a/History.md b/History.md
@@ -1,3 +1,11 @@
+Unpublished
+===========
+
+  * update dependencies (nan v2.11.1, async v2.6.1, lodash v4.17.11)
+  * adapt to V8 7.0: replace v8Value->Int32Value() with Nan::To<int32_t>(v8Value).FromJust()
+  * adapt to V8 7.0: replace v8Value->Uint32Value() with Nan::To<uint32_t>(v8Value).FromJust()
+  * adapt to V8 7.0: replace v8Value->BooleanValue() with Nan::To<bool>(v8Value).FromJust()
+
 4.0.1 / Jul 28 2018
 ===================
 

diff --git a/package.json b/package.json
@@ -20,11 +20,11 @@
   },
   "dependencies": {
     "bindings": "^1.3.0",
-    "nan": "^2.10.0"
+    "nan": "^2.11.1"
   },
   "devDependencies": {
-    "async": "^2.6.0",
-    "lodash": "^4.17.5"
+    "async": "^2.6.1",
+    "lodash": "^4.17.11"
   },
   "keywords": [
     "i2c",

diff --git a/src/deviceid.cc b/src/deviceid.cc
@@ -46,8 +46,8 @@ NAN_METHOD(DeviceIdAsync) {
       "incorrect arguments passed to deviceId(int fd, int address, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u16 address = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u16 address = Nan::To<int32_t>(info[1]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[2].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new DeviceIdWorker(callback, fd, address));
@@ -59,8 +59,8 @@ NAN_METHOD(DeviceIdSync) {
       "incorrect arguments passed to deviceIdSync(int fd, int address)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u16 address = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u16 address = Nan::To<int32_t>(info[1]).FromJust();
 
   __s32 ret = DeviceId(fd, address);
   if (ret == -1) {

diff --git a/src/i2cfuncs.cc b/src/i2cfuncs.cc
@@ -45,7 +45,7 @@ NAN_METHOD(I2cFuncsAsync) {
       "incorrect arguments passed to i2cFuncs(int fd, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new I2cFuncsWorker(callback, fd));
@@ -57,7 +57,7 @@ NAN_METHOD(I2cFuncsSync) {
       "incorrect arguments passed to i2cFuncsSync(int fd)"));
   }
 
-  int fd = info[0]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
 
   unsigned long i2cfuncs;
   __s32 ret = I2cFuncs(fd, &i2cfuncs);

diff --git a/src/readblock.cc b/src/readblock.cc
@@ -63,8 +63,8 @@ NAN_METHOD(ReadBlockAsync) {
       "(int fd, int cmd, Buffer buffer, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[2].As<v8::Object>();
   Nan::Callback *callback = new Nan::Callback(info[3].As<v8::Function>());
 
@@ -95,8 +95,8 @@ NAN_METHOD(ReadBlockSync) {
       "(int fd, int cmd, Buffer buffer)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[2].As<v8::Object>();
 
   __u8* bufferData = (__u8*) node::Buffer::Data(bufferHandle);

diff --git a/src/readbyte.cc b/src/readbyte.cc
@@ -46,8 +46,8 @@ NAN_METHOD(ReadByteAsync) {
       "incorrect arguments passed to readByte(int fd, int cmd, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[2].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new ReadByteWorker(callback, fd, cmd));
@@ -59,8 +59,8 @@ NAN_METHOD(ReadByteSync) {
       "incorrect arguments passed to readByteSync(int fd, int cmd)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
 
   __s32 byte = ReadByte(fd, cmd);
   if (byte == -1) {

diff --git a/src/readi2cblock.cc b/src/readi2cblock.cc
@@ -66,9 +66,9 @@ NAN_METHOD(ReadI2cBlockAsync) {
       "(int fd, int cmd, int length, Buffer buffer, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u32 length = info[2]->Uint32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u32 length = Nan::To<uint32_t>(info[2]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[3].As<v8::Object>();
   Nan::Callback *callback = new Nan::Callback(info[4].As<v8::Function>());
 
@@ -106,9 +106,9 @@ NAN_METHOD(ReadI2cBlockSync) {
       "(int fd, int cmd, int length, Buffer buffer)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u32 length = info[2]->Uint32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u32 length = Nan::To<uint32_t>(info[2]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[3].As<v8::Object>();
 
   __u8* bufferData = (__u8*) node::Buffer::Data(bufferHandle);

diff --git a/src/readword.cc b/src/readword.cc
@@ -46,8 +46,8 @@ NAN_METHOD(ReadWordAsync) {
       "incorrect arguments passed to readWord(int fd, int cmd, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[2].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new ReadWordWorker(callback, fd, cmd));
@@ -59,8 +59,8 @@ NAN_METHOD(ReadWordSync) {
       "incorrect arguments passed to readWordSync(int fd, int cmd)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
 
   __s32 word = ReadWord(fd, cmd);
   if (word == -1) {

diff --git a/src/receivebyte.cc b/src/receivebyte.cc
@@ -45,7 +45,7 @@ NAN_METHOD(ReceiveByteAsync) {
       "incorrect arguments passed to receiveByte(int fd, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new ReceiveByteWorker(callback, fd));
@@ -57,7 +57,7 @@ NAN_METHOD(ReceiveByteSync) {
       "incorrect arguments passed to receiveByteSync(int fd)"));
   }
 
-  int fd = info[0]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
 
   __s32 byte = ReceiveByte(fd);
   if (byte == -1) {

diff --git a/src/sendbyte.cc b/src/sendbyte.cc
@@ -44,8 +44,8 @@ NAN_METHOD(SendByteAsync) {
       "incorrect arguments passed to sendByte(int fd, int byte, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 byte = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 byte = Nan::To<int32_t>(info[1]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[2].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new SendByteWorker(callback, fd, byte));
@@ -57,8 +57,8 @@ NAN_METHOD(SendByteSync) {
       "incorrect arguments passed to sendByteSync(int fd, int byte)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 byte = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 byte = Nan::To<int32_t>(info[1]).FromJust();
 
   __s32 ret = SendByte(fd, byte);
   if (ret == -1) {

diff --git a/src/setaddr.cc b/src/setaddr.cc
@@ -44,9 +44,9 @@ NAN_METHOD(SetAddrAsync) {
       "incorrect arguments passed to setAddr(int fd, int addr, bool forceAccess, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  int addr = info[1]->Int32Value();
-  bool forceAccess = info[2]->BooleanValue();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  int addr = Nan::To<int32_t>(info[1]).FromJust();
+  bool forceAccess = Nan::To<bool>(info[2]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[3].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new SetAddrWorker(callback, fd, addr, forceAccess));
@@ -58,9 +58,9 @@ NAN_METHOD(SetAddrSync) {
       "incorrect arguments passed to setAddrSync(int fd, int addr, bool forceAccess)"));
   }
 
-  int fd = info[0]->Int32Value();
-  int addr = info[1]->Int32Value();
-  bool forceAccess = info[2]->BooleanValue();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  int addr = Nan::To<int32_t>(info[1]).FromJust();
+  bool forceAccess = Nan::To<bool>(info[2]).FromJust();
 
   if (SetAddr(fd, addr, forceAccess) != 0) {
     return Nan::ThrowError(Nan::ErrnoException(errno, "setAddrSync", ""));

diff --git a/src/writeblock.cc b/src/writeblock.cc
@@ -67,9 +67,9 @@ NAN_METHOD(WriteBlockAsync) {
       "(int fd, int cmd, int length, Buffer buffer, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u32 length = info[2]->Uint32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u32 length = Nan::To<uint32_t>(info[2]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[3].As<v8::Object>();
   Nan::Callback *callback = new Nan::Callback(info[4].As<v8::Function>());
 
@@ -107,9 +107,9 @@ NAN_METHOD(WriteBlockSync) {
       "(int fd, int cmd, int length, Buffer buffer)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u32 length = info[2]->Uint32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u32 length = Nan::To<uint32_t>(info[2]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[3].As<v8::Object>();
 
   const __u8* bufferData = (const __u8*) node::Buffer::Data(bufferHandle);

diff --git a/src/writebyte.cc b/src/writebyte.cc
@@ -46,9 +46,9 @@ NAN_METHOD(WriteByteAsync) {
       "(int fd, int cmd, int byte, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u8 byte = info[2]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u8 byte = Nan::To<int32_t>(info[2]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[3].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new WriteByteWorker(callback, fd, cmd, byte));
@@ -60,9 +60,9 @@ NAN_METHOD(WriteByteSync) {
       "incorrect arguments passed to writeByteSync(int fd, int cmd, int byte)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u8 byte = info[2]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u8 byte = Nan::To<int32_t>(info[2]).FromJust();
 
   __s32 ret = WriteByte(fd, cmd, byte);
   if (ret == -1) {

diff --git a/src/writei2cblock.cc b/src/writei2cblock.cc
@@ -65,9 +65,9 @@ NAN_METHOD(WriteI2cBlockAsync) {
       "(int fd, int cmd, int length, Buffer buffer, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u32 length = info[2]->Uint32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u32 length = Nan::To<uint32_t>(info[2]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[3].As<v8::Object>();
   Nan::Callback *callback = new Nan::Callback(info[4].As<v8::Function>());
 
@@ -105,9 +105,9 @@ NAN_METHOD(WriteI2cBlockSync) {
       "(int fd, int cmd, int length, Buffer buffer)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u32 length = info[2]->Uint32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u32 length = Nan::To<uint32_t>(info[2]).FromJust();
   v8::Local<v8::Object> bufferHandle = info[3].As<v8::Object>();
 
   const __u8* bufferData = (const __u8*) node::Buffer::Data(bufferHandle);

diff --git a/src/writequick.cc b/src/writequick.cc
@@ -44,8 +44,8 @@ NAN_METHOD(WriteQuickAsync) {
       "incorrect arguments passed to writeQuick(int fd, int bit, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 bit = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 bit = Nan::To<int32_t>(info[1]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[2].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new WriteQuickWorker(callback, fd, bit));
@@ -57,8 +57,8 @@ NAN_METHOD(WriteQuickSync) {
       "incorrect arguments passed to writeQuickSync(int fd, int bit)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 bit = info[1]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 bit = Nan::To<int32_t>(info[1]).FromJust();
 
   __s32 ret = WriteQuick(fd, bit);
   if (ret == -1) {

diff --git a/src/writeword.cc b/src/writeword.cc
@@ -46,9 +46,9 @@ NAN_METHOD(WriteWordAsync) {
       "(int fd, int cmd, int word, function cb)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u16 word = info[2]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u16 word = Nan::To<int32_t>(info[2]).FromJust();
   Nan::Callback *callback = new Nan::Callback(info[3].As<v8::Function>());
 
   Nan::AsyncQueueWorker(new WriteWordWorker(callback, fd, cmd, word));
@@ -61,9 +61,9 @@ NAN_METHOD(WriteWordSync) {
       "(int fd, int cmd, int word)"));
   }
 
-  int fd = info[0]->Int32Value();
-  __u8 cmd = info[1]->Int32Value();
-  __u16 word = info[2]->Int32Value();
+  int fd = Nan::To<int32_t>(info[0]).FromJust();
+  __u8 cmd = Nan::To<int32_t>(info[1]).FromJust();
+  __u16 word = Nan::To<int32_t>(info[2]).FromJust();
 
   __s32 ret = WriteWord(fd, cmd, word);
   if (ret == -1) {