From 8d56facea61dffd29e8b13f771d728fba98e07ce Mon Sep 17 00:00:00 2001
From: durs <dy@hotbox.ru>
Date: Sun, 16 Apr 2017 10:52:39 +0300
Subject: [PATCH 1/2] sources corrected for new V8 interface (node > 4.0.0)

---
 README.md                    |    2 +-
 package.json                 |    6 +-
 src/client.cc                |  378 ++++-----
 src/client.h                 |    8 +-
 src/force_gc_extension.cc    |   70 +-
 src/force_gc_internal.cc     |   63 +-
 src/node_win32ole.cc         |  119 ++-
 src/node_win32ole.h          |   69 +-
 src/ole32core.cpp            |   20 +-
 src/ole32core.h              |   71 +-
 src/v8variant.cc             | 1400 +++++++++++++++++-----------------
 src/v8variant.h              |   66 +-
 src/win32ole_gettimeofday.cc |  126 ++-
 13 files changed, 1212 insertions(+), 1186 deletions(-)

diff --git a/README.md b/README.md
index c321ebf..6438574 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # NAME
 
-node-win32ole - Asynchronous, non-blocking win32ole bindings for [node.js](https://github.com/joyent/node) powered by v8 engine .
+node-win32ole - Windows COM bindings for [node.js](https://github.com/joyent/node)
 
 win32ole makes accessibility from node.js to Excel, Word, Access, Outlook, InternetExplorer, WSH ( ActiveXObject / COM ) and so on. It does not need TypeLibrary.
 
diff --git a/package.json b/package.json
index 2cbf014..26600aa 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "win32ole",
-  "version": "0.1.3",
-  "description": "Asynchronous, non-blocking win32ole bindings",
+  "version": "0.2.0",
+  "description": "Windows COM bindings",
   "homepage": "https://github.com/idobatter/node-win32ole",
   "keywords": [
     "OLE", "COM", "ActiveX", "ActiveXObject", "CreateObject", "WSH", "WMI",
@@ -33,7 +33,7 @@
     "ref": ">= 0.1.3"
   },
   "engines": {
-    "node": ">= 0.8.18 && < 0.9.0"
+    "node": ">= 4.0.0"
   },
   "scripts": {
     "test": "nmake /a test"
diff --git a/src/client.cc b/src/client.cc
index 0c289b5..65e8e38 100644
--- a/src/client.cc
+++ b/src/client.cc
@@ -10,211 +10,223 @@ using namespace ole32core;
 
 namespace node_win32ole {
 
-Persistent<FunctionTemplate> Client::clazz;
-
-void Client::Init(Handle<Object> target)
-{
-  HandleScope scope;
-  Local<FunctionTemplate> t = FunctionTemplate::New(New);
-  clazz = Persistent<FunctionTemplate>::New(t);
-  clazz->InstanceTemplate()->SetInternalFieldCount(2);
-  clazz->SetClassName(String::NewSymbol("Client"));
-//  NODE_SET_PROTOTYPE_METHOD(clazz, "New", New);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "Dispatch", Dispatch);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "Finalize", Finalize);
-  target->Set(String::NewSymbol("Client"), clazz->GetFunction());
-}
-
-Handle<Value> Client::New(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  if(!args.IsConstructCall())
-    return ThrowException(Exception::TypeError(
-      String::New("Use the new operator to create new Client objects")));
-  std::string cstr_locale(".ACP"); // default
-  if(args.Length() >= 1){
-    if(!args[0]->IsString())
-      return ThrowException(Exception::TypeError(
-        String::New("Argument 1 is not a String")));
-    String::Utf8Value u8s_locale(args[0]);
-    cstr_locale = std::string(*u8s_locale);
-  }
-  OLE32core *oc = new OLE32core();
-  if(!oc)
-    return ThrowException(Exception::TypeError(
-      String::New("Can't create new Client object (null OLE32core)")));
-  bool cnresult = false;
-  try{
-    cnresult = oc->connect(cstr_locale);
-  }catch(OLE32coreException e){
-    std::cerr << e.errorMessage((char *)cstr_locale.c_str());
-  }catch(char *e){
-    std::cerr << e << cstr_locale.c_str() << std::endl;
-  }
-  if(!cnresult)
-    return ThrowException(Exception::TypeError(
-      String::New("May be CoInitialize() is failed.")));
-  Local<Object> thisObject = args.This();
-  Client *cl = new Client(); // must catch exception
-  cl->Wrap(thisObject); // InternalField[0]
-  thisObject->SetInternalField(1, External::New(oc));
-  Persistent<Object> objectDisposer = Persistent<Object>::New(thisObject);
-  objectDisposer.MakeWeak(oc, Dispose);
-  DISPFUNCOUT();
-  return args.This();
-}
-
-Handle<Value> Client::Dispatch(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  BEVERIFY(done, args.Length() >= 1);
-  BEVERIFY(done, args[0]->IsString());
-  wchar_t *wcs;
-  {
-    String::Utf8Value u8s(args[0]); // must create here
-    wcs = u8s2wcs(*u8s);
-  }
-  BEVERIFY(done, wcs);
+    Persistent<FunctionTemplate> Client::clazz;
+
+    void Client::Init(Handle<Object> target)
+    {
+        Isolate* isolate = target->GetIsolate();
+
+        // Prepare constructor template
+        Local<String> clazz_name(String::NewFromUtf8(isolate, "Client"));
+        Local<FunctionTemplate> clazz = FunctionTemplate::New(isolate, New);
+        clazz->SetClassName(clazz_name);
+        clazz->InstanceTemplate()->SetInternalFieldCount(2);
+
+        NODE_SET_PROTOTYPE_METHOD(clazz, "Dispatch", Dispatch);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "Finalize", Finalize);
+
+        //constructor.Reset(isolate, clazz->GetFunction());
+        target->Set(clazz_name, clazz->GetFunction());
+    }
+
+    void Client::New(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        if (!args.IsConstructCall()) RETURN_TYPE_ERROR("Use the new operator to create new Client objects")
+        std::string cstr_locale(".ACP"); // default
+        if (args.Length() >= 1) {
+            if (!args[0]->IsString()) RETURN_TYPE_ERROR("Argument 1 is not a String")
+            String::Utf8Value u8s_locale(args[0]);
+            cstr_locale = std::string(*u8s_locale);
+        }
+        OLE32core *oc = new OLE32core();
+        if (!oc) RETURN_TYPE_ERROR("Can't create new Client object (null OLE32core)")
+        bool cnresult = false;
+        try {
+            cnresult = oc->connect(cstr_locale);
+        }
+        catch (OLE32coreException e) {
+            std::cerr << e.errorMessage((char *)cstr_locale.c_str());
+        }
+        catch (char *e) {
+            std::cerr << e << cstr_locale.c_str() << std::endl;
+        }
+        if (!cnresult) RETURN_TYPE_ERROR("May be CoInitialize() is failed.")
+
+        Local<Object> thisObject = args.This();
+        Client *cl = new Client(); // must catch exception
+        cl->Wrap(thisObject); // InternalField[0]
+        thisObject->SetInternalField(1, External::New(isolate, oc));
+        //Persistent<Object> objectDisposer = Persistent<Object>::New(isolate, thisObject);
+        //objectDisposer.MakeWeak(oc, Dispose);
+
+        args.GetReturnValue().Set(thisObject);
+        DISPFUNCOUT();
+    }
+
+    void Client::Dispatch(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        BEVERIFY(done, args.Length() >= 1);
+        BEVERIFY(done, args[0]->IsString());
+        wchar_t *wcs;
+        {
+            String::Utf8Value u8s(args[0]); // must create here
+            wcs = u8s2wcs(*u8s);
+        }
+        BEVERIFY(done, wcs);
 #ifdef DEBUG
-  char *mbs = wcs2mbs(wcs);
-  if(!mbs) free(wcs);
-  BEVERIFY(done, mbs);
-  fprintf(stderr, "ProgID: %s\n", mbs);
-  free(mbs);
+        char *mbs = wcs2mbs(wcs);
+        if (!mbs) free(wcs);
+        BEVERIFY(done, mbs);
+        fprintf(stderr, "ProgID: %s\n", mbs);
+        free(mbs);
 #endif
-  CLSID clsid;
-  HRESULT hr = CLSIDFromProgID(wcs, &clsid);
-  free(wcs);
-  BEVERIFY(done, !FAILED(hr));
+        CLSID clsid;
+        HRESULT hr = CLSIDFromProgID(wcs, &clsid);
+        free(wcs);
+        BEVERIFY(done, !FAILED(hr));
 #ifdef DEBUG
-  fprintf(stderr, "clsid:"); // 00024500-0000-0000-c000-000000000046 (Excel) ok
-  for(int i = 0; i < sizeof(CLSID); ++i)
-    fprintf(stderr, " %02x", ((unsigned char *)&clsid)[i]);
-  fprintf(stderr, "\n");
+        fprintf(stderr, "clsid:"); // 00024500-0000-0000-c000-000000000046 (Excel) ok
+        for (int i = 0; i < sizeof(CLSID); ++i)
+            fprintf(stderr, " %02x", ((unsigned char *)&clsid)[i]);
+        fprintf(stderr, "\n");
 #endif
-  Handle<Object> vApp = V8Variant::CreateUndefined();
-  BEVERIFY(done, !vApp.IsEmpty());
-  BEVERIFY(done, !vApp->IsUndefined());
-  BEVERIFY(done, vApp->IsObject());
-  OCVariant *app = castedInternalField<OCVariant>(vApp);
-  CHECK_OCV(app);
-  app->v.vt = VT_DISPATCH;
-  // When 'CoInitialize(NULL)' is not called first (and on the same instance),
-  // next functions will return many errors.
-  // (old style) GetActiveObject() returns 0x000036b7
-  //   The requested lookup key was not found in any active activation context.
-  // (OLE2) CoCreateInstance() returns 0x000003f0
-  //   An attempt was made to reference a token that does not exist.
-  REFIID riid = IID_IDispatch; // can't connect to Excel etc with IID_IUnknown
+        Handle<Object> vApp;
+        V8Variant::CreateUndefined(isolate, vApp);
+        BEVERIFY(done, !vApp.IsEmpty());
+        BEVERIFY(done, !vApp->IsUndefined());
+        BEVERIFY(done, vApp->IsObject());
+        OCVariant *app = castedInternalField<OCVariant>(vApp);
+        CHECK_OCV(app);
+        app->v.vt = VT_DISPATCH;
+        // When 'CoInitialize(NULL)' is not called first (and on the same instance),
+        // next functions will return many errors.
+        // (old style) GetActiveObject() returns 0x000036b7
+        //   The requested lookup key was not found in any active activation context.
+        // (OLE2) CoCreateInstance() returns 0x000003f0
+        //   An attempt was made to reference a token that does not exist.
+        REFIID riid = IID_IDispatch; // can't connect to Excel etc with IID_IUnknown
+
 #ifdef DEBUG // obsolete (it needs that OLE target has been already executed)
-  IUnknown *pUnk;
-  hr = GetActiveObject(clsid, NULL, (IUnknown **)&pUnk);
-  BEVERIFY(done, !FAILED(hr));
-  hr = pUnk->QueryInterface(riid, (void **)&app->v.pdispVal);
-  pUnk->Release();
+        IUnknown *pUnk;
+        hr = GetActiveObject(clsid, NULL, (IUnknown **)&pUnk);
+        BEVERIFY(done, !FAILED(hr));
+        hr = pUnk->QueryInterface(riid, (void **)&app->v.pdispVal);
+        pUnk->Release();
 #else
   // C -> C++ changes types (&clsid -> clsid, &IID_IDispatch -> IID_IDispatch)
   // options (CLSCTX_INPROC_SERVER CLSCTX_INPROC_HANDLER CLSCTX_LOCAL_SERVER)
-  DWORD ctx = CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER;
-  hr = CoCreateInstance(clsid, NULL, ctx, riid, (void **)&app->v.pdispVal);
-  if(FAILED(hr)){
-    // Retry with WOW6432 bridge option.
-    // This may not be a right way, but better.
-    BDISPFUNCDAT("FAILED CoCreateInstance: %d: 0x%08x\n", 0, hr);
+        DWORD ctx = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER;
+        hr = CoCreateInstance(clsid, NULL, ctx, riid, (void **)&app->v.pdispVal);
+        if (FAILED(hr)) {
+            // Retry with WOW6432 bridge option.
+            // This may not be a right way, but better.
+            BDISPFUNCDAT("FAILED CoCreateInstance: %d: 0x%08x\n", 0, hr);
 #if defined(_WIN64)
-    ctx |= CLSCTX_ACTIVATE_32_BIT_SERVER; // 32bit COM server on 64bit OS
+            ctx |= CLSCTX_ACTIVATE_32_BIT_SERVER; // 32bit COM server on 64bit OS
 #else
-    ctx |= CLSCTX_ACTIVATE_64_BIT_SERVER; // 64bit COM server on 32bit OS
+            ctx |= CLSCTX_ACTIVATE_64_BIT_SERVER; // 64bit COM server on 32bit OS
 #endif
-    hr = CoCreateInstance(clsid, NULL, ctx, riid, (void **)&app->v.pdispVal);
-  }
+            hr = CoCreateInstance(clsid, NULL, ctx, riid, (void **)&app->v.pdispVal);
+        }
 #endif
-  if(FAILED(hr)) BDISPFUNCDAT("FAILED CoCreateInstance: %d: 0x%08x\n", 1, hr);
-  BEVERIFY(done, !FAILED(hr));
-  DISPFUNCOUT();
-  return scope.Close(vApp);
-done:
-  DISPFUNCOUT();
-  return ThrowException(Exception::TypeError(String::New("Dispatch failed")));
-}
-
-Handle<Value> Client::Finalize(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
+        if (FAILED(hr)) BDISPFUNCDAT("FAILED CoCreateInstance: %d: 0x%08x\n", 1, hr);
+        BEVERIFY(done, !FAILED(hr));
+        DISPFUNCOUT();
+        args.GetReturnValue().Set(vApp);
+        return;
+    done:
+        DISPFUNCOUT();
+        RETURN_TYPE_ERROR("Dispatch failed");
+    }
+
+    void Client::Finalize(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
 #if(0)
-  std::cerr << __FUNCTION__ << " Finalizer is called\a" << std::endl;
-  std::cerr.flush();
+        std::cerr << __FUNCTION__ << " Finalizer is called\a" << std::endl;
+        std::cerr.flush();
 #endif
-  Local<Object> thisObject = args.This();
+        Local<Object> thisObject = args.This();
 #if(0)
-  Client *cl = ObjectWrap::Unwrap<Client>(thisObject);
-  if(cl) delete cl; // it has been already deleted ?
-  thisObject->SetInternalField(0, External::New(NULL));
+        Client *cl = ObjectWrap::Unwrap<Client>(thisObject);
+        if (cl) delete cl; // it has been already deleted ?
+        thisObject->SetInternalField(0, External::New(NULL));
 #endif
 #if(1) // now GC will call Disposer automatically
-  OLE32core *oc = castedInternalField<OLE32core>(thisObject);
-  if(oc){
-    try{
-      delete oc; // will call oc->disconnect();
-    }catch(OLE32coreException e){ std::cerr << e.errorMessage(__FUNCTION__);
-    }catch(char *e){ std::cerr << e << __FUNCTION__ << std::endl;
-    }
-  }
+        OLE32core *oc = castedInternalField<OLE32core>(thisObject);
+        if (oc) {
+            try {
+                delete oc; // will call oc->disconnect();
+            }
+            catch (OLE32coreException e) {
+                std::cerr << e.errorMessage(__FUNCTION__);
+            }
+            catch (char *e) {
+                std::cerr << e << __FUNCTION__ << std::endl;
+            }
+        }
 #endif
-  thisObject->SetInternalField(1, External::New(NULL));
-  DISPFUNCOUT();
-  return args.This();
-}
-
-void Client::Dispose(Persistent<Value> handle, void *param)
-{
-  DISPFUNCIN();
+        thisObject->SetInternalField(1, External::New(isolate, NULL));
+        args.GetReturnValue().Set(thisObject);
+        DISPFUNCOUT();
+    }
+
+    void Client::Dispose(Isolate* isolate, Persistent<Value> handle, void *param)
+    {
+        DISPFUNCIN();
 #if(0)
-//  std::cerr << __FUNCTION__ << " Disposer is called\a" << std::endl;
-  std::cerr << __FUNCTION__ << " Disposer is called" << std::endl;
-  std::cerr.flush();
+        //  std::cerr << __FUNCTION__ << " Disposer is called\a" << std::endl;
+        std::cerr << __FUNCTION__ << " Disposer is called" << std::endl;
+        std::cerr.flush();
 #endif
-  Local<Object> thisObject = handle->ToObject();
+        Local<Object> thisObject = handle.Get(isolate)->ToObject();
 #if(0) // it has been already deleted ?
-  Client *cl = ObjectWrap::Unwrap<Client>(thisObject);
-  if(!cl){
-    std::cerr << __FUNCTION__;
-    std::cerr << " InternalField[0] has been already deleted" << std::endl;
-    std::cerr.flush();
-  }else delete cl; // it has been already deleted ?
-  BEVERIFY(done, thisObject->InternalFieldCount() > 0);
-  thisObject->SetInternalField(0, External::New(NULL));
+        Client *cl = ObjectWrap::Unwrap<Client>(thisObject);
+        if (!cl) {
+            std::cerr << __FUNCTION__;
+            std::cerr << " InternalField[0] has been already deleted" << std::endl;
+            std::cerr.flush();
+        }
+        else delete cl; // it has been already deleted ?
+        BEVERIFY(done, thisObject->InternalFieldCount() > 0);
+        thisObject->SetInternalField(0, External::New(NULL));
 #endif
-  OLE32core *p = castedInternalField<OLE32core>(thisObject);
-  if(!p){
-    std::cerr << __FUNCTION__;
-    std::cerr << " InternalField[1] has been already deleted" << std::endl;
-    std::cerr.flush();
-  }
-//  else{
-    OLE32core *oc = static_cast<OLE32core *>(param); // oc may be same as p
-    if(oc){
-      try{
-        delete oc; // will call oc->disconnect();
-      }catch(OLE32coreException e){ std::cerr << e.errorMessage(__FUNCTION__);
-      }catch(char *e){ std::cerr << e << __FUNCTION__ << std::endl;
-      }
+        OLE32core *p = castedInternalField<OLE32core>(thisObject);
+        if (!p) {
+            std::cerr << __FUNCTION__;
+            std::cerr << " InternalField[1] has been already deleted" << std::endl;
+            std::cerr.flush();
+        }
+        //  else{
+        OLE32core *oc = static_cast<OLE32core *>(param); // oc may be same as p
+        if (oc) {
+            try {
+                delete oc; // will call oc->disconnect();
+            }
+            catch (OLE32coreException e) {
+                std::cerr << e.errorMessage(__FUNCTION__);
+            }
+            catch (char *e) {
+                std::cerr << e << __FUNCTION__ << std::endl;
+            }
+        }
+        //  }
+        BEVERIFY(done, thisObject->InternalFieldCount() > 1);
+        thisObject->SetInternalField(1, External::New(isolate, NULL));
+    done:
+        handle.Reset();
+        DISPFUNCOUT();
+    }
+
+    void Client::Finalize()
+    {
+        assert(!finalized);
+        finalized = true;
     }
-//  }
-  BEVERIFY(done, thisObject->InternalFieldCount() > 1);
-  thisObject->SetInternalField(1, External::New(NULL));
-done:
-  handle.Dispose();
-  DISPFUNCOUT();
-}
-
-void Client::Finalize()
-{
-  assert(!finalized);
-  finalized = true;
-}
 
 } // namespace node_win32ole
diff --git a/src/client.h b/src/client.h
index 6a06c77..5d93d86 100644
--- a/src/client.h
+++ b/src/client.h
@@ -11,14 +11,14 @@ class Client : public node::ObjectWrap {
 public:
   static Persistent<FunctionTemplate> clazz;
   static void Init(Handle<Object> target);
-  static Handle<Value> New(const Arguments& args);
-  static Handle<Value> Dispatch(const Arguments& args);
-  static Handle<Value> Finalize(const Arguments& args);
+  static void New(const FunctionCallbackInfo<Value>& args);
+  static void Dispatch(const FunctionCallbackInfo<Value>& args);
+  static void Finalize(const FunctionCallbackInfo<Value>& args);
 public:
   Client() : node::ObjectWrap(), finalized(false) {}
   ~Client() { if(!finalized) Finalize(); }
 protected:
-  static void Dispose(Persistent<Value> handle, void *param);
+  static void Dispose(Isolate* isolate, Persistent<Value> handle, void *param);
   void Finalize();
 protected:
   bool finalized;
diff --git a/src/force_gc_extension.cc b/src/force_gc_extension.cc
index 0cfa897..8f43b52 100644
--- a/src/force_gc_extension.cc
+++ b/src/force_gc_extension.cc
@@ -10,41 +10,39 @@ using namespace ole32core;
 
 namespace node_win32ole {
 
-Handle<Value> Method_force_gc_extension(const Arguments& args) // v8/gc : gc()
-{
-  BDISPFUNCDAT("context %s "__FUNCTION__" %s\n", "preset", "start");
-  // create context with extension(s)
-  const char *extensionNames[] = {"v8/gc",};
-  ExtensionConfiguration extensions(
-    sizeof(extensionNames) / sizeof(extensionNames[0]), extensionNames);
-  Handle<ObjectTemplate> global = ObjectTemplate::New();
-  // another way get 'global' by ( global = context->Global() ) but no context
-  // Persistent<Context> context = Context::New(NULL, global);
-  Persistent<Context> context = Context::New(&extensions, global);
-  Context::Scope context_scope(context);
-  BDISPFUNCDAT("context %s "__FUNCTION__" %s\n", "preset", "end");
-  HandleScope scope;
-  BDISPFUNCIN();
-  Local<String> sourceObj = String::New("gc()");
-  TryCatch try_catch;
-  Local<Script> scriptObj = Script::Compile(sourceObj);
-  if(scriptObj.IsEmpty()){
-    std::string msg("Can't compile v8/gc : gc();\n");
-    String::Utf8Value u8s(try_catch.Exception());
-    msg += *u8s;
-    return ThrowException(Exception::TypeError(String::New(msg.c_str())));
-  }
-  Local<Value> local_result = scriptObj->Run();
-  if(local_result.IsEmpty()){
-    std::string msg("Can't get execution result of v8/gc : gc();\n");
-    String::Utf8Value u8s(try_catch.Exception());
-    msg += *u8s;
-    return ThrowException(Exception::TypeError(String::New(msg.c_str())));
-  }
-  String::Utf8Value result(local_result);
-  context.Dispose(); // dispose Persistent<Context>
-  BDISPFUNCOUT();
-  return scope.Close(String::New(*result));
-}
+    void Method_force_gc_extension(const FunctionCallbackInfo<Value>& args) // v8/gc : gc()
+    {
+        Isolate *isolate = args.GetIsolate();
+        BDISPFUNCDAT("context %s " __FUNCTION__ " %s\n", "preset", "start");
+        // create context with extension(s)
+        const char *extensionNames[] = { "v8/gc", };
+        ExtensionConfiguration extensions(sizeof(extensionNames) / sizeof(extensionNames[0]), extensionNames);
+
+        //Local<Context> context = isolate->GetCurrentContext();
+        //Handle<ObjectTemplate> global = context->Global();
+
+        BDISPFUNCDAT("context %s " __FUNCTION__ " %s\n", "preset", "end");
+        BDISPFUNCIN();
+        Local<String> sourceObj = String::NewFromUtf8(isolate, "gc()");
+        TryCatch try_catch;
+        Local<Script> scriptObj = Script::Compile(sourceObj);
+        if (scriptObj.IsEmpty()) {
+            std::string msg("Can't compile v8/gc : gc();\n");
+            String::Utf8Value u8s(try_catch.Exception());
+            msg += *u8s;
+            RETURN_TYPE_ERROR(msg.c_str())
+        }
+        Local<Value> local_result = scriptObj->Run();
+        if (local_result.IsEmpty()) {
+            std::string msg("Can't get execution result of v8/gc : gc();\n");
+            String::Utf8Value u8s(try_catch.Exception());
+            msg += *u8s;
+            RETURN_TYPE_ERROR(msg.c_str())
+        }
+
+        //String::Utf8Value result(local_result);
+        args.GetReturnValue().Set(local_result->ToString());
+        BDISPFUNCOUT();
+    }
 
 } // namespace node_win32ole
diff --git a/src/force_gc_internal.cc b/src/force_gc_internal.cc
index ea1244a..a046432 100644
--- a/src/force_gc_internal.cc
+++ b/src/force_gc_internal.cc
@@ -2,59 +2,28 @@
   force_gc_internal.cc
 */
 
-// #define __OLD_FORCE_GC_INTERNAL__
-#ifdef __OLD_FORCE_GC_INTERNAL__
-#include <v8.h> // position: v8/include/v8.h
-#include <../src/v8.h> // position: v8/src/v8.h
-// *** don't include other headers ***
-#else
 #include "node_win32ole.h"
-#endif
+#include "ole32core.h"
 #include <iostream>
 
 using namespace v8;
 
 namespace node_win32ole {
 
-Handle<Value> Method_force_gc_internal(const Arguments& args) // v8/src/v8.h
-{
-  HandleScope scope;
-  std::cerr << "-in: " __FUNCTION__ << std::endl;
-  if(args.Length() < 1)
-    return ThrowException(Exception::TypeError(
-      String::New("this function takes at least 1 argument(s)")));
-  if(!args[0]->IsInt32())
-    return ThrowException(Exception::TypeError(
-      String::New("type of argument 1 must be Int32")));
-  int flags = (int)args[0]->Int32Value();
-#ifdef __OLD_FORCE_GC_INTERNAL__
-  std::string reason("called from win32ole.force_gc_internal"); // default
-  if(args.Length() >= 2){
-    if(!args[1]->IsString())
-      return ThrowException(Exception::TypeError(
-        String::New("type of argument 2 must be (utf8)String")));
-    String::Utf8Value u8s(args[1]);
-    reason = std::string(*u8s);
-  }
-/*
-  ( v8 bundled node 0.8.18 )
-  0: kNoGCFlags
-  1: kSweepPreciselyMask
-  2: kReduceMemoryFootprintMask
-  4: kAbortIncrementalMarkingMask
-  kMakeHeapIterableMask = kSweepPreciselyMask | kAbortIncrementalMarkingMask
-*/
-  // Performs a full garbage collection. If (flags & kMakeHeapIterableMask) is
-  // non-zero, then the slower precise sweeper is used, which leaves the heap
-  // in a state where we can iterate over the heap visiting all objects.
-  v8::internal::Heap::CollectAllGarbage(flags, reason.c_str());
-  // Last hope GC, should try to squeeze as much as possible.
-  // v8::internal::Heap::CollectAllAvailableGarbage(reason.c_str());
-#else
-  while(!v8::V8::IdleNotification()){}
-#endif
-  std::cerr << "-out: " __FUNCTION__ << std::endl;
-  return scope.Close(Boolean::New(true));
-}
+    void Method_force_gc_internal(const FunctionCallbackInfo<Value>& args) // v8/src/v8.h
+    {
+        Isolate *isolate = args.GetIsolate();
+        std::cerr << "-in: " __FUNCTION__ << std::endl;
+        if (args.Length() < 1) RETURN_TYPE_ERROR("this function takes at least 1 argument(s)")
+        if (!args[0]->IsInt32()) RETURN_TYPE_ERROR("type of argument 1 must be Int32")
+        int flags = (int)args[0]->Int32Value();
+
+        //while (!v8::V8::IdleNotification()) {}
+        //isolate->IdleNotificationDeadline();   
+        RETURN_ERROR("function not implemented, becose IdleNotification is depricated");
+
+        std::cerr << "-out: " __FUNCTION__ << std::endl;
+        args.GetReturnValue().Set(Boolean::New(isolate, true));
+    }
 
 } // namespace node_win32ole
diff --git a/src/node_win32ole.cc b/src/node_win32ole.cc
index 09a8b95..a800d4e 100644
--- a/src/node_win32ole.cc
+++ b/src/node_win32ole.cc
@@ -14,44 +14,44 @@ using namespace v8;
 
 namespace node_win32ole {
 
-Persistent<Object> module_target;
-
-Handle<Value> Method_version(const Arguments& args)
-{
-  HandleScope scope;
-  if(args.Length() >= 0){
-    //
-  }
+    Persistent<Object> module_target;
+
+    void Method_version(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        if (args.Length() >= 0) {
+            //
+        }
 #ifdef DEBUG
-  node::node_module_struct *nms = node::get_builtin_module("Array");
-  if(!nms) return scope.Close(String::NewSymbol("not found"));
-  return scope.Close(String::New(nms->modname));
+        node::node_module *nms = 0;// node::get_builtin_module("Array");
+        const char *info = nms ? nms->nm_modname : "not found";
 #else
-  return scope.Close(module_target->Get(String::NewSymbol("VERSION")));
+        const char *info ="VERSION";
 #endif
-}
-
-Handle<Value> Method_printACP(const Arguments& args) // UTF-8 to MBCS (.ACP)
-{
-  HandleScope scope;
-  if(args.Length() >= 1){
-    String::Utf8Value s(args[0]);
-    char *cs = *s;
-    printf(UTF82MBCS(std::string(cs)).c_str());
-  }
-  return scope.Close(Boolean::New(true));
-}
-
-Handle<Value> Method_print(const Arguments& args) // through (as ASCII)
-{
-  HandleScope scope;
-  if(args.Length() >= 1){
-    String::Utf8Value s(args[0]);
-    char *cs = *s;
-    printf(cs); // printf("%s\n", cs);
-  }
-  return scope.Close(Boolean::New(true));
-}
+        args.GetReturnValue().Set(String::NewFromUtf8(isolate, info));
+    }
+
+    void Method_printACP(const FunctionCallbackInfo<Value>& args) // UTF-8 to MBCS (.ACP)
+    {
+        Isolate* isolate = args.GetIsolate();
+        if (args.Length() >= 1) {
+            String::Utf8Value s(args[0]);
+            char *cs = *s;
+            printf(UTF82MBCS(std::string(cs)).c_str());
+        }
+        args.GetReturnValue().Set(Boolean::New(isolate, true));
+    }
+
+    void Method_print(const FunctionCallbackInfo<Value>& args) // through (as ASCII)
+    {
+        Isolate* isolate = args.GetIsolate();
+        if (args.Length() >= 1) {
+            String::Utf8Value s(args[0]);
+            char *cs = *s;
+            printf(cs); // printf("%s\n", cs);
+        }
+        args.GetReturnValue().Set(Boolean::New(isolate, true));
+    }
 
 } // namespace node_win32ole
 
@@ -59,35 +59,26 @@ using namespace node_win32ole;
 
 namespace {
 
-void init(Handle<Object> target)
-{
-  module_target = Persistent<Object>::New(target);
-  V8Variant::Init(target);
-  Client::Init(target);
-  target->Set(String::NewSymbol("VERSION"),
-    String::New("0.0.0 (will be set later)"),
-    static_cast<PropertyAttribute>(DontDelete));
-  target->Set(String::NewSymbol("MODULEDIRNAME"),
-    String::New("/tmp"),
-    static_cast<PropertyAttribute>(DontDelete));
-  target->Set(String::NewSymbol("SOURCE_TIMESTAMP"),
-    String::NewSymbol(__FILE__ " " __DATE__ " " __TIME__),
-    static_cast<PropertyAttribute>(ReadOnly | DontDelete));
-  target->Set(String::NewSymbol("version"),
-    FunctionTemplate::New(Method_version)->GetFunction());
-  target->Set(String::NewSymbol("printACP"),
-    FunctionTemplate::New(Method_printACP)->GetFunction());
-  target->Set(String::NewSymbol("print"),
-    FunctionTemplate::New(Method_print)->GetFunction());
-  target->Set(String::NewSymbol("gettimeofday"),
-    FunctionTemplate::New(Method_gettimeofday)->GetFunction());
-  target->Set(String::NewSymbol("sleep"),
-    FunctionTemplate::New(Method_sleep)->GetFunction());
-  target->Set(String::NewSymbol("force_gc_extension"),
-    FunctionTemplate::New(Method_force_gc_extension)->GetFunction());
-  target->Set(String::NewSymbol("force_gc_internal"),
-    FunctionTemplate::New(Method_force_gc_internal)->GetFunction());
-}
+    void init(Handle<Object> target)
+    {
+        Isolate* isolate = target->GetIsolate();
+
+        module_target.Reset(isolate, target);
+        V8Variant::Init(target);
+        Client::Init(target);
+
+        NODE_DEFINE_PROP(target, "VERSION", "0.0.0");       // replaced from package.json
+        NODE_DEFINE_PROP(target, "MODULEDIRNAME", "/tmp");  // replaced for actual path
+        NODE_DEFINE_PROP_READONLY(target, "SOURCE_TIMESTAMP", __DATE__ " " __TIME__);
+
+        NODE_SET_METHOD(target, "version", Method_version);
+        NODE_SET_METHOD(target, "printACP", Method_printACP);
+        NODE_SET_METHOD(target, "print", Method_print);
+        NODE_SET_METHOD(target, "gettimeofday", Method_gettimeofday);
+        NODE_SET_METHOD(target, "sleep", Method_sleep);
+        NODE_SET_METHOD(target, "force_gc_extension", Method_force_gc_extension);
+        NODE_SET_METHOD(target, "force_gc_internal", Method_force_gc_internal);
+    }
 
 } // namespace
 
diff --git a/src/node_win32ole.h b/src/node_win32ole.h
index 52d2d3f..e211707 100644
--- a/src/node_win32ole.h
+++ b/src/node_win32ole.h
@@ -1,19 +1,39 @@
 #ifndef __NODE_WIN32OLE_H__
 #define __NODE_WIN32OLE_H__
 
-#include <node_buffer.h>
-#include <node.h>
 #include <v8.h>
+#include <node.h>
+#include <node_buffer.h>
+#include <node_object_wrap.h>
 
 using namespace v8;
 
 namespace node_win32ole {
 
-#define CHECK_OCV(ocv) do{ \
-    if(!(ocv)) \
-      return ThrowException(Exception::TypeError(String::New( \
-        __FUNCTION__" can't access to V8Variant (null OCVariant)"))); \
-  }while(0)
+#define NODE_DEFINE_PROP(target, key, val) NODE_DEFINE_PROP_(target, key, val, 0) 
+#define NODE_DEFINE_PROP_READONLY(target, key, val) NODE_DEFINE_PROP_(target, key, val, ReadOnly) 
+#define NODE_DEFINE_PROP_(target, key, val, opt) { \
+    Isolate* isolate = target->GetIsolate(); \
+    Local<Context> context = isolate->GetCurrentContext(); \
+    target->DefineOwnProperty(context, String::NewFromUtf8(isolate, key), \
+        String::NewFromUtf8(isolate, val), \
+        static_cast<PropertyAttribute>(opt | DontDelete)); \
+}
+
+#define THROW_ERROR_T(terr, msg) isolate->ThrowException(terr(String::NewFromUtf8(isolate, msg)))
+#define THROW_ERROR(msg) RETURN_ERROR_T(Exception::Error, msg)
+#define THROW_TYPE_ERROR(msg) RETURN_ERROR_T(Exception::TypeError, msg)
+#define THROW_RANGE_ERROR(msg) RETURN_ERROR_T(Exception::TangeError, msg)
+
+#define RETURN_ERROR_T(terr, msg) { THROW_ERROR_T(terr, msg); return; }
+#define RETURN_ERROR(msg) RETURN_ERROR_T(Exception::Error, msg)
+#define RETURN_TYPE_ERROR(msg) RETURN_ERROR_T(Exception::TypeError, msg)
+#define RETURN_RANGE_ERROR(msg) RETURN_ERROR_T(Exception::RangeError, msg)
+
+    
+#define CHECK_OCV(ocv) do { \
+    if (!(ocv)) RETURN_ERROR(__FUNCTION__" can't access to V8Variant (null OCVariant)") \
+  } while (0)
 
 #if(0)
 #define OLETRACEIN() BDISPFUNCIN()
@@ -41,11 +61,12 @@ namespace node_win32ole {
 #define OLE_PROCESS_CARRY_OVER(th) do{ \
     V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(th); \
     if(v8v->property_carryover.empty()) break; \
-    Handle<Value> r = V8Variant::OLEFlushCarryOver(th); \
+    Handle<Value> r; V8Variant::OLEFlushCarryOver(isolate, th, r); \
     if(!r->IsObject()){ \
       std::cerr << "** CarryOver primitive ** " << __FUNCTION__ << std::endl; \
       std::cerr.flush(); \
-      return scope.Close(r); \
+      args.GetReturnValue().Set(r); \
+      return; \
     } \
     th = r->ToObject(); \
   }while(0)
@@ -58,19 +79,19 @@ namespace node_win32ole {
 #define OLETRACEARGS()
 #define OLETRACEFLUSH()
 #define OLETRACEOUT()
-#define OLE_PROCESS_CARRY_OVER(th) do{ \
+#define OLE_PROCESS_CARRY_OVER(th) do { \
     V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(th); \
-    if(v8v->property_carryover.empty()) break; \
-    Handle<Value> r = V8Variant::OLEFlushCarryOver(th); \
-    if(!r->IsObject()) return scope.Close(r); \
+    if (v8v->property_carryover.empty()) break; \
+    Handle<Value> r; V8Variant::OLEFlushCarryOver(isolate, th, r); \
+    if (!r->IsObject()) { args.GetReturnValue().Set(r); return; }\
     th = r->ToObject(); \
-  }while(0)
+  } while(0)
 #endif
 
-#define GET_PROP(obj, prop) (obj)->Get(String::NewSymbol(prop))
+#define GET_PROP(obj, prop) (obj)->Get(String::NewFromUtf8(isolate, prop))
 
-#define ARRAY_AT(a, i) (a)->Get(String::NewSymbol(to_s(i).c_str()))
-#define ARRAY_SET(a, i, v) (a)->Set(String::NewSymbol(to_s(i).c_str()), (v))
+#define ARRAY_AT(a, i) (a)->Get(String::NewFromUtf8(isolate, to_s(i).c_str()))
+#define ARRAY_SET(a, i, v) (a)->Set(String::NewFromUtf8(isolate, to_s(i).c_str()), (v))
 
 #define INSTANCE_CALL(obj, method, argc, argv) Handle<Function>::Cast( \
   GET_PROP((obj), (method)))->Call((obj), (argc), (argv))
@@ -83,13 +104,13 @@ template <class T> T *castedInternalField(Handle<Object> object, int fidx=1)
 
 extern Persistent<Object> module_target;
 
-Handle<Value> Method_version(const Arguments& args);
-Handle<Value> Method_printACP(const Arguments& args); // UTF-8 to MBCS (.ACP)
-Handle<Value> Method_print(const Arguments& args); // through (as ASCII)
-Handle<Value> Method_gettimeofday(const Arguments& args);
-Handle<Value> Method_sleep(const Arguments& args); // ms, bool: msg, bool: \n
-Handle<Value> Method_force_gc_extension(const Arguments& args); // v8/gc : gc()
-Handle<Value> Method_force_gc_internal(const Arguments& args); // v8/src/v8.h
+void Method_version(const FunctionCallbackInfo<Value>& args);
+void Method_printACP(const FunctionCallbackInfo<Value>& args); // UTF-8 to MBCS (.ACP)
+void Method_print(const FunctionCallbackInfo<Value>& args); // through (as ASCII)
+void Method_gettimeofday(const FunctionCallbackInfo<Value>& args);
+void Method_sleep(const FunctionCallbackInfo<Value>& args); // ms, bool: msg, bool: \n
+void Method_force_gc_extension(const FunctionCallbackInfo<Value>& args); // v8/gc : gc()
+void Method_force_gc_internal(const FunctionCallbackInfo<Value>& args); // v8/src/v8.h
 
 } // namespace node_win32ole
 
diff --git a/src/ole32core.cpp b/src/ole32core.cpp
index b7862ef..bd98875 100644
--- a/src/ole32core.cpp
+++ b/src/ole32core.cpp
@@ -9,7 +9,7 @@ using namespace std;
 
 namespace ole32core {
 
-BOOL chkerr(BOOL b, char *m, int n, char *f, char *e)
+bool chkerr(bool b, char *m, int n, char *f, char *e)
 {
   if(b) return b;
   DWORD code = GetLastError();
@@ -199,7 +199,7 @@ OCVariant::OCVariant() : next(NULL)
 {
   DISPFUNCIN();
   VariantInit(&v);
-  DISPFUNCDAT("--construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
@@ -208,7 +208,7 @@ OCVariant::OCVariant(const OCVariant &s) : next(NULL)
   DISPFUNCIN();
   VariantInit(&v); // It will be free before copy.
   VariantCopy(&v, (VARIANT *)&s.v);
-  DISPFUNCDAT("--copy construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--copy construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
@@ -218,7 +218,7 @@ OCVariant::OCVariant(bool c_boolVal) : next(NULL)
   VariantInit(&v);
   v.vt = VT_BOOL;
   v.boolVal = c_boolVal ? VARIANT_TRUE : VARIANT_FALSE;
-  DISPFUNCDAT("--construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
@@ -228,7 +228,7 @@ OCVariant::OCVariant(long lVal) : next(NULL)
   VariantInit(&v);
   v.vt = VT_I4;
   v.lVal = lVal;
-  DISPFUNCDAT("--construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
@@ -238,7 +238,7 @@ OCVariant::OCVariant(double dblVal) : next(NULL)
   VariantInit(&v);
   v.vt = VT_R8;
   v.dblVal = dblVal;
-  DISPFUNCDAT("--construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
@@ -248,7 +248,7 @@ OCVariant::OCVariant(double date, bool isdate) : next(NULL)
   VariantInit(&v);
   v.vt = VT_DATE;
   v.date = date;
-  DISPFUNCDAT("--construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
@@ -258,7 +258,7 @@ OCVariant::OCVariant(BSTR bstrVal) : next(NULL)
   VariantInit(&v);
   v.vt = VT_BSTR;
   v.bstrVal = bstrVal;
-  DISPFUNCDAT("--construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
@@ -268,14 +268,14 @@ OCVariant::OCVariant(string str) : next(NULL)
   VariantInit(&v);
   v.vt = VT_BSTR;
   v.bstrVal = MBCS2BSTR(str);
-  DISPFUNCDAT("--construction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--construction-- %p %08lx\n", &v, v.vt);
   DISPFUNCOUT();
 }
 
 OCVariant::~OCVariant()
 {
   DISPFUNCIN();
-  DISPFUNCDAT("--destruction-- %08lx %08lx\n", &v, v.vt);
+  DISPFUNCDAT("--destruction-- %p %08lx\n", &v, v.vt);
   DISPFUNCDAT("---(first step in)%d%d", 0, 0);
 #if(0) // recursive (use stack)
   if(next){
diff --git a/src/ole32core.h b/src/ole32core.h
index 7f0a432..3bb9af8 100644
--- a/src/ole32core.h
+++ b/src/ole32core.h
@@ -17,9 +17,9 @@
 
 namespace ole32core {
 
-#define BDISPFUNCIN() do{std::cerr<<"-IN "<<__FUNCTION__<<std::endl;}while(0)
-#define BDISPFUNCOUT() do{std::cerr<<"-OUT "<<__FUNCTION__<<std::endl;}while(0)
-#define BDISPFUNCDAT(f, a, t) do{fprintf(stderr, (f), (a), (t));}while(0)
+#define BDISPFUNCIN() do {std::cerr<<"-IN " << __FUNCTION__ << std::endl;} while(0)
+#define BDISPFUNCOUT() do {std::cerr<<"-OUT " << __FUNCTION__ << std::endl;} while(0)
+#define BDISPFUNCDAT(f, a, t) do {fprintf(stderr, (f), (a), (t));} while(0)
 #if defined(_DEBUG) || defined(DEBUG)
 #define DISPFUNCIN() BDISPFUNCIN()
 #define DISPFUNCOUT() BDISPFUNCOUT()
@@ -30,7 +30,7 @@ namespace ole32core {
 #define DISPFUNCDAT(f, a, t) // BDISPFUNCDAT((f), (a), (t))
 #endif
 
-#define BASSERT(x) chkerr((BOOL)(x), __FILE__, __LINE__, __FUNCTION__, #x)
+#define BASSERT(x) (chkerr((bool)(x), __FILE__, __LINE__, __FUNCTION__, #x))
 #define BVERIFY(x) BASSERT(x)
 #if defined(_DEBUG) || defined(DEBUG)
 #define DASSERT(x) BASSERT(x)
@@ -39,7 +39,8 @@ namespace ole32core {
 #define DASSERT(x)
 #define DVERIFY(x) (x)
 #endif
-extern BOOL chkerr(BOOL b, char *m, int n, char *f, char *e);
+
+extern bool chkerr(bool b, char *m, int n, char *f, char *e);
 #define BEVERIFY(y, x) if(!BVERIFY(x)){ goto y; }
 #define DEVERIFY(y, x) if(!DVERIFY(x)){ goto y; }
 
@@ -66,49 +67,49 @@ extern std::string BSTR2MBCS(BSTR bstr);
 
 class OLE32coreException {
 protected:
-  std::string rmsg;
+    std::string rmsg;
 public:
-  OLE32coreException(std::string rm) : rmsg(rm) {}
-  virtual ~OLE32coreException() {}
-  std::string errorMessage(char *m=NULL);
+    OLE32coreException(std::string rm) : rmsg(rm) {}
+    virtual ~OLE32coreException() {}
+    std::string errorMessage(char *m = NULL);
 };
 
 class OCVariant {
 public:
-  VARIANT v;
-  OCVariant *next;
+    VARIANT v;
+    OCVariant *next;
 public:
-  OCVariant(); // result
-  OCVariant(const OCVariant &s); // copy
-  OCVariant(bool c_boolVal); // VT_BOOL
-  OCVariant(long lVal); // VT_I4
-  OCVariant(double dblVal); // VT_R8
-  OCVariant(double date, bool isdate); // VT_DATE
-  OCVariant(BSTR bstrVal); // VT_BSTR (previous allocated)
-  OCVariant(std::string str); // allocate and convert to VT_BSTR
-  virtual ~OCVariant();
-  OCVariant *push(OCVariant *p); // push to chain top
-  unsigned int size(); // length of chain (count next and self)
-  void checkOLEresult(std::string msg);
+    OCVariant(); // result
+    OCVariant(const OCVariant &s); // copy
+    OCVariant(bool c_boolVal); // VT_BOOL
+    OCVariant(long lVal); // VT_I4
+    OCVariant(double dblVal); // VT_R8
+    OCVariant(double date, bool isdate); // VT_DATE
+    OCVariant(BSTR bstrVal); // VT_BSTR (previous allocated)
+    OCVariant(std::string str); // allocate and convert to VT_BSTR
+    virtual ~OCVariant();
+    OCVariant *push(OCVariant *p); // push to chain top
+    unsigned int size(); // length of chain (count next and self)
+    void checkOLEresult(std::string msg);
 protected:
-  HRESULT AutoWrap(int autoType, VARIANT *pvResult,
-    LPOLESTR ptName, OCVariant *argchain=NULL);
+    HRESULT AutoWrap(int autoType, VARIANT *pvResult,
+        LPOLESTR ptName, OCVariant *argchain = NULL);
 public:
-  OCVariant *getProp(LPOLESTR prop, OCVariant *argchain=NULL);
-  OCVariant *putProp(LPOLESTR prop, OCVariant *argchain=NULL);
-  OCVariant *invoke(LPOLESTR method, OCVariant *argchain=NULL, bool re=false);
+    OCVariant *getProp(LPOLESTR prop, OCVariant *argchain = NULL);
+    OCVariant *putProp(LPOLESTR prop, OCVariant *argchain = NULL);
+    OCVariant *invoke(LPOLESTR method, OCVariant *argchain = NULL, bool re = false);
 };
 
 class OLE32core {
 protected:
-  bool finalized;
-  std::string oldlocale;
+    bool finalized;
+    std::string oldlocale;
 public:
-  OLE32core() : finalized(true) {}
-  virtual ~OLE32core() { if(!finalized) disconnect(); }
-  void checkOLEresult(std::string msg);
-  bool connect(std::string locale);
-  bool disconnect(void);
+    OLE32core() : finalized(true) {}
+    virtual ~OLE32core() { if (!finalized) disconnect(); }
+    void checkOLEresult(std::string msg);
+    bool connect(std::string locale);
+    bool disconnect(void);
 };
 
 } // namespace ole32core
diff --git a/src/v8variant.cc b/src/v8variant.cc
index 1ad5148..36f9be5 100644
--- a/src/v8variant.cc
+++ b/src/v8variant.cc
@@ -7,726 +7,764 @@
 using namespace v8;
 using namespace ole32core;
 
-namespace node_win32ole {
-
 #define CHECK_OLE_ARGS(args, n, av0, av1) do{ \
-    if(args.Length() < n) \
-      return ThrowException(Exception::TypeError( \
-        String::New(__FUNCTION__" takes exactly " #n " argument(s)"))); \
-    if(!args[0]->IsString()) \
-      return ThrowException(Exception::TypeError( \
-        String::New(__FUNCTION__" the first argument is not a Symbol"))); \
+    if(args.Length() < n) RETURN_TYPE_ERROR(__FUNCTION__" takes exactly " #n " argument(s)") \
+    if(!args[0]->IsString()) RETURN_TYPE_ERROR(__FUNCTION__" the first argument is not a Symbol") \
     if(n == 1) \
       if(args.Length() >= 2) \
-        if(!args[1]->IsArray()) \
-          return ThrowException(Exception::TypeError(String::New( \
-            __FUNCTION__" the second argument is not an Array"))); \
+        if(!args[1]->IsArray()) RETURN_TYPE_ERROR(__FUNCTION__" the second argument is not an Array") \
         else av1 = args[1]; /* Array */ \
-      else av1 = Array::New(0); /* change none to Array[] */ \
+      else av1 = Array::New(isolate, 0); /* change none to Array[] */ \
     else av1 = args[1]; /* may not be Array */ \
     av0 = args[0]; \
   }while(0)
 
-Persistent<FunctionTemplate> V8Variant::clazz;
-
-void V8Variant::Init(Handle<Object> target)
-{
-  HandleScope scope;
-  Local<FunctionTemplate> t = FunctionTemplate::New(New);
-  clazz = Persistent<FunctionTemplate>::New(t);
-  clazz->InstanceTemplate()->SetInternalFieldCount(2);
-  clazz->SetClassName(String::NewSymbol("V8Variant"));
-  NODE_SET_PROTOTYPE_METHOD(clazz, "isA", OLEIsA);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "vtName", OLEVTName);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "toBoolean", OLEBoolean);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "toInt32", OLEInt32);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "toInt64", OLEInt64);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "toNumber", OLENumber);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "toDate", OLEDate);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "toUtf8", OLEUtf8);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "toValue", OLEValue);
-//  NODE_SET_PROTOTYPE_METHOD(clazz, "New", New);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "call", OLECall);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "get", OLEGet);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "set", OLESet);
-/*
- In ParseUnaryExpression() < v8/src/parser.cc >
- v8::Object::ToBoolean() is called directly for unary operator '!'
- instead of v8::Object::valueOf()
- so NamedPropertyHandler will not be called
- Local<Boolean> ToBoolean(); // How to fake ? override v8::Value::ToBoolean
-*/
-  Local<ObjectTemplate> instancetpl = clazz->InstanceTemplate();
-  instancetpl->SetCallAsFunctionHandler(OLECallComplete);
-  instancetpl->SetNamedPropertyHandler(OLEGetAttr, OLESetAttr);
-//  instancetpl->SetIndexedPropertyHandler(OLEGetIdxAttr, OLESetIdxAttr);
-  NODE_SET_PROTOTYPE_METHOD(clazz, "Finalize", Finalize);
-  target->Set(String::NewSymbol("V8Variant"), clazz->GetFunction());
-}
-
-std::string V8Variant::CreateStdStringMBCSfromUTF8(Handle<Value> v)
-{
-  String::Utf8Value u8s(v);
-  wchar_t * wcs = u8s2wcs(*u8s);
-  if(!wcs){
-    std::cerr << "[Can't allocate string (wcs)]" << std::endl;
-    std::cerr.flush();
-    return std::string("'!ERROR'");
-  }
-  char *mbs = wcs2mbs(wcs);
-  if(!mbs){
-    free(wcs);
-    std::cerr << "[Can't allocate string (mbs)]" << std::endl;
-    std::cerr.flush();
-    return std::string("'!ERROR'");
-  }
-  std::string s(mbs);
-  free(mbs);
-  free(wcs);
-  return s;
-}
-
-OCVariant *V8Variant::CreateOCVariant(Handle<Value> v)
-{
-  if (v->IsNull()){
-		return new OCVariant();
-  }
-
-  BEVERIFY(done, !v.IsEmpty());
-  BEVERIFY(done, !v->IsUndefined());
-  BEVERIFY(done, !v->IsExternal());
-  BEVERIFY(done, !v->IsNativeError());
-  BEVERIFY(done, !v->IsFunction());
-// VT_USERDEFINED VT_VARIANT VT_BYREF VT_ARRAY more...
-  if(v->IsBoolean()){
-    return new OCVariant((bool)(v->BooleanValue() ? !0 : 0));
-  }else if(v->IsArray()){
-// VT_BYREF VT_ARRAY VT_SAFEARRAY
-    std::cerr << "[Array (not implemented now)]" << std::endl; return NULL;
-    std::cerr.flush();
-  }else if(v->IsInt32()){
-    return new OCVariant((long)v->Int32Value());
+namespace node_win32ole {
+
+    Persistent<FunctionTemplate> V8Variant::clazz;
+    Persistent<Function> V8Variant::constructor;
+
+    void V8Variant::Init(Handle<Object> target)
+    {
+        Isolate* isolate = target->GetIsolate();
+
+        // Prepare constructor template
+        Local<String> clazz_name(String::NewFromUtf8(isolate, "V8Variant"));
+        Local<FunctionTemplate> clazz = FunctionTemplate::New(isolate, New);
+        clazz->SetClassName(clazz_name);
+        clazz->InstanceTemplate()->SetInternalFieldCount(2);
+
+        // Prototype
+        NODE_SET_PROTOTYPE_METHOD(clazz, "isA", OLEIsA);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "vtName", OLEVTName);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "toBoolean", OLEBoolean);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "toInt32", OLEInt32);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "toInt64", OLEInt64);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "toNumber", OLENumber);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "toDate", OLEDate);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "toUtf8", OLEUtf8);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "toValue", OLEValue);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "call", OLECall);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "get", OLEGet);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "set", OLESet);
+        NODE_SET_PROTOTYPE_METHOD(clazz, "Finalize", Finalize);
+
+        Local<ObjectTemplate> instancetpl = clazz->InstanceTemplate();
+        instancetpl->SetCallAsFunctionHandler(OLECallComplete);
+        instancetpl->SetNamedPropertyHandler(OLEGetAttr, OLESetAttr);
+
+        constructor.Reset(isolate, clazz->GetFunction());
+        target->Set(clazz_name, clazz->GetFunction());
+    }
+
+    void V8Variant::New(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+
+        DISPFUNCIN();
+        if (!args.IsConstructCall()) RETURN_TYPE_ERROR("Use the new operator to create new V8Variant objects")
+
+        OCVariant *ocv = new OCVariant();
+        CHECK_OCV(ocv);
+
+        Local<Object> thisObject = args.This();
+        V8Variant *v = new V8Variant(); // must catch exception
+        v->Wrap(thisObject); // InternalField[0]
+        thisObject->SetInternalField(1, External::New(isolate, ocv));
+        //Persistent<Object> objectDisposer = Persistent<Object>::New(thisObject);
+        //objectDisposer.MakeWeak(ocv, Dispose);
+
+        args.GetReturnValue().Set(thisObject);
+        DISPFUNCOUT();
+    }
+
+    void V8Variant::CreateUndefined(Isolate* isolate, Local<Object> &instance)
+    {
+        DISPFUNCIN();
+        Local<Context> context = isolate->GetCurrentContext();
+        Local<Function> cons = Local<Function>::New(isolate, constructor);
+        instance = cons->NewInstance(context, 0, 0).ToLocalChecked();
+        DISPFUNCOUT();
+    }
+
+    std::string V8Variant::CreateStdStringMBCSfromUTF8(Handle<Value> v)
+    {
+        String::Utf8Value u8s(v);
+        wchar_t * wcs = u8s2wcs(*u8s);
+        if (!wcs) {
+            std::cerr << "[Can't allocate string (wcs)]" << std::endl;
+            std::cerr.flush();
+            return std::string("'!ERROR'");
+        }
+        char *mbs = wcs2mbs(wcs);
+        if (!mbs) {
+            free(wcs);
+            std::cerr << "[Can't allocate string (mbs)]" << std::endl;
+            std::cerr.flush();
+            return std::string("'!ERROR'");
+        }
+        std::string s(mbs);
+        free(mbs);
+        free(wcs);
+        return s;
+    }
+
+    OCVariant *V8Variant::CreateOCVariant(Handle<Value> v)
+    {
+        if (v.IsEmpty()) 
+        {
+            std::cerr << "[Empty(!)]" << std::endl;
+            std::cerr.flush();
+        }
+        else if (v->IsUndefined())
+        {
+            std::cerr << "[Undefined(!)]" << std::endl;
+            std::cerr.flush();
+        }
+        else if (v->IsExternal())
+        {
+            std::cerr << "[External(!)]" << std::endl;
+            std::cerr.flush();
+        }
+        else if (v->IsNativeError())
+        {
+            std::cerr << "[NativeError(!)]" << std::endl;
+            std::cerr.flush();
+        }
+        else if (v->IsNull()) {
+            return new OCVariant();
+        }
+        else if (v->IsBoolean()) {
+            return new OCVariant((bool)(v->BooleanValue() ? !0 : 0));
+        }
+        else if (v->IsArray()) {
+            // VT_BYREF VT_ARRAY VT_SAFEARRAY
+            std::cerr << "[Array (not implemented now)]" << std::endl; return NULL;
+            std::cerr.flush();
+        }
+        else if (v->IsInt32()) {
+            return new OCVariant((long)v->Int32Value());
 #if(0) // may not be supported node.js / v8
-  }else if(v->IsInt64()){
-    return new OCVariant((long long)v->Int64Value());
+        }
+        else if (v->IsInt64()) {
+            return new OCVariant((long long)v->Int64Value());
 #endif
-  }else if(v->IsNumber()){
-    std::cerr << "[Number (VT_R8 or VT_I8 bug?)]" << std::endl;
-    std::cerr.flush();
-// if(v->ToInteger()) =64 is failed ? double : OCVariant((longlong)VT_I8)
-    return new OCVariant((double)v->NumberValue()); // double
-  }else if(v->IsNumberObject()){
-    std::cerr << "[NumberObject (VT_R8 or VT_I8 bug?)]" << std::endl;
-    std::cerr.flush();
-// if(v->ToInteger()) =64 is failed ? double : OCVariant((longlong)VT_I8)
-    return new OCVariant((double)v->NumberValue()); // double
-  }else if(v->IsDate()){
-    double d = v->NumberValue();
-    time_t sec = (time_t)(d / 1000.0);
-    int msec = (int)(d - sec * 1000.0);
-    struct tm *t = localtime(&sec); // *** must check locale ***
-    if(!t){
-      std::cerr << "[Date may not be valid]" << std::endl;
-      std::cerr.flush();
-      return NULL;
-    }
-    SYSTEMTIME syst;
-    syst.wYear = t->tm_year + 1900;
-    syst.wMonth = t->tm_mon + 1;
-    syst.wDay = t->tm_mday;
-    syst.wHour = t->tm_hour;
-    syst.wMinute = t->tm_min;
-    syst.wSecond = t->tm_sec;
-    syst.wMilliseconds = msec;
-    SystemTimeToVariantTime(&syst, &d);
-    return new OCVariant(d, true); // date
-  }else if(v->IsRegExp()){
-    std::cerr << "[RegExp (bug?)]" << std::endl;
-    std::cerr.flush();
-    return new OCVariant(CreateStdStringMBCSfromUTF8(v->ToDetailString()));
-  }else if(v->IsString()){
-    return new OCVariant(CreateStdStringMBCSfromUTF8(v));
-  }else if(v->IsStringObject()){
-    std::cerr << "[StringObject (bug?)]" << std::endl;
-    std::cerr.flush();
-    return new OCVariant(CreateStdStringMBCSfromUTF8(v));
-  }else if(v->IsObject()){
+        }
+        else if (v->IsNumber()) {
+            std::cerr << "[Number (VT_R8 or VT_I8 bug?)]" << std::endl;
+            std::cerr.flush();
+            // if(v->ToInteger()) =64 is failed ? double : OCVariant((longlong)VT_I8)
+            return new OCVariant((double)v->NumberValue()); // double
+        }
+        else if (v->IsNumberObject()) {
+            std::cerr << "[NumberObject (VT_R8 or VT_I8 bug?)]" << std::endl;
+            std::cerr.flush();
+            // if(v->ToInteger()) =64 is failed ? double : OCVariant((longlong)VT_I8)
+            return new OCVariant((double)v->NumberValue()); // double
+        }
+        else if (v->IsDate()) {
+            double d = v->NumberValue();
+            time_t sec = (time_t)(d / 1000.0);
+            int msec = (int)(d - sec * 1000.0);
+            struct tm *t = localtime(&sec); // *** must check locale ***
+            if (!t) {
+                std::cerr << "[Date may not be valid]" << std::endl;
+                std::cerr.flush();
+                return NULL;
+            }
+            SYSTEMTIME syst;
+            syst.wYear = t->tm_year + 1900;
+            syst.wMonth = t->tm_mon + 1;
+            syst.wDay = t->tm_mday;
+            syst.wHour = t->tm_hour;
+            syst.wMinute = t->tm_min;
+            syst.wSecond = t->tm_sec;
+            syst.wMilliseconds = msec;
+            SystemTimeToVariantTime(&syst, &d);
+            return new OCVariant(d, true); // date
+        }
+        else if (v->IsRegExp()) {
+            std::cerr << "[RegExp (bug?)]" << std::endl;
+            std::cerr.flush();
+            return new OCVariant(CreateStdStringMBCSfromUTF8(v->ToDetailString()));
+        }
+        else if (v->IsString()) {
+            return new OCVariant(CreateStdStringMBCSfromUTF8(v));
+        }
+        else if (v->IsStringObject()) {
+            std::cerr << "[StringObject (bug?)]" << std::endl;
+            std::cerr.flush();
+            return new OCVariant(CreateStdStringMBCSfromUTF8(v));
+        }
+        //else if (!v->IsFunction()) {}
+        else if (v->IsObject()) {
 #if(0)
-    std::cerr << "[Object (test)]" << std::endl;
-    std::cerr.flush();
+            std::cerr << "[Object (test)]" << std::endl;
+            std::cerr.flush();
 #endif
-    OCVariant *ocv = castedInternalField<OCVariant>(v->ToObject());
-    if(!ocv){
-      std::cerr << "[Object may not be valid (null OCVariant)]" << std::endl;
-      std::cerr.flush();
-      return NULL;
+            OCVariant *ocv = castedInternalField<OCVariant>(v->ToObject());
+            if (!ocv) {
+                std::cerr << "[Object may not be valid (null OCVariant)]" << std::endl;
+                std::cerr.flush();
+                return NULL;
+            }
+            // std::cerr << ocv->v.vt;
+            return new OCVariant(*ocv);
+        }
+        else {
+            std::cerr << "[unknown type (not implemented now)]" << std::endl;
+            std::cerr.flush();
+        }
+        return new OCVariant(); // NULL
+    }
+
+    void V8Variant::OLEIsA(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        args.GetReturnValue().Set(Int32::New(isolate, ocv->v.vt));
+        DISPFUNCOUT();
+    }
+
+    void V8Variant::OLEVTName(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        Array *a = Array::Cast(*GET_PROP(module_target.Get(isolate), "vt_names"));
+        args.GetReturnValue().Set(ARRAY_AT(a, ocv->v.vt));
+        DISPFUNCOUT();
+    }
+
+    void V8Variant::OLEBoolean(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        if (ocv->v.vt != VT_BOOL) RETURN_TYPE_ERROR("OLEBoolean source type OCVariant is not VT_BOOL")
+        bool c_boolVal = ocv->v.boolVal == VARIANT_FALSE ? 0 : !0;
+        args.GetReturnValue().Set(Boolean::New(isolate, c_boolVal));
+        DISPFUNCOUT();
     }
-    // std::cerr << ocv->v.vt;
-    return new OCVariant(*ocv);
-  }else{
-    std::cerr << "[unknown type (not implemented now)]" << std::endl;
-    std::cerr.flush();
-  }
-done:
-  return NULL;
-}
-
-Handle<Value> V8Variant::OLEIsA(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  DISPFUNCOUT();
-  return scope.Close(Int32::New(ocv->v.vt));
-}
-
-Handle<Value> V8Variant::OLEVTName(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  Array *a = Array::Cast(*GET_PROP(module_target, "vt_names"));
-  DISPFUNCOUT();
-  return scope.Close(ARRAY_AT(a, ocv->v.vt));
-}
-
-Handle<Value> V8Variant::OLEBoolean(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  if(ocv->v.vt != VT_BOOL)
-    return ThrowException(Exception::TypeError(
-      String::New("OLEBoolean source type OCVariant is not VT_BOOL")));
-  bool c_boolVal = ocv->v.boolVal == VARIANT_FALSE ? 0 : !0;
-  DISPFUNCOUT();
-  return scope.Close(Boolean::New(c_boolVal));
-}
-
-Handle<Value> V8Variant::OLEInt32(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  if(ocv->v.vt != VT_I4 && ocv->v.vt != VT_INT
-  && ocv->v.vt != VT_UI4 && ocv->v.vt != VT_UINT)
-    return ThrowException(Exception::TypeError(
-      String::New("OLEInt32 source type OCVariant is not VT_I4 nor VT_INT nor VT_UI4 nor VT_UINT")));
-  DISPFUNCOUT();
-  return scope.Close(Int32::New(ocv->v.lVal));
-}
-
-Handle<Value> V8Variant::OLEInt64(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  if(ocv->v.vt != VT_I8 && ocv->v.vt != VT_UI8)
-    return ThrowException(Exception::TypeError(
-      String::New("OLEInt64 source type OCVariant is not VT_I8 nor VT_UI8")));
-  DISPFUNCOUT();
+
+    void V8Variant::OLEInt32(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        if (ocv->v.vt != VT_I4 && ocv->v.vt != VT_INT
+            && ocv->v.vt != VT_UI4 && ocv->v.vt != VT_UINT)
+            RETURN_TYPE_ERROR("OLEInt32 source type OCVariant is not VT_I4 nor VT_INT nor VT_UI4 nor VT_UINT")
+        DISPFUNCOUT();
+        args.GetReturnValue().Set(Int32::New(isolate, ocv->v.lVal));
+    }
+
+    void V8Variant::OLEInt64(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        if (ocv->v.vt != VT_I8 && ocv->v.vt != VT_UI8)
+            RETURN_TYPE_ERROR("OLEInt64 source type OCVariant is not VT_I8 nor VT_UI8")
+        DISPFUNCOUT();
 #if(0) // may not be supported node.js / v8
-  return scope.Close(Int64::New(ocv->v.llVal));
+        args.GetReturnValue().Set(Int64::New(isolate, ocv->v.llVal));
 #else
-  return scope.Close(Number::New(ocv->v.llVal));
+        args.GetReturnValue().Set(Number::New(isolate, (double)ocv->v.llVal));
 #endif
-}
-
-Handle<Value> V8Variant::OLENumber(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  if(ocv->v.vt != VT_R8)
-    return ThrowException(Exception::TypeError(
-      String::New("OLENumber source type OCVariant is not VT_R8")));
-  DISPFUNCOUT();
-  return scope.Close(Number::New(ocv->v.dblVal));
-}
-
-Handle<Value> V8Variant::OLEDate(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  if(ocv->v.vt != VT_DATE)
-    return ThrowException(Exception::TypeError(
-      String::New("OLEDate source type OCVariant is not VT_DATE")));
-  SYSTEMTIME syst;
-  VariantTimeToSystemTime(ocv->v.date, &syst);
-  struct tm t = {0}; // set t.tm_isdst = 0
-  t.tm_year = syst.wYear - 1900;
-  t.tm_mon = syst.wMonth - 1;
-  t.tm_mday = syst.wDay;
-  t.tm_hour = syst.wHour;
-  t.tm_min = syst.wMinute;
-  t.tm_sec = syst.wSecond;
-  DISPFUNCOUT();
-  return scope.Close(Date::New(mktime(&t) * 1000LL + syst.wMilliseconds));
-}
-
-Handle<Value> V8Variant::OLEUtf8(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  if(ocv->v.vt != VT_BSTR)
-    return ThrowException(Exception::TypeError(
-      String::New("OLEUtf8 source type OCVariant is not VT_BSTR")));
-  Handle<Value> result;
-  if(!ocv->v.bstrVal) result = Undefined(); // or Null();
-  else result = String::New(MBCS2UTF8(BSTR2MBCS(ocv->v.bstrVal)).c_str());
-  DISPFUNCOUT();
-  return scope.Close(result);
-}
-
-Handle<Value> V8Variant::OLEValue(const Arguments& args)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(args.This());
-  OLETRACEFLUSH();
-  Local<Object> thisObject = args.This();
-  OLE_PROCESS_CARRY_OVER(thisObject);
-  OLETRACEVT(thisObject);
-  OLETRACEFLUSH();
-  OCVariant *ocv = castedInternalField<OCVariant>(thisObject);
-  if(!ocv){ std::cerr << "ocv is null"; std::cerr.flush(); }
-  CHECK_OCV(ocv);
-  Handle<Value> result = Undefined();
-  if(ocv->v.vt == VT_EMPTY) ; // do nothing
-  else if(ocv->v.vt == VT_NULL) result = Null();
-  else if(ocv->v.vt == VT_DISPATCH) result = thisObject; // through it
-  else if(ocv->v.vt == VT_BOOL) result = OLEBoolean(args);
-  else if(ocv->v.vt == VT_I4 || ocv->v.vt == VT_INT
-  || ocv->v.vt == VT_UI4 || ocv->v.vt == VT_UINT) result = OLEInt32(args);
-  else if(ocv->v.vt == VT_I8 || ocv->v.vt == VT_UI8) result = OLEInt64(args);
-  else if(ocv->v.vt == VT_R8) result = OLENumber(args);
-  else if(ocv->v.vt == VT_DATE) result = OLEDate(args);
-  else if(ocv->v.vt == VT_BSTR) result = OLEUtf8(args);
-  else if(ocv->v.vt == VT_ARRAY || ocv->v.vt == VT_SAFEARRAY){
-    std::cerr << "[Array (not implemented now)]" << std::endl;
-    std::cerr.flush();
-  }else{
-    Handle<Value> s = INSTANCE_CALL(thisObject, "vtName", 0, NULL);
-    std::cerr << "[unknown type " << ocv->v.vt << ":" << *String::Utf8Value(s);
-    std::cerr << " (not implemented now)]" << std::endl;
-    std::cerr.flush();
-  }
-done:
-  OLETRACEOUT();
-  return scope.Close(result);
-}
-
-Handle<Object> V8Variant::CreateUndefined(void)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-#if(0)
-  const size_t argc = 1;
-  Handle<Value> argv[argc] = {args[0]};
-  // Class {}
-  //   static Persistent<Function> V8Variant::constructor_func;
-  // Init()
-  //   constructor_func = Persistent<Function>::New(clazz->GetFunction());
-  Local<Object> instance = constructor->NewInstance(argc, argv);
-#else
-  Local<Object> instance = clazz->GetFunction()->NewInstance(0, NULL);
-#endif
-#if(0) // needless to do (instance has been already wrapped in New)
-  V8Variant *v = new V8Variant(); // must catch exception
-  v->Wrap(instance); // InternalField[0]
-#endif
-  DISPFUNCOUT();
-  return scope.Close(instance);
-}
-
-Handle<Value> V8Variant::New(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
-  if(!args.IsConstructCall())
-    return ThrowException(Exception::TypeError(
-      String::New("Use the new operator to create new V8Variant objects")));
-  OCVariant *ocv = new OCVariant();
-  CHECK_OCV(ocv);
-  Local<Object> thisObject = args.This();
-  V8Variant *v = new V8Variant(); // must catch exception
-  v->Wrap(thisObject); // InternalField[0]
-  thisObject->SetInternalField(1, External::New(ocv));
-  Persistent<Object> objectDisposer = Persistent<Object>::New(thisObject);
-  objectDisposer.MakeWeak(ocv, Dispose);
-  DISPFUNCOUT();
-  return args.This();
-}
-
-Handle<Value> V8Variant::OLEFlushCarryOver(Handle<Value> v)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(v->ToObject());
-  Handle<Value> result = Undefined();
-  V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(v->ToObject());
-  if(v8v->property_carryover.empty()){
-    std::cerr << " *** carryover empty *** " << __FUNCTION__ << std::endl;
-    std::cerr.flush();
-    // *** or throw exception
-  }else{
-    const char *name = v8v->property_carryover.c_str();
+    }
+
+    void V8Variant::OLENumber(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        if (ocv->v.vt != VT_R8) RETURN_TYPE_ERROR("OLENumber source type OCVariant is not VT_R8")
+        DISPFUNCOUT();
+        args.GetReturnValue().Set(Number::New(isolate, ocv->v.dblVal));
+    }
+
+    void V8Variant::OLEDate(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        if (ocv->v.vt != VT_DATE) RETURN_TYPE_ERROR("OLEDate source type OCVariant is not VT_DATE")
+        SYSTEMTIME syst;
+        VariantTimeToSystemTime(ocv->v.date, &syst);
+        struct tm t = { 0 }; // set t.tm_isdst = 0
+        t.tm_year = syst.wYear - 1900;
+        t.tm_mon = syst.wMonth - 1;
+        t.tm_mday = syst.wDay;
+        t.tm_hour = syst.wHour;
+        t.tm_min = syst.wMinute;
+        t.tm_sec = syst.wSecond;
+        DISPFUNCOUT();
+        args.GetReturnValue().Set(Date::New(isolate, (double)(mktime(&t) * 1000LL + syst.wMilliseconds)));
+    }
+
+    void V8Variant::OLEUtf8(const FunctionCallbackInfo<Value>& args)
     {
-      OLETRACEPREARGV(String::NewSymbol(name));
-      OLETRACEARGV();
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        if (ocv->v.vt != VT_BSTR) RETURN_TYPE_ERROR("OLEUtf8 source type OCVariant is not VT_BSTR")
+        Handle<Value> result;
+        if (!ocv->v.bstrVal) result = Undefined(isolate); // or Null(isolate);
+        else result = String::NewFromUtf8(isolate, MBCS2UTF8(BSTR2MBCS(ocv->v.bstrVal)).c_str());
+        DISPFUNCOUT();
+        args.GetReturnValue().Set(result);
     }
-    OLETRACEFLUSH();
-    Handle<Value> argv[] = {String::NewSymbol(name), Array::New(0)};
-    int argc = sizeof(argv) / sizeof(argv[0]);
-    v8v->property_carryover.erase();
-    result = INSTANCE_CALL(v->ToObject(), "call", argc, argv);
-    if(!result->IsObject()){
-      OCVariant *rv = V8Variant::CreateOCVariant(result);
-      CHECK_OCV(rv);
-      OCVariant *o = castedInternalField<OCVariant>(v->ToObject());
-      CHECK_OCV(o);
-      *o = *rv; // copy and don't delete rv
+
+    void V8Variant::OLEValue(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        OLETRACEIN();
+        OLETRACEVT(args.This());
+        OLETRACEFLUSH();
+        Local<Object> thisObject = args.This();
+        OLE_PROCESS_CARRY_OVER(thisObject);
+        OLETRACEVT(thisObject);
+        OLETRACEFLUSH();
+        OCVariant *ocv = castedInternalField<OCVariant>(thisObject);
+        if (!ocv) { std::cerr << "ocv is null"; std::cerr.flush(); }
+        CHECK_OCV(ocv);
+        switch (ocv->v.vt) {
+        case VT_EMPTY: 
+            args.GetReturnValue().Set(Undefined(isolate));
+            break;
+        case VT_NULL:
+            args.GetReturnValue().Set(Null(isolate));
+            break;
+        case VT_DISPATCH: 
+            args.GetReturnValue().Set(thisObject); // through it
+            break;
+        case VT_BOOL:
+            OLEBoolean(args); 
+            break; 
+        case VT_I4:
+        case VT_INT:
+        case VT_UI4:
+        case VT_UINT: 
+            OLEInt32(args); 
+            break;
+        case VT_I8: 
+        case VT_UI8:
+            OLEInt64(args);
+            break;
+        case VT_R8: 
+            OLENumber(args);
+            break;
+        case VT_DATE: 
+            OLEDate(args);
+            break;
+        case VT_BSTR: 
+            OLEUtf8(args);
+            break;
+        case VT_ARRAY: 
+        case VT_SAFEARRAY:
+            std::cerr << "[Array (not implemented now)]" << std::endl;
+            std::cerr.flush();
+            break;
+        default:
+            Handle<Value> s = INSTANCE_CALL(thisObject, "vtName", 0, NULL);
+            std::cerr << "[unknown type " << ocv->v.vt << ":" << *String::Utf8Value(s);
+            std::cerr << " (not implemented now)]" << std::endl;
+            std::cerr.flush();
+        }
+        OLETRACEOUT();
     }
-  }
-  OLETRACEOUT();
-  return scope.Close(result);
-}
-
-Handle<Value> V8Variant::OLEInvoke(bool isCall, const Arguments& args)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(args.This());
-  OLETRACEARGS();
-  OLETRACEFLUSH();
-  OCVariant *ocv = castedInternalField<OCVariant>(args.This());
-  CHECK_OCV(ocv);
-  Handle<Value> av0, av1;
-  CHECK_OLE_ARGS(args, 1, av0, av1);
-  OCVariant *argchain = NULL;
-  Array *a = Array::Cast(*av1);
-  for(size_t i = 0; i < a->Length(); ++i){
-    OCVariant *o = V8Variant::CreateOCVariant(
-      ARRAY_AT(a, (i ? i : a->Length()) - 1));
-    CHECK_OCV(o);
-    if(!i) argchain = o;
-    else argchain->push(o);
-  }
-  Handle<Object> vResult = V8Variant::CreateUndefined();
-  String::Utf8Value u8s(av0);
-  wchar_t *wcs = u8s2wcs(*u8s);
-  if(!wcs && argchain) delete argchain;
-  BEVERIFY(done, wcs);
-  try{
-    OCVariant *rv = isCall ? // argchain will be deleted automatically
-      ocv->invoke(wcs, argchain, true) : ocv->getProp(wcs, argchain);
-    if(rv){
-      OCVariant *o = castedInternalField<OCVariant>(vResult);
-      CHECK_OCV(o);
-      *o = *rv; // copy and don't delete rv
+
+    void V8Variant::OLEFlushCarryOver(Isolate* isolate, Handle<Value> v, Handle<Value> &result)
+    {
+        OLETRACEIN();
+        OLETRACEVT(v->ToObject());
+        result = Undefined(isolate);
+        V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(v->ToObject());
+        if (v8v->property_carryover.empty()) {
+            std::cerr << " *** carryover empty *** " << __FUNCTION__ << std::endl;
+            std::cerr.flush();
+            // *** or throw exception
+        }
+        else {
+            const char *name = v8v->property_carryover.c_str();
+            {
+                OLETRACEPREARGV(String::NewSymbol(name));
+                OLETRACEARGV();
+            }
+            OLETRACEFLUSH();
+            Handle<Value> argv[] = { String::NewFromUtf8(isolate, name), Array::New(isolate, 0) };
+            int argc = sizeof(argv) / sizeof(argv[0]);
+            v8v->property_carryover.erase();
+            result = INSTANCE_CALL(v->ToObject(), "call", argc, argv);
+            if (!result->IsObject()) {
+                OCVariant *rv = V8Variant::CreateOCVariant(result);
+                CHECK_OCV(rv);
+                OCVariant *o = castedInternalField<OCVariant>(v->ToObject());
+                CHECK_OCV(o);
+                *o = *rv; // copy and don't delete rv
+            }
+        }
+        OLETRACEOUT();
     }
-  }catch(OLE32coreException e){ std::cerr << e.errorMessage(*u8s); goto done;
-  }catch(char *e){ std::cerr << e << *u8s << std::endl; goto done;
-  }
-  free(wcs); // *** it may leak when error ***
-#if(0) // It does not work. (when access to NamedPropertyHandler)
-  Handle<Value> result = vResult;
-#else // It works.
-  Handle<Value> result = INSTANCE_CALL(vResult, "toValue", 0, NULL);
-#endif
-  OLETRACEOUT();
-  return scope.Close(result);
-done:
-  OLETRACEOUT();
-  return ThrowException(Exception::TypeError(
-    String::New(__FUNCTION__" failed")));
-}
-
-Handle<Value> V8Variant::OLECall(const Arguments& args)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(args.This());
-  OLETRACEARGS();
-  OLETRACEFLUSH();
-  Handle<Value> r = V8Variant::OLEInvoke(true, args); // as Call
-  OLETRACEOUT();
-  return scope.Close(r);
-}
-
-Handle<Value> V8Variant::OLEGet(const Arguments& args)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(args.This());
-  OLETRACEARGS();
-  OLETRACEFLUSH();
-  Handle<Value> r = V8Variant::OLEInvoke(false, args); // as Get
-  OLETRACEOUT();
-  return scope.Close(r);
-}
-
-Handle<Value> V8Variant::OLESet(const Arguments& args)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(args.This());
-  OLETRACEARGS();
-  OLETRACEFLUSH();
-  Local<Object> thisObject = args.This();
-  OLE_PROCESS_CARRY_OVER(thisObject);
-  OCVariant *ocv = castedInternalField<OCVariant>(thisObject);
-  CHECK_OCV(ocv);
-  Handle<Value> av0, av1;
-  CHECK_OLE_ARGS(args, 2, av0, av1);
-  OCVariant *argchain = V8Variant::CreateOCVariant(av1);
-  if(!argchain)
-    return ThrowException(Exception::TypeError(String::New(
-      __FUNCTION__" the second argument is not valid (null OCVariant)")));
-  bool result = false;
-  String::Utf8Value u8s(av0);
-  wchar_t *wcs = u8s2wcs(*u8s);
-  BEVERIFY(done, wcs);
-  try{
-    ocv->putProp(wcs, argchain); // argchain will be deleted automatically
-  }catch(OLE32coreException e){ std::cerr << e.errorMessage(*u8s); goto done;
-  }catch(char *e){ std::cerr << e << *u8s << std::endl; goto done;
-  }
-  free(wcs); // *** it may leak when error ***
-  result = true;
-  OLETRACEOUT();
-  return scope.Close(Boolean::New(result));
-done:
-  OLETRACEOUT();
-  return ThrowException(Exception::TypeError(
-    String::New(__FUNCTION__" failed")));
-}
-
-Handle<Value> V8Variant::OLECallComplete(const Arguments& args)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(args.This());
-  Handle<Value> result = Undefined();
-  V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(args.This());
-  if(v8v->property_carryover.empty()){
-    std::cerr << " *** carryover empty *** " << __FUNCTION__ << std::endl;
-    std::cerr.flush();
-    // *** or throw exception
-  }else{
-    const char *name = v8v->property_carryover.c_str();
+
+    void V8Variant::OLEInvoke(bool isCall, const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        Handle<Value> av0, av1;
+        CHECK_OLE_ARGS(args, 1, av0, av1);
+        OLETRACEIN();
+        OLETRACEVT(args.This());
+        OLETRACEARGS();
+        OLETRACEFLUSH();
+        OCVariant *ocv = castedInternalField<OCVariant>(args.This());
+        CHECK_OCV(ocv);
+        OCVariant *argchain = NULL;
+        Array *a = Array::Cast(*av1);
+        for (size_t i = 0; i < a->Length(); ++i) {
+            OCVariant *o = V8Variant::CreateOCVariant(
+                ARRAY_AT(a, (i ? i : a->Length()) - 1));
+            CHECK_OCV(o);
+            if (!i) argchain = o;
+            else argchain->push(o);
+        }
+        Local<Object> vResult;
+        V8Variant::CreateUndefined(isolate, vResult);
+        String::Utf8Value u8s(av0);
+        wchar_t *wcs = u8s2wcs(*u8s);
+        if (!wcs && argchain) delete argchain;
+        bool rcode;
+        if (!wcs) {
+            std::cerr << "identity is null" << std::endl;
+            rcode = false;
+        }
+        else try {
+            OCVariant *rv = isCall // argchain will be deleted automatically
+                ? ocv->invoke(wcs, argchain, true)
+                : ocv->getProp(wcs, argchain);
+            if (rv) {
+                OCVariant *o = castedInternalField<OCVariant>(vResult);
+                CHECK_OCV(o);
+                *o = *rv; // copy and don't delete rv
+            }
+            rcode = true;
+        }
+        catch (OLE32coreException e) {
+            std::cerr << e.errorMessage(*u8s);
+            rcode = false;
+        }
+        catch (char *e) {
+            std::cerr << e << *u8s << std::endl;
+            rcode = false;
+        }
+        free(wcs); // *** it may leak when error ***
+
+        if (rcode) {
+            Handle<Value> result = INSTANCE_CALL(vResult, "toValue", 0, NULL);
+            args.GetReturnValue().Set(result);
+        }
+        else {
+            THROW_TYPE_ERROR(__FUNCTION__" failed")
+        }
+        OLETRACEOUT();
+    }
+
+    void V8Variant::OLECall(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        OLETRACEIN();
+        OLETRACEVT(args.This());
+        OLETRACEARGS();
+        OLETRACEFLUSH();
+        V8Variant::OLEInvoke(true, args); // as Call
+        OLETRACEOUT();
+    }
+
+    void V8Variant::OLEGet(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        OLETRACEIN();
+        OLETRACEVT(args.This());
+        OLETRACEARGS();
+        OLETRACEFLUSH();
+        V8Variant::OLEInvoke(false, args); // as Get
+        OLETRACEOUT();
+    }
+
+    void V8Variant::OLESet(const FunctionCallbackInfo<Value>& args)
     {
-      OLETRACEPREARGV(String::NewSymbol(name));
-      OLETRACEARGV();
+        Isolate* isolate = args.GetIsolate();
+        Handle<Value> av0, av1;
+        CHECK_OLE_ARGS(args, 2, av0, av1);
+        OLETRACEIN();
+        OLETRACEVT(args.This());
+        OLETRACEARGS();
+        OLETRACEFLUSH();
+        Local<Object> thisObject = args.This();
+        OLE_PROCESS_CARRY_OVER(thisObject);
+        OCVariant *ocv = castedInternalField<OCVariant>(thisObject);
+        CHECK_OCV(ocv);
+        OCVariant *argchain = V8Variant::CreateOCVariant(av1);
+        if (!argchain) {
+            OLETRACEOUT();
+            RETURN_TYPE_ERROR(__FUNCTION__" the second argument is not valid (null OCVariant)");
+        }
+        bool rcode;
+        String::Utf8Value u8s(av0);
+        wchar_t *wcs = u8s2wcs(*u8s);
+        if (!wcs) {
+            std::cerr << "identity is null" << std::endl;
+            rcode = false;
+        }
+        else try {
+            ocv->putProp(wcs, argchain); // argchain will be deleted automatically
+            rcode = true;
+        }
+        catch (OLE32coreException e) {
+            std::cerr << e.errorMessage(*u8s);
+            rcode = false;
+        }
+        catch (char *e) {
+            std::cerr << e << *u8s << std::endl;
+            rcode = false;
+        }
+        free(wcs); // *** it may leak when error ***
+        if (!rcode) THROW_ERROR(__FUNCTION__ " failed")
+        else args.GetReturnValue().Set(Boolean::New(isolate, true));
+        OLETRACEOUT();
     }
-    OLETRACEARGS();
-    OLETRACEFLUSH();
-    Handle<Array> a = Array::New(args.Length());
-    for(int i = 0; i < args.Length(); ++i) ARRAY_SET(a, i, args[i]);
-    Handle<Value> argv[] = {String::NewSymbol(name), a};
-    int argc = sizeof(argv) / sizeof(argv[0]);
-    v8v->property_carryover.erase();
-    result = INSTANCE_CALL(args.This(), "call", argc, argv);
-  }
-//_
-//Handle<Value> r = INSTANCE_CALL(Handle<Object>::Cast(v), "toValue", 0, NULL);
-  OLETRACEOUT();
-  return scope.Close(result);
-}
-
-Handle<Value> V8Variant::OLEGetAttr(
-  Local<String> name, const AccessorInfo& info)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(info.This());
-  {
-    OLETRACEPREARGV(name);
-    OLETRACEARGV();
-  }
-  OLETRACEFLUSH();
-  String::Utf8Value u8name(name);
-  Local<Object> thisObject = info.This();
-
-  // Why GetAttr comes twice for () in the third loop instead of CallComplete ?
-  // Because of the Crankshaft v8's run-time optimizer ?
-  {
-    V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(thisObject);
-    if(!v8v->property_carryover.empty()){
-      if(v8v->property_carryover == *u8name){
+
+    void V8Variant::OLECallComplete(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        OLETRACEIN();
+        OLETRACEVT(args.This());
+        Handle<Value> result = Undefined(isolate);
+        V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(args.This());
+        if (v8v->property_carryover.empty()) {
+            std::cerr << " *** carryover empty *** " << __FUNCTION__ << std::endl;
+            std::cerr.flush();
+            // *** or throw exception
+        }
+        else {
+            const char *name = v8v->property_carryover.c_str();
+            {
+                OLETRACEPREARGV(String::NewSymbol(name));
+                OLETRACEARGV();
+            }
+            OLETRACEARGS();
+            OLETRACEFLUSH();
+            Handle<Array> a = Array::New(isolate, args.Length());
+            for (int i = 0; i < args.Length(); ++i) ARRAY_SET(a, i, args[i]);
+            Handle<Value> argv[] = { String::NewFromUtf8(isolate, name), a };
+            int argc = sizeof(argv) / sizeof(argv[0]);
+            v8v->property_carryover.erase();
+            result = INSTANCE_CALL(args.This(), "call", argc, argv);
+        }
+        //_
+        //Handle<Value> r = INSTANCE_CALL(Handle<Object>::Cast(v), "toValue", 0, NULL);
         OLETRACEOUT();
-        return scope.Close(thisObject); // through it
-      }
+        args.GetReturnValue().Set(result);
     }
-  }
+
+    void V8Variant::OLEGetAttr(Local<String> name, const PropertyCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        Local<Object> thisObject = args.This();
+        String::Utf8Value u8name(name);
+
+        OLETRACEIN();
+        OLETRACEVT(thisObject);
+        {
+            OLETRACEPREARGV(name);
+            OLETRACEARGV();
+        }
+        OLETRACEFLUSH();
+
+        // Why GetAttr comes twice for () in the third loop instead of CallComplete ?
+        // Because of the Crankshaft v8's run-time optimizer ?
+        {
+            V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(thisObject);
+            if (!v8v->property_carryover.empty()) {
+                if (v8v->property_carryover == *u8name) {
+                    OLETRACEOUT();
+                    args.GetReturnValue().Set(thisObject); // through it
+                    return;
+                }
+            }
+        }
 
 #if(0)
-  if(std::string("call") == *u8name || std::string("get") == *u8name
-  || std::string("_") == *u8name || std::string("toValue") == *u8name
-//|| std::string("valueOf") == *u8name || std::string("toString") == *u8name
-  ){
-    OLE_PROCESS_CARRY_OVER(thisObject);
-  }
+        if (std::string("call") == *u8name || std::string("get") == *u8name
+            || std::string("_") == *u8name || std::string("toValue") == *u8name
+            //|| std::string("valueOf") == *u8name || std::string("toString") == *u8name
+            ) {
+            OLE_PROCESS_CARRY_OVER(thisObject);
+        }
 #else
-  if(std::string("set") != *u8name
-  && std::string("toBoolean") != *u8name
-  && std::string("toInt32") != *u8name && std::string("toInt64") != *u8name
-  && std::string("toNumber") != *u8name && std::string("toDate") != *u8name
-  && std::string("toUtf8") != *u8name
-  && std::string("inspect") != *u8name && std::string("constructor") != *u8name
-  && std::string("valueOf") != *u8name && std::string("toString") != *u8name
-  && std::string("toLocaleString") != *u8name
-  && std::string("hasOwnProperty") != *u8name
-  && std::string("isPrototypeOf") != *u8name
-  && std::string("propertyIsEnumerable") != *u8name
-//&& std::string("_") != *u8name
-  ){
-    OLE_PROCESS_CARRY_OVER(thisObject);
-  }
+        if (std::string("set") != *u8name
+            && std::string("toBoolean") != *u8name
+            && std::string("toInt32") != *u8name && std::string("toInt64") != *u8name
+            && std::string("toNumber") != *u8name && std::string("toDate") != *u8name
+            && std::string("toUtf8") != *u8name
+            && std::string("inspect") != *u8name && std::string("constructor") != *u8name
+            && std::string("valueOf") != *u8name && std::string("toString") != *u8name
+            && std::string("toLocaleString") != *u8name
+            && std::string("hasOwnProperty") != *u8name
+            && std::string("isPrototypeOf") != *u8name
+            && std::string("propertyIsEnumerable") != *u8name
+            //&& std::string("_") != *u8name
+            ) 
+        {
+            OLE_PROCESS_CARRY_OVER(thisObject);
+        }
 #endif
-  OLETRACEVT(thisObject);
-  // Can't use INSTANCE_CALL here. (recursion itself)
-  // So it returns Object's fundamental function and custom function:
-  //   inspect ?, constructor valueOf toString toLocaleString
-  //   hasOwnProperty isPrototypeOf propertyIsEnumerable
-  static fundamental_attr fundamentals[] = {
-    {0, "call", OLECall}, {0, "get", OLEGet}, {0, "set", OLESet},
-    {0, "isA", OLEIsA}, {0, "vtName", OLEVTName}, // {"vt_names", ???},
-    {!0, "toBoolean", OLEValue},
-    {!0, "toInt32", OLEValue}, {!0, "toInt64", OLEValue},
-    {!0, "toNumber", OLEValue}, {!0, "toDate", OLEValue},
-    {!0, "toUtf8", OLEValue},
-    {0, "toValue", OLEValue},
-    {0, "inspect", NULL}, {0, "constructor", NULL}, {0, "valueOf", OLEValue},
-    {0, "toString", OLEValue}, {0, "toLocaleString", OLEValue},
-    {0, "hasOwnProperty", NULL}, {0, "isPrototypeOf", NULL},
-    {0, "propertyIsEnumerable", NULL}
-  };
-  for(int i = 0; i < sizeof(fundamentals) / sizeof(fundamentals[0]); ++i){
-    if(std::string(fundamentals[i].name) != *u8name) continue;
-    if(fundamentals[i].obsoleted){
-      std::cerr << " *** ## [." << fundamentals[i].name;
-      std::cerr << "()] is obsoleted. ## ***" << std::endl;
-      std::cerr.flush();
-    }
-    OLETRACEFLUSH();
-    OLETRACEOUT();
-    return scope.Close(FunctionTemplate::New(
-      fundamentals[i].func, thisObject)->GetFunction());
-  }
-  if(std::string("_") == *u8name){ // through it when "_"
+        OLETRACEVT(thisObject);
+        // Can't use INSTANCE_CALL here. (recursion itself)
+        // So it returns Object's fundamental function and custom function:
+        //   inspect ?, constructor valueOf toString toLocaleString
+        //   hasOwnProperty isPrototypeOf propertyIsEnumerable
+        static fundamental_attr fundamentals[] = {
+          {0, "call", OLECall}, {0, "get", OLEGet}, {0, "set", OLESet},
+          {0, "isA", OLEIsA}, {0, "vtName", OLEVTName}, // {"vt_names", ???},
+          {!0, "toBoolean", OLEValue},
+          {!0, "toInt32", OLEValue}, {!0, "toInt64", OLEValue},
+          {!0, "toNumber", OLEValue}, {!0, "toDate", OLEValue},
+          {!0, "toUtf8", OLEValue},
+          {0, "toValue", OLEValue},
+          {0, "inspect", NULL}, {0, "constructor", NULL}, {0, "valueOf", OLEValue},
+          {0, "toString", OLEValue}, {0, "toLocaleString", OLEValue},
+          {0, "hasOwnProperty", NULL}, {0, "isPrototypeOf", NULL},
+          {0, "propertyIsEnumerable", NULL}
+        };
+        for (int i = 0; i < sizeof(fundamentals) / sizeof(fundamentals[0]); ++i) {
+            if (std::string(fundamentals[i].name) != *u8name) continue;
+            if (fundamentals[i].obsoleted) {
+                std::cerr << " *** ## [." << fundamentals[i].name;
+                std::cerr << "()] is obsoleted. ## ***" << std::endl;
+                std::cerr.flush();
+            }
+            OLETRACEFLUSH();
+            OLETRACEOUT();
+            args.GetReturnValue().Set(FunctionTemplate::New(isolate, 
+                fundamentals[i].func, thisObject)->GetFunction());
+            return;
+        }
+        if (std::string("_") == *u8name) { // through it when "_"
 #if(0)
-    std::cerr << " *** ## [._] is obsoleted. ## ***" << std::endl;
-    std::cerr.flush();
+            std::cerr << " *** ## [._] is obsoleted. ## ***" << std::endl;
+            std::cerr.flush();
 #endif
-  }else{
-    Handle<Object> vResult = V8Variant::CreateUndefined(); // uses much memory
-    OCVariant *rv = V8Variant::CreateOCVariant(thisObject);
-    CHECK_OCV(rv);
-    OCVariant *o = castedInternalField<OCVariant>(vResult);
-    CHECK_OCV(o);
-    *o = *rv; // copy and don't delete rv
-    V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(vResult);
-    v8v->property_carryover.assign(*u8name);
-    OLETRACEPREARGV(name);
-    OLETRACEARGV();
-    OLETRACEFLUSH();
-    OLETRACEOUT();
-    return scope.Close(vResult); // convert and hold it (uses much memory)
-  }
-  OLETRACEFLUSH();
-  OLETRACEOUT();
-  return scope.Close(thisObject); // through it
-}
-
-Handle<Value> V8Variant::OLESetAttr(
-  Local<String> name, Local<Value> val, const AccessorInfo& info)
-{
-  HandleScope scope;
-  OLETRACEIN();
-  OLETRACEVT(info.This());
-  Handle<Value> argv[] = {name, val};
-  int argc = sizeof(argv) / sizeof(argv[0]);
-  OLETRACEARGV();
-  OLETRACEFLUSH();
-  Handle<Value> r = INSTANCE_CALL(info.This(), "set", argc, argv);
-  OLETRACEOUT();
-  return scope.Close(r);
-}
-
-Handle<Value> V8Variant::Finalize(const Arguments& args)
-{
-  HandleScope scope;
-  DISPFUNCIN();
+        }
+        else {
+            Handle<Object> vResult;
+            V8Variant::CreateUndefined(isolate, vResult); // uses much memory
+            OCVariant *rv = V8Variant::CreateOCVariant(thisObject);
+            CHECK_OCV(rv);
+            OCVariant *o = castedInternalField<OCVariant>(vResult);
+            CHECK_OCV(o);
+            *o = *rv; // copy and don't delete rv
+            V8Variant *v8v = ObjectWrap::Unwrap<V8Variant>(vResult);
+            v8v->property_carryover.assign(*u8name);
+            OLETRACEPREARGV(name);
+            OLETRACEARGV();
+            OLETRACEFLUSH();
+            OLETRACEOUT();
+            args.GetReturnValue().Set(vResult); // convert and hold it (uses much memory)
+            return;
+        }
+        OLETRACEFLUSH();
+        OLETRACEOUT();
+        args.GetReturnValue().Set(thisObject); // through it
+    }
+
+    void V8Variant::OLESetAttr(Local<String> name, Local<Value> val, const PropertyCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        OLETRACEIN();
+        OLETRACEVT(info.This());
+        Handle<Value> argv[] = { name, val };
+        int argc = sizeof(argv) / sizeof(argv[0]);
+        OLETRACEARGV();
+        OLETRACEFLUSH();
+        Handle<Value> r = INSTANCE_CALL(args.This(), "set", argc, argv);
+        args.GetReturnValue().Set(r);
+        OLETRACEOUT();
+    }
+
+    void V8Variant::Finalize(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        DISPFUNCIN();
 #if(0)
-  std::cerr << __FUNCTION__ << " Finalizer is called\a" << std::endl;
-  std::cerr.flush();
+        std::cerr << __FUNCTION__ << " Finalizer is called\a" << std::endl;
+        std::cerr.flush();
 #endif
-  Local<Object> thisObject = args.This();
+        Local<Object> thisObject = args.This();
 #if(0)
-  V8Variant *v = ObjectWrap::Unwrap<V8Variant>(thisObject);
-  if(v) delete v; // it has been already deleted ?
-  thisObject->SetInternalField(0, External::New(NULL));
+        V8Variant *v = ObjectWrap::Unwrap<V8Variant>(thisObject);
+        if (v) delete v; // it has been already deleted ?
+        thisObject->SetInternalField(0, External::New(isolate, NULL));
 #endif
 #if(1) // now GC will call Disposer automatically
-  OCVariant *ocv = castedInternalField<OCVariant>(thisObject);
-  if(ocv) delete ocv;
+        OCVariant *ocv = castedInternalField<OCVariant>(thisObject);
+        if (ocv) delete ocv;
 #endif
-  thisObject->SetInternalField(1, External::New(NULL));
-  DISPFUNCOUT();
-  return args.This();
-}
-
-void V8Variant::Dispose(Persistent<Value> handle, void *param)
-{
-  DISPFUNCIN();
+        thisObject->SetInternalField(1, External::New(isolate, NULL));
+        args.GetReturnValue().Set(thisObject);
+        DISPFUNCOUT();
+    }
+
+    void V8Variant::Dispose(Isolate* isolate, Persistent<Object> handle, void *param)
+    {
+        DISPFUNCIN();
 #if(0)
-//  std::cerr << __FUNCTION__ << " Disposer is called\a" << std::endl;
-  std::cerr << __FUNCTION__ << " Disposer is called" << std::endl;
-  std::cerr.flush();
+        //  std::cerr << __FUNCTION__ << " Disposer is called\a" << std::endl;
+        std::cerr << __FUNCTION__ << " Disposer is called" << std::endl;
+        std::cerr.flush();
 #endif
-  Local<Object> thisObject = handle->ToObject();
+        Local<Object> thisObject = handle.Get(isolate);
 #if(0) // it has been already deleted ?
-  V8Variant *v = ObjectWrap::Unwrap<V8Variant>(thisObject);
-  if(!v){
-    std::cerr << __FUNCTION__;
-    std::cerr << "InternalField[0] has been already deleted" << std::endl;
-    std::cerr.flush();
-  }else delete v; // it has been already deleted ?
-  BEVERIFY(done, thisObject->InternalFieldCount() > 0);
-  thisObject->SetInternalField(0, External::New(NULL));
+        V8Variant *v = ObjectWrap::Unwrap<V8Variant>(thisObject);
+        if (!v) {
+            std::cerr << __FUNCTION__;
+            std::cerr << "InternalField[0] has been already deleted" << std::endl;
+            std::cerr.flush();
+        }
+        else delete v; // it has been already deleted ?
+        BEVERIFY(done, thisObject->InternalFieldCount() > 0);
+        thisObject->SetInternalField(0, External::New(isolate, NULL));
 #endif
-  OCVariant *p = castedInternalField<OCVariant>(thisObject);
-  if(!p){
-    std::cerr << __FUNCTION__;
-    std::cerr << "InternalField[1] has been already deleted" << std::endl;
-    std::cerr.flush();
-  }
-//  else{
-    OCVariant *ocv = static_cast<OCVariant *>(param); // ocv may be same as p
-    if(ocv) delete ocv;
-//  }
-  BEVERIFY(done, thisObject->InternalFieldCount() > 1);
-  thisObject->SetInternalField(1, External::New(NULL));
-done:
-  handle.Dispose();
-  DISPFUNCOUT();
-}
-
-void V8Variant::Finalize()
-{
-  assert(!finalized);
-  finalized = true;
-}
+        OCVariant *p = castedInternalField<OCVariant>(thisObject);
+        if (!p) {
+            std::cerr << __FUNCTION__;
+            std::cerr << "InternalField[1] has been already deleted" << std::endl;
+            std::cerr.flush();
+        }
+        //  else{
+        OCVariant *ocv = static_cast<OCVariant *>(param); // ocv may be same as p
+        if (ocv) delete ocv;
+        //  }
+        BEVERIFY(done, thisObject->InternalFieldCount() > 1);
+        thisObject->SetInternalField(1, External::New(isolate, NULL));
+    done:
+        handle.Reset();
+        DISPFUNCOUT();
+    }
+
+    void V8Variant::Finalize()
+    {
+        assert(!finalized);
+        finalized = true;
+    }
 
 } // namespace node_win32ole
diff --git a/src/v8variant.h b/src/v8variant.h
index 766ce7b..d4b7a6f 100644
--- a/src/v8variant.h
+++ b/src/v8variant.h
@@ -12,46 +12,46 @@ namespace node_win32ole {
 typedef struct _fundamental_attr {
   bool obsoleted;
   const char *name;
-  Handle<Value> (*func)(const Arguments& args);
+  void (*func)(const FunctionCallbackInfo<Value>& args);
 } fundamental_attr;
 
 class V8Variant : public node::ObjectWrap {
 public:
-  static Persistent<FunctionTemplate> clazz;
-  static void Init(Handle<Object> target);
-  static std::string CreateStdStringMBCSfromUTF8(Handle<Value> v); // *** p.
-  static OCVariant *CreateOCVariant(Handle<Value> v); // *** private
-  static Handle<Value> OLEIsA(const Arguments& args);
-  static Handle<Value> OLEVTName(const Arguments& args);
-  static Handle<Value> OLEBoolean(const Arguments& args); // *** p.
-  static Handle<Value> OLEInt32(const Arguments& args); // *** p.
-  static Handle<Value> OLEInt64(const Arguments& args); // *** p.
-  static Handle<Value> OLENumber(const Arguments& args); // *** p.
-  static Handle<Value> OLEDate(const Arguments& args); // *** p.
-  static Handle<Value> OLEUtf8(const Arguments& args); // *** p.
-  static Handle<Value> OLEValue(const Arguments& args);
-  static Handle<Object> CreateUndefined(void); // *** private
-  static Handle<Value> New(const Arguments& args);
-  static Handle<Value> OLEFlushCarryOver(Handle<Value> v); // *** p.
-  static Handle<Value> OLEInvoke(bool isCall, const Arguments& args); // *** p.
-  static Handle<Value> OLECall(const Arguments& args);
-  static Handle<Value> OLEGet(const Arguments& args);
-  static Handle<Value> OLESet(const Arguments& args);
-  static Handle<Value> OLECallComplete(const Arguments& args); // *** p.
-  static Handle<Value> OLEGetAttr(
-    Local<String> name, const AccessorInfo& info); // *** p.
-  static Handle<Value> OLESetAttr(
-    Local<String> name, Local<Value> val, const AccessorInfo& info); // *** p.
-  static Handle<Value> Finalize(const Arguments& args);
+	static Persistent<FunctionTemplate> clazz;
+	static void Init(Handle<Object> target);
+	static void New(const FunctionCallbackInfo<Value>& args);
+
+	static std::string CreateStdStringMBCSfromUTF8(Handle<Value> v); // *** p.
+	static OCVariant *CreateOCVariant(Handle<Value> v); // *** private
+	static void CreateUndefined(Isolate* isolate, Local<Object> &instance); // *** private
+	static void OLEIsA(const FunctionCallbackInfo<Value>& args);
+	static void OLEVTName(const FunctionCallbackInfo<Value>& args);
+	static void OLEBoolean(const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLEInt32(const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLEInt64(const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLENumber(const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLEDate(const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLEUtf8(const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLEValue(const FunctionCallbackInfo<Value>& args);
+	static void OLEFlushCarryOver(Isolate* isolate, Handle<Value> v, Handle<Value> &result); // *** p.
+	static void OLEInvoke(bool isCall, const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLECall(const FunctionCallbackInfo<Value>& args);
+	static void OLEGet(const FunctionCallbackInfo<Value>& args);
+	static void OLESet(const FunctionCallbackInfo<Value>& args);
+	static void OLECallComplete(const FunctionCallbackInfo<Value>& args); // *** p.
+	static void OLEGetAttr(Local<String> name, const PropertyCallbackInfo<Value>& args); // *** p.
+	static void OLESetAttr(Local<String> name, Local<Value> val, const PropertyCallbackInfo<Value>& args); // *** p.
+	static void Finalize(const FunctionCallbackInfo<Value>& args);
 public:
-  V8Variant() : node::ObjectWrap(), finalized(false), property_carryover() {}
-  ~V8Variant() { if(!finalized) Finalize(); }
+	V8Variant() : node::ObjectWrap(), finalized(false), property_carryover() {}
+	~V8Variant() { if(!finalized) Finalize(); }
 protected:
-  static void Dispose(Persistent<Value> handle, void *param);
-  void Finalize();
+	static void Dispose(Isolate* isolate, Persistent<Object> handle, void *param);
+	void Finalize();
 protected:
-  bool finalized;
-  std::string property_carryover;
+	bool finalized;
+	static Persistent<Function> constructor;
+	std::string property_carryover;
 };
 
 } // namespace node_win32ole
diff --git a/src/win32ole_gettimeofday.cc b/src/win32ole_gettimeofday.cc
index 8665003..8479f61 100644
--- a/src/win32ole_gettimeofday.cc
+++ b/src/win32ole_gettimeofday.cc
@@ -14,76 +14,72 @@ using namespace ole32core;
 
 namespace node_win32ole {
 
-void timeval_gettimeofday(struct timeval *ptv)
-{
+    void timeval_gettimeofday(struct timeval *ptv)
+    {
 #ifdef _WIN32
-  _timeb btv;
-  _ftime(&btv);
-  ptv->tv_sec = btv.time; // unsafe convert __time64_t to long
-  ptv->tv_usec = 1000LL * btv.millitm;
+        _timeb btv;
+        _ftime(&btv);
+        ptv->tv_sec = (long)btv.time; // unsafe convert __time64_t to long
+        ptv->tv_usec = 1000LL * btv.millitm;
 #else
-  gettimeofday(ptv, NULL); // no &tz
+        gettimeofday(ptv, NULL); // no &tz
 #endif
-}
-
-Handle<Value> Method_gettimeofday(const Arguments& args)
-{
-  HandleScope scope;
-  boolean result = false;
-  BEVERIFY(done, args.Length() >= 2);
-  struct timeval tv;
-  timeval_gettimeofday(&tv);
-  BEVERIFY(done, args[0]->IsObject());
-  v8::Handle<v8::Object> buf = args[0]->ToObject();
-  BEVERIFY(done, node::Buffer::Length(buf) == sizeof(struct timeval));
-  memcpy(node::Buffer::Data(buf), &tv, sizeof(struct timeval));
-  result = true;
-done:
-  return scope.Close(Boolean::New(result));
-}
+    }
 
-Handle<Value> Method_sleep(const Arguments& args) // ms, bool: msg, bool: \n
-{
-  HandleScope scope;
-  boolean result = false;
-  BEVERIFY(done, args.Length() >= 1);
-  if(!args[0]->IsInt32())
-    return ThrowException(Exception::TypeError(
-      String::New("type of argument 1 must be Int32")));
-  long ms = args[0]->Int32Value();
-  bool msg = false;
-  if(args.Length() >= 2){
-    if(!args[1]->IsBoolean())
-      return ThrowException(Exception::TypeError(
-        String::New("type of argument 2 must be Boolean")));
-    msg = args[1]->BooleanValue();
-  }
-  bool crlf = false;
-  if(args.Length() >= 3){
-    if(!args[2]->IsBoolean())
-      return ThrowException(Exception::TypeError(
-        String::New("type of argument 3 must be Boolean")));
-    crlf = args[2]->BooleanValue();
-  }
-  if(ms){
-    if(msg){
-      printf("waiting %ld milliseconds...", ms);
-      if(crlf) printf("\n");
+    void Method_gettimeofday(const FunctionCallbackInfo<Value>& args)
+    {
+        Isolate* isolate = args.GetIsolate();
+        boolean result = false;
+        if BVERIFY(args.Length() >= 2) {
+            struct timeval tv;
+            timeval_gettimeofday(&tv);
+            if BVERIFY(args[0]->IsObject()) {
+                v8::Handle<v8::Object> buf = args[0]->ToObject();
+                if BVERIFY(node::Buffer::Length(buf) == sizeof(struct timeval)) {
+                    memcpy(node::Buffer::Data(buf), &tv, sizeof(struct timeval));
+                    result = true;
+                }
+            }
+        }
+        args.GetReturnValue().Set(Boolean::New(isolate, result));
     }
-    struct timeval tv_start;
-    timeval_gettimeofday(&tv_start);
-    while(true){
-      struct timeval tv_now;
-      timeval_gettimeofday(&tv_now);
-      // it is wrong way (must release CPU)
-      if((double)tv_now.tv_sec + (double)tv_now.tv_usec / 1000. / 1000.
-      >= (double)tv_start.tv_sec + (double)tv_start.tv_usec / 1000. / 1000.
-        + (double)ms / 1000.) break;
+
+    void Method_sleep(const FunctionCallbackInfo<Value>& args) // ms, bool: msg, bool: \n
+    {
+        Isolate* isolate = args.GetIsolate();
+        if (!BVERIFY(args.Length() >= 1)) {
+            args.GetReturnValue().Set(Boolean::New(isolate, false));
+            return;
+        }
+        if (!args[0]->IsInt32()) RETURN_TYPE_ERROR("type of argument 1 must be Int32");
+        long ms = args[0]->Int32Value();
+        bool msg = false;
+        if (args.Length() >= 2) {
+            if (!args[1]->IsBoolean()) RETURN_TYPE_ERROR("type of argument 2 must be Boolean")
+            msg = args[1]->BooleanValue();
+        }
+        bool crlf = false;
+        if (args.Length() >= 3) {
+            if (!args[2]->IsBoolean()) RETURN_TYPE_ERROR("type of argument 3 must be Boolean")
+            crlf = args[2]->BooleanValue();
+        }
+        if (ms) {
+            if (msg) {
+                printf("waiting %ld milliseconds...", ms);
+                if (crlf) printf("\n");
+            }
+            struct timeval tv_start;
+            timeval_gettimeofday(&tv_start);
+            while (true) {
+                struct timeval tv_now;
+                timeval_gettimeofday(&tv_now);
+                // it is wrong way (must release CPU)
+                if ((double)tv_now.tv_sec + (double)tv_now.tv_usec / 1000. / 1000.
+                    >= (double)tv_start.tv_sec + (double)tv_start.tv_usec / 1000. / 1000.
+                    + (double)ms / 1000.) break;
+            }
+        }
+        args.GetReturnValue().Set(Boolean::New(isolate, true));
     }
-  }
-  result = true;
-done:
-  return scope.Close(Boolean::New(result));
-}
 
 } // namespace node_win32ole

From 390a98d313d802e49e024227e4072122d886933a Mon Sep 17 00:00:00 2001
From: yukiexe <lf2kexe@gmail.com>
Date: Fri, 15 Jun 2018 19:07:52 +0800
Subject: [PATCH 2/2] fix: package.json

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 26600aa..aa0b035 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/idobatter/node-win32ole.git"
+    "url": "git://github.com/durs/node-win32ole.git"
   },
   "dependencies": {
     "assert": ">= 0.4.9",
@@ -40,4 +40,4 @@
   },
   "licenses": [{ "type": "BSD" }],
   "main": "./lib/win32ole"
-}
\ No newline at end of file
+}