Implement 'JavaScriptCallFrame'

Author: 3y3

InjectedScript/JavaScriptCallFrame.js

@@ -0,0 +1,110 @@
+"use strict";
+
+(function(binding) {
+  function JavaScriptCallFrame(proto) {
+    Object.defineProperty(this, 'proto', {
+      get: function() { return proto; }
+    });
+  }
+
+  JavaScriptCallFrame.prototype = binding.JavaScriptCallFrame;
+
+  Object.defineProperties(JavaScriptCallFrame.prototype, {
+    setVariableValue: {
+      value: function(scopeNumber, variableName, resolvedValue) {
+        return this.proto.setVariableValue(scopeNumber, variableName, resolvedValue);
+      }
+    },
+
+    caller: {
+      get: function() {
+        var caller = this.proto.caller;
+        if (!caller) return;
+
+        return new JavaScriptCallFrame(caller);
+      }
+    },
+
+    sourceID: {
+      get: function() {
+        return Number(this.proto.sourceID());
+      }
+    },
+
+    line: {
+      get: function() {
+        return Number(this.proto.line());
+      }
+    },
+
+    column: {
+      get: function() {
+        return Number(this.proto.column());
+      }
+    },
+
+    scriptName: {
+      get: function() {
+        return String(this.proto.scriptName());
+      }
+    },
+
+    functionName: {
+      get: function() {
+        return String(this.proto.functionName());
+      }
+    },
+
+    functionLine: {
+      get: function() {
+        return Number(this.proto.functionLine());
+      }
+    },
+
+    functionColumn: {
+      get: function() {
+        return Number(this.proto.functionColumn());
+      }
+    },
+
+    scopeChain: {
+      get: function() {
+        var scopeChain = this.proto.scopeChain();
+        return scopeChain.slice();
+      }
+    },
+
+    scopeType: {
+      value: function(index) {
+        var scopeType = this.proto.scopeType();
+        return Number(scopeType[index]);
+      }
+    },
+
+    thisObject: {
+      get: function() {
+        return this.proto.thisObject;
+      }
+    },
+
+    stepInPositions: {
+      get: function() {
+        return String(this.proto.stepInPositions());
+      }
+    },
+
+    isAtReturn: {
+      get: function() {
+        return Boolean(this.proto.isAtReturn);
+      }
+    },
+
+    returnValue: {
+      get: function() {
+        return this.proto.returnValue;
+      }
+    }
+  });
+
+  return JavaScriptCallFrame;
+});

binding.gyp

@@ -15,7 +15,8 @@
       'conditions' : [
         ['node_next=="true"', {
             'sources': [
-                'src/InjectedScriptHost.cc'
+                'src/InjectedScriptHost.cc',
+                'src/JavaScriptCallFrame.cc'
             ],
             'defines': ['NODE_NEXT=1']
         }]

src/JavaScriptCallFrame.cc

@@ -0,0 +1,98 @@
+#include <v8-debug.h>
+
+#include "JavaScriptCallFrame.h"
+#include "tools.h"
+
+using v8::Isolate;
+using v8::Local;
+using v8::Value;
+using v8::Number;
+using v8::Integer;
+using v8::String;
+using v8::Object;
+using v8::Message;
+using v8::Function;
+using Nan::To;
+using Nan::New;
+using Nan::Get;
+using Nan::Set;
+using Nan::SetMethod;
+using Nan::EscapableHandleScope;
+using Nan::Undefined;
+using Nan::TryCatch;
+using Nan::ThrowError;
+using Nan::ThrowTypeError;
+using Nan::MaybeLocal;
+
+namespace nodex {
+  void JavaScriptCallFrame::Initialize(Local<Object> target) {
+    Local<Object> javaScriptCallFrame = New<Object>();
+    SetMethod(javaScriptCallFrame, "evaluateWithExceptionDetails", EvaluateWithExceptionDetails);
+    SetMethod(javaScriptCallFrame, "restart", Restart);
+
+    SET(target, "JavaScriptCallFrame", javaScriptCallFrame);
+  }
+
+  Local<Object> JavaScriptCallFrame::createExceptionDetails(Local<Message> message) {
+    EscapableHandleScope scope;
+
+    Local<Object> exceptionDetails = New<Object>();
+    SET(exceptionDetails, "text", message->Get());
+
+    SET(exceptionDetails, "url", message->GetScriptOrigin().ResourceName());
+    SET(exceptionDetails, "scriptId", New<Integer>((int32_t)message->GetScriptOrigin().ScriptID()->Value()));
+    SET(exceptionDetails, "line", New<Integer>(message->GetLineNumber()));
+    SET(exceptionDetails, "column", New<Number>(message->GetStartColumn()));
+
+    if (!message->GetStackTrace().IsEmpty())
+      SET(exceptionDetails, "stackTrace", message->GetStackTrace()->AsArray());
+    else
+      SET(exceptionDetails, "stackTrace", Undefined());
+
+    return scope.Escape(exceptionDetails);
+  };
+
+  NAN_METHOD(JavaScriptCallFrame::EvaluateWithExceptionDetails) {
+    Local<Object> callFrame = CHK(To<Object>(CHK(Get(info.Holder(), CHK(New("proto"))))));
+    Local<Function> evalFunction = Local<Function>::Cast(CHK(Get(callFrame, CHK(New("evaluate")))));
+
+    Local<Value> expression = info[0];
+    Local<Value> scopeExtension = info[1];
+    v8::Local<v8::Value> argv[] = {
+        expression,
+        scopeExtension
+    };
+
+    Local<Object> wrappedResult = New<Object>();
+
+    TryCatch tryCatch;
+    MaybeLocal<Value> result;
+
+    result = evalFunction->Call(callFrame, 2, argv);
+
+    if (tryCatch.HasCaught()) {
+      SET(wrappedResult, "result", tryCatch.Exception());
+      SET(wrappedResult, "exceptionDetails", createExceptionDetails(tryCatch.Message()));
+    } else {
+      SET(wrappedResult, "result", CHK(result));
+      SET(wrappedResult, "exceptionDetails", Undefined());
+    }
+
+    RETURN(wrappedResult);
+  };
+
+  NAN_METHOD(JavaScriptCallFrame::Restart) {
+    Local<Object> callFrame = CHK(To<Object>(CHK(Get(info.Holder(), CHK(New("proto"))))));
+    Local<Function> restartFunction = Local<Function>::Cast(CHK(Get(callFrame, CHK(New("restart")))));
+
+    TryCatch tryCatch;
+    MaybeLocal<Value> result;
+
+    v8::Debug::SetLiveEditEnabled(info.GetIsolate(), true);
+    result = restartFunction->Call(callFrame, 0, NULL);
+    v8::Debug::SetLiveEditEnabled(info.GetIsolate(), false);
+
+    MAYBE_RETHROW();
+    RETURN(CHK(result));
+  };
+}

src/JavaScriptCallFrame.h

@@ -0,0 +1,18 @@
+#ifndef X_JAVASCRIPT_CALL_FRAME_
+#define X_JAVASCRIPT_CALL_FRAME_
+
+#include <nan.h>
+
+namespace nodex {
+
+  class JavaScriptCallFrame {
+   public:
+     static void Initialize(v8::Local<v8::Object> target);
+     static NAN_METHOD(EvaluateWithExceptionDetails);
+     static NAN_METHOD(Restart);
+   private:
+     static v8::Local<v8::Object> createExceptionDetails(v8::Local<v8::Message> message);
+  };
+
+} //namespace nodex
+#endif  // X_JAVASCRIPT_CALL_FRAME_

src/debug.cc

@@ -4,6 +4,7 @@
 #include "tools.h"
 #if (NODE_NEXT)
 #include "InjectedScriptHost.h"
+#include "JavaScriptCallFrame.h"
 #endif
 
 using v8::Isolate;
@@ -121,6 +122,7 @@ namespace nodex {
   NAN_MODULE_INIT(Initialize) {
 #if (NODE_NEXT)
     InjectedScriptHost::Initialize(target);
+    JavaScriptCallFrame::Initialize(target);
 #endif
 
     SetMethod(target, "call", Debug::Call);

src/tools.h

@@ -14,14 +14,14 @@
 
 #define RUNSCRIPT(EXPRESSION, RESULT) while (true) {                          \
     Nan::MaybeLocal<Nan::BoundScript> script = Nan::CompileScript(EXPRESSION);\
-    if (tryCatch.HasCaught()) break;                                     \
+    if (tryCatch.HasCaught()) break;                                          \
     RESULT = Nan::RunScript(CHK(script));                                     \
     break;                                                                    \
   }
 
 #define MAYBE_RETHROW()                                                       \
-  if (tryCatch.HasCaught()) {                                            \
-    tryCatch.ReThrow();                                                  \
+  if (tryCatch.HasCaught()) {                                                 \
+    tryCatch.ReThrow();                                                       \
     return;                                                                   \
   }
 

v8-debug.js

@@ -18,6 +18,7 @@ function InjectedScriptDir(link) {
 var DebuggerScriptLink = InjectedScriptDir('DebuggerScript.js');
 var InjectedScriptLink = InjectedScriptDir('InjectedScriptSource.js');
 var InjectedScriptHostLink = InjectedScriptDir('InjectedScriptHost.js');
+var JavaScriptCallFrameLink = InjectedScriptDir('JavaScriptCallFrame.js');
 
 var overrides = {
   extendedProcessDebugJSONRequestHandles_: {},
@@ -254,6 +255,9 @@ V8Debug.prototype.enableWebkitProtocol = function() {
   InjectedScriptHostSource = fs.readFileSync(InjectedScriptHostLink, 'utf8');
   InjectedScriptHost = this.runInDebugContext(InjectedScriptHostSource)(binding, DebuggerScript);
 
+  JavaScriptCallFrameSource = fs.readFileSync(JavaScriptCallFrameLink, 'utf8');
+  JavaScriptCallFrame = this.runInDebugContext(JavaScriptCallFrameSource)(binding, DebuggerScript);
+
   var injectedScript = InjectedScript(InjectedScriptHost, global, 1);
 
   this.registerAgentCommand = function(command, parameters, callback) {
@@ -265,6 +269,15 @@ V8Debug.prototype.enableWebkitProtocol = function() {
     this.registerCommand(command, new WebkitProtocolCallback(parameters, callback));
   };
 
+  this.wrapCallFrames = function(execState, maximumLimit, scopeDetails) {
+    var scopeBits = 2;
+
+    if (maximumLimit < 0) throw new Error('Incorrect stack trace limit.');
+    var data = (maximumLimit << scopeBits) | scopeDetails;
+
+    return JavaScriptCallFrame.currentCallFrame(execState, data);;
+  };
+
   this._webkitProtocolEnabled = true;
 
   function WebkitProtocolCallback(argsList, callback) {
@@ -282,6 +295,7 @@ V8Debug.prototype.enableWebkitProtocol = function() {
   }
 };
 
+V8Debug.prototype.wrapCallFrames =
 V8Debug.prototype.registerAgentCommand = function(command, parameters, callback) {
   throw new Error('Use "enableWebkitProtocol" before using this method');
 };