Add external exception wiring option to V8\Isolate::ThrowException()

Author: pinepain

src/php_v8_isolate.cc

@@ -21,6 +21,7 @@
 #include "php_v8_context.h"
 #include "php_v8_exceptions.h"
 #include "php_v8_stack_trace.h"
+#include "php_v8_object.h"
 #include "php_v8_value.h"
 #include "php_v8_a.h"
 #include "php_v8.h"
@@ -346,8 +347,9 @@ static PHP_METHOD(V8Isolate, GetEnteredContext) {
 static PHP_METHOD(V8Isolate, ThrowException) {
     zval *php_v8_context_zv;
     zval *php_v8_value_zv;
+    zval *exception_zv = NULL;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_value_zv) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo|o", &php_v8_context_zv, &php_v8_value_zv, &exception_zv) == FAILURE) {
         return;
     }
 
@@ -364,6 +366,22 @@ static PHP_METHOD(V8Isolate, ThrowException) {
 
     v8::Local<v8::Value> local_value = php_v8_value_get_local(php_v8_value);
 
+    if (NULL != exception_zv) {
+        if (!local_value->IsObject()) {
+            PHP_V8_THROW_VALUE_EXCEPTION("Unable to associate external exception with non-object value");
+            return;
+        }
+
+        php_v8_value_t *php_v8_value = php_v8_object_get_self_ptr(php_v8_isolate, local_value.As<v8::Object>());
+
+        if (!Z_ISUNDEF(php_v8_value->exception)) {
+            PHP_V8_THROW_VALUE_EXCEPTION("Another external exception is already associated with a given value");
+            return;
+        }
+
+        ZVAL_COPY(&php_v8_value->exception, exception_zv);
+    }
+
     isolate->ThrowException(local_value);
 }
 
@@ -505,6 +523,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_INFO_EX(arginfo_v8_isolate_ThrowException, ZEND_SEND_BY_VAL, ZEND_RETURN_VALUE, 2)
                 ZEND_ARG_OBJ_INFO(0, context, V8\\Context, 0)
                 ZEND_ARG_OBJ_INFO(0, value, V8\\Value, 0)
+                ZEND_ARG_OBJ_INFO(0, e, Throwable, 0)
 ZEND_END_ARG_INFO()
 
 PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_v8_isolate_IdleNotificationDeadline, ZEND_RETURN_VALUE, 1, _IS_BOOL, 0)

src/php_v8_try_catch.cc

@@ -43,8 +43,15 @@ void php_v8_try_catch_create_from_try_catch(zval *return_value, php_v8_isolate_t
 
     if (try_catch && !try_catch->Exception().IsEmpty()) {
         zval exception_zv;
-        php_v8_get_or_create_value(&exception_zv, try_catch->Exception(), php_v8_isolate);
+        php_v8_value_t * php_v8_value = php_v8_get_or_create_value(&exception_zv, try_catch->Exception(), php_v8_isolate);
         zend_update_property(this_ce, return_value, ZEND_STRL("exception"), &exception_zv);
+
+        if (!Z_ISUNDEF(php_v8_value->exception)) {
+            zend_update_property(this_ce, return_value, ZEND_STRL("external_exception"), &php_v8_value->exception);
+            zval_ptr_dtor(&php_v8_value->exception);
+            ZVAL_UNDEF(&php_v8_value->exception);
+        }
+
         zval_ptr_dtor(&exception_zv);
     }
 
@@ -71,18 +78,20 @@ static PHP_METHOD(V8TryCatch, __construct) {
     zval *php_v8_exception_zv = NULL;
     zval *php_v8_stack_trace_zv = NULL;
     zval *php_v8_message_zv = NULL;
+    zval *external_exception_zv = NULL;
 
     zend_bool can_continue = '\0';
     zend_bool has_terminated = '\0';
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo|o!o!o!bb",
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo|o!o!o!bbo!",
                               &php_v8_isolate_zv,
                               &php_v8_context_zv,
                               &php_v8_exception_zv,
                               &php_v8_stack_trace_zv,
                               &php_v8_message_zv,
                               &can_continue,
-                              &has_terminated) == FAILURE) {
+                              &has_terminated,
+                              &external_exception_zv) == FAILURE) {
         return;
     }
 
@@ -114,6 +123,10 @@ static PHP_METHOD(V8TryCatch, __construct) {
 
     zend_update_property_bool(this_ce, getThis(), ZEND_STRL("can_continue"), can_continue);
     zend_update_property_bool(this_ce, getThis(), ZEND_STRL("has_terminated"), has_terminated);
+
+    if (external_exception_zv != NULL) {
+        zend_update_property(this_ce, getThis(), ZEND_STRL("external_exception"), external_exception_zv);
+    }
 }
 
 static PHP_METHOD(V8TryCatch, GetIsolate)
@@ -203,6 +216,18 @@ static PHP_METHOD(V8TryCatch, HasTerminated)
 }
 
 
+static PHP_METHOD(V8TryCatch, getExternalException)
+{
+    zval rv;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    RETVAL_ZVAL(zend_read_property(this_ce, getThis(), ZEND_STRL("external_exception"), 0, &rv), 1, 0);
+}
+
+
 ZEND_BEGIN_ARG_INFO_EX(arginfo_v8_try_catch___construct, ZEND_SEND_BY_VAL, ZEND_RETURN_VALUE, 2)
                 ZEND_ARG_OBJ_INFO(0, isolate, V8\\Isolate, 0)
                 ZEND_ARG_OBJ_INFO(0, context, V8\\Context, 0)
@@ -211,6 +236,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_v8_try_catch___construct, ZEND_SEND_BY_VAL, ZEND_
                 ZEND_ARG_OBJ_INFO(0, message, V8\\Message, 1)
                 ZEND_ARG_TYPE_INFO(0, can_continue, _IS_BOOL, 0)
                 ZEND_ARG_TYPE_INFO(0, has_terminated, _IS_BOOL, 0)
+                ZEND_ARG_OBJ_INFO(0, external_exception, Throwable, 1)
 ZEND_END_ARG_INFO()
 
 PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_v8_try_catch_GetIsolate, ZEND_RETURN_VALUE, 0, V8\\Isolate, 0)
@@ -234,6 +260,9 @@ ZEND_END_ARG_INFO()
 PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_v8_try_catch_HasTerminated, ZEND_RETURN_VALUE, 0, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
+PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_v8_try_catch_getExternalException, ZEND_RETURN_VALUE, 0, Throwable, 1)
+ZEND_END_ARG_INFO()
+
 
 static const zend_function_entry php_v8_try_catch_methods[] = {
         PHP_ME(V8TryCatch, __construct,     arginfo_v8_try_catch___construct,     ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
@@ -248,6 +277,8 @@ static const zend_function_entry php_v8_try_catch_methods[] = {
         PHP_ME(V8TryCatch, CanContinue,     arginfo_v8_try_catch_CanContinue,   ZEND_ACC_PUBLIC)
         PHP_ME(V8TryCatch, HasTerminated,   arginfo_v8_try_catch_HasTerminated, ZEND_ACC_PUBLIC)
 
+        PHP_ME(V8TryCatch, getExternalException, arginfo_v8_try_catch_getExternalException, ZEND_ACC_PUBLIC)
+
         PHP_FE_END
 };
 
@@ -266,5 +297,7 @@ PHP_MINIT_FUNCTION (php_v8_try_catch) {
     zend_declare_property_null(this_ce, ZEND_STRL("can_continue"), ZEND_ACC_PRIVATE);
     zend_declare_property_null(this_ce, ZEND_STRL("has_terminated"), ZEND_ACC_PRIVATE);
 
+    zend_declare_property_null(this_ce, ZEND_STRL("external_exception"), ZEND_ACC_PRIVATE);
+
     return SUCCESS;
 }

src/php_v8_value.cc

@@ -91,6 +91,16 @@ static HashTable * php_v8_value_gc(zval *object, zval **table, int *n) {
 
     php_v8_callbacks_gc(php_v8_value->persistent_data, &php_v8_value->gc_data, &php_v8_value->gc_data_count, table, n);
 
+    if(!Z_ISUNDEF(php_v8_value->exception)) {
+        *n = *n + 1;
+
+        if (php_v8_value->gc_data_count < *n) {
+            php_v8_value->gc_data = (zval *)safe_erealloc(php_v8_value->gc_data, *n, sizeof(zval), 0);
+        }
+
+        ZVAL_COPY_VALUE(&php_v8_value->gc_data[*n-1], &php_v8_value->exception);
+    }
+
     return zend_std_get_properties(object);
 }
 
@@ -114,6 +124,11 @@ static void php_v8_value_free(zend_object *object) {
         }
     }
 
+    if (!Z_ISUNDEF(php_v8_value->exception)) {
+        zval_ptr_dtor(&php_v8_value->exception);
+        ZVAL_UNDEF(&php_v8_value->exception);
+    }
+
     if (php_v8_value->gc_data) {
         efree(php_v8_value->gc_data);
     }

src/php_v8_value.h

@@ -111,6 +111,7 @@ struct _php_v8_value_t {
     bool is_weak;
     v8::Persistent<v8::Value> *persistent;
     phpv8::PersistentData *persistent_data;
+    zval exception;
 
     zval *gc_data;
     int   gc_data_count;

stubs/src/Isolate.php

@@ -15,6 +15,10 @@
 namespace V8;
 
 
+use Throwable;
+use V8\Exceptions\ValueException;
+
+
 class Isolate
 {
     public function __construct(StartupData $snapshot = null)
@@ -79,11 +83,17 @@ public function GetEnteredContext(): Context
      * has been handled does it become legal to invoke JavaScript operations.
      *
      * @param Context $context
-     * @param Value   $value
+     * @param Value $value
+     * @param Throwable|null $e Exception to associate with a given value.
+     *                          Because how underlying object wiring done, wiring PHP to V8 exceptions
+     *                          is possible only for V8 exception that are instances of ObjectValue.
      *
      * @return void
+     *
+     * @throws ValueException When trying to associate external exception with non-object value
+     * @throws ValueException When another external exception is already associated with a given value
      */
-    public function ThrowException(Context $context, Value $value)
+    public function ThrowException(Context $context, Value $value, Throwable $e = null)
     {
     }
 
@@ -130,20 +140,6 @@ public function CancelTerminateExecution()
     {
     }
 
-//    /**
-//     * Request V8 to interrupt long running JavaScript code and invoke
-//     * the given |callback| passing the given |data| to it. After |callback|
-//     * returns control will be returned to the JavaScript code.
-//     * There may be a number of interrupt requests in flight.
-//     * Can be called from another thread without acquiring a |Locker|.
-//     * Registered |callback| must not reenter interrupted Isolate.
-//     */
-////    void RequestInterrupt(InterruptCallback callback, void* data);
-//    public function RequestInterrupt()
-//    {
-//
-//    }
-
     /**
      * Optional notification that the embedder is idle.
      * V8 uses the notification to perform garbage collection.
@@ -199,7 +195,7 @@ public function IsInUse(): bool
      * and report it to the message listeners. The option is off by default.
      *
      * @param bool $capture
-     * @param int  $frame_limit
+     * @param int $frame_limit
      */
     public function SetCaptureStackTraceForUncaughtExceptions(bool $capture, int $frame_limit = 10)
     {

stubs/src/TryCatch.php

@@ -14,6 +14,9 @@
 
 namespace V8;
 
+use Throwable;
+
+
 /**
  * An external exception handler.
  */
@@ -47,6 +50,10 @@ class TryCatch
      * @var bool
      */
     private $has_terminated;
+    /**
+     * @var null|Throwable
+     */
+    private $external_exception;
 
     /**
      * Creates a new try/catch block and registers it with v8.  Note that
@@ -55,11 +62,12 @@ class TryCatch
      *
      * @param Isolate $isolate
      * @param Context $context
-     * @param Value   $exception
-     * @param Value   $stack_trace
+     * @param Value $exception
+     * @param Value $stack_trace
      * @param Message $message
-     * @param bool    $can_continue
-     * @param bool    $has_terminated
+     * @param bool $can_continue
+     * @param bool $has_terminated
+     * @param Throwable|null $external_exception
      */
     public function __construct(
         Isolate $isolate,
@@ -68,14 +76,16 @@ public function __construct(
         Value $stack_trace = null,
         Message $message = null,
         bool $can_continue = false,
-        bool $has_terminated = false
+        bool $has_terminated = false,
+        Throwable $external_exception = null
     ) {
         $this->isolate        = $isolate;
         $this->exception      = $exception;
         $this->stack_trace    = $stack_trace;
         $this->message        = $message;
         $this->can_continue   = $can_continue;
         $this->has_terminated = $has_terminated;
+        $this->external_exception = $external_exception;
     }
 
     public function GetIsolate(): Isolate
@@ -160,4 +170,12 @@ public function HasTerminated(): bool
     {
         return $this->has_terminated;
     }
+
+    /**
+     * @return null|Throwable
+     */
+    public function getExternalException()
+    {
+        return $this->external_exception;
+    }
 }

tests/V8ExceptionsTryCatchException.phpt

@@ -58,7 +58,7 @@ object(V8\Exceptions\TryCatchException)#5 (10) {
     }
   }
   ["try_catch":"V8\Exceptions\TryCatchException":private]=>
-  object(V8\TryCatch)#4 (7) {
+  object(V8\TryCatch)#4 (8) {
     ["isolate":"V8\TryCatch":private]=>
     object(V8\Isolate)#2 (0) {
     }
@@ -78,6 +78,8 @@ object(V8\Exceptions\TryCatchException)#5 (10) {
     bool(false)
     ["has_terminated":"V8\TryCatch":private]=>
     bool(false)
+    ["external_exception":"V8\TryCatch":private]=>
+    NULL
   }
 }