Implement exceptions

Author: joehoyle

README.md

@@ -33,7 +33,8 @@ The extension includes builds of libv8, via the [v8 crate](https://docs.rs/v8/la
 - [x] `setModuleLoader`
 - [ ] `setModuleNormaliser`
 - [ ] Subclassing V8Js
-- [ ] Custom exceptions for `V8JsScriptException`, `V8JsMemoryLimitException` and `V8JsTimeLimitException`
+- [x] Custom exceptions for `V8JsScriptException`, `V8JsMemoryLimitException` and `V8JsTimeLimitException`
+- [ ] Support for `V8JsScriptException::getJsLineNumber` etc.
 - [ ] Support for `FLAG_PROPAGATE_PHP_EXCEPTIONS`, `V8Js::FLAG_FORCE_ARRAY`
 - [ ] Throw correct exception subclasses
 - [ ] PHP INI settings `v8js.flags`

src/lib.rs

@@ -14,8 +14,9 @@ mod runtime;
 pub use crate::runtime::JSRuntime;
 pub use crate::runtime::Error as RuntimeError;
 
-static mut V8JSTIMELIMITEXCEPTION_EXCEPTION: Option<&'static ClassEntry> = None;
-static mut V8JSMEMORYLIMITEXCEPTION_EXCEPTION: Option<&'static ClassEntry> = None;
+static mut V8JS_TIME_LIMIT_EXCEPTION: Option<&'static ClassEntry> = None;
+static mut V8JS_MEMORY_LIMIT_EXCEPTION: Option<&'static ClassEntry> = None;
+static mut V8JS_SCRIPT_EXCEPTION: Option<&'static ClassEntry> = None;
 
 pub fn zval_from_jsvalue(result: v8::Local<v8::Value>, scope: &mut v8::HandleScope) -> Zval {
     if result.is_string() {
@@ -214,12 +215,15 @@ impl V8Js {
             Err(e) => {
                 match e {
                     RuntimeError::ExecutionTimeout => {
-                        Err(PhpException::new("".into(), 0, unsafe{ V8JSTIMELIMITEXCEPTION_EXCEPTION.unwrap() } ))
+                        Err(PhpException::new("".into(), 0, unsafe{ V8JS_TIME_LIMIT_EXCEPTION.unwrap() } ))
                     },
                     RuntimeError::MemoryLimitExceeded => {
-                        Err(PhpException::new("".into(), 0, unsafe{ V8JSMEMORYLIMITEXCEPTION_EXCEPTION.unwrap() } ))
+                        Err(PhpException::new("".into(), 0, unsafe{ V8JS_MEMORY_LIMIT_EXCEPTION.unwrap() } ))
                     },
-                    _ => Err(PhpException::default(String::from("Exception")))
+                    RuntimeError::ScriptExecutionError(error) => {
+                        Err(PhpException::new(error.message.into(), 0, unsafe{ V8JS_SCRIPT_EXCEPTION.unwrap() } ))
+                    }
+                    _ => Err(PhpException::default(String::from("Unknown error.")))
                 }
             }
         }
@@ -468,13 +472,19 @@ pub fn startup() {
         .extends(ce::exception())
         .build()
         .expect("Failed to build V8JsTimeLimitException");
-    unsafe { V8JSTIMELIMITEXCEPTION_EXCEPTION.replace(ce) };
+    unsafe { V8JS_TIME_LIMIT_EXCEPTION.replace(ce) };
 
     let ce = ClassBuilder::new("V8JsMemoryLimitException")
         .extends(ce::exception())
         .build()
         .expect("Failed to build V8JsMemoryLimitException");
-    unsafe { V8JSMEMORYLIMITEXCEPTION_EXCEPTION.replace(ce) };
+    unsafe { V8JS_MEMORY_LIMIT_EXCEPTION.replace(ce) };
+
+    let ce = ClassBuilder::new("V8JsScriptException")
+        .extends(ce::exception())
+        .build()
+        .expect("Failed to build V8JsScriptException");
+    unsafe { V8JS_SCRIPT_EXCEPTION.replace(ce) };
 }
 
 #[php_module]

src/runtime.rs

@@ -14,12 +14,24 @@ pub struct JsRuntimeState {
     pub commonjs_modules: HashMap<String, v8::Global<v8::Value>>,
 }
 
+#[derive(Debug)]
+pub struct ScriptExecutionErrorData {
+    pub file_name: String,
+    pub line_number: u64,
+    pub start_column: u64,
+    pub end_column: u64,
+    pub source_line: String,
+    pub trace: String,
+    pub message: String,
+}
+
 #[derive(Debug)]
 pub enum Error {
     JSRuntimeError,
     ExecutionTimeout,
     MemoryLimitExceeded,
     V8Error,
+    ScriptExecutionError(ScriptExecutionErrorData),
 }
 
 fn init_v8() {
@@ -159,8 +171,11 @@ impl JSRuntime {
             false,
             false,
         );
+
+        let try_catch = &mut v8::TryCatch::new(scope);
+
         let script =
-            v8::Script::compile(scope, code, Some(&script_origin)).ok_or(Error::JSRuntimeError)?;
+            v8::Script::compile(try_catch, code, Some(&script_origin)).ok_or(Error::JSRuntimeError)?;
         let stop_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
         let time_limit_hit = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
         let memory_limit_hit = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
@@ -217,7 +232,7 @@ impl JSRuntime {
             });
         }
 
-        let result = script.run(scope);
+        let result = script.run(try_catch);
         stop_flag.store(true, std::sync::atomic::Ordering::SeqCst);
         let time_limit_hit = time_limit_hit.load(std::sync::atomic::Ordering::SeqCst);
         let memory_limit_hit = memory_limit_hit.load(std::sync::atomic::Ordering::SeqCst);
@@ -237,8 +252,24 @@ impl JSRuntime {
 
         stop_flag.store(true, std::sync::atomic::Ordering::SeqCst);
         let result = match result {
-            Some(result) => Ok(Some(v8::Global::new(scope, result))),
-            None => Ok(None),
+            Some(result) => Ok(Some(v8::Global::new(try_catch, result))),
+            None => {
+                let exception = try_catch.exception().unwrap();
+                let exception_string = exception
+                    .to_string(try_catch)
+                    .unwrap()
+                    .to_rust_string_lossy(try_catch);
+                let message = try_catch.message().unwrap();
+                Err(Error::ScriptExecutionError(ScriptExecutionErrorData {
+                    file_name: message.get_script_resource_name(try_catch).unwrap().to_rust_string_lossy(try_catch),
+                    line_number: u64::try_from(message.get_line_number(try_catch).unwrap()).unwrap(),
+                    start_column: u64::try_from(message.get_start_column()).unwrap(),
+                    end_column: u64::try_from(message.get_end_column()).unwrap(),
+                    trace: "".into(), // todo,
+                    message: exception_string,
+                    source_line: message.get_source_line(try_catch).unwrap().to_rust_string_lossy(try_catch),
+                }))
+            }
         };
         result
     }

tests/compile_error.php

@@ -0,0 +1,12 @@
+<?php
+
+$v8js = new V8Js;
+
+try {
+    $result = $v8js->executeString( 'my_func();' );
+} catch ( V8JsScriptException $e ) {
+    assert( $e->getJsFileName() );
+}
+
+
+